深入理解 C/C++ 中的左值、纯右值与将亡值：从入门到实战

2026-02-08 00:13:24 0条评论 3次阅读 0人点赞

如果你是一名 C++ 开发者，你是否曾经在阅读编译器报错或者浏览标准库源码时，被“左值”和“右值”这两个术语搞得晕头转向？或者，你是否还在沿用 C 语言时代的旧观念，认为“赋值号左边的就是左值，右边的就是右值”？

如果是这样，请不要担心，你并不孤单。在现代 C++ 的发展历程中，移动语义和完美转出的引入彻底改变了我们编写代码的方式，而这一切的基础，正是对表达式值类别（Value Categories）的深刻理解。

在这篇文章中，我们将一起通过实用的代码示例和通俗的语言，彻底理清这些概念。我们将抛弃那些晦涩的标准条文，用“实战工程师”的视角来剖析内存、表达式和对象生命周期之间的关系。无论你是想看透移动语义的本质，还是仅仅是为了通过面试，这篇文章都将是你坚实的后盾。

1 旧观念的崩塌：为什么我们不再谈论“左边”和“右边”？
2 左值：内存中的“定位器”
3 纯右值：短暂的“幽灵”
4 将亡值：移动语义的主角
5 实战中的值类别：重载决议与性能优化
6 常见错误与最佳实践
7 总结：我们将学到了什么？

旧观念的崩塌：为什么我们不再谈论“左边”和“右边”？

让我们从最经典的误解开始。在 C 语言（K&R C）的早期岁月里，区分左值和右值确实非常简单：

> 左值：位于赋值运算符左侧的表达式（它代表一个地址）。

> 右值：位于赋值运算符右侧的表达式（它代表一个值）。

这种定义在简单的 C 程序中似乎行得通，比如 INLINECODE4e483159。INLINECODE5e743982 在左边，是左值；b + c 在右边，是右值。但只要稍微深入一点，这种逻辑就会崩塌。考虑以下情况：

int a;
a = 10;    // a 是左值，10 是右值（没问题）
10 = a;    // 编译错误！因为 10 是右值，不能被赋值
int* p = &a; // 这里，p 是左值，&a 也是左值（因为它是地址）！

在上述代码中，INLINECODE209c6cd0 出现在了赋值号的右边，但它绝对是一个左值（因为它代表了对象 INLINECODEc4035a1c 的地址）。仅仅依据“在赋值号的哪一侧”来判断，已经无法解释现代 C++ 的复杂场景了。

因此，我们这里给出的第一条建议是：

> 忘掉“赋值运算符的左边”和“右边”这种简单粗暴的分类法。我们需要深入到内存和表达式的本质。

当我们翻开 C++11 以后的标准，我们会看到一个令人望而生畏的分类树。与其死记硬背，不如先看这个简化的图景：

expression (表达式)
          /       \
    glvalue (泛左值)   rvalue (右值)
       /      \      /      \
  lvalue   xvalue (将亡值)   prvalue (纯右值)

这个“将亡值”是很多人感到困惑的根源。它是 C++11 引入移动语义后的产物。对于初学者来说，我们很容易在 xvalue 中迷失方向。所以，我们的第二条建议是：

> 在大部分情况下，先专注于区分“左值”和“纯右值”。一旦你掌握了这两个核心概念，将亡值自然会成为你理解高级特性的桥梁，而不是绊脚石。

左值：内存中的“定位器”

什么是左值？用最朴实的话来说：左值就是有身份的表达式。

如果你能对某个表达式取地址（使用 & 运算符），那么它就是一个左值。它不仅仅是一个值，它代表了存储在内存中某个特定位置的一个对象。它甚至可以是函数（函数指针）。我们可以把“lvalue”重新记忆为 Locator Value（定位值）。

让我们看看代码中的例子：

// 示例 1：典型的左值表现形式
#include 

int main() {
    // 1. 变量名是最基本的左值
    int lv1 = 42;          

    // 2. 引用本质上是对象的别名，也是左值
    int& lv2 = lv1;        

    // 3. 指针变量本身（p）也是一个左值，它存储在内存中
    int* lv3 = &lv1;                

    // 4. 解引用指针（*lv3）返回的是指向的对象，这也是左值
    *lv3 = 10; // 修改了 lv1

    // 5. 返回引用的函数，其返回值是左值
    // 这也是为什么我们可以给函数调用赋值的原因！
    int& lv4_func() {
        return lv1;
    }

    lv4_func() = 100; // 完全合法：将 100 赋值给 lv1 引用的对象

    std::cout << lv1; // 输出 100

    return 0;
}

在这个例子中，INLINECODEead3483c 可能会让很多新手感到惊讶。这正是因为 INLINECODE09552e08 返回了一个左值引用，它指向了内存中一个真实的对象（lv1），所以我们可以修改它。

