详解拷贝构造函数

类X的拷贝构造函数的形式为X(X& x)。

 

1、什么时候会用到拷贝构造函数？
     当任何你想复印东西的时候，而不管东西被复印成什么样子。即任何你想利用一个已有的类实例给另一个类实例赋值时，这种赋值可能是显式的，也可能是隐式的
显式：classa_1=class_2;
隐式：函数的形参有用到类对象却没有用引用或传址技术时
      函数的返回值是一个对象也没有应用传址技术时
2、什么时候有必要用拷贝构造函数？
    上述3种情况，如果没有涉及到深拷贝问题，就没有必要自己来编写拷贝构造函数，编译器有默认的可以很完美的完成任务，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝。

 

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

class AB {      int t; public:      AB(int b) {t=b;}      void Show()  { cout<<t<<endl; }      AB(const AB& C) { t=C.t; }     //此行可省。  };   int main() {   AB a(100);   AB b = a;   b.Show();  //output 100   return 0; }

浅拷贝和深拷贝
　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

拷贝构造函数和赋值运算符

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

以下讨论中将用到的例子:

class CExample

{

public:

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

       ~CExample(){delete pBuffer;}

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

    CExample(const CExample&); //拷贝构造函数,如果没有它就是浅拷贝。

private:

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

       int nSize;

};

 

CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义

{

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

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

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

}

 

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

{

CExample theObjone;

       theObjone.Init(40);

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

       CExample theObjtwo=theObjone;

}

 

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

BOOL testfunc(CExample obj);

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

 

BOOL testfunc(CExample obj)

{

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

}

赋值符的重载

下面的代码与上例相似

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

{

       CExample theObjone;

       theObjone.Init(40);

      

       CExample theObjthree;

       theObjthree.Init(60);

 

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

       theObjthree=theObjone;

       return 0;

}

也用到了"="号，但与上面的例子并不同，上面的例子中，"="在对象声明语句中，表示初始化。更多时候,这种初始化也可用括号表示。例如 CExample theObjone(theObjtwo)。

而本例子中，"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;，这其中涉及到对象theObjthree原有内容的丢弃，新内容的复制。但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。由于对象内包含指针，将造成不良后果:指针的值被丢弃了，但指针指向的内容并未释放。指针的值被复制了，但指针所指内容并未复制。

因此，包含动态分配成员的类除提供拷贝构造函数外，还应该考虑重载"="赋值操作符号。

 

这样，类定义要变为:

class CExample

{

       ...

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

       CExample& operator = (const CExample&); //赋值符重载

       ...

}

 

//赋值操作符重载

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

}

 

此时，拷贝构造函数使用赋值运算符重载的代码：

CExample::CExample(const CExample& RightSides)

{

pBuffer=NULL;

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

}

相关的三个问题:

1. 以下函数哪个是拷贝构造函数,为什么?

1. X::X(const X&);   
2. X::X(X);   
3. X::X(X&, int a=1);   
4. X::X(X&, int a=1, b=2);  

2. 一个类中可以存在多于一个的拷贝构造函数吗?

3. 写出以下程序段的输出结果, 并说明为什么? 如果你都能回答无误的话，那么你已经对拷贝构造函数有了相当的了解。

1. struct X {   
2.   template<typename T>   
3.   X( T& ) { std::cout << "This is ctor." << std::endl; }   
4.   
5.   template<typename T>   
6.     X& operator=( T& ) { std::cout << "This is ctor." << std::endl; }   
7. };   
8.   
9. void main() {   
10.   X a(5);   
11.   X b(10.5);   
12.   X c = a;   
13.   c = b;   
14. }  

解答如下：

1. 对于一个类X,如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数. 

1. X::X(const X&);  //是拷贝构造函数   
2. X::X(X&, int=1); //是拷贝构造函数  

 2.类中可以存在超过一个拷贝构造函数, 

1. class X {      
2. public:      
3.   X(const X&);      
4.   X(X&);            // OK   
5. };  

注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.

1. class X {   
2. public:   
3.   X();   
4.   X(X&);   
5. };   
6.     
7. const X cx;   
8. X x = cx;    // error   

如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数.
这个默认的参数可能为X::X(const X&)或X::X(X&),由编译器根据上下文决定选择哪一个.

默认拷贝构造函数的行为如下:
 默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造.
 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作.
 a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数.
 b)如果数据成员是一个数组,对数组的每一个执行按位拷贝. 
 c)如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符对其进行赋值.

3.  拷贝构造函数不能由成员函数模版生成. 

1. struct X {   
2.     template<typename T>   
3.     X( const T& );    // NOT copy ctor, T can't be X   
4.   
5.     template<typename T>   
6.     operator=( const T& );  // NOT copy ass't, T can't be X   
7. };   

原因很简单, 成员函数模版并不改变语言的规则,而语言的规则说,如果程序需要一个拷贝构造函数而你没有声明它,那么编译器会为你自动生成一个. 所以成员函数模版并不会阻止编译器生成拷贝构造函数, 赋值运算符重载也遵循同样的规则.(参见Effective C++ 3edition, Item45)。