C++中构造函数，拷贝构造函数，析构函数

标签：默认构造函数   构造函数   拷贝构造函数   赋值操作符   

C++中默认构造函数就是没有形参的构造函数。准确的说法，按照《C++ Primer》中定义：只要定义一个对象时没有提供初始化式，就是用默认构造函数。为所有 的形参提供默认实参的构造函数也定义了默认构造函数。

合成的默认构造函数，即编译器自动生成的默认构造函数。《C++ Primer》中的说明：一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。这条规则的根据是，如果一个类再某种情况下需要控制对象初始化，则该类很可能在所有情况下都需要控制。只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。

需要注意的是自定义的构造函数包括拷贝构造函数。就是说在下面这种情况下，编译器也不会自动生成默认构造函数，代码会出错。把拷贝构造函数删除掉后就没有问题了。

编译器为类自动生成的函数包括默认构造函数，拷贝构造函数，析构函数，赋值函数。但是如果自己定义了拷贝构造函数，那么默认构造函数编译器就不会自动生成了。但是自己定义了默认构造函数时其他函数都会自动生成。

#include <iostream>

using namespace std;

class Base{
public:
	//构造函数
	//Base(){
	//	cout<<"default constructor invoke!"<<endl;
	//}
	//Base(int d){
	//	this->data=d;
	//	cout<<"constructor invoke!"<<endl;
	//}
	//拷贝构造函数
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<endl;
		this->data=b.data;
	}
	//赋值操作符
	Base & operator=(const Base &b){
		cout<<"operator constructor invoke!"<<endl;
		this->data=b.data;
	}
	//7构函数
	~Base(){
		cout<<"deconstructor invoke!"<<endl;
	}
private:
	int data;

};

int main(){

	Base b;
	return 0;
}

#include <iostream>

using namespace std;

class Base{
public:
	//构造函数
	Base(){
		cout<<"default constructor invoke!"<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<endl;
	}
	//拷贝构造函数
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<endl;
		this->data=b.data;
	}
	//赋值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<endl;
		this->data=b.data;
	}
	//析构函数
	~Base(){
		cout<<"deconstructor invoke!"<<endl;
	}

private:
	int data;

};

int main(){

	Base b(1);//构造函数调用

	Base b2=b;//拷贝构造函数调用

	Base b3;//默认构造函数调用
	b3=b;//赋值操作符调用

	return 0;
}

在g++和vs中执行的结果都是一样的。

然后添加一个函数调用来测试：

#include <iostream>

using namespace std;

class Base{
	public:
		//构造函数
		Base(){
			cout<<"default constructor invoke!"<<endl;
		}
		Base(int d){
			this->data=d;
			cout<<"constructor invoke!"<<endl;
		}
		//拷贝构造函数
		Base(const Base &b){
			cout<<"copy constructor invoke!"<<endl;
			this->data=b.data;
		}
		//赋值操作符
		void  operator=(const Base &b){
			cout<<"operator constructor invoke!"<<endl;
			this->data=b.data;
		}
		//7构函数
		~Base(){
			cout<<"deconstructor invoke!"<<endl;
		}

		Base play(Base b){
			return b;
		}
	private:
		int data;

};

int main(){

	Base b(1);//构造函数调用

	Base b2=b;//拷贝构造函数调用

	Base b3;//默认构造函数调用
	b3=b;//赋值操作符调用

	b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）

	return 0;
}

然后使用直接调用时：

#include <iostream>

using namespace std;

class Base{
	public:
		//构造函数
		Base(){
			cout<<"default constructor invoke!"<<endl;
		}
		Base(int d){
			this->data=d;
			cout<<"constructor invoke!"<<endl;
		}
		//拷贝构造函数
		Base(const Base &b){
			cout<<"copy constructor invoke!"<<endl;
			this->data=b.data;
		}
		//赋值操作符
		void  operator=(const Base &b){
			cout<<"operator constructor invoke!"<<endl;
			this->data=b.data;
		}
		//7构函数
		~Base(){
			cout<<"deconstructor invoke!"<<endl;
		}

		Base play(Base  b){
			return b;
		}
	private:
		int data;

};

int main(){

	Base b(1);//构造函数调用

	Base b2=b;//拷贝构造函数调用

	Base b3;//默认构造函数调用
	b3=b;//赋值操作符调用

	b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）
	b.play(b);//<span style="font-size: 11.8181819915771px; font-family: Arial, Helvetica, sans-serif;">第一次拷贝构造函数调用是构造形参，第二次拷贝构造函数调用是函数返回值</span>

	return 0;
}

最开始也不明白为什么是两次拷贝构造函数调用。那么打印出每个对象的地址吧。

vs中的结果：

g++中的结果，可以发现g++中的结果参数进栈的顺序还是有规律的，但是vs好像就没有规律了。

这样还是看不明白，但是和下面代码的这种情况进行比较就比较容易理解了：

#include <iostream>

using namespace std;

class Base{
public:
	//构造函数
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷贝构造函数
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//赋值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7构函数
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	Base play(Base  b){
		return b;
	}
private:
	int data;

};

int main(){

	Base b(1);//构造函数调用

	Base b2=b;//拷贝构造函数调用

	Base b3;//默认构造函数调用
	b3=b;//赋值操作符调用

	b.play(2);//构造函数调用，拷贝构造函数调用（由于函数返回引起的）
	b.play(b);//第一次拷贝构造函数调用是构造形参，第二次拷贝构造函数调用是函数返回值

	cout<<"---------------"<<endl;
	Base b4=b.play(2);
	cout<<"---------------"<<endl;
	Base b5=b.play(b);
	cout<<"---------------"<<endl;
	return 0;
}

可以发现Base b4=b.play(2);和b.play(2);这行代码相比，析构函数的位置发生了变化，之前是连续两次析构，现在换成了先析构一次，然后函数结束后又析构一次。并且是第二次拷贝构造函数创建的对象在函数结束后析构的（根据对象的地址可以得知）。那么情况可能是这样的，即第二次拷贝构造函数是由于函数返回对象时引起的。因为在函数play调用结束后形参b会被析构掉，所以需要将b复制到一个新的内存区域。调用b.play(2)时的内存布局可能是这样的（根据上面的地址绘制）：

为了验证这个测试，可以让play函数不返回B的对象，代码如下：

#include <iostream>

using namespace std;

class Base{
public:
	//构造函数
	Base(){
		cout<<"default constructor invoke!"<<(int *)this<<endl;
	}
	Base(int d){
		this->data=d;
		cout<<"constructor invoke!"<<(int *)this<<endl;
	}
	//拷贝构造函数
	Base(const Base &b){
		cout<<"copy constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//赋值操作符
	void  operator=(const Base &b){
		cout<<"operator constructor invoke!"<<(int *)this<<endl;
		this->data=b.data;
	}
	//7构函数
	~Base(){
		cout<<"deconstructor invoke!"<<(int *)this<<endl;
	}

	void play(Base  b){
		
	}
private:
	int data;

};

int main(){

	Base b(1);//构造函数调用

	Base b2=b;//拷贝构造函数调用

	Base b3;//默认构造函数调用
	b3=b;//赋值操作符调用

	b.play(2);//构造函数调用
	b.play(b);//调用一次拷贝构造函数

	return 0;
}

到这里应该对构造函数，拷贝构造函数和赋值操作符在何时会调用应该有一个清晰的认识了。

C++中构造函数，拷贝构造函数，析构函数

标签：默认构造函数   构造函数   拷贝构造函数   赋值操作符   

原文地址：http://blog.csdn.net/u012501459/article/details/44156069