copy constructor

构造函数和析构函数都没返回值（注意不是返回值为void，而是没有）

构造函数的重载
1.应该注意的是，构造函数是public的（因为他是在创建对象时调用的，如果不是public，在类

外的对象声明就相当于访问了类的私有（private）或者保护（protected），是不允许的）
2。构造函数没有返回类型（也不能写void）

 

 

构造函数、析构函数、拷贝构造函数，赋值函数都可以被c++编译器默认，如果不显示声明出来的

话，但是为什么还要对构造函数提供重载呢？为什么很多时候我们需要自己写析构函数呢？为什

么还要自己写拷贝构造函数和赋值函数呢？

 

先解释前面两个问题。为什么需要自己去写构造函数和析构函数呢？ 如果我们使用默认的构造函

数和析构函数，就意味着我们在构造函数里面对于指针p只能初始化为NULL，int i只能为0。放弃

了我们按照需要自己初始化成员变量的权利。析构函数也一样。
后面的两个问题会在拷贝构造函数中详细回答。

 

拷贝构造函数
如果我们不自己写拷贝构造函数的话，编译器就会以默认的“按成员拷贝”的方式自动的生成默认

的拷贝构造函数。如果类定义中有指针或者引用变量的时候就会出现一些隐患。我们来看一个最

简单的情况：所有的数据成员都是基本类型（如果数据成员有其他类型，可以递归的访问默认（

或者定义）的拷贝构造函数，到最后也是只剩下基本数据类型），因为基本数据类型拷贝的时候

是按位（bit）进行的，比如指针类型，拷贝给新的对象后结果是原来的对象和新的对象的指针指

向了同一个地址空间，对于引用也一样。这可能不是我们想看到的。当我们把原来的对象销毁后

再去访问新的对象的话，意味着指针变成了野指针，访问出错。

相对于拷贝构造函数，拷贝赋值函数也有类似的隐患。

要是自己可以定义拷贝构造函数在函数运行的过程中不让两个指针指向同一个地址，就相当于我

么必须把动态申请的资源（指针所指的内容）也复制一份。这种情况称之为深拷贝，前面的对应

的称之为浅拷贝。

下面是一个深拷贝的例子：
#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;
}

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这

个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程

并未复制资源的情况视为浅拷贝。

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

我的例子

#include <cstdlib>
#include <iostream>
using namespace std;
class Obj
{
      private:
              int a;
              char* str;
      public:
             Obj(int b,char* cstr)
             {
                     a=b;
                     str=new char[b];
                     if(str!=0)
                               strcpy(str,cstr);
             }    
             Obj(const Obj& o)
             {
                       a=o.a;
                       str=new char[a];//深层拷贝
                       if(str!=0)
                                 strcpy(str,o.str);
             }

             void show()
             {
                  cout<<str<<endl;
             }
             ~Obj()
             {
                   delete str;
             }
};

int main(void)
{
    Obj a(6,"hello");
    a.show();
    //a.~Obj();//析构以后str所在的内存空间就是随机的值
    Obj b=a;
    b.show();
    cout<<&a<<"/t"<<&b<<endl; //a和b的地址确实不同，但是这并不代表堆中对象的地址（估计只是栈中对象指针存储的地址！！！）
    //如果不写拷贝构造函数，编译器会给一个默认拷贝构造函数，此时为浅拷贝，ab指向同一空间
    //如果a被析构，那么b对象就没有资源了，显然出错
    //深层拷贝的话就不会出现这种问题
    a.~Obj();
    a.show();
    b.show();//如果使用自定义的深层拷贝，那么即使a中str的资源释放掉，b对象还是照样不受影响
    
   
   
    system("pause");
    return 1;
}

文章出处：DIY部落(http://www.diybl.com/course/3_program/c/c_js/20090303/157440.html)