详解C++ 临时量与临时对象及程序的相关优化

什么是临时量和临时对象

在C++中，我们可以通过语句创建临时变量，这些临时变量被称为临时量（temporary），也称为临时表达式（temporary expression）。例如：

int i = 2;
int j = i + 3;

在第二个语句中，i + 3是一个临时量，它在完成表达式的计算后就会被销毁。

临时量实际上是C++中的表达式计算结果，因此我们通常把它们称为临时对象（temporary object）。临时对象是在表达式被求值后自动创建的，其作用仅在评估表达式期间存在，表达式完成后临时对象将自动销毁。

什么时候会创建临时对象

临时对象作为函数参数传递

当我们把一个对象拷贝到函数参数中的时候，会创建临时对象。例如：

void Func(const MyClass& obj)
{
    // ...
}

MyClass obj;
Func(obj);

在函数调用过程中，需要将obj拷贝到参数const MyClass& obj所表示的临时对象中。

临时对象作为函数返回值返回

当我们从函数中返回一个对象时，也会创建临时对象。例如：

MyClass Func()
{
    MyClass obj;
    // ...
    return obj;
}

在函数调用结束后，需要将obj拷贝到返回值所表示的临时对象中。

如何避免不必要的临时对象

使用引用

当我们在函数中使用引用作为参数或返回值时，可以避免创建不必要的临时对象，从而提高程序的性能。

例如，我们可以把上面的Func函数改写为：

void Func(const MyClass& obj)
{
    // ...
}

const MyClass& Func()
{
    static MyClass obj;
    // ...
    return obj;
}

在第一个例子中，我们把obj作为引用传递给函数，避免了不必要的拷贝。在第二个例子中，我们使用了一个静态变量obj，可以避免在每次调用函数时都创建新的临时对象。

使用移动语义

在C++11中，我们引入了移动语义，可以避免不必要的对象拷贝，提高程序性能。使用移动语义需要了解右值引用和移动构造函数的概念。

右值引用（Rvalue reference）是一种新的引用类型，用于表示可以被移动的对象。它的语法为T&&，其中T表示对象类型。

移动构造函数（Move constructor）是一种特殊的构造函数，用于从一个右值引用中构造出新的对象。移动构造函数使用移动语义完成对象的构造。

例如：

MyClass(MyClass&& obj)
{
    // 使用移动语义构造
}

当我们返回一个临时对象时，编译器会自动调用移动构造函数来构造对象，从而避免了命名对象和临时对象之间的不必要拷贝。

示例说明

示例一：比较函数调用时的拷贝次数

假设我们有一个MyClass类，它包含一个std::string类型的成员变量。

class MyClass
{
public:
    MyClass() {}
    MyClass(const MyClass& obj) : m_data(obj.m_data) {}
    MyClass(MyClass&& obj) : m_data(std::move(obj.m_data)) {}
private:
    std::string m_data;
};

我们定义一个函数Func1，它接受一个MyClass类型的参数：

void Func1(const MyClass& obj)
{
    // do something
}

我们依次调用Func1函数10次，并记录每次调用时发生的拷贝次数：

MyClass obj;
int count = 0;
for (int i = 0; i < 10; i++)
{
    MyClass temp = obj;
    count++;
    Func1(temp);
}
std::cout << "拷贝次数：" << count << std::endl;

结果输出为：

拷贝次数：10

我们发现，在每次函数调用时都会发生一次拷贝，这会降低程序的性能。

接下来我们将Func1函数改写成使用右值引用的版本Func2：

void Func2(MyClass&& obj)
{
    // do something
}

我们依次调用Func2函数10次，并记录每次调用时发生的拷贝次数：

MyClass obj;
int count = 0;
for (int i = 0; i < 10; i++)
{
    count++;
    Func2(MyClass(obj));
}
std::cout << "拷贝次数：" << count << std::endl;

结果输出为：

拷贝次数：0

我们发现，在调用Func2函数时，没有发生拷贝，这说明使用右值引用可以避免不必要的对象拷贝，提高程序的性能。

示例二：比较函数返回时的拷贝次数

我们定义一个函数Func3，它返回一个MyClass类型的对象：

MyClass Func3()
{
    MyClass obj;
    return obj;
}

我们依次调用Func3函数10次，并记录每次调用时发生的拷贝次数：

int count = 0;
for (int i = 0; i < 10; i++)
{
    MyClass temp = Func3();
    count++;
}
std::cout << "拷贝次数：" << count << std::endl;

结果输出为：

拷贝次数：20

我们发现，在每次返回时都会发生一次拷贝，这会降低程序的性能。

接下来我们将Func3函数改写成使用移动语义的版本Func4：

MyClass Func4()
{
    MyClass obj;
    return std::move(obj);
}

我们依次调用Func4函数10次，并记录每次调用时发生的拷贝次数：

int count = 0;
for (int i = 0; i < 10; i++)
{
    MyClass temp = Func4();
    count++;
}
std::cout << "拷贝次数：" << count << std::endl;

结果输出为：

拷贝次数：10

我们发现，在调用Func4函数时，只发生了10次拷贝，这说明使用移动语义可以避免不必要的对象拷贝，提高程序的性能。