C++中的Temporary Materialization（临时物化）：prvalue到xvalue/lvalue的转换机制

C++ Temporary Materialization：prvalue到xvalue/lvalue的转换机制

各位同学，大家好。今天我们来深入探讨C++中一个比较重要的概念——Temporary Materialization（临时物化）。这是一个涉及prvalue（纯右值）到xvalue（将亡值）/lvalue（左值）转换的机制，理解它对于编写高效且符合标准的C++代码至关重要。

1. 值类别（Value Categories）回顾

在深入了解临时物化之前，我们首先需要回顾一下C++中的值类别。C++11引入了五种值类别，它们是：

• glvalue (generalized lvalue)：广义左值，表示一个对象的identity（身份）和value（值）。
  • lvalue (left value)：左值，具有持久性，可以位于赋值运算符的左侧。
  • xvalue (expiring value)：将亡值，表示对象即将被销毁，资源可以被移动。
• rvalue (right value)：右值，可以位于赋值运算符的右侧。
  • prvalue (pure right value)：纯右值，表示计算结果，不与特定的对象关联，例如字面量，算术表达式的结果。
  • xvalue (expiring value)：将亡值，同时也是右值，表示对象即将被销毁。

理解这些值类别对于理解临时物化至关重要。特别是prvalue和xvalue之间的关系。

2. 什么是Temporary Materialization？

临时物化是一种隐式转换，它将prvalue转换为xvalue或lvalue。更具体地说，当一个prvalue被要求具有对象的身份（identity）时，编译器会创建一个临时对象来存储该prvalue的结果，并将该临时对象转换为一个xvalue或lvalue。

换句话说，原本只是一个“计算结果”的prvalue，因为某些操作需要一个实际存在的对象（具有内存地址），所以编译器“物化”了这个计算结果，将其存储在一个临时对象中。

3. 临时物化发生的场景

以下是一些常见的触发临时物化的场景：

• 对prvalue进行成员访问： 当我们需要访问prvalue的成员时，比如prvalue.member，编译器必须先将prvalue物化成一个对象才能进行成员访问。

• prvalue被绑定到lvalue引用： 非const左值引用不能直接绑定到prvalue。如果要绑定，必须先将prvalue物化，然后绑定到这个临时对象的引用。

• prvalue被用作需要lvalue的函数参数： 如果函数参数是lvalue引用或需要lvalue的类型，而我们传递的是prvalue，编译器会先物化prvalue。

• prvalue被用作数组下标： 数组下标操作需要一个lvalue。如果下标表达式是一个prvalue，它会被物化。

• prvalue被用作取地址运算符&的操作数： 取地址运算符需要一个lvalue。如果操作数是一个prvalue，它会被物化。

4. 临时物化的具体示例

让我们通过一些代码示例来详细说明临时物化：

示例1: 成员访问

#include <iostream>

struct MyStruct {
  int x;
  int y;
  int getSum() const { return x + y; }
};

MyStruct createMyStruct() {
  return {10, 20}; // 返回一个prvalue
}

int main() {
  int sum = createMyStruct().getSum(); // 临时物化发生在这里
  std::cout << "Sum: " << sum << std::endl;
  return 0;
}

在这个例子中，createMyStruct()返回一个MyStruct类型的prvalue。为了调用.getSum()方法，编译器必须首先将这个prvalue物化为一个临时对象。然后，getSum()方法才能在这个临时对象上调用。这个临时对象在.getSum()调用完成后立即销毁。

示例2: 绑定到lvalue引用

#include <iostream>

int createInt() {
  return 42; // 返回一个prvalue
}

int main() {
  // int& ref = createInt(); // 错误：非const左值引用不能绑定到prvalue
  const int& constRef = createInt(); // 正确：const左值引用可以绑定到prvalue (会发生临时物化)
  std::cout << "Value: " << constRef << std::endl;
  // constRef = 50; // 错误：const引用不能修改
  return 0;
}

