临时对象对开发人员来说，可能是个意外情况，因为是编译器偷偷产生的，并不在源码中出现。由于临时对象可能影响程序性能，本文主要探讨这种额外产生的临时对象。

产生临时对象

假设有理数类Rational：

// 有理数
class Rational
{
    friend Rational operator+(const Rational&, const Rational&);

public:
    Rational(int a= 0, int b = 1)
        : m(a), n(b)
    {}

private:
    int m; // 被除数
    int n; // 除数
};

通常，有下面3种等价方式实例化Rational对象，

Rational r1(100);            // 1
Rational r2 = Rational(100); // 2
Rational r3 = 100;           // 3

除了r1/r2/r3，这三种形式中，只有情形1才能保证不管编译器如何实现，都不会产生临时对象。
对于情形2，可能会产生临时对象Rational(100, 1)；
对于情形3，可能会产生临时对象Rational(100, 1)。
产生临时对象后，再调用operator=，拷贝构造r2/r3。

创建r3对象伪码：

{
    Rational r3;
    Rational _temp;
    _temp.Rational::Rational(100, 1); // 构造函数
    r3.Rational::Rational(_temp);     // 拷贝构造函数
    _temp.Rational::~Rational();      // 析构_temp对象
}

类型不匹配

上面例子，情形2、3，是常见的类型不匹配的情况。当用一个整数初始化Rational对象时，编译器会将该整数类型转换为所需类型的对象。这个过程中，可能会产生临时对象。
如下所示：

Rational r;
r = 100; 
// <=>
r = Rational(100, 1);

因为Rational没有定义operator=，编译器合成的缺省operator=希望右边是一个Rational对象，因此会将整型数转换为Rational对象。

如何消除临时对象？

• 方法一：使用explicit
  C++ 11标准能让程序员禁止编译器进行这种转换，方法是将构造函数声明为explicit。

class Rational
{
public:
    explicit Rational(int a= 0, int b = 1)
        : m(a), n(b)
    {}
    ...
};

explicit关键字是告诉编译器，反对将修饰的构造函数用作转换构造函数。

• 方法二：重载Rational::operator=
  使该函数接受一个整型参数，而不必调用缺省的operator=，期待等式右边是一个Rational对象。

class Rational
{
public:
    ...
    Rational& operator=(int a)
    {
        m = a;
        n = 1;
        return *this;
    }
    ...
};

消除循环体中的临时对象

在下面for循环体中，a、b是复数类对象，ib也是个复数，而每次 ib + 1.0得到的也是一个复数。由于类型不匹配，每次循环都会反复创建一个临时对象，将1.0转换为Complex对象。

// 复数类 z = a + bi
class Complex
{
    friend Complex operator*(int , const Complex&);
    friend Complex operator*(const Complex&, int );
public:
    Complex(int a = 0, int b = 0) : a(a), b(b) {}
    ...
private:
    int a;
    int b;
};

Complex a, b;
for (int i = 0; i < 100; i++) {
    a = i * b + 1.0;
}

既然每次都创建的临时对象对应值不变，那么有没有什么办法避免多次创建临时对象呢？
答案是有的，可以将临时对象的创建前移到循环体前，将临时对象转换成命名Complex对象。

Complex one(1.0);
for (int i = 0; i < 100; i++) {
  a = i * b + one;
}

按值传递

传参

函数调用中，经常使用按值传递参数：

// 函数定义
void g(T formalArg)
{
  ...
}

// 函数调用
T t;
g(t);

这种按值传递等价于：

// T参数类型
// formalArg 形参
// actualArg 实参
T formalArg = actualArg;

调用g()时, 会在栈中创建一个临时对象，将其内容复制给形参formArg。这也是一个临时对象的拷贝构造过程。
如果创建、清除临时对象的代价昂贵，就需要将按值传递改为按引用或地址传递，从而消除临时对象。

传返回值

按值传递也存在于回传返回值中。这种情况，就是前面一篇文章（C++ 返回值优化RVO）中提到的RVO。可以通过多种方式，消除临时对象，比如使用匿名临时对象，或者用std::move将左值转换为右值，这样在调用处就会调用移动构造函数，而不是拷贝构造函数，从而减少一次对象复制。

string operator+(const string &s, const string &p)
{
    char *buffer = new char[s.length() + p.length() + 1];

    strcpy(buffer, s.c_str()); // Copy first character string
    strcat(buffer, p.c_str()); // Add second character string
    string result(buffer);     // Create return object
    delete buffer;
    return result; // 返回值是一个临时对象
}

用operator=()消除临时对象

前面主要从类型不匹配或者传值角度出发，避免类型转换或传值，从而消除临时对象。还有另一种方式，就是使用自定义operator=()来消除临时对象。

遇到下面这种情况：

string s1, s2, s3;
// ...
s3 = s1 + s2; // 产生临时对象string(s1+s2)

可以用string::operator+=()代替+，重新代码，以阻止临时对象的创建。

s3 = s1;  // operator=() 没有临时对象产生
s3 += s2; // operator+=() 没有临时对象产生

下面代码中，第一段更优雅，但中性能要求苛刻的地方，第二段会更有效，不会产生临时对象。

// 第一段 会产生3个临时对象
s5 = s1 + s2 + s3 + s4;

// 第二段 不会产生临时对象
s5 = s1;
s5 += s2;
s5 += s3;
s5 += s4;

总结

• 临时对象会以构造函数和析构函数的形式损失性能；
• 将构造函数声明为explicit，可以阻止编译器中偷偷进行类型转换；
• 编译器为了解决类型不匹配问题，创建临时对象，此时可以通过函数重载避免；
• 应尽量使用引用传递参数和对象，避免对象复制；
• 操作符是+-*/时，可使用operator=消除临时对象。

参考

[1]DovBulka, DavidMayhew, 布尔卡,等. 提高C++性能的编程技术[M]. 清华大学出版社, 2003.