浅谈编译器对构造函数和拷贝构造的优化

一、前言

①我们先看一段程序，传值传参和传引用传参

#include <iostream>
using namespace std;

class D
{
public:
	D(int a=0)//构造
		:_a(a)
	{
		cout << "D(int a=0)" << endl;
	}
	D(const D& d)//拷贝
	{
		_a = d._a;
		cout << "D(const D& d)" << endl;
	}
	~D()//析构
	{
		cout << "~D()" << endl;
	}
private:
	int _a;
 };
void  Func1(D &d)
{

}
void  Func2(D d)
{

}

int main() {
	
	D d;
	printf(".......");
	Func2(d);//传值传参
	printf("...");
	Func1(d);//传引用传参

	return 0;
}

结果 

 可以发现传值传参调用了拷贝构造，传引用传参没有调用拷贝构造

②接着看下面的程序，传值返回和传引用返回

#include <iostream>
using namespace std;

class D
{
public:
	D(int a=0)//构造
		:_a(a)
	{
		cout << "D(int a=0)" << endl;
	}
	D(const D& d)//拷贝
	{
		_a = d._a;
		cout << "D(const D& d)" << endl;
	}
	~D()//析构
	{
		cout << "~D()" << endl;
	}
private:
	int _a;
 };
D  Func1(D &d)
{
	return d;
}
 D& Func2(D& d)
{
	 return d;
}

int main() {
	
	D d;
	printf(".......");
	Func1(d);//传值返回
	printf("...");
	Func2(d);//传引用返回

	return 0;
}

结果：

 可以发现，传值返回会调用拷贝构造函数，传引用返回不会调用拷贝构造函数

总结：传参和传返回值时，如果是引用的话，那么就不会调用拷贝构造函数，否则需要调用拷贝构造函数

二、编译器的优化

①现在开始谈谈编译器的优化，请看下面的程序

#include <iostream>
using namespace std;

class D
{
public:
	D(int a=0)//构造
		:_a(a)
	{
		cout << "构造D(int a=0)" << endl;
	}
	D(const D& d)//拷贝
	{
		_a = d._a;
		cout << "拷贝D(const D& d)" << endl;
	}
	~D()//析构
	{
		cout << "析构~D()" << endl;
	}
private:
	int _a;
 };
void Func(D d)
{}

int main() {
	//D(8)为匿名对象
	Func(D(8));

	return 0;
}

看上面的程序，再想它的运行顺序可以想到，该程序会先调用构造函数初始化匿名对象，然后因为该函数是传值传参，所以要调用拷贝构造将该匿名对象的值拷贝一份给形参。然而，真的是这样执行的吗？

如果要了解匿名对象的相关知识请前往这：匿名对象的相关知识

看结果：

 可以发现它只调用了构造函数，而没有调用析构函数。

②再看看下面的程序

#include <iostream>
using namespace std;

class D
{
public:
	D(int a=0)//构造
		:_a(a)
	{
		cout << "构造D(int a=0)" << endl;
	}
	D(const D& d)//拷贝
	{
		_a = d._a;
		cout << "拷贝D(const D& d)" << endl;
	}
	~D()//析构
	{
		cout << "析构~D()" << endl;
	}
private:
	int _a;
 };
void Func(D d)
{}

int main() {
	//会发生隐式转换 D d = D(2) ;
	D d = 2;

	return 0;
}

根据匿名对象的相关知识可以知道，D d =2;该语句会先调用构造函数初始化匿名对象，然后再调用拷贝构造将匿名对象的值赋给d。

结果：

 可以发现，又和我们预期的结果不一样

③让我们接着看最后一个程序

#include <iostream>
using namespace std;

class D
{
public:
	D(int a=0)//构造
		:_a(a)
	{
		cout << "构造D(int a=0)" << endl;
	}
	D(const D& d)//拷贝
	{
		_a = d._a;
		cout << "拷贝D(const D& d)" << endl;
	}
	~D()//析构
	{
		cout << "析构~D()" << endl;
	}
private:
	int _a;
 };
void Func(D d)
{}

int main() {
	D d1;
	Func(d1);

	return 0;
}

结果：

 可以发现，这时即调用了构造函数又调用了拷贝构造函数，为什么和上面的结果不一样呢？

原因：

一个表达式中，连续构造+拷贝构造会被编译器优化为一个只调用一个拷贝构造函数。

ok，关于编译器对构造和拷贝构造函数的优化的知识就分享到这里了，感谢支持