拷贝构造函数

 

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

            上面这个例子只是简单的对象相互之间的赋值；

拷贝构造函数运用的几个场合

　在C++中，下面三种对象需要调用拷贝构造函数（有时也称“复制构造函数”）：

　　1) 一个对象作为函数参数，以值传递的方式传入函数体；

　　2) 一个对象作为函数返回值，以值传递的方式从函数返回；

　　3) 一个对象用于给另外一个对象进行初始化（常称为复制初始化）；

        三点的共同之处在于，需要将一个类的对象赋值给一个类的引用；

浅拷贝

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

深拷贝

  code B:

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

 

深拷贝和浅拷贝产生的原因：

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

 

深拷贝和浅拷贝可以简单理解为：

               如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

 

         比如 code B 中

CA(const CA& C)// 拷贝构造函数定义
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
  

          深拷贝就发生在　str=new char[a];   因为我们希望str能指向一个新的内存区域；

 

         另外

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