C++相关概念和易错语法（8）（匿名对象、构造+拷贝构造优化、构造析构顺序）

1.匿名对象

当我们实例化对象后，有的对象可能只使用一次，之后就没用了。这个时候我们往往要主动去析构它，否则会占着浪费空间。但是如果遇到大量的这种情况，我们并不想每次都去创建对象、调用、析构，这样会写出很多重复无聊的代码，为了精简，可以考虑使用匿名对象

下面是它使用的一个实例：

#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0, int b = 0)
		:_a(a)
		,_b(b)
	{
		cout << "A(int a = 0, int b = 0)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	void Fun()
	{
		cout << "调用函数" << endl;
	}
private:
	int _a;
	int _b;
};

int main()
{
	cout << "在这之后构造\n" << endl;

	A().Fun();

	cout << "\n在这之前析构" << endl;

	return 0;
}

运行的结果是

我们可以发现，匿名对象的生命周期就在那一行，在调用之后就会立马销毁。这会让我们在某些情况下代码量大大减少，看上去也很直观。

注意书写格式：

2.构造函数、拷贝构造、析构函数的优化

对于任何表达式，它都会有一个返回值，这个返回值是一个临时常变量，如果有变量接收就赋值给它，如果没有就抛弃。对于类和对象的相关操作理论上也应如此。但和内置类型不同，对象每次进行一次复制需要的开销都很大，对性能影响很大，所以编译器会做出优化，简化现有逻辑，提高效率。

下面是一些常见的在VS2022上Debug下的优化：

对于优化问题，我们常常讨论的是构造次数，因为析构和构造成对出现。

主要的优化类型是：构造+拷贝构造->构造

a.隐式类型转换

#include <iostream>
using namespace std;

class A
{

public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	A(const A& a)
		: _a(a._a)
	{
		cout << "A(A& a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

int main()
{
	A a = 1;

	return 0;
}

对于A a = 1，一般逻辑是先将1作为形参调用单参数的A的构造函数得到临时常对象tmp，再采用拷贝构造给a初始化。

但是优化之后就不会生成这个临时变量了。编译器会直接将1作为参数调用对象a对应的构造函数进行初始化。这样的话就少了一次拷贝。

b.隐式类型转换+调用函数

#include <iostream>
using namespace std;

class A
{

public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	A(const A& a)
		: _a(a._a)
	{
		cout << "A(A& a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	static	void Fun(A a)
	{
		cout << "Fun(A a)" << endl;
	}

private:
	int _a;
};

int main()
{
	A::Fun(1);

	return 0;
}

在这段代码中，1应该先调用构造生成临时对象，再将这个对象拷贝构造给形参a。

但是在这里，我们就直接将1作为参数去调用a的对应的构造函数，就不会去生成那个临时变量了。

c.当匿名对象作为实参

#include <iostream>
using namespace std;

class A
{

public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	A(const A& a)
		: _a(a._a)
	{
		cout << "A(A& a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	static	void Fun(A a)
	{
		cout << "Fun(A a)" << endl;
	}

private:
	int _a;
};

int main()
{
	A::Fun(A(1));

	return 0;
}

这里，本来的逻辑是1先去调用匿名对象的构造函数，完成匿名对象的初始化；然后匿名对象再去调用形参a的拷贝构造，完成a的初始化。

但是我们知道匿名对象是即用即扔的，它和临时对象没什么区别，都只在当前行有作用，因此这里依然是跳过构造匿名对象，直接将1作为参数去调用形参的构造函数。

借助这个优化，我们可以减少代码量

int main()
{
	A::Fun(A(1));//两种写法相同
	A::Fun(1);

	return 0;
}

一般来说采用后者的写法，毕竟要写的代码量更小，而且提高可读性。

d.函数返回值是自定义类型

#include <iostream>
using namespace std;

class A
{

public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	A(const A& a)
		: _a(a._a)
	{
		cout << "A(A& a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	static	A Fun()
	{
		cout << "Fun(A a)" << endl;
		return A(2);
	}

private:
	int _a;
};

int main()
{
	A ret = A::Fun();

	return 0;
}

在调用完函数后，函数应该返回值并赋值。这里的逻辑应该是先将2作为参数去调用匿名对象的构造函数，然后将这个匿名对象拷贝构造给ret，使其初始化。

在优化后，我们直接将2作为参数去调用ret的构造函数。

但是，有的情况并不会优化，主要是看构造函数和拷贝构造有没有在一行代码中连续调用。

#include <iostream>
using namespace std;

class A
{

public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	A(const A& a)
		: _a(a._a)
	{
		cout << "A(A& a)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	A& operator= (const A& tmp)
	{
		cout << "A& operator= (const A& tmp)" << endl;
		_a = tmp._a;
		return *this;
	}

	static	A Fun()
	{
		cout << "Fun(A a)" << endl;
		return A(2);
	}

private:
	int _a;
};

int main()
{
	A ret;

	ret = A::Fun();

	return 0;
}

很明显，这里ret的初始化在调用函数前一行，会直接调用它的构造函数。之后进入函数，返回值需要再调用一次匿名对象的构造函数 ，之后调用的是赋值重载运算符。

在这里没有使用构造+拷贝构造，所以没有可优化的地方，一切执行逻辑和我们的推导逻辑一致。

3.构造和析构的顺序

（1）全局对象最先构造，在程序开始时就按顺序构造。

（2）局部static对象在第一次调用才构造，第二次就不构造了。

（3）普通的局部对象按顺序构造

（4）除了static修饰的局部对象以外，所有对象（局部、全局）先构造的后析构。

（5）static修饰的局部对象因为生命周期发生了改变，在所有局部对象都析构之后，在全局对象析构之前按“栈”的规则析构