c++类会自动生成拷贝构造函数（operator=），是不是就意味着我们没有必要重写这个函数了？？？

无无无无无无无无 2011-12-16 10:51:34

c++类会自动生成拷贝构造函数（operator=），是不是就意味着我们没有必要重写这个函数了？？？
我感到很疑惑...........

...全文

523 18 打赏收藏转发到动态举报

写回复

用AI写文章

18 条回复

切换为时间正序

请发表友善的回复…

发表回复

zhozhoyu 2011-12-17

打赏
举报

还是要看你成员变量中有没有指向动态分配的内存，如果有的话，还是最好自己写这个构造拷贝函数和重载赋值操作符！

无无无无无无无无 2011-12-17

打赏
举报

不得了大家都很专业啊，学习了学习了

无无无无无无无无 2011-12-16

打赏
举报

[Quote=引用 7 楼 sryan 的回复:]

引用 4 楼 daoluanxiaozi 的回复:

引用 2 楼 sryan 的回复:

operator=不是拷贝构造函数啊！
拷贝构造函数只有在用一个对象来初始化定义一个新对象才会调用
假设对象成员有指针会引起多次delete而导致程序崩溃

我表示很惭愧，应该叫拷贝赋值操作符重载...
那问题就变为“c++类会自动生成拷贝赋值操作符重载（operator=），是不是就……
[/Quote]
对深拷贝和浅拷贝了解了，就是不知道缺省的赋值操作符重载的是简单的赋值而已...

碎炎 2011-12-16

打赏
举报

[Quote=引用 4 楼 daoluanxiaozi 的回复:]

引用 2 楼 sryan 的回复:

operator=不是拷贝构造函数啊！
拷贝构造函数只有在用一个对象来初始化定义一个新对象才会调用
假设对象成员有指针会引起多次delete而导致程序崩溃

我表示很惭愧，应该叫拷贝赋值操作符重载...
那问题就变为“c++类会自动生成拷贝赋值操作符重载（operator=），是不是就意味着我们没有必要重写这个函数了？？？”
[/Quote]

no
假设a类有个int *成员，有实例instA和instB，instA=instB，instA的int*由于默认operator=的关系也指向了instB，当A析构的时候instB中的指针指向已经被释放了，然后B再析构就会出错

google 深拷贝浅拷贝

或者好好看书书上有的

AnDay_Fly 2011-12-16

打赏
举报

默认的operator = 是浅拷贝，简单的对对象成员的赋值，如果你的成员中有指针的话，很有可能不是你想要的结果

无无无无无无无无 2011-12-16

打赏
举报

[Quote=引用 3 楼 pathuang68 的回复:]

1. operator = 不叫拷贝构造函数，而是叫拷贝赋值操作符。
2. 缺省的拷贝赋值操作符是浅拷贝。如果你的代码用浅拷贝就能解决，那就不用自己实现，否则就需要。
[/Quote]
我表示很惭愧，应该叫拷贝赋值操作符重载...
那问题就变为“c++类会自动生成拷贝赋值操作符重载（operator=），是不是就意味着我们没有必要重写这个函数了？？？”

无无无无无无无无 2011-12-16

打赏
举报

[Quote=引用 2 楼 sryan 的回复:]

operator=不是拷贝构造函数啊！
拷贝构造函数只有在用一个对象来初始化定义一个新对象才会调用
假设对象成员有指针会引起多次delete而导致程序崩溃
[/Quote]
我表示很惭愧，应该叫拷贝赋值操作符重载...
那问题就变为“c++类会自动生成拷贝赋值操作符重载（operator=），是不是就意味着我们没有必要重写这个函数了？？？”

pathuang68 2011-12-16

打赏
举报

1. operator = 不叫拷贝构造函数，而是叫拷贝赋值操作符。
2. 缺省的拷贝赋值操作符是浅拷贝。如果你的代码用浅拷贝就能解决，那就不用自己实现，否则就需要。

碎炎 2011-12-16

打赏
举报

operator=不是拷贝构造函数啊！
拷贝构造函数只有在用一个对象来初始化定义一个新对象才会调用
假设对象成员有指针会引起多次delete而导致程序崩溃

peng_weida 2011-12-16

打赏
举报

当然不是啊
有传说中的深拷贝和浅拷贝

qscool1987 2011-12-16

打赏
举报

深拷贝，浅拷贝的问题
当你的类成员函数含有指针类型，并且指向了动态分配了空间时需要定义自己的拷贝构造和赋值函数

JZY4077 2011-12-16

打赏
举报

