C++进阶技巧:如何在同一对象中存储左值或右值

2024-04-16 14:44

本文主要是介绍C++进阶技巧:如何在同一对象中存储左值或右值,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目录

1.背景

2.跟踪值

2.1.存储引用

2.2.存储值

3.存储variant

4.通用存储类

4.1.定义const访问

4.2.定义非const访问

5.创建存储

6.总结


1.背景

        C++ 代码似乎经常出现一个问题:如果该值可以来自左值或右值,则对象如何跟踪该值?即如果保留该值作为引用,那么就无法绑定到临时对象。如果将其保留为一个值,那么当它从左值初始化时,会产生不必要的副本。

        有几种方法可以应对这种情况。使用std::variant提供了一个很好的折衷方案来获得有表现力的代码。

2.跟踪值

        假设有一个类MyClass。想让MyClass访问某个std::string。如何表示MyClass内部的字符串?有两种选择:

  • 将其存储为引用。

  • 将其存储为副本。

2.1.存储引用

如果将其存储为引用,例如const引用:

class MyClass
{
public:explicit MyClass(std::string const& s) : s_(s) {}void print() const{std::cout << s_ << '\n';}
private:std::string const& s_;
};

则可以用一个左值初始化我们的引用:

std::string s = "hello";
MyClass myObject{s};
myObject.print();

看起来很不错。但是,如果想用右值初始化我们的对象呢?例如:

MyClass myObject{std::string{"hello"}};
myObject.print();

或者这样的代码:

std::string getString(); // function declaration returning by valueMyClass myObject{getString()};
myObject.print();

那么代码具有未定义的行为。原因是,临时字符串对象在创建它的同一条语句中被销毁。当调用print时,字符串已经被破坏,使用它是非法的,并导致未定义的行为。

为了说明这一点,如果将std::string替换为类型X,并且在X的析构函数打印日志:

