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

有几种方法可以应对这种情况。使用

提供了一个很好的折衷方案来获得有表现力的代码。

如果将其存储为引用，例如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 value

MyClass myObject{getString()};
myObject.print();

那么代码具有未定义的行为。原因是，临时字符串对象在创建它的同一条语句中被销毁。当调用

时，字符串已经被破坏，使用它是非法的，并导致未定义的行为。

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();

可以看到，在尝试使用之前，这个

#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();
}

另一种选择是存储一个值。这允许使用

语义将传入的临时值移动到存储值中：

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

)，并且没有未定义的行为。实际上，即使临时对象被销毁，

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

那么就不再做两次移动了：做了一次复制(构造

访问字符串的权限，如果做一个拷贝，就有了一个不同于进来的实例。所以它们不会同步。

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

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

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

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

，它可以是任意一个。不过，如果尝试在一个变量中存储引用，就像这样：

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

variant must have no reference alternative

为了达到我们的目的，需要将引用放在另一个类型中；即必须编写特定的代码来处理数据成员。如果为

编写这样的代码，则不能将其用于其他类型。

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

存储需要是一个值或一个引用。既然现在是为通用目的编写这段代码，那么也可以允许非

引用。由于变量不能直接保存引用，那么可以将它们存储到包装器中:

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>>;

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

访问，需要使变量内部的三种可能类型中的每一种都产生一个

为了访问变量中的数据，将使用

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

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
    );
}

非const引用的创建使用相同的技术，除了

之外，它不能产生非const引用。然而，当

访问一个变量时，必须为它的每一个可能的类型编写代码：

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
    );
}

已经定义了存储类，可以在示例中使用它来访问传入的

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_;
};

匹配第一个构造函数，并在存储成员内部创建一个

这个函数匹配第三个构造函数，并将值移动到存储中。

为c++中跟踪左值或右值的经典问题提供了一种非常适合的解决方案。这种技术的代码具有表现力，因为

允许表达与我们的意图非常接近的东西：“根据上下文，对象可以是引用或值”。

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

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

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

编程语言

C++中如何高效处理左值和右值？本文探讨了使用std::variant存储引用的解决方案，避免不必要的拷贝和未定义行为。通过定义通用存储类，实现根据上下文智能选择引用或值存储，提升代码表现力和安全性。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

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

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

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