C++类的拷贝构造函数和赋值构造函数

转自：http://blog.chinaunix.net/uid-27177626-id-3938547.html

在C++中，对于一个空的类，编译器一般默认它会有4个成员函数：构造函数，析构函数，复制构造函数和赋值函数。对于初学者而言，构造函数一定是要知道的：它的功能就是在创建一个新的对象的时候给数据成员赋初值，也就是给对象做初始化。析构函数则是用来释放一个对象，在对象删除之前用它来做一些内存释放等的清理工作，与构造函数的功能相反。

关于类的构造函数和析构函数的典型应用：在构造函数中用new来为指针成员开辟一个独立的动态内存空间，而在析构函数中用delete来释放它。

关于C++中对一个对象的初始化可以是下面这样：

点击(此处)折叠或打开

//<类名><对象名1>(<对象名2>)

ClassName o1("object");
//A:通过构造函数设定初始值

ClassName o3(o2);
//B:通过指定的对象设定初始值

在上面的语句中，B语句将o2作为o3的初值，和o2一样，o3的初始化形式要调用相应的构造函数，但是此时找不到与之匹配的构造函数，因为ClassName类中没有哪个构造函数的形参是ClassName类的对象，由此引出ClassName所隐含的一个特殊的默认构造函数，其原型是：

点击(此处)折叠或打开

ClassName(const ClassName &);

这种默认的构造函数就称作默认拷贝(复制)构造函数。不过这仅仅是将内存空间的内容做了拷贝，这种拷贝方式称为浅拷贝。而对于数据成员有指针类型的类来说，默认的拷贝构造函数无法完成对其内容的拷贝，此时的解决办法就是必须自己定义一个拷贝构造函数，然后在进行数值拷贝之前为指针类型的数据成员重新开辟一个独立的内存空间，这种还需要另开辟新的内存空间的拷贝方式称作是深拷贝。(关于深拷贝和浅拷贝后面深入学习。。。)

拷贝构造函数除了要保持和普通构造函数的声明和实现规则之外，还要按照下列格式定义：

引言——

class CExample

{

public:

CExample(){pBuffer=NULL; nSize=0;}

~CExample(){delete pBuffer;}

void Init(int n){ pBuffer=new char
; nSize=n;}

private:

char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源

int nSize;

};

这个类的主要特点是包含指向其他资源的指针。

pBuffer指向堆中分配的一段内存空间。

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

　　　　　　　用到拷贝构造函数--main1

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

1）、拷贝构造函数

当用已有的一个对象去初始化另外一个对象的时候。
int main(int argc, char* argv[])

{

CExample theObjone;

theObjone.Init40);

//现在需要另一个对象,需要将他初始化称对象一的状态

CExample theObjtwo=theObjone;

...

}

　　即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。

所以需要采用必要的手段来避免此类情况。

回顾以下此语句的具体过程:首先建立对象theObjtwo，并调用其构造函数，然后成员被拷贝。

可以在构造函数中添加操作来解决指针成员的问题。

所以C++语法中除了提供缺省形式的构造函数外，还规范了另一种特殊的构造函数：拷贝构造函数，上面的语句中，如果类中定义了拷贝构造函数，这对象建立时，调用的将是拷贝构造函数，在拷贝构造函数中，可以根据传入的变量，复制指针所指向的资源。

拷贝构造函数的格式为:构造函数名(对象的引用)

原则上，应该为所有包含动态分配成员的类都提供拷贝构造函数。

／＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊

　　　　　　　　　　用到赋值函数--main2

＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊／

int main(int argc, char* argv[])

{

CExample theObjone;

theObjone.Init(40);

CExample theObjthree;

theObjthree.Init(60);

//现在需要一个对象赋值操作,被赋值对象的原内容被清除，并用右边对象的内容填充。

theObjthree=theObjone;

return 0;

}

语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。

其完成方式是内存拷贝，复制所有成员的值。

完成后，theObjtwo.pBuffer==theObjone.pBuffer。

　　由于对象内包含指针，将造成不良后果:指针的值被丢弃了(指针内容丢失了也就是说地址丢失了，但是该地址中所存储的内容没有丢失，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。

　 main1和main2都用到了"="号，但main2与main1中的例子并不同，main1的例子中，"="在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。 例如 CExample theObjone(theObjtwo);-- 即它们将指向同样的地方，指针虽然复制了，但所指向的空间并没有复制，而是由两个对象共用了。这样不符合要求，对象之间不独立了，并为空间的删除带来隐患。

　　　而main2中，"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;，这其中涉及到对象　theObjthree原有内容的丢弃，新内容的复制。-- 由于对象内包含指针，将造成不良后果:指针的值被丢弃了(指针内容丢失了也就是说地址丢失了，但是该地址中所存储的内容没有丢失，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。

2）拷贝构造函数的另一种调用。

当对象直接作为参数传给函数时，函数将建立对象的临时拷贝，这个拷贝过程也将调同拷贝构造函数。

例如

BOOL testfunc(CExample obj);

testfunc(theObjone); //对象直接作为参数。

BOOL testfunc(CExample obj)

{

//针对obj的操作实际上是针对复制后的临时拷贝进行的

}

3）还有一种情况，也是与临时对象有关的

当函数中的局部对象被被返回给函数调者时，也将建立此局部对象的一个临时拷贝，拷贝构造函数也将被调用

CTest func()

{

CTest theTest;

return theTest

}

在 C++ 中，赋值和拷贝是不同的，

1)拷贝构造函数是对未初始化的内存进行初始化操作

