C++复制构造函数和拷贝构造函数

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)。

1. 何时调用复制构造函数

    复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下：

    class_name（const class_name&）；

    它接受一个指向类对象的常量引用作为参数。例如，String类的复制构造函数的原型如下：

    String（const String&）；

    新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。这在很多情况下都可能发生，最常见的情况是将新对象显示地初始化为现有的对象。例如，假设motto是一个String对象，则下面4种声明都将调用复制构造函数：

    String ditto（motto）；

    String metoo = motto；

    String also = String（motto）；

    String *pString = new String（motto）；

    其中中间的2种声明可能会使用复制构造函数直接创建metto和also，也可能会使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给metoo和also，这取决于具体的实现。最后一种声明使用motto初始化一个匿名对象，并将新对象的地址赋给pString指针。

    2. 何时调用赋值构造函数

    赋值构造函数是通过重载赋值操作符实现的，这种操作符的原型如下：

    Class_name& Class_name：：operator=（const Class_name&）；

    它接受并返回一个指向类对象的引用。例如，String 类的赋值操作符的原型如下：

    String& String：：operator=（const String&）；

    将已有的对象赋给另一个对象时，将使用重载的赋值操作符：

    String headline1（"test"）；

    String knot；

    knot = headline1；

    初始化对象时，并不一定会使用赋值操作符：

    String metoo = knot；

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

#include <iostream>
using namespace std;

class Test
{
public:
	Test();
	~Test();
	Test(const Test& t);
	Test& operator=(const Test& t);

private:
	int t1;
};

Test::Test()
{
	cout<<"调用构造函数"<<endl;
}

Test::~Test()
{
	cout<<"调用析构函数"<<endl;
}

Test::Test(const Test& t)
{
	cout<<"调用复制构造函数"<<endl;
}

Test& Test::operator =(const Test& t)
{
	cout<<"调用赋值构造函数"<<endl;
	t1 = t.t1;
	return *this;
}

void main()
{
	Test t1;
	Test t2 = t1;
	Test t3;
	t3 = t1;
}

输出如下：