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

冷不防 2024-03-16 19:44 12阅读 0赞

## 系列文章目录 ##

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

**期待你的关注哦！！！**  
![在这里插入图片描述][475acfa0e4d24c59b75e31ddb6056bfb.png_pic_left]

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

#### 深入理解C++临时对象 ####

*  系列文章目录
 *  一、产生临时对象的情况
 *   *  1.1 以值的方式给函数传递参数 - 如何优化呢？
     *  1.2 类型转换生成的临时对象 - 如何优化呢？
     *   *  1.2.1 类型转换生成的临时对象
         *  1.2.2 隐式类型转换以保证函数调用成功
     *  1.4 函数返回值的时候 - 如何优化呢？
 *  二、小结

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

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

## 一、产生临时对象的情况 ##

### 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）锻炼眼神，能够尽量看出哪些地方可能会产生临时对象，尤其是一个函数只要返回一个对象，一般机会产生临时对象。**

[C]: https://blog.csdn.net/weixin_30197685/category_12344315.html
[C 1]: https://blog.csdn.net/weixin_30197685/category_12332626.html
[Link 1]: https://blog.csdn.net/weixin_30197685/category_12332639.html
[C 2]: https://blog.csdn.net/weixin_30197685/category_12332628.html
[475acfa0e4d24c59b75e31ddb6056bfb.png_pic_left]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/a4e48be1357c49dbaa13fbb3b4f45ce4.png