---

课程总目录

---

---

一、对象会调用哪些方法、对象优化的三个原则

代码示例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

来分析一下：

1. t1构造：Test(int)
2. t2构造：Test(int)
3. 实参t1拷贝构造到形参t：Test(const Test&)
4. 用val构造一个临时的Test对象tmp：Test(int)
5. tmp被拷贝构造到返回值（main函数栈帧上临时的匿名对象）：Test(const Test&)
6. tmp被析构：~Test()
7. 形参t被析构：~Test()
8. 返回值（main函数栈帧上临时的匿名对象）赋值给t2：operator=
9. 返回值（main函数栈帧上临时的匿名对象）出了语句t2 = GetObject(t1);就被析构了：~Test()
10. t2析构：~Test()
11. 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个函数调用，所以我们还是要牢记这三个原则！！！
（优先引用传递、优先返回临时对象、优先初始化方式接受）

二、CMyString的代码问题

三、

四、添加带右值引用参数的拷贝构造和赋值函数

五、CMyString在vector上的应用

六、move移动语义和forward类型完美转发

七、再聊vector容器使用对象过程中的优化