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

最新推荐文章于 2023-08-06 09:25:50 发布

vincent-xia

最新推荐文章于 2023-08-06 09:25:50 发布

阅读量4.1k

点赞数 3

分类专栏： C++ 文章标签：默认构造函数构造函数拷贝构造函数赋值操作符

本文链接：https://blog.csdn.net/u012501459/article/details/44156069

版权

C++ 专栏收录该内容

82 篇文章 5 订阅

订阅专栏

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

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

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

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

注意拷贝构造函数的参数类型为const Base &类型。&是必须的很容易理解，需要传递引用才行。至于const参数在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;
	}
	//赋值操作符
	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;
}

结果如下：函数b.play(2)执行时，首先会使用构造函数（即接受一个int型变量的构造函数）进行隐式的类型转换，即调用一次构造函数。注意,如果play的形参是B&类型的话，就不可以这样做。否则会出错。

然后使用直接调用时：

#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;
}

g++中执行结果为：

可以发现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;
}

可以发现少了一次拷贝构造函数的调用：

最后再来看看函数参数为引用的时候的情况，这种情况下不会再创建形参，函数是直接对实参进行操作：

#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){
		
	}
	void refer(Base  b){
		cout<<"refer address:"<<(int *)&b<<endl;
	}
private:
	int data;

};

int main(){

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

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

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

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

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}

执行结果为：

refer函数参数为引用返回对象时：

#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){
		
	}

	Base refer(Base & b){
		cout<<"refer address:"<<(int *)&b<<endl;
		return b;
	}
private:
	int data;

};

int main(){

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

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

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

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

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}

依然调用了拷贝构造函数来复制返回值：

refer函数参数为引用并且返回引用时，才不会调用拷贝构造函数：

#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){
		
	}

	Base& refer(Base & b){
		cout<<"refer address:"<<(int *)&b<<endl;
		return b;
	}
private:
	int data;

};

int main(){

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

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

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

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

	cout<<"-----------------"<<endl;
	b.refer(b);
	cout<<"-----------------"<<endl;
	return 0;
}

输出：

注意：不能返回局部对象的引用，所以如果参数不为引用是不能返回一个引用的对象的。

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

vincent-xia

关注

3
点赞
踩
12

收藏

觉得还不错? 一键收藏
0
评论
C++中构造函数，拷贝构造函数，析构函数

C++中默认构造函数就是没有形参的构造函数。准确的说法，按照《C++ Primer》中定义：只要定义一个对象时没有提供初始化式，就是用默认构造函数。为所有的形参提供默认实参的构造函数也定义了默认构造函数。合成的默认构造函数，即编译器自动生成的默认构造函数。《C++ Primer》中的说明：一个类哪怕只定义了一个构造函数，编译器也不会再生成默认构造函数。这条规则的根据是，如果一个类再某种情况下
复制链接

扫一扫