C++拷贝构造函数和operator=

1 拷贝构造函数参数的特点
对于一个类X,如果一个构造函数的第一个参数是下列之一:
a) X&
b) const X&
c) volatile X&
d) const volatile X&
因此 X::X(X&, int=1); //是拷贝构造函数
并且类中可以存在超过一个拷贝构造函数。拷贝构造函数采用引用作参数原因：
1) 效率 。
2) 避免死循环。 当一个对象需要以值方式传递时，编译器会生成代码调用它的拷贝构造函数以生成一个复本，因此当使用拷贝构造函数时会造成死循环。

2 默认拷贝构造函数
如果一个类中没有定义拷贝构造函数，那么编译器会自动产生一个默认的拷贝构造函数。这个默认的参数可能为X::X(const X&)或X::X(X&)，由编译器根据上下文决定选择哪一个。默认拷贝构造函数的行为如下（递归的）(默认的构造函数X()、默认的拷贝赋值函数X& operator=(X& a) 被调用时行为同理)：
首先调用父类拷贝构造函数。然后拷贝构造函数对类中每一个数据成员执行成员拷贝的动作：
a) 如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数。
b) 如果数据成员是一个数组(或指针、引用),对数组的每一个执行按位拷贝。
c) 如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符对其进行赋值。
注：如果父类或成员的类提供的拷贝构造函数为private，则不能通过编译。这一点对默认的构造函数和默认的拷贝赋值函数被调用时同样适用，因此最好自己定义这三个函数和析构函数。

3 拷贝构造函数调用时机
以下情况都会调用拷贝构造函数：
1) 一个对象以值传递的方式传入函数体。
2) 一个对象以值传递的方式从函数返回。
3) 一个对象需要通过另外一个对象进行初始化。

 

4 理解copy constructor和copy assignment的一个例子
class callwitch{
      string name ;
      static int objcount;
      public :
             callwitch(const string& na = "") : name(na) {
                   objcount ++;
                   print("callwitch(const string&)");
             };
             ~callwitch(){
                   objcount --;
                   print("~callwitch()");   
             }
             callwitch(const callwitch& obj):name(obj.name) {
                   name = "copy of " + name;
                   objcount ++;
                   print("copy constructor");
             };
             callwitch& operator=(callwitch& obj){
                   print("copy assignment");
             }
             void print(const string& msg = "")const {
                  if(msg.size() !=0)
                      cout << msg << endl ;
               cout << '/t' << name << ": " << "objcount = " << objcount << endl;
             }
};
int callwitch::objcount = 0 ;

callwitch f(callwitch obj)
{
   cout << "returning from f()" << endl;
   return obj ;
}
int main(int argc, char *argv[])
{
    callwitch c1("c1");
callwitch c2 = c1 ; //copy constructor called。因为此时c2还未被初始化成为对象(即还未构造出来)，无法调用copy assignment函数！
    callwitch c4 ;
    c4 = c1 ;               //copy assignment called
    c2.print("call f()");
    callwitch c3 = f(c1);
    cout << "call f(),no need return value" << endl;
    f(c1);
    system("PAUSE");
    return EXIT_SUCCESS;
}
以下是运行结果：
callwitch(int)
        c1: objcount = 1
copy constructor
        copy of c1: objcount = 2
callwitch(int)
        : objcount = 3
copy assignment
        : objcount = 3
call f()
        copy of c1: objcount = 3
copy constructor
        copy of c1: objcount = 4
returning from f()
copy constructor
        copy of copy of c1: objcount = 5
~callwitch()
        copy of c1: objcount = 4
call f(),no need return value
copy constructor
        copy of c1: objcount = 5
returning from f()
copy constructor
        copy of copy of c1: objcount = 6
~callwitch()
        copy of copy of c1: objcount = 5
~callwitch()
        copy of c1: objcount = 4

5 其它：
1)  最好自定义拷贝构造函数。如果使用编译器生成的拷贝构造函数，调用拷贝构造函数时实行位拷贝，当类内成员变量需要动态开辟堆内存时，执行classA obj1 ; classA obj2(obj1)。如果obj1中有一个成员变量指针已经申请了内存，那obj2中的那个成员变量也指向同一块内存。这就出现了问题：当obj1把内存释放后，obj2内的指针就是无效指针了，出现运行错误。
2) 最好自定义operator=。如果打算在一个内含reference成员、内含const成员时，必须自己定义copy assignment操作符，因为C++本身不允许引用改指不同的对象，也不允许更改const成员；如果base class将copy assignment操作声明为private，编译器同样拒绝为其derived class生成一个copy assignment操作符(effective C++ Item 6)。