关键点总结： 所有的左值都有一个共同特征——它们持久存在于内存中，直到超出作用域。

纯右值：短暂的“幽灵”

如果左值是实实在在的“房子”，那么纯右值就是住在房子里的“人”或者“数据”。它是用来初始化对象的值。

纯右值 没有身份（不能取地址），它通常是一个字面量（如 INLINECODE420b03bb, INLINECODEa6446fa6）或者是临时计算的结果（如 x + y）。它的生命周期通常很短，往往在表达式结束后就销毁了（除非被用来初始化一个左值引用并延长生命周期，这是另一个话题）。

让我们看看纯右值的典型场景：

// 示例 2：纯右值
#include 
#include 

int main() {
    // 1. 字面量是典型的纯右值
    // 你不能写 &10，这是非法的，因为 10 没有内存地址
    int a = 10; 

    // 2. 表达式的计算结果通常是纯右值
    int b = a + 5; // (a + 5) 计算出的结果是临时的，是纯右值

    // 3. 临时对象是纯右值
    // std::string("Hello") 构造了一个临时 string 对象
    // 在 C++11 之前，它是 const 左值引用，但在 C++11 中，它是纯右值（即将消亡）
    std::string s = std::string("Hello"); 

    // 4. 返回非引用类型的函数，返回值是纯右值
    int add(int x, int y) {
        return x + y;
    }
    int c = add(3, 4); // add(3, 4) 的结果是一个临时的纯右值

    // 错误示范：试图给纯右值赋值
    // 10 = a;      // 错误！
    // a + 5 = b;   // 错误！(a + 5) 是临时结果，没有地址

    return 0;
}

为什么区分它们很重要？

想象一下，你正在写一个重载运算符函数，或者是一个通用的 INLINECODE914e7b92 类。当你处理 INLINECODE09896db4 时，v2 + v3 的结果是一个临时的纯右值。如果你能识别出它是纯右值，你就可以“偷”走它的资源（比如动态数组的指针），而不是昂贵的复制一份。这就是 C++ 移动语义的核心思想。

将亡值：移动语义的主角

现在我们来到了最神秘的地方：将亡值。

它是“左值”和“纯右值”的混合体。它像左值一样，代表一个具体的对象（有身份）；但它像纯右值一样，是可以被移动的（不再被需要）。

它是怎么产生的？

最常见的情况是：当我们将一个左值强制转换为右值引用时（使用 std::move），或者当函数返回右值引用时。

让我们来看看代码，这是理解现代 C++ 性能优化的关键：

// 示例 3：理解将亡值与 std::move
#include 
#include  // for std::move
#include 

void printReference(std::string& str) {
    std::cout << "Lvalue reference: " << str << std::endl;
}

void printReference(std::string&& str) {
    std::cout << "Rvalue reference (xvalue): " << str << std::endl;
}

int main() {
    std::string s = "Hello, World!"; // s 是一个左值

    // 情况 1：直接传参
    printReference(s); // 调用 void printReference(string&)
    // 因为 s 是左值

    // 情况 2：使用 std::move
    // std::move 本质上并不“移动”任何东西，它只是一个 static_cast
    // 它将左值 s 转换为一个右值引用
    // 此时，s 变成了一个“将亡值”
    printReference(std::move(s)); 
    // 调用 void printReference(string&&)
    // 注意：s 现在可能处于空状态（取决于实现），因为它被“移动”走了

    // 情况 3：返回右值引用的函数
    std::string&& getXValue() {
        return std::string("Temporary"); // 注意：这通常是危险的，仅作演示语法
    }

    return 0;
}

在这个例子中，INLINECODE2afc25c8 告诉编译器：“嘿，我有一个变量 INLINECODE935564c1，但我不再需要它了，你可以把它当做临时对象处理。” 这使得编译器能够调用移动构造函数或移动赋值运算符，从而接管 s 内部管理的内存，而不是进行深拷贝。

实战中的值类别：重载决议与性能优化

理解这些概念的最终目的是为了写出更好的 C++ 代码。让我们通过一个更复杂的例子来看看编译器是如何根据值类别来选择函数的。

实用示例：智能资源管理

假设你有一个管理大块内存的类。你想复制它（当源很重要时），或者移动它（当源是临时对象或即将销毁时）。

// 示例 4：利用值类别优化复制与移动
#include 
#include 

class BigData {
    int* data;
    size_t size;

public:
    // 构造函数
    BigData(size_t s) : size(s), data(new int[s]) {
        std::cout << "Allocating resources..." << std::endl;
    }

    // 析构函数
    ~BigData() {
        delete[] data;
        std::cout << "Freeing resources..." << std::endl;
    }

    // 拷贝构造函数
    // 参数是一个 const 左值引用
    // 它接收：左值
    BigData(const BigData& other) : size(other.size), data(new int[other.size]) {
        std::cout << "Deep Copy invoked (Expensive!)..." << std::endl;
        std::copy(other.data, other.data + other.size, data);
    }

    // 移动构造函数
    // 参数是一个右值引用
    // 它接收：纯右值 或 将亡值
    BigData(BigData&& other) noexcept : data(other.data), size(other.size) {
        std::cout << "Move invoked (Cheap!)..." << std::endl;
        // 窃取资源
        other.data = nullptr;
        other.size = 0;
    }
};

BigData processData() {
    BigData temp(1000000); // temp 是左值
    // ... 一些处理 ...
    return temp; // 返回时，temp 被隐式转换为将亡值（RVO优化除外）
}

int main() {
    // 场景 1：从函数返回值初始化
    // processData() 返回一个纯右值/将亡值
    // 编译器优先选择移动构造函数
    BigData d1 = processData(); 

    std::cout << "---" << std::endl;

    // 场景 2：左值初始化
    // d1 是左值
    // 编译器只能选择拷贝构造函数
    BigData d2 = d1; 

    std::cout << "---" << std::endl;

    // 场景 3：显式使用 std::move
    // 我们把 d1 (左值) 强制转换为将亡值
    // 编译器选择移动构造函数
    BigData d3 = std::move(d1);

    // 注意：d1 现在已经空了，不再有效使用

    return 0;
}

在这个例子中，请注意输出的区别：

当处理返回值时（INLINECODEdba9e8a3），尽管我们写的是 INLINECODEd51e09e6，但并没有发生昂贵的深拷贝，而是发生了移动（Move）或者直接被编译器优化掉（RVO）。
只有当我们把一个命名变量（左值）赋值给另一个变量时，才会发生昂贵的深拷贝。
当我们显式告诉编译器“这个变量我不在乎了”（std::move(d1)），就会触发移动构造。

常见错误与最佳实践

在理解了这些概念后，让我们来看看实际开发中容易踩的坑。

错误 1：返回局部变量的引用

// 危险代码
int& badFunction() {
    int temp = 10;
    return temp; // 返回局部变量的引用
}

分析： INLINECODEc7d23c9c 是函数内的局部变量（左值）。函数结束后，INLINECODE81740d7d 被销毁。返回的引用变成了“悬空引用”，指向了一块已经失效的内存。这是 C++ 中最危险的错误之一。

错误 2：误用 std::move

// 令人困惑的代码
std::string s = "Hello";
std::string s2 = std::move(s); // s 现在可能为空
std::cout << s << std::endl; // 输出可能为空，未定义行为取决于后续使用

分析： INLINECODE8be199e5 是一个承诺，意味着你承诺不再使用 INLINECODEa5c4a4f2。如果你在移动了 INLINECODEc0c45295 之后还试图读取它，你会得到空字符串或者未定义的行为。不要在还需要使用变量的时候对它使用 INLINECODE047fbb37。

最佳实践：按值传递还是按引用传递？

在现代 C++ 中，对于需要“拿走”所有权的函数参数，我们通常推荐按值传递（如果是复制昂贵的话，利用移动）：

// 推荐的现代写法
void setData(std::string str) { // 按值传递
    internal_str = std::move(str); // 再移动一次到成员变量
}

当调用者传入左值 INLINECODE4cbc8dab 时，会发生一次拷贝构造。当调用者传入右值 INLINECODEff29bade 时，会发生一次移动构造。这种写法既清晰又高效。

总结：我们将学到了什么？

在这篇文章中，我们通过代码和实际场景，重新定义了 C/C++ 中左值、纯右值和将亡值的概念：

左值：有身份，有地址，代表内存中的持久对象。它是“定位器”。
纯右值：无身份，无地址，代表初始化对象的临时值或字面量。它是“数据”。
将亡值：既有身份（对象）又可以被移动（像右值）。它是连接移动语义的桥梁。

我们不再简单地通过“在赋值号的哪一侧”来判断类型，而是通过表达式背后的生命周期和身份来理解它们。

给开发者的建议：

当你在编写高性能的 C++ 代码时，时刻问自己：“这个对象是持久的还是临时的？我是在复制它还是窃取它？” 一当你能够直觉地回答这些问题，你就已经掌握了 C++ 值类别的精髓。

继续探索吧，尝试在你的下一个项目中重构一个函数，利用移动语义来优化性能。你会发现，理解这些底层概念带来的回报是巨大的。

投稿给我们	如何建站？
vps是什么？	如何安装宝塔？
如何通过博客赚钱？	便宜wordpress托管方案
免费wordpress主题	这些都是免费方案

豆丁博客