在这个例子中，createInt()返回一个int类型的prvalue。 不能将一个非const的左值引用直接绑定到这个prvalue。 但是，可以将其绑定到一个const左值引用。 在这种情况下，编译器会创建一个临时int对象来存储createInt()的返回值，并将constRef绑定到这个临时对象上。这个临时对象的生命周期会延长到constRef的生命周期结束。

示例3: 作为函数参数

#include <iostream>

struct Point {
  int x;
  int y;
};

Point createPoint() {
  return {1, 2};
}

void printPoint(const Point& p) {
  std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;
}

int main() {
  printPoint(createPoint()); // 临时物化发生在这里
  return 0;
}

printPoint函数接受一个const Point&类型的参数。当我们传递createPoint()的返回值（一个Point类型的prvalue）时，编译器会创建一个临时的Point对象，并将它绑定到p。

示例4: 取地址运算符

#include <iostream>

int createInt() {
    return 100;
}

int main() {
    //int* ptr = &createInt(); // error: cannot take the address of an rvalue
    const int& temp = createInt();
    int* ptr = const_cast<int*>(&temp);  // 强制转换才能获取地址。
    std::cout << "Address of temporary: " << ptr << std::endl;
    *ptr = 200; // Undefined behavior: 修改了临时对象的值
    std::cout << "Value of temporary: " << *ptr << std::endl;

    return 0;
}

在这个例子中，直接使用&createInt() 会报错，因为无法直接获取rvalue的地址。必须通过创建一个临时对象，然后获取临时对象的地址。需要注意的是，修改这个临时对象的值是未定义行为，因为临时对象的生命周期通常很短。

5. 临时对象的生命周期

理解临时对象的生命周期对于避免潜在的bug至关重要。通常，临时对象的生命周期结束于包含创建该临时对象的完整表达式的末尾。但是，有一个重要的例外：

• 绑定到const左值引用或rvalue引用: 当一个prvalue被物化并绑定到const左值引用或rvalue引用时，临时对象的生命周期会延长到该引用的生命周期结束。

这意味着在绑定到const左值引用的情况下，我们可以安全地使用该引用，因为临时对象会一直存在，直到引用失效。 但是，过度依赖临时对象的生命周期延长可能导致代码难以理解和维护。

6. 临时物化和性能

临时物化本身会带来一些性能开销，因为它涉及对象的创建和销毁。 在某些情况下，编译器可以优化掉一些不必要的临时物化，但我们仍然应该尽量避免不必要的临时对象的创建。

以下是一些减少临时物化的方法：

• 避免返回大型对象的prvalue: 尽量使用移动语义或直接构造对象来避免不必要的拷贝和临时对象。

• 使用引用传递参数: 如果不需要拷贝对象，可以使用const左值引用或rvalue引用传递参数。

• 使用移动语义: 当确实需要返回对象时，可以使用移动语义来避免拷贝，从而减少临时对象的创建。

7. 临时物化与std::move

std::move 并不会直接触发临时物化，它的作用是将一个lvalue转换为xvalue。 但是，std::move 可以间接地影响临时物化。

例如，考虑以下代码：

#include <iostream>
#include <string>

std::string createString() {
  return "Hello, world!";
}

int main() {
  std::string str = createString(); // 拷贝构造
  std::string str2 = std::move(createString()); // 移动构造
  return 0;
}

在第一行中，createString() 返回一个 std::string 类型的 prvalue。 这个 prvalue 首先被物化为一个临时对象，然后通过拷贝构造函数将临时对象的内容拷贝到 str 中。

在第二行中，std::move(createString()) 将 createString() 的返回值转换为一个 xvalue。 由于 std::string 具有移动构造函数，因此可以直接将临时对象的内容移动到 str2 中，而无需进行拷贝。 这通常比拷贝构造更有效率。 需要注意的是，这里的临时物化仍然发生了，但是由于使用了移动语义，避免了昂贵的拷贝操作。

