C++技能系列 ( 4 ) - 深入理解C++临时对象【解析与提高性能手段】

系列文章目录

C++技能系列
C++高性能优化编程系列
深入理解软件架构设计系列
高级C++并发线程编程

期待你的关注哦！！！

现在的一切都是为将来的梦想编织翅膀，让梦想在现实中展翅高飞。
Now everything is for the future of dream weaving wings, let the dream fly in reality.

有些临时对象是系统自己产生的，又有一些临时对象却是因为代码的书写问题而产生的，因为临时对象会额外消耗系统资源，所以编写代码的原则就是产生的临时对象越少越好。临时对象一般都是在栈上，所以一般都不会手动去释放。

为什么要了解临时对象？因为临时对象的产生和销毁都是有成本的，都会影响程序的执行性能和效率，所以如果能有效地减少临时对象的产生，那么无疑意味着程序性能和效率的提升。

一、产生临时对象的情况

1.1 以值的方式给函数传递参数 - 如何优化呢？

先看如下案例：

class CTempValue
{
public:
    int val1;
    int val2;
public:
    //构造函数
    CTempValue(int v1 = 0, int v2 = 0)
    {
        cout << "调用构造函数" << endl;
        val1 = v1;
        val2 = v2;
        cout << "val1 = " << val1 << endl;
        cout << "val2 = " << val2 << endl;
    }
    ~CTempValue()
    {
        cout << "调用了析构函数" << endl;
    }
    //拷贝构造函数
    CTempValue(const CTempValue& t)
    {
        cout << "调用拷贝构造函数" << endl;
        val1 = t.val1;
        val2 = t.val2;
        cout << "val1 = " << val1 << endl;
        cout << "val2 = " << val2 << endl;
    }
    int Add(CTempValue tobj)
    {
        int tmp = tobj.val1 + tobj.val2;
        tobj.val1 = 1000;   //这里的修改对外界没有影响
        return tmp;
    }
};

int main()
{
	CTempValue tm(10, 20);  //调用构造函数
	int Sum = tm.Add(tm);   // 这会调用拷贝构造函数的执行
	cout << "Sum = " << Sum << endl;  //Sum = 30
	cout << "tm.val1 = " << tm.val1 << endl; //tm.val1 = 10
	return 0;
}

运行结果如下：

调用构造函数
调用拷贝构造函数
调用了析构函数
Sum = 30
tm.val1 = 10
调用了析构函数

⚠️请注意，结果中调用了拷贝构造函数，为什么调用CTempValue类的拷贝构造函数呢？

这是因为调用Add成员函数时把对象tm传递给了Add成员函数，此时，系统会调用拷贝构造函数创建一个副本tobj（成员函数Add的形参），用于在函数体Add内使用，因为tm对象的vall值（tm对象的vall值仍旧为10）。

形参tobj是一个局部对象（局部变量），从程序功能的角度来讲，函数体内需要临时使用它一下，来完成一个程序上的一个功能，它确实是一个局部变量，只能在Add函数体里使用。所以严格意义来讲，它又不能称为一个真正意义的临时对象，因为真正的临时对象往往指的是真实存在，但又感觉不到的对象（至少从代码上不能直接看到的对象）。

但是，对于目前确实生成了tobj对象，并且调用了类的拷贝构造函数，有了复制的动作，就会影响程序的执行效率。

那如何优化呢？

我们可以使用引用：

int Add(CTempValue& tobj){}

1.2 类型转换生成的临时对象 - 如何优化呢？

1.2.1 类型转换生成的临时对象

接下来，我们看下真正意义的临时对象，因为这个临时对象确实存在，但是从程序代码的角度不能直接看到它。

CTempValue sum;
sum = 1000;

执行一下，程序结果如下：

调用构造函数
val1 = 0
val2 = 0
调用构造函数
val1 = 1000
val2 = 0
调用了析构函数
调用了析构函数

在执行sum = 1000;系统调用了一次CTempValue类的构造函数和析构函数，这说明系统肯定产生了一个对象，但这个对象在哪里，通过代码完全看不到，所以这个对象是一个真正的临时对象。

那么，产生这个临时对象的原因是什么呢？

是因为把1000赋给sum，而sum本身是一个CTempValue类型的对象，1000是一个数字，那怎么把数字能转化成CTempValue类型的对象呢？所以编译器这里帮助我们以1000为参数调用了CTempValue的构造函数创建了一个临时对象，因为CTempValue构造函数的两个参数都有默认值，所以这里的数字1000就顶替了第一个参数，而第二个参数系统就用了默认值，所以从1000是可以成功创建出CTempValue对象的。

为了进一步观察，增加拷贝赋值运算符的代码：

CTempValue& operator=(const CTempValue& tmpv)
{
	cout << "调用了拷贝赋值运算符" << endl;
	val1 = tmpv.val1;
	val2 = tmpv.val2;
	cout << "val1 = " << val1 << endl;
    cout << "val2 = " << val2 << endl;
	return *this;
}

执行程序，看下结果：

调用构造函数
val1 = 0
val2 = 0
调用构造函数
val1 = 1000
val2 = 0
调用了拷贝赋值运算符
val1 = 1000
val2 = 0
调用了析构函数
调用了析构函数

总结sum = 1000;这行代码系统做了哪些事：

用1000这个数字创建了一个类型为CTempValue的临时对象；调用拷贝赋值运算符把这个临时对象里面的各个成员值赋给了sum对象；销毁这个刚刚创建的CTempValue临时对象。

那如何优化呢？

可以把main主函数中刚刚写的两行代码优化成下面一行：

CTempValue sum = 1000; //" = " 在这里不是赋值运算符，而是定义初始化的概念

运行结果如下：

调用构造函数
val1 = 1000
val2 = 0
调用了析构函数

可以看到，系统没有生成临时对象，所以系统少调用了一次构造函数，少调用了一次拷贝赋值运算符、少调用了一次析构函数。

1.2.2 隐式类型转换以保证函数调用成功

int calc(const string& strsource, char ch)
{
	const char * p = strsource.c_str();
	int icount = 0;
	//......具体的统计代码
	return icount;
}
//在main主函数的代码如下：
int main()
{
	char mystr[100] = "I love China, oh, yeah!";
	int result = calc(mystr, 'o');
	return 0;
}

一个是char数组，一个是const string&，但是这个函数就能调用成功，为什么呢？

当然是编译器帮助我们做了一些事情，解决类型不匹配，那是如何做的呢？

那就是编译器产生了一个类型sring的临时对象，这个临时对象的构造方式就是用mystr作为参数，调用了string的构造函数，这样形参strsoutce就绑定到这个string临时对象上了。当calc函数返回的时候，这个临时对象会被自动销毁。

C++只会为const string&(const引用)产生临时对象，不会为string&(非const)产生临时对象。

1.4 函数返回值的时候 - 如何优化呢？

我们在main主函数上面加一个普通的全局函数：

CTempValue Double(CTempValue& ts)
{
	CTempValue tmpm;	//这里会消耗一次构造函数和一次析构函数的调用
	tmpm.val1 = ts.val1 * 2;
	tmpm.val2 = ts.val2 * 2;
	return tmpm; //这里会调用构造函数和析构函数，这表示生成了一个临时对象
}

int main()
{
	CTempValue ts1(10, 20);
	CTempValue ts2 = Double(ts1);  //其实临时对象接管的就是右值
	CTempValue&& ts2 = Double(ts1);  
}

临时对象就是一种右值

那如何优化呢？

CTempValue Double(CTempValue& ts)
{
	return CTempValue(ts.val1 * 2, ts.val2 * 2); 
}

通过如上的优化系统会调用一次拷贝构造函数，一次析构函数。

二、小结

（1）写代码的时候，减少临时变量的产生。
（2）锻炼眼神，能够尽量看出哪些地方可能会产生临时对象，尤其是一个函数只要返回一个对象，一般机会产生临时对象。