2)而赋值是对现有的已经初始化的对象进行操作。(这里我对“已经初始化”的理解是已经调用了构造函数，并且构造函数体可以未执行，只要调用到即可)，赋值函数应该给所有数据成员都初始化。

3)重点:包含动态分配成员的类
应提供拷贝构造函数,并重载"="赋值操作符。

4）可以说，C++中什么时候有临时对象产生，此时刻c++一定要调用拷贝构造函数。（临时对象产生时有一个特例，此时不需要调用拷贝构造函数，例如类Ａ，Ａ　ａ＝１０００；）

5)理解了拷贝构造函数和赋值函数的作用，相信他们两个的函数体一定会写了。

1.按值拷贝和按位拷贝

了便于说明我们以String类为例：

首先定义String类，而并不实现其成员函数。

1. Class String{

2. public:

3. String(const char *ch=NULL);//默认构造函数

4. String(const String &str);//拷贝构造函数

5. ~String(void);

6. String &operator=(const String &str);//赋值函数

7. private:

8. char *m_data;

9. };

位拷贝拷贝的是地址，而值拷贝则拷贝的是内容。如果定义两个String对象A和B。A.m_data和B.m_data分别指向一段区域，A.m_data=”windows”,B.m_data=“linux”;

如果未重写赋值函数，将B赋给A;则编译器会默认进行位拷贝，A.m_data=B.m_data

则A.m_data和B.m_data指向同一块区域，虽然A.m_data指向的内容会改变成”linux”,但是这样容易出现这些问题：

(1):A.m_data原来指向的内存区域未释放，造成内存泄露。

(2):A.m_data和B.m_data指向同一块区域，任何一方改变都会影响另一方

(3)：当对象被析构时，B.m_data被释放两次。

对于编译器，如果不主动编写拷贝函数和赋值函数，它会以“位拷贝”的方式自动生成缺省的函数。

如果重写赋值函数和拷贝构造函数后，

A.m_data=B.m_data，进行的是值拷贝，会将B.m_data的内容赋给A.m_data,A.m_data还是指向原来的内存区域，但是其内容改变。

2. 赋值构造函数的作用

每个类只有一个析构函数，但可以有多个构造函数（包含一个拷贝构造函数，其它的称为普通构造函数）和多个赋值函数（除了同类的赋值以外，还有其他的赋值方法）。对于任意一个类A，如果不想编写上述函数，C++编译器将自动为A产生四个缺省的函数，如

A(void); // 缺省的无参数构造函数

A(const A &a); // 缺省的拷贝构造函数

~A(void); // 缺省的析构函数

A & operate =(const A &a); // 缺省的赋值函数

有几个需要注意的内容：

1). 构造函数与析构函数的另一个特别之处是没有返回值类型

2). 构造从类层次的最顶层的基类开始，在每一层中，首先调用基类的构造函数，然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行，在析构的时候，最低层的派生类的析构函数最开始被调用，然后调用每个基类的析构函数。

3). “缺省的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现，倘若类中含有指针变量，这两个函数注定将出错

下面通过例子进一步说明，

1.构造函数的初始化表

设存在两个类：

class A

{

…

A(void); // 无参数构造函数

A(const A &other); // 拷贝构造函数

A & operate =( const A &other); // 赋值函数

virtual ~A(void); //析构函数

}；

class B

{

public:

B(const A &a); // B的构造函数

private:

A m_a; // 成员对象

};

下面面是B的构造函数的2个实现，其中第一个的类B的构造函数在其初始化表里调用了类A的拷贝构造函数，从而将成员对象m_a初始化；而第二个的B的构造函数在函数体内用赋值的方式将成员对象m_a初始化。我们看到的只是一条赋值语句，但实际上B的构造函数干了两件事：先暗地里创建m_a对象（调用了A的无参数构造函数），再调用类A的赋值函数，将参数a赋给m_a。

B::B(const A &a)

: m_a(a)

{

…

}

B::B(const A &a)

{

m_a = a;

…

}

3. 关于拷贝构造函数和赋值函数

关于拷贝构造函数和赋值函数，是被很多程序员忽视的问题，具体到我自身，我几乎没有自己亲手编制过这两个函数！拷贝构造函数和赋值函数，无论是在使用上，还是在两个函数的编制上都有所不同！所以当今天MSRA面试我时，我根本就忘掉了拷贝构造函数和赋值函数的区别！脑海里有这两个概念，知道他们二者是不同的，但是要我答他们二者的不同，没有办法cry吧！

别小看，下面这程序，你要是String类的每一个函数（构造，拷贝构造，赋值，析构）都能写对，你确实牛比，直接去华为，中兴之类的面试吧。

