什么时候会用到拷贝构造函数？

一、什么时候会用到拷贝构造函数？ 

          拷贝构造函数 Person(const Person & per) 特点：具有单个形参（常用const修饰，是对本身类类型的引用，因为是要拷贝同类型（相同类）的对象）

1当用类的一个对象初始化该类的另一个对象时.例如:

C/C++ code

?

1 2 3 4 5

int  main() {     point A(1,2);     point B(A); //用对象A初始化对象B,拷贝构造函数被调用. }

2 如果函数的形参是类的对象,调用函数时,进行形参和实参结合时.

C/C++ code

?

1 2 3 4 5 6 7 8

void  f(point p) { } main() {     point A(1,2);     f(A); //函数的形参为类的对象时,当调用函数时,拷贝构造函数被调用. }

3 如果函数的返回值是类的对象,函数执行完成返回调用者时. C/C++ code

?

1 2 3 4 5 6 7 8 9 10

point g() {     point A(1,2);     return  A; //函数的返回值是类的对象,返回函数值时,调用拷贝构造函数. } void  main() {       point B;     B = g(); }

二、什么时候有必要用拷贝构造函数？（类有有指针成员、创建新对象时候做特定的工作）

上述3种情况，如果没有涉及到深拷贝问题，就没有必要自己来编写拷贝构造函数，编译器有默认的可以很完美的完成任务
还一种情况就是变态的拷贝：在拷内过程中进行缩放，放大等处理，不过没什么用

//关于深拷贝 以下是引用：traceback:http://www.netology.cn/blog/user1/bachelor/archives/2006/375.html

如果一个类中含有指针成员变量，则在利用一个已存在对象构造新的对象时，就会面临两种选择：深拷贝和浅拷贝。
1. 浅拷贝只是将对象间对应的指针成员变量进行简单的拷贝，即拷贝结束后新旧对象的指针指向相同的资源（指针的值是相同的）；这种拷贝会导致对象的成员不可用（当一个对象 destory后，另一个对象的指针成员不能访问），如下例：
     class Person
     {
        public :
        //....
        char * home;//the person's home 
        void SetHome(char * str)
        {home = str;}
        ~Person()
         {
           //...
           delete [] home;
         }
     }
    //....
    char * place = new char [20];
    strcpy(place,"China");
    Person *A = new Person();
    A->SetHome(place);
    
    Person * B= Person(A);
    delete A;
   //....
   此时对象A 和对象B的成员home值相同,如果A对象 destroy，则对象B的成员home指向的地址变为不可用（对象A撤销时将home指向的资源释放了）。

2. 深拷贝是相对于浅拷贝而言的，为了避免上述情况的发生，将上例中的代码改造：对象拷贝时将指针指向的内容拷贝，代码如下：
   class Person
     {
        public :
        //....
        char * home;//the person's home 
        void SetHome(char * str)
        {home = str;}
        
        Person & Person(const Person & per) //自己定义的拷贝构造函数
        {
             //...
             if(* this == per)//copy itself
     return *this;
             home = new char[strlen(per.home) +1];//alloc new memory
    strcpy(home,per.home);
    return * this;
        } 
        ~Person()
         {
           //...
           delete [] home;
         }
     }
  深拷贝之后，新旧对象的home成员指向的内容的值相同，而其自身的值不同。这样就可避免出现其中之一
  destroy 之后，另一对象的home成员不可用。

深拷贝缺点：（指针成员指向的数据量很大时)

  但是，此种开辟新的内存区域然后赋值拷贝的方法在面临指针成员指向的数据量很大时出现效率低下的问题，因此又有下面的处理方法：为指针保留引用计数（reference counting）。
  当类每次拷贝这个指针时，就增加它的计数；对象destroy时检察指针的引用计数，如果为0就删除其指向的资源，否则计数减小。如果指针所指数据相对恒定是，指针引用计数尤为有效。而且在数据量庞大的时候，可以有较高的执行效率。

虽然引用计数的处理方法貌似不错，但是其亦存在其弊端：在多线程的条件下，其执行效率尤为低下。