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

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

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

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

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。
实例：
#include
using namespace std;
class CA
{
   public:
     CA(int b, string s) :  a(b), str(s) {}  //显示定义 构造函数初始化列表
     CA(const CA& C) :   a(C.a), str(C.str) {}  // 显示定义复制构造函数列表
     void show();
     ~CA() {};

   private:
      int a;
     string str;
};

void CA::show()
{
     cout << this->a << " , " << this->str << endl; 
}

int main()
{
 string s="Hello";

 CA A(10, s);  //调用构造函数
 CA B=A;    // 调用复制构造函数
 B.show(); 

 return 2013;
}

浅拷贝和深拷贝

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

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

#include
using namespace std;


class CA
{
   public:
     CA(int b, char*cstr);  //构造函数
     CA(const CA& C);    //复制构造函数
     void show();
     ~CA();

   private:
     int a;
     char* str;
};

CA::CA(int b, char* cstr)
{
 this->a = b;
 this->str = new char[b];
 if(this->str)
  strcpy(this->str, cstr);
}

CA::CA(const CA& C)
{
 this->a = C.a;   // C.a 此处正确，即使a为private，类的成员函数中可以访问其所有成员，此处有点特殊。
 this->str = new char[C.a];
 if(this->str)
  strcpy(this->str, C.str);
}

CA::~CA()
{
 delete str;
}

void CA::show()
{
 cout << this->a << " , " << this->str << endl; 
}

int main()
{
 CA A(10, "Hello"); //调用构造函数
 CA B=A;        // 调用复制构造函数
 B.show();

// cout << B.a <

 return 2013;
}