面向对象程序设计类复制构造函数

最新推荐文章于 2023-07-29 18:17:59 发布

三千越甲可吞吴、

最新推荐文章于 2023-07-29 18:17:59 发布

阅读量284

点赞数

分类专栏：学习c++ 文章标签：面向对象程序设计类复制构造函数

本文链接：https://blog.csdn.net/qq_42717239/article/details/102653310

版权

学习c++ 专栏收录该内容

59 篇文章 1 订阅

订阅专栏

当定义一个对象时，若希望将已存在的类对象的值赋给该类对象，则需要调用复制构造函数。

#include<iostream>
using namespace std;
class test
{
	int x;
	int y;
public:
	test(int a,int b);
	//test(const test &x);//复制构造函数
	void disp();	
};
test::test(int a,int b):x(a),y(b)
{
}
//test::test(const test &dt)//如果不定义复制构造函数，系统会自动构造复制构造函数 
//{
//	x=dt.x;
//	y=dt.y;	
//} 
void test::disp()
{
	cout<<"x="<<x<<endl;
	cout<<"y="<<y<<endl;
}
int main()
{
	test p(10,20),q(100,200);
	p.disp();
	q.disp();
	p=q;//调用复制构造函数 
	p.disp();
}
/*result:
x=10
y=20
x=100
y=200
x=100
y=200
*/

通过上面的程序我们可以发现，即使我们不定义复制构造函数的话，系统也会自动调用赋值构造函数，编译也不会报错。所以引入复制构造函数的作用是什么呢？

如果类中没有定义复制构造函数，则系统将自动生成一个带有一个参数的复制构造函数（默认复制构造函数），工作方式是将对象的值进行原原本本的复制，如果用户想要附加一些其他的，就必须要自己定义复制构造函数了。

综上所述，如果我们想要实现把一个对象的值*3以后赋给另一个对象，就需要自己构造复制构造函数。

#include<iostream>
using namespace std;
class test
{
	int x;
	int y;
public:
	test(int a,int b);
	test(const test &dt,int n);
	void disp();
};
test::test(int a,int b):x(a),y(b)
{
}
test::test(const test &dt,int n)//带有两个参数的复制构造函数 
{
	x=dt.x*n;//相当于扩大了n倍 
	y=dt.y*n;
}
void test::disp()
{
	cout<<"x="<<x<<endl;
	cout<<"y="<<y<<endl;
}
int main()
{
	test p(10,20),q(p,3);//调用复制构造函数,相当于n=3
	//如果test q(p);或者test q=p;相当于n=1
	p.disp();
	q.disp();
}
/*result:
x=10
y=20
x=30
y=60
*/

当一个类中包含指针变量时，这时如果利用默认复制构造函数来复制对象，由于默认复制构造函数仅仅是将指针变量中的地址，复制到另一个对象中去，这样，两个对象中的指针都是相同的，即他们都指向同一存储区域。这在多数情况下是不方便的。

经过验证，上述程序中的p、q拥有不同的存储空间。

我们举一个简单的例子：

#include<iostream>
#include<string.h>
using namespace std;
class test
{
	char *x;
public:
	test(const char *s);//构造函数 
	~test();//析构函数 
	void string_add(const char *s);//将字符串s接到x上 
	void disp();
};
test::test(const char *s)
{
	x=new char[strlen(s)+1];
	strcpy(x,s);
}
test::~test()
{
	delete[] x;
}
void test::string_add(const char *s)
{
	strcat(x,s);
}
void test::disp()
{
	cout<<"x="<<x<<endl;
}
int main()
{
	test p("good");
	test q=p;//调用默认复制构造函数 
	p.disp();
	q.disp();
	q.string_add("boy");
	p.disp();
	q.disp();
}
/*result:
p=good
q=good
p=goodboy
q=goodboy
*/

由结果可以看出，我们没有给出复制构造函数的定义，所以系统自动调用默认复制构造函数，所以两个对象拥有相同的存储空间。当我们改变其中一个对象的内容时，另一个对象的数据成员也发生改变。

所以，如果我们想要两个对象拥有不同的存储空间，即改变一个对象的存储内容时，另一个对象的内容不会收到影响。可以在成员函数中定义复制构造函数。

class test
{
	char *x;
public:
	...
	test(const test &s)
	{
		x=new char[strlen(s.x)+1];
		strcpy(x,s.x);
	}
	...
};

其余程序不做改变，我们会得到结果：

/*result:
p=good
q=good
p=good
q=goodboy
*/

因此，我们称第一种复制方式为“浅复制”，后一种复制方式为“深复制”。

复制构造函数的进一步说明：
（1）当利用已有类的已有对象来初始化该类的另一个新对象时，系统将自动调用复制构造函数
（2）如果函数的形参是类对象，则在进行函数调用时（准确地说是在将实参对象传递给形参时），将自动调用复制构造函数
（3）如果函数的形参是指向类对象的指针或者对象引用，则在函数调用时不调用复制构造函数
（4）如果函数的返回值是类对象，则在执行返回语句时将自动调用复制构造函数

#include<iostream>
using namespace std;
class test
{
	int x;
	int y;
	int z;
public:
	test(int a,int b,int c):x(a),y(b),z(c)
	{
	}
	test(test &s)//复制构造函数的定义 
	{
		cout<<"enter copy constructor !"<<endl;
		x=s.x;y=s.y;z=s.z;
	}
	void disp()
	{
		cout<<"x="<<x<<" "<<"y="<<y<<" "<<"z="<<z<<endl;
	}
};
void f1(test s)//函数的形参是类对象，将实参传递给形参时，调用复制构造函数 
{
	cout<<"f1:";s.disp();
}
void f2(test &s)//函数的形参是对象的引用，调用函数时，不调用复制构造函数 
{
	cout<<"f2:";s.disp();
}
void f3(test *s)//函数的形参是指向对象的指针，调用函数时，不调用复制构造函数 
{
	cout<<"f3:";s->disp();
}
test f4()//函数的返回值类型是类的对象，在执行返回操作时，调用复制构造函数 
{
	test s(4,5,6);
	cout<<"f4:";s.disp();
	return s;
} 
int main()
{
	test p(1,2,3),q(7,8,9),*s;
	p.disp();
	q.disp();
	f1(q);
	f2(q);
	s=&q;
	f3(s);
	q=f4();
}
/*result:
x=1 y=2 z=3
x=7 y=8 z=9
enter copy constructor !
f1:x=7 y=8 z=9
f2:x=7 y=8 z=9
f3:x=7 y=8 z=9
f4:x=4 y=5 z=6
enter copy constructor !
*/
//注意：编译器为devc++的话，最后一个函数f4不会显示“enter copy constructor !”，这是编译器的问题