C++匿名对象、编译器对拷贝构造和构造的优化等的介绍

---

前言

C++匿名对象、编译器对拷贝构造和构造的优化等的介绍

---

一、C++匿名对象

1. 匿名对象的生命周期

#include <iostream>
using namespace std;

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

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

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

int main()
{
	A aa1(1); // 有名对象--- 生命周期在局部作用域
	A(1);     // 匿名对象--- 生命周期在当前行   即用即销毁

	return 0;
}

• 有名对象的生命周期在当前函数局部作用域
• 匿名对象的生命周期在当前行，即用即销毁

2. 匿名对象调用成员函数

#include <iostream>
using namespace std;

class Solution
{
public:
	Solution(int a = 10)
		: _a(a)
	{
		cout << "Solution(int a)" << endl;
	}
	int sum_solution(int n)
	{
		//....
		cout << "int sum_solution(int n)" << endl;

		return n;

	}
	~Solution()
	{
		cout << "~Solution()" << endl;
	}
private:
	int _a;
};

int main()
{
	cout << "--------有名对象---------" << endl;
	// 有名对象
	// 不传参数
	Solution sl1;
	sl1.sum_solution(1);

	// 传参数
	Solution sl2(10);
	sl2.sum_solution(3);

	cout << "--------匿名对象---------" << endl;

	// 匿名对象
	// 不传参数
	Solution().sum_solution(2);

	// 传参数
	Solution(10).sum_solution(4);

	return 0;
}

3. 匿名对象具有常性

#include <iostream>
using namespace std;

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

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

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};


class Solution
{
public:
	Solution(int a = 10)
		: _s(a)
	{
		cout << "Solution(int a)" << endl;
	}
	int sum_solution(int n)
	{
		//....
		cout << "int sum_solution(int n)" << endl;

		return n;

	}
	~Solution()
	{
		cout << "~Solution()" << endl;
	}
private:
	int _s;
};

int main()
{

	Solution(10);

	A& ra = A(10);
	
	return 0;
}

const修饰可以解决上述问题

int main()
{

	Solution(10).sum_solution(1);

	const A& ra = A(10);
	
	return 0;
}

同时const 修饰可以延长匿名对象的生命周期，延长至当前函数的局部作用域

int main()
{

	Solution(10).sum_solution(1);

	const A& ra = A(10);

	Solution(20);
	
	return 0;
}

二、编译器对拷贝构造和构造的优化

#include <iostream>
using namespace std;

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

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

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;

		if (this != &aa)
		{
			_a = aa._a;
		}

		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};

void Func1(A aa)
{

}

void Func2(const A& aa)
{

}

int main()
{
	A a1;
	Func1(a1);

	Func2(a1);

	return 0;
}

• 有上述可知，传引用调用可以减少拷贝构造的调用。

---

A Func3()
{
	A aa;
	return aa;
}

A& Func4()
{
	static A aa;
	return aa;
}

int main()
{
	Func3();

	Func4();

	return 0;
}

• 按道理来讲，Func3应该是先调用构造函数再调用拷贝构造传值返回，最后调用析构函数，但是编译器进行优化，省去了拷贝构造函数，但本质上返回的值仍然是拷贝构造的对象。
• Func4是传引用返回，返回时不需要拷贝构造
• 所以，按道理来讲，应该传引用返回可以减少拷贝构造。

---

A Func5()
{
	A aa;
	return aa;
}

int main()
{
	A ra = Func5(); 

	return 0;
}

如果换一种写法，可能干扰编译器的优化

int main()
{
	//A ra = Func5(); 
	A ra;
	ra = Func5();
	return 0;
}

---

void Func1(A aa)
{

}
int main()
{
	A aa1(1);
	Func1(aa1);   // 不会优化， 构造 + 拷贝构造

	Func1(A(1)); // 构造 + 拷贝构造 -> 构造

	A aa2 = 1;  // 构造 + 拷贝构造 -> 构造

	return 0;
}

总结

C++匿名对象、编译器对拷贝构造和构造的优化等的介绍