C++ 拷贝构造函数(深拷贝，浅拷贝)


对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a;
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。


#include <iostream>
using namespace std;

class CExample {
private:
    　int a;
public:
    　CExample(int b)
    　{ a=b;}
    　void Show ()
    　{
        cout<<a<<endl;
    }
};

int main()
{
    　CExample A(100);
    　CExample B=A;
    　B.Show ();
    　return 0;
}

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。


#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    CExample(int b)
    { a=b;}
   
    CExample(const CExample& C)
    {
        a=C.a;
    }
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B=A;
    B.Show ();
    return 0;
}

CExample(const
CExample&
C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X&
x)。


当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化。


如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。


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

浅拷贝和深拷贝


　　在某些状况下，类内成员变量需要动态开辟堆内存，如果
实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内
存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。


　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。


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


深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。


浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。


        Test(Test
&c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动
调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test
&c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。

转自：http://www.cnblogs.com/BlueTzar/articles/1223313.html
__________________________________________________________________

拷贝构造函数是C++最基础的概念之一，大家自认为对拷贝构造函数了解么？请大家先回答一下三个问题:


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. #include <iostream></iostream>
     
     
  2. #include <string></string>
     
     
  3.  
  4. struct X {
     
  5.   template<typename T>
     
  6.   X( T& ) { std::cout << "This is ctor." << std::endl; }
     
  7.  
  8.   template<typename T>
     
  9.     X& operator=( T& ) { std::cout << "This is ctor." << std::endl; }
     
  10. };  
  11.  
  12. void main() {
     
  13.   X a(5);  
  14.   X b(10.5);  
  15.   X c = a;  
  16.   c = b;  
  17. } 


解答如下：


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. };  
  8.  

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


转自：
http://cpp-circle.group.javaeye.com/group/blog/43289

posted @ 2011-05-10 22:06  BloodAndBone  Views(695)  Comments(0)  Edit  收藏  举报