（1）拷贝构造函数和赋值函数的使用比较。

String a("zhangbufeng");

String b("cuixiaoyuan");

String c(a);//对象创建时，使用拷贝构造函数

c=b; //c已经被初始化，从而调用了赋值函数。上次多写了个String，造成了重定义。

（2）

在vc6.0中，File->New->C/C++ source File,然后将此段程序输入进去运行即可！

#include "iostream.h"

#include "stdio.h"

#include "string.h"

class String

{

public:

String(const char *str = NULL); // 普通构造函数

String(const String &other); // 拷贝构造函数

~ String(void); // 析构函数

String & operator =(const String &other); // 赋值函数

private:

char *m_String; //私有成员，保存字符串

};

String::~String(void)

{

cout<<"Destructing"<<ENDL;

delete [] m_String;

}

String::String(const char *str)

{

cout<<"Construcing"<<ENDL;

if(str==NULL)

{

m_String = new char[1];

*m_String = '\0';

}

else

{

int length = strlen(str);

m_String = new char[length+1];

strcpy(m_String, str);

}

}

String::String(const String &other)

{

cout<<"Constructing Copy"<<ENDL;

int length = strlen(other.m_String);

m_String = new char[length+1];

strcpy(m_String, other.m_String);

}

String & String::operator =(const String &other)//赋值函数只有=左面的对象才调用

{

cout<<"Operate = Function"<<endl;

//检查自赋值

if(this == &other)

return *this;

//释放原有的内存资源

delete [] m_String;

//分配新的内存资源，并复制内容

int length = strlen(other.m_String);

m_String = new char[length+1];

strcpy(m_String, other.m_String);

//返回本对象的引用

return *this;

}

////////////////////////////////

//赋值操作符重载

CExample & CExample::operator = (const CExample& RightSides)

{

nSize=RightSides.nSize; //复制常规成员

char *temp=new char[nSize]; //复制指针指向的内容

memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

delete []pBuffer; //删除原指针指向内容 (将删除操作放在后面，避免X=X特殊情况下，内容的丢失)

pBuffer=temp; //建立新指向

return *this

}

////////////////////////////////////

void main()

{

String a("zhangbufeng");

String b("cuixiaoyuan");

String c(a);

c=b;

}

运行结果如下：Constructing

Constructing

Constructing Copy

Operator ＝ Function

Destructing

Destructing

Destructing

4.赋值拷贝构造函数

运用Copy函数和Copy assignment函数进行赋值操作应该注意的两点:

1) 复制所有local成员变量

2) 调用所有基类内的适当的copying函数。

这里面有一个很可怕的规则:当你不用编译器默认的拷贝函数或者赋值函数时，编译器也不会对你自己写的这两个函数进行报警。所以必须要很谨慎和小心。

对于没有继承的类来说，写这两个函数一般注意指针类型的复制就可以了

Class Base{

Public:

Base(Base& base);

Base& operator=(const Base& base);

Private:

char* name;

int age;

};

Base& Base::operator=(const Base& base)

{

if(strcmp(name,base .name) = = 0) return *this; //自我复制的检测

name = new char[strlen(base.name)+1];

strcpy(name,base.name);

return *this;

}

如果后来增加了一个int age，但operator=里面什么都没有做，编译器不会出错！！

还有一种是对于继承类:

Class SubBase : public Base

{

public:

SubBase(SubBase& subbase);

SubBase& operator=(const SubBase& subbase);

pirvate:

int subage;

};

如果

SubBase::SubBase(SubBase &subbase)

：subage(subbase . subage) //这样做就够了吗？

{

}

SubBase& SubBase::operator=(const SubBase& subbase)

{

subage = subbase . subbase; //这样做就够了吗？

return *this;

}

如果仅仅这样，就说明了当进行Coyp构造函数时，实际上真正赋值的对象只有子类SubBase类中的subbase;而基类里面并没有实现正确赋值，因为你没有显示的调用基类的的这Copy构造函数，没有显示调用，编译器就会默认使用无参构造函数进行初始化。

调用到copy assignment函数时是对基类的所有东西不做任何操作。

怎么办？

SubBase::SubBase(SubBase &subbase)//

: Base(subbase);

,subage(subbase . subage)

{

}

SubBase& SubBase::operator=(const SubBase& subbase)

{

subage = subbase . subbase;

Base::operator=(subbase);//基类有private类型的量，无法直接调用。

return *this;

}

５）、拷贝构造函数使用赋值运算符重载的代码。

CExample::CExample(const CExample& RightSides)

{

pBuffer=NULL;

*this=RightSides //调用重载后的"="

}

CExample& operator = (const CExample& instance)

{

if(this == &instance) {

return *this;

}

nSize= instance.nSize;

if(NULL != pBuffer) {

delete [] pBuffer;

}

pBuffer = new char[nSize];

if(NULL != pBuffer) {

strncpy(pBuffer , instance.pBuffer , nSize);

}

return *this;

}

1,char temp=new char[nSize]; //复制指针指向的内容

char* temp = new char[nSize];

2,delete pBuffer;

delete[] pBuffer;