struct X
{~X() { std::cout << "X destroyed" << '\n';}
};class MyClass
{
public:explicit MyClass(X const& x) : x_(x) {}void print() const{// using x_;}
private:X const& x_;
};

在调用的地方也打印日志:

MyClass myObject(X{});
std::cout << "before print" << '\n';
myObject.print();

输出:

X destroyed
before print

可以看到,在尝试使用之前,这个X已经被破坏了。

完整示例:

#include <iostream>
#include <string>struct X
{~X() { std::cout << "X destroyed" << '\n';}
};class MyClass
{
public:explicit MyClass(X const& x) : x_(x) {}void print(){(void) x_; // using x_;}
private:X const& x_;
};int main()
{MyClass myObject(X{});std::cout << "before print" << '\n';myObject.print();
}

2.2.存储值

另一种选择是存储一个值。这允许使用move语义将传入的临时值移动到存储值中:

class MyClass
{
public:explicit MyClass(std::string s) : s_(std::move(s)) {}void print() const{std::cout << s_ << '\n';}
private:std::string s_;
};

现在调用它:

MyClass myObject{std::string{"hello"}};
myObject.print();

产生两次移动(一次构造s,一次构造s_),并且没有未定义的行为。实际上,即使临时对象被销毁,print也会使用类内部的实例。

不幸的是,如果带着左值返回到第一个调用点:

std::string s = "hello";
MyClass myObject{s};
myObject.print();

那么就不再做两次移动了:做了一次复制(构造s)和一次移动(构造s_)。

更重要的是,我们的目的是给MyClass访问字符串的权限,如果做一个拷贝,就有了一个不同于进来的实例。所以它们不会同步。

对于临时对象来说,这不是问题,因为它无论如何都会被销毁,并且我们在之前将它移了进来,所以仍然可以访问字符串。但是通过复制,我们不再给MyClass访问传入字符串的权限。

所以存储一个值也不是一个好的解决方案。

3.存储variant

存储引用不是一个好的解决方案,存储值也不是一个好的解决方案。我们想做的是,如果引用是从左值初始化的,则存储引用;如果引用是从右值初始化的,则存储引用。

但是数据成员只能是一种类型:值或引用,对吗?

但是,对于std::variant,它可以是任意一个。不过,如果尝试在一个变量中存储引用,就像这样:

std::variant<std::string, std::string const&>

将得到一个编译错误:

variant must have no reference alternative

为了达到我们的目的,需要将引用放在另一个类型中;即必须编写特定的代码来处理数据成员。如果为std::string编写这样的代码,则不能将其用于其他类型。

在这一点上,最好以通用的方式编写代码。

4.通用存储类

存储需要是一个值或一个引用。既然现在是为通用目的编写这段代码,那么也可以允许非const引用。由于变量不能直接保存引用,那么可以将它们存储到包装器中:

template<typename T>
struct NonConstReference
{T& value_;explicit NonConstReference(T& value) : value_(value){};
};template<typename T>
struct ConstReference
{T const& value_;explicit ConstReference(T const& value) : value_(value){};
};template<typename T>
struct Value
{T value_;explicit Value(T&& value) : value_(std::move(value)) {}
};

将存储定义为这两种情况之一:

template<typename T>
using Storage = std::variant<Value<T>, ConstReference<T>, NonConstReference<T>>;

现在需要通过提供引用来访问变量的底层值。创建了两种类型的访问:一种是const,另一种是非const

4.1.定义const访问

要定义const访问,需要使变量内部的三种可能类型中的每一种都产生一个const引用。

为了访问变量中的数据,将使用std::visit和规范的overload 模式,这可以在c++ 17中实现:

template<typename... Functions>
struct overload : Functions...
{using Functions::operator()...;overload(Functions... functions) : Functions(functions)... {}
};

要获得const引用,只需为每种variant创建一个:

template<typename T>
T const& getConstReference(Storage<T> const& storage)
{return std::visit(overload([](Value<T> const& value) -> T const&             { return value.value_; },[](NonConstReference<T> const& value) -> T const& { return value.value_; },[](ConstReference<T> const& value) -> T const&    { return value.value_; }),storage);
}

4.2.定义非const访问

非const引用的创建使用相同的技术,除了variantConstReference之外,它不能产生非const引用。然而,当std::visit访问一个变量时,必须为它的每一个可能的类型编写代码:

template<typename T>
T& getReference(Storage<T>& storage)
{return std::visit(overload([](Value<T>& value) -> T&             { return value.value_; },[](NonConstReference<T>& value) -> T& { return value.value_; },[](ConstReference<T>& ) -> T&.        { /* code handling the error! */ }),storage);
}

进一步优化,抛出一个异常:

struct NonConstReferenceFromReference : public std::runtime_error
{explicit NonConstReferenceFromReference(std::string const& what) : std::runtime_error{what} {}
};template<typename T>
T& getReference(Storage<T>& storage)
{return std::visit(overload([](Value<T>& value) -> T&             { return value.value_; },[](NonConstReference<T>& value) -> T& { return value.value_; },[](ConstReference<T>& ) -> T& { throw NonConstReferenceFromReference{"Cannot get a non const reference from a const reference"} ; }),storage);
}

5.创建存储

已经定义了存储类,可以在示例中使用它来访问传入的std::string,而不管它的值类别:

class MyClass
{
public:explicit MyClass(std::string& value) :       storage_(NonConstReference(value)){}explicit MyClass(std::string const& value) : storage_(ConstReference(value)){}explicit MyClass(std::string&& value) :      storage_(Value(std::move(value))){}void print() const{std::cout << getConstReference(storage_) << '\n';}private:Storage<std::string> storage_;
};

(1)调用时带左值:

std::string s = "hello";
MyClass myObject{s};
myObject.print();

匹配第一个构造函数,并在存储成员内部创建一个NonConstReference。当print函数调用getConstReference时,非const引用被转换为const引用。

(2)使用临时值:

MyClass myObject{std::string{"hello"}};
myObject.print();

这个函数匹配第三个构造函数,并将值移动到存储中。getConstReference然后将该值的const引用返回给print函数。

6.总结

  std::variant为c++中跟踪左值或右值的经典问题提供了一种非常适合的解决方案。这种技术的代码具有表现力,因为std::variant允许表达与我们的意图非常接近的东西:“根据上下文,对象可以是引用或值”。

        在C++ 17和std::variant之前,解决这个问题很棘手,导致代码难以正确编写。随着语言的发展,标准库变得越来越强大,可以用越来越多的表达性代码来表达我们的意图。

这篇关于C++进阶技巧:如何在同一对象中存储左值或右值的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/909084

相关文章

Java对象转换的实现方式汇总

《Java对象转换的实现方式汇总》:本文主要介绍Java对象转换的多种实现方式,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录Java对象转换的多种实现方式1. 手动映射(Manual Mapping)2. Builder模式3. 工具类辅助映

关于MongoDB图片URL存储异常问题以及解决

《关于MongoDB图片URL存储异常问题以及解决》:本文主要介绍关于MongoDB图片URL存储异常问题以及解决方案,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录MongoDB图片URL存储异常问题项目场景问题描述原因分析解决方案预防措施js总结MongoDB图

Python ZIP文件操作技巧详解

《PythonZIP文件操作技巧详解》在数据处理和系统开发中,ZIP文件操作是开发者必须掌握的核心技能,Python标准库提供的zipfile模块以简洁的API和跨平台特性,成为处理ZIP文件的首选... 目录一、ZIP文件操作基础三板斧1.1 创建压缩包1.2 解压操作1.3 文件遍历与信息获取二、进阶技

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作。由于数据类

Linux下如何使用C++获取硬件信息

《Linux下如何使用C++获取硬件信息》这篇文章主要为大家详细介绍了如何使用C++实现获取CPU,主板,磁盘,BIOS信息等硬件信息,文中的示例代码讲解详细,感兴趣的小伙伴可以了解下... 目录方法获取CPU信息:读取"/proc/cpuinfo"文件获取磁盘信息:读取"/proc/diskstats"文

Java字符串操作技巧之语法、示例与应用场景分析

《Java字符串操作技巧之语法、示例与应用场景分析》在Java算法题和日常开发中,字符串处理是必备的核心技能,本文全面梳理Java中字符串的常用操作语法,结合代码示例、应用场景和避坑指南,可快速掌握字... 目录引言1. 基础操作1.1 创建字符串1.2 获取长度1.3 访问字符2. 字符串处理2.1 子字

Java Optional的使用技巧与最佳实践

《JavaOptional的使用技巧与最佳实践》在Java中,Optional是用于优雅处理null的容器类,其核心目标是显式提醒开发者处理空值场景,避免NullPointerExce... 目录一、Optional 的核心用途二、使用技巧与最佳实践三、常见误区与反模式四、替代方案与扩展五、总结在 Java

C++使用printf语句实现进制转换的示例代码

《C++使用printf语句实现进制转换的示例代码》在C语言中,printf函数可以直接实现部分进制转换功能,通过格式说明符(formatspecifier)快速输出不同进制的数值,下面给大家分享C+... 目录一、printf 原生支持的进制转换1. 十进制、八进制、十六进制转换2. 显示进制前缀3. 指

Python中判断对象是否为空的方法

《Python中判断对象是否为空的方法》在Python开发中,判断对象是否为“空”是高频操作,但看似简单的需求却暗藏玄机,从None到空容器,从零值到自定义对象的“假值”状态,不同场景下的“空”需要精... 目录一、python中的“空”值体系二、精准判定方法对比三、常见误区解析四、进阶处理技巧五、性能优化

C++中初始化二维数组的几种常见方法

《C++中初始化二维数组的几种常见方法》本文详细介绍了在C++中初始化二维数组的不同方式,包括静态初始化、循环、全部为零、部分初始化、std::array和std::vector,以及std::vec... 目录1. 静态初始化2. 使用循环初始化3. 全部初始化为零4. 部分初始化5. 使用 std::a