拷贝构造函数

C++拷贝构造函数详解

拷贝构造函数的声明

  A(const A& a);

using namespace std;class A{        public:                int x,y;                A();                A(const A& a);                ~A();};A::A(){        cout << "A create"<<endl;}A::A(const A& a){        cout << "copy" << endl;        x = a.x;        y = a.y;}A::~A(){        cout << "A destroy"<<endl;}int main(){        A a;        a.x = 10;        // 拷贝对象        A b = a;        // 和上一行效果相同，都会调用拷贝构造函数        A c(a);        return 0;}

拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它必须的一个参数是本类型的一个引用变量。

调用拷贝构造函数的三种情况

1. 以值传递传入函数参数
2. 以值传递方式从函数返回
3. 直接拷贝

void test(A a){        cout << a.x << endl;}A test2(){        A a;        return a;}int main(){        A a;        a.x = 10;        //第一种调用拷贝构造函数的方式        A b = a;        // 和上一行效果相同        A c(a);        //第二种调用拷贝构造函数的方式        test(a);        //第三种调用拷贝构造函数的方式        test2();        return 0;}

默认拷贝构造函数

很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值，它一般具有以下形式：

Rect::Rect(const Rect& r)  {      width = r.width;      height = r.height;  }  

默认拷贝构造函数没有处理静态数据成员。

如果我们要用一个静态变量记下对象的生成数量，除了构造函数和析构函数外，在拷贝构造函数中也应该有相应的逻辑处理。如：

class Rect  {  public:      Rect()      // 构造函数，计数器加1      {          count++;      }      Rect(const Rect& r)   // 拷贝构造函数      {          width = r.width;          height = r.height;          count++;          // 计数器加1      }      ~Rect()     // 析构函数，计数器减1      {          count--;      }      static int getCount()   // 返回计数器的值      {          return count;      }  private:      int width;      int height;      static int count;       // 一静态成员做为计数器  };  

浅拷贝

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了，让我们考虑如下一段代码：

class Rect  {  public:      Rect()      // 构造函数，p指向堆中分配的一空间      {          p = new int(100);      }      ~Rect()     // 析构函数，释放动态分配的空间      {          if(p != NULL)          {              delete p;          }      }  private:      int width;      int height;      int *p;     // 一指针成员  };  int main()  {      Rect rect1;      Rect rect2(rect1);   // 复制对象      return 0;  }  

在这段代码运行结束之前，会出现一个运行错误。

在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间，这不是我们所期望的结果，在销毁对象时，两个对象的析构函数将对同一个内存空间释放两次，这就是错误出现的原因。我们需要的不是两个p有相同的值，而是两个p指向的空间有相同的值，解决办法就是使用“深拷贝”。

深拷贝

在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间，如上面的例子就应该按照如下的方式进行处理：

class Rect  {  public:      Rect()      // 构造函数，p指向堆中分配的一空间      {          p = new int(100);      }      Rect(const Rect& r)      {          width = r.width;          height = r.height;          p = new int;    // 为新对象重新动态分配空间          *p = *(r.p);      }      ~Rect()     // 析构函数，释放动态分配的空间      {          if(p != NULL)          {              delete p;          }      }  private:      int width;      int height;      int *p;     // 一指针成员  };  

此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”。

防止默认拷贝发生

通过对对象复制的分析，我们发现对象的复制大多在进行“值传递”时发生，这里有一个小技巧可以防止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数，这样因为拷贝构造函数是私有的，如果用户试图按值传递或函数返回该类对象，将得到一个编译错误，从而可以避免按值传递或返回对象。

// 防止按值传递  class CExample   {  private:      int a;  public:      //构造函数      CExample(int b)      {           a = b;          cout<<"creat: "<<a<<endl;      }  private:      //拷贝构造，只是声明      CExample(const CExample& C);  public:      ~CExample()      {          cout<< "delete: "<<a<<endl;      }      void Show ()      {          cout<<a<<endl;      }  };  //全局函数  void g_Fun(CExample C)  {      cout<<"test"<<endl;  }  int main()  {      CExample test(1);      //g_Fun(test); 按值传递将出错      return 0;  }   

拷贝构造函数的几个细节

拷贝构造函数里能调用private成员变量吗?

拷贝构造函数其时就是一个特殊的构造函数，操作的还是自己类的成员变量，所以不受private的限制。

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

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

解答：对于一个类X, 如果一个构造函数的第一个参数是下列之一:
- X&
- const X&
- volatile X&
- const volatile X&

且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.

X::X(const X&);  //是拷贝构造函数      X::X(X&, int=1); //是拷贝构造函数     X::X(X&, int a=1, int b=2); //当然也是拷贝构造函数  

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

解答：类中可以存在超过一个拷贝构造函数。

class X {   public:           X(const X&);      // const 的拷贝构造    X(X&);            // 非const的拷贝构造  };  

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

class X {      public:    X();        X(X&);  };      const X cx;      X x = cx;    // error  

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