复制构造函数，赋值操作符重载之间的区别

1. 何时调用拷贝（复制）构造函数：

   StringBad ditto (motto);   
   StringBad metoo = motto; 
   StringBad also = StringBad(motto); 
   StringBad * pStringBad = new StringBad (motto);

   以上4中方式都将调用：StringBad(const StringBad &)

   • 其中中间两种声明可能会使用复制构造函数直接创建metoo和also对象，也可能使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给metoo和also，这取决于具体的实现。最后一种声明使用motto初始化一个匿名对象，并将新对象的地址赋给pStringBad指针。
   • 每当程序生成了对象副本时，编译器都将使用复制构造函数。具体的说，当函数按值传递对象或函数返回对象时，都将使用复制构造函数。记住，按值传递意味着创建原始变量的一个副本。
   • 编译器生成临时对象时，也将使用复制构造函数。例如，将3个Vector对象相加时，编译器可能生成临时的Vector对象来保存中间的结果。
   • 另外，String sailor = sports;等价于String sailor = (String)sports;因此调用的是拷贝构造函数

2. 何时调用赋值运算符：

   • 将已有的对象赋给另一个对象时，将调用重载的赋值运算符。
   • 初始化对象时，并不一定会使用赋值操作符：

     StringBad metoo=knot;   // use copy constructor, possibly assignment, too

     这里，metoo是一个新创建的对象，被初始化为knot的值，因此使用赋值构造函数。不过，正如前面指出的，实现时也可能分两步来处理这条语句：使用复制构造函数创建一个临时对象，然后通过赋值操作符将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用=操作符时也可能调用赋值构造函数。

   与复制构造函数相似，赋值运算符的隐式实现也对成员进行逐个复制。如果成员本身就是类对象，则程序将使用为这个类定义的赋值运算符来复制该成员，但静态数据成员不受影响。

3. 赋值运算符和拷贝构造函数在实现上的区别：

   • 由于目标对象可能引用了以前分配的数据，所以函数应使用delete[]来释放这些数据。
   • 函数应当避免将对象赋给自身；否则给对象重新赋值前，释放内存操作可能删除对象的内容。
   • 函数返回一个指向调用对象的引用（方便串联使用），而拷贝构造函数没有返回值。

   下面的代码说明了如何为StringBad类编写赋值操作符：

   StringBad & StringBad::operator=(const StringBad & st)
   {
    if(this == & st)
       return * this;
    delete [] str;
    len = st.len;
    str = new char [len + 1];
    strcpy(str,st.str);
    return *this;
   }

   代码首先检查自我复制，这是通过查看赋值操作符右边的地址(&s)是否与接收对象(this)的地址相同来完成的，如果相同，程序将返回*this,然后结束。
   如果不同，释放str指向的内存，这是因为稍后将把一个新字符串的地址赋给str。如果不首先使用delete操作符，则上述字符串将保留在内存中。由于程序程序不再包含指向字符串的指针，一次这些内存被浪费掉。
   接下来的操作与复制构造函数相似，即为新字符串分配足够的内存空间，然后复制字符串。
   赋值操作并不创建新的对象，因此不需要调整静态数据成员num_strings的值。

4. class TestChild
   {
   public:
       TestChild()
       {
           x=0;
           y=0;
           printf("TestChild: Constructor be called!\n");
       }
       ~TestChild(){}
       TestChild(const TestChild& tc)
       {
           x=tc.x;
           y=tc.y;
           printf("TestChild: Copy Constructor called!//因为写在了Test(拷贝)构造函数的初始化列表里\n");
       }
       
       const TestChild& operator=(const TestChild& right)
       {
           x=right.x;
           y=right.y;
           printf("TestChild: Operator = be called! //因为写在了Test(拷贝)构造函数的函数体里\n");
           return *this;
       }
   
       int x,y;
   };
   
   class Test
   {
   public:
   
       Test(){printf("Test:      Constructor be called!\n");}
       explicit Test(const TestChild& tcc)
       {
           tc=tcc;
       }
       ~Test(){}
       Test(const Test& test):tc(test.tc)
       {
           tc=test.tc;
           printf("Test:      Copy Constructor be called!\n");
       }
   
       const Test & operator=(const Test& right)
       {
           tc=right.tc;
           printf("Test:      Operator= be called!\n");
           return *this;
       }
   
       TestChild tc;
   };
   
   int main()
   {
       printf("1、Test中包含一个TestChild，这两个类分别具有构造函数、\n   拷贝构造函数、重载operator=。\n\n");
       printf("2、在调用Test的构造函数和拷贝构造函数之前，会根据跟在\n   这些函数后的初始化列表去初始化其\n   TestChild变量（调用TestChild的拷贝构造函数去初始化）\n\n");
       printf("3、一旦进入Test的构造函数体或拷贝构造函数体，则说明其成员变量TestChild已\n   经通过TestChild的构造函数或TestChild的拷贝构造函数构造出了对象\n");
       printf("   所以，在Test的构造函数体或拷贝构造函数体中，再去使用=号\n   给TestChild的时候，调用的就是TestChild的operator=，\n   而不是TestChild的拷贝构造函数了\n");
       printf("   这就是Test构造函数后面 “:” 初始化列表的存在意义！（\n   为了调用成员变量的构造函数或者拷贝构造函数）\n\n");
       printf("4、最后！揪出让人困惑的终极原因！！！！！\n   Test test2=test1和Test test2(test1)这两种是TM一模一样的\n   （都调用拷贝构造函数）！！！！除了这点儿之外，其他地方都是该是什么是什么（\"()\"调用构造函数，\"=\"调用赋值操作符）！！！\n\n");
       printf("5、一个对象初始化完毕后，所有对这个对象的赋值都调用operator=\n\n输出如下：");
   
       printf("Test test1; DO:\n");
       Test test1;
       printf("\n");
       printf("Test test2=test1; DO:\n");
       Test test2=test1;
       printf("\n");
       printf("Test test3(test2); DO:\n");
       Test test3(test2);
       printf("\n");
       printf("test3=test1; DO:\n");
       test3=test1;
   
        return 0;
   }