类中含有指针变量的话，就自己写拷贝构造和函数，否则没有必要写拷贝构造函数，楼主说的那个operator =是运算符重载，和拷贝构造函数不是一回事，有三种情况系统会去调用拷贝构造函数，

1）函数的类对象参数传递
2）返回类对象
3）定义类对象时将一个对象赋值给另一个类对象

彭家老三 2011-12-16

打赏
举报

楼主可以参考C++ Primer Plus第五版的第12章，或C++ Primer第四版的12、13章
[Quote=引用 12 楼 pengjialaosan 的回复:]

为楼主写了个简单的说明的类，楼主参考下：
C/C++ code

#include <iostream>
using namespace std;

class test
{
private:
int *myInt;
unsigned int len;
public:
test(); //默认的构造函数
~test();//析构函数
test(……
[/Quote]

iamnobody 2011-12-16

打赏
举报

很简单，搞清楚缺省的复制操作符为你做了什么。如果他做的事符合你的要求，那么就不用重载，如果不合要求，就要重载。

彭家老三 2011-12-16

打赏
举报

为楼主写了个简单的说明的类，楼主参考下：



#include <iostream>

using namespace std;



class test

{

private: 

	int *myInt;

	unsigned int len;

public:

	test();	//默认的构造函数

	~test();//析构函数

	test(int* num,unsigned int numLen);//自定义构造函数

	test(const test& myTest);//复制构造函数

	test& operator=(const test& myTest);

	void show();

};



test::test()

{

	len = 1;

	myInt = new int[len];

	myInt[0] = 0;

}



test::~test()

{

	delete [] myInt;

	myInt = NULL;

}



test::test(int* num,unsigned int numLen)

{

	len = numLen;

	myInt = new int[len];

	for(unsigned int i=0;i<len;++i)//复制

	{

		myInt[i] = num[i]; 

	}

}



test::test(const test &myTest)

{

	len = myTest.len;

	myInt = new int[len];

	for(unsigned int i=0;i<len;++i)//复制

	{

		myInt[i] = myTest.myInt[i];

	}

}



test& test::operator =(const test &myTest)

{

	if(this == &myTest)

		return *this;		//第一步：检查是否为自赋值

	delete [] myInt;		//第二步：释放原有内存资源，这一步我感觉

							//主要应该是用在释放动态数组的内存，如果myInt不是动态数组

							//应该不需要这第二步，直接第三步：*myInt = *myTest.myInt;

	len = myTest.len;

	myInt = new int[len];

	for(unsigned int i=0;i<len;++i)		//第三步：复制动态内存的指向的内容

	{									//这大概就是所谓的深拷贝，浅拷贝就是直接赋值指针:myInt=myTest.myInt;

		myInt[i] = myTest.myInt[i]; 	//浅拷贝的问题就是，a=b;当b的myInt释放的时候，a的myInt就会指向

	}									//相同的内存，此内存被b释放，而a却在用，就是所谓野指针了。

	return *this;			//第四步：返回*this

}



void test::show()

{

	cout<<"len= "<<len<<endl;

	for(unsigned int i=0;i<len;++i)

	{

		cout<<myInt[i]<<"   ";

	}

	cout<<endl;

}





int main()

{

	const int N = 3;

	int t[N] = {1,2,3};

	test a;

	a.show();

	test b(t,N);

	test c = b;//注意，这个是初始化，调用的是复制构造函数，而不是=操作符

	a = b;//这个是赋值，才是调用=操作符

	test d(b);//复制构造函数

	a.show();

	b.show();

	c.show();

	d.show();



	getchar();

	return 0;

}

小清新爱大光明 2011-12-16

打赏
举报

这个问题引出深浅拷贝智能指针

小清新爱大光明 2011-12-16

打赏
举报

若类中无指针成员可以用编译器合成的缺省赋值操作符函数

cxxer 2011-12-16

打赏
举报

#include <iostream>

using namespace std;

class CA

{

　public:

　　CA(int b,char* cstr)

　　{

　　　a=b;

　　　str=new char[b];

　　　strcpy(str,cstr);

　　}

　　CA(const CA& C)

　　{

　　　a=C.a;

　　　str=new char[a]; //深拷贝

　　　if(str!=0)

　　　　strcpy(str,C.str);

　　}

　　void Show()

　　{

　　　cout<<str<<endl;

　　}

　　~CA()

　　{

　　　delete str;

　　}

　private:

　　int a;

　　char *str;

};



int main()

{

　CA A(10,"Hello!");

　CA B=A;

　B.Show();

　return 0;

}