8. 临时物化与C++17的改变

C++17引入了强制拷贝消除（Mandatory Copy Elision），在某些情况下，可以完全避免拷贝或移动构造，从而消除了临时对象的创建。 但是，强制拷贝消除并不总是能够发生，因此我们仍然需要理解临时物化的概念。

9. 临时物化和constexpr

constexpr 函数可以在编译时求值。当 constexpr 函数返回一个 prvalue 时，如果该 prvalue 需要被物化，那么物化也必须在编译时进行。 这意味着临时对象必须是字面值类型，并且其构造函数也必须是 constexpr。

10. 代码示例：深入理解临时物化

#include <iostream>

struct Tracer {
    Tracer(const char* name) : name(name) {
        std::cout << name << " constructor" << std::endl;
    }
    Tracer(const Tracer& other) : name(other.name) {
        std::cout << name << " copy constructor" << std::endl;
    }
    Tracer(Tracer&& other) noexcept : name(other.name) {
        std::cout << name << " move constructor" << std::endl;
    }
    ~Tracer() {
        std::cout << name << " destructor" << std::endl;
    }

    Tracer& operator=(const Tracer& other) {
        std::cout << name << " copy assignment" << std::endl;
        name = other.name;
        return *this;
    }

    Tracer& operator=(Tracer&& other) noexcept {
        std::cout << name << " move assignment" << std::endl;
        name = other.name;
        return *this;
    }

    const char* name;
};

Tracer createTracer(const char* name) {
    return Tracer(name); // Returns a prvalue
}

int main() {
    std::cout << "--- Example 1: Member Access ---" << std::endl;
    createTracer("Temp1").name; // Temporary materialization to access member

    std::cout << "n--- Example 2: Binding to const lvalue reference ---" << std::endl;
    const Tracer& ref = createTracer("Temp2"); // Temporary materialization and lifetime extension
    std::cout << "ref is still valid" << std::endl;

    std::cout << "n--- Example 3: Function Argument ---" << std::endl;
    void func(const Tracer& t) {
        std::cout << "Inside func" << std::endl;
    }
    func(createTracer("Temp3")); // Temporary materialization to pass as argument

    std::cout << "n--- Example 4: std::move ---" << std::endl;
    Tracer moved = std::move(createTracer("Temp4")); // Temporary materialization followed by move
}

这个例子使用了Tracer结构体来跟踪构造函数、拷贝构造函数、移动构造函数和析构函数的调用。通过观察这些函数的调用顺序，我们可以更清楚地了解临时物化在不同场景下的行为。

表格总结

操作	是否发生临时物化？	临时对象生命周期
prvalue.member	是	包含该表达式的完整语句结束时
const T& ref = prvalue;	是	延长到 ref 的生命周期结束时
func(prvalue) (函数参数是const T&)	是	函数调用结束时
T x = prvalue;	是, 除非拷贝消除	包含该表达式的完整语句结束时，或被拷贝/移动到x上的时候
T x = std::move(prvalue);	是, 除非拷贝消除	包含该表达式的完整语句结束时，或被移动到x上的时候

11. 实践中的注意事项

• 尽量避免不必要的拷贝操作，使用移动语义可以提高性能。
• 理解临时对象的生命周期，避免悬挂引用。
• 关注编译器的优化能力，有些临时对象可能会被优化掉。
• 在性能敏感的代码中，仔细分析临时对象的创建和销毁情况。
• 充分理解值类别，特别是prvalue，xvalue，lvalue之间的区别。

最后的一些话

临时物化是C++中一个重要的概念，理解它对于编写高效、安全和符合标准的C++代码至关重要。 通过理解prvalue到xvalue/lvalue的转换机制，我们可以更好地控制对象的生命周期，避免不必要的拷贝，并充分利用移动语义来提高性能。希望今天的讲解对大家有所帮助。

更多IT精英技术系列讲座，到智猿学院