对象被优化以后才是高效的C++编程
课程总目录
文章目录
- 一、对象会调用哪些方法、对象优化的三个原则
- 二、CMyString的代码问题
- 三、
- 四、添加带右值引用参数的拷贝构造和赋值函数
- 五、CMyString在vector上的应用
- 六、move移动语义和forward类型完美转发
- 七、再聊vector容器使用对象过程中的优化
一、对象会调用哪些方法、对象优化的三个原则
代码示例1：
有一个Test类：
class Test
{
public:Test(int a = 10) :ma(a) { cout << "Test(int)" << endl; }~Test() { cout << "~Test()" << endl; }Test(const Test& t) :ma(t.ma) { cout << "Test(const Test&)" << endl; }Test& operator=(const Test& t){cout << "operator=" << endl;ma = t.ma;return *this;}
private:int ma;
};
Test t1;
Test t2(t1);
Test t3 = t1; // 定义的时候，这也是拷贝构造，不要被迷惑// 运行结果：
Test(int)
Test(const Test&)
Test(const Test&)
~Test()
~Test()
~Test()
// 显式生成临时对象，生存周期：所在的语句
// 语句结束，临时对象会析构
Test t4 = Test(20);
cout << "-----------------------" << endl;// 运行结果：
Test(int)
-----------------------
~Test()
这里的运行结果很奇怪，很多人可能认为Test t4=Test(20);是临时对象先构造，然后拿临时对象拷贝构造t4，然后语句结束，临时对象析构，那为什么这里析构是在横线之后？？
这就是因为c++编译器对于对象的构造的优化：用临时对象生成新对象的时候，临时对象就不产生了，相当于直接构造新对象
也就是Test t4 = Test(20);等价于Test t4(20);，所以此时对象的析构析构是在对象生命周期结束时（main函数结束处）
再来看一些语句：
t4 = t2; // 这调用的是t4.operator=(t2)赋值函数，因为t4原本已存在
t4 = Test(30);
/*
Test(30)显式生成临时对象
t4原本已存在，所以不是构造，这个临时对象肯定要构造生成的
临时对象生成后，给t4赋值，t4.operator=(const Test &t)
出语句后，临时对象析构
*/t4 = (Test)30;
/*
这里是把30强转成Test类型
把其他类型转成类类型的时候，编译器就看这个类类型有没有合适的构造函数
现在把int转成Test，就看这个类类型有没有带int类型参数的构造函数 int->Test(int)
有的话，就可以显式生成临时对象Test(30)赋值给t4，出语句后，临时对象析构
*/// 隐式生成临时对象Test(30)，效果同上，这仨都是一样的效果
t4 = 30; // int->Test(int)
Test* p = &Test(40);
/*
生成一个临时对象，出语句后，临时对象析构了
此时p指向的是一个已经析构的临时对象，p相当于野指针了，这是不行的
而且，这段代码也会报错：“&"要求左值
*/const Test& ref = Test(50);
/*
生成一个临时对象，但是此时是常量左值引用
那么此时 出语句后，临时对象不析构了，因为引用相当于是别名，这块内存起了个名字
所以，引用变量引用临时对象是安全的，临时对象的生命周期就变成引用变量的生命周期了
现在，引用变量是这个函数的局部变量，main函数结束，这个临时对象才析构
*/
代码示例2：
class Test
{
public:// 这里有默认值，Test() Test(10) Test(10, 10)这三种都行Test(int a = 5, int b = 5):ma(a), mb(b){cout << "Test(int, int)" << endl;}~Test() { cout << "~Test()" << endl; }Test(const Test& src):ma(src.ma), mb(src.mb){cout << "Test(const Test&)" << endl;}void operator=(const Test& src){ma = src.ma;mb = src.mb;cout << "operator=" << endl;}
private:int ma;int mb;
};Test t1(10, 10); // 1.Test(int, int)
int main()
{Test t2(20, 20); // 3.Test(int, int)Test t3 = t2; // 4.Test(const Test&)// 优化了，相当于：static Test t4(30, 30);static Test t4 = Test(30, 30); // 5.Test(int, int)// 显式生成临时对象t2 = Test(40, 40); // 6.Test(int, int) operator= ~Test()// 显式生成临时对象// (20, 50)括号表达式，值是50// 也即(Test)50，去找Test(int)一个参数的构造t2 = (Test)(20, 50); // 7.Test(int, int) operator= ~Test()// 隐式生成临时对象// 去找Test(int)一个参数的构造t2 = 60; // 8.Test(int, int) operator= ~Test()// new出来的要delete才析构Test* p1 = new Test(70, 70); // 9.Test(int, int)Test* p2 = new Test[2]; // 10.Test(int, int) Test(int, int)Test* p3 = &Test(80, 80); // 11.Test(int, int) ~Test()，报错，别这样用const Test& p4 = Test(90, 90); // 12.Test(int, int)delete p1; // 13.~Test()delete[]p2; // 14.~Test() ~Test()
}
Test t5(100, 100); // 2.Test(int, int)
代码示例3：
class Test
{
public:Test(int data = 10) :ma(data) { cout << "Test(int)" << endl; }~Test() { cout << "~Test()" << endl; }Test(const Test& t) :ma(t.ma) { cout << "Test(const Test&)" << endl; }void operator=(const Test& t){cout << "operator=" << endl;ma = t.ma;}int getData()const { return ma; }private:int ma;
};Test GetObject(Test t)
{int val = t.getData();Test tmp(val);return tmp;
}int main()
{Test t1;Test t2;t2 = GetObject(t1);return 0;
}
理论运行结果：
Test(int) // 1
Test(int) // 2
Test(const Test&) // 3
Test(int) // 4
Test(const Test&) // 5
~Test() // 6
~Test() // 7
operator= // 8
~Test() // 9
~Test() // 10
~Test() // 11
来分析一下：
t1构造：Test(int)t2构造：Test(int)- 实参
t1拷贝构造到形参t：Test(const Test&) - 用
val构造一个临时的Test对象tmp：Test(int) tmp被拷贝构造到返回值（main函数栈帧上临时的匿名对象）：Test(const Test&)tmp被析构：~Test()- 形参
t被析构：~Test() - 返回值（
main函数栈帧上临时的匿名对象）赋值给t2：operator= - 返回值（
main函数栈帧上临时的匿名对象）出了语句t2 = GetObject(t1);就被析构了：~Test() t2析构：~Test()t1析构：~Test()
可以看到，这么一段小代码，背后调用了11个函数
但是，我使用的编译器是VS2022，会有返回值优化（RVO）或命名返回值优化（NRVO），把上面分析步骤中的5和6进行了优化，因此实际执行结果如下：
Test(int) // 1
Test(int) // 2
Test(const Test&) // 3
Test(int) // 4
~Test() // 7
operator= // 8
~Test() // 9
~Test() // 10
~Test() // 11
我们分析的时候，还是不要考虑这些编译器的优化，按上面那11步进行分析即可
总结三条对象优化的规则
主要针对上面的代码示例3，总结了三条对象优化的规则
1. 函数参数传递过程中，对象优先按引用传递，这样可以省去一个形参t的拷贝构造调用，形参没有构建新的对象，出作用域也不用析构了，优化了3、7
Test GetObject(Test& t) { ... }
运行结果：
Test(int) // 1
Test(int) // 2
Test(int) // 4
Test(const Test&) // 5
~Test() // 6
operator= // 8
~Test() // 9
~Test() // 10
~Test() // 11
2. 函数返回对象的时候，应该优先返回一个临时对象，而不要返回一个定义过的对象，优化了5、6
Test GetObject(Test& t)
{int val = t.getData();// 直接返回临时对象return Test(val);
}
运行结果：
Test(int) // 1
Test(int) // 2
Test(int) // 4
operator= // 8
~Test() // 9
~Test() // 10
~Test() // 11
实际上，VS2022编译器的RVO/NRVO已经把这步给优化了，但由于其他编译器不一定有优化，我们还是要写成返回一个临时对象
3. 接收返回值是对象的函数调用的时候，优先按初始化的方式接收，不要按赋值的方式接收，优化了4、8、9
int main()
{Test t1;Test t2 = GetObject(t1);return 0;
}
运行结果：
Test(int) // 1
Test(int) // 2
~Test() // 10
~Test() // 11
这个看起来优化的很厉害，来分析一下：
所以，经过一系列优化，现在连这个main函数栈帧的临时对象都不产生了，而是直接构造t2
至此，从最先开始的11个函数调用优化成了4个函数调用，所以我们还是要牢记这三个原则！！！
（优先引用传递、优先返回临时对象、优先初始化方式接受）