C++拷贝构造函数

拷贝构造函数

对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a; 
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。

本文地址：http://www.cnblogs.com/archimedes/p/cpp-copy-constructor.html，转载请注明源地址。

1、对象的定义形式

C++支持两种定义形式：直接初始化和复制初始化，复制初始化采用=符号，直接初始化将初始化式放在圆括号中

用于类类型对象时，直接初始化直接调用与实参匹配的构造函数，复制初始化总是调用拷贝构造函数，复制初始化首先使用指定构造函数创建一个临时对象，然后拷贝构造函数将那个临时对象拷贝到正在创建的对象

string null_book="9-454-45546"； //复制初始化
string dots(10,'.');    //直接初始化
string empty_copy=string();  //复制初始化
string empty_direct;   //直接初始化

通常，直接初始化和复制初试化只在低级别优化上存在差异，但是对于不支持复制的类型，或者使用非explicit构造函数的时候，它们就有本质的区别：

ifstream file1("filename");  //ok
ifstream file2="filename";  //error! 复制构造函数是私有的

2、形参与返回值

当形参是非引用类型的时候，将复制实参的值，以非引用类型作为返回值的时候，将返回return语句中值的副本

3、初始化容器元素

复制初始化函数可用于初始化顺序容器中的元素，容器的这种构造方式使用了默认构造函数和拷贝构造函数：

vector<string> svec(5);

4、构造函数与数组元素

如果没有为类类型数组提供元素的初始化形式，则将使用默认构造函数初始化每个元素，然而，如果使用常规的花括号括住的数组初始化列表来提供显示元素的初始化式，则使用复制初始化来初始化每个元素：

A a[]={ string("hdsf"),
    string("weiyrw"),
    string("cxvbc"),
    A()
};

合成的拷贝构造函数

如果没有定义拷贝构造函数，编译器会为我们合成一个，即使我们定义了其他的构造函数，也会合成拷贝构造函数。合成拷贝构造函数的行为是，执行逐个成员的初始化。编译器将现有对象的每个非static成员，依次复制到正创建的对象，合成拷贝构造函数直接复制内置类型成员的值，类类型成员使用该类的拷贝构造函数进行复制，数组成员使用合成拷贝构造函数将复制数组的每一个元素

class A{
private:
    string s;
    int n;
    double b;
};

A::A(const A &a):s(a.s),n(a.n),b(a.b){}

定义自己的拷贝构造函数

class A{
public:
    A();
    A(const &A);
    //......
};

下面看一个类对象拷贝的简单例子：

#include<iostream>
using namespace std;

class A{
private:
    int n;
public:
    A(int m) { n=m;}
    void print()
    {
        cout<<n<<endl;
    }
};
int main()
{
    A a(100);
    A a1=a;
    a1.print();
    return 0;
}

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象a1分配了内存并完成了与对象a的拷贝过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝函数的工作过程:

#include<iostream>
using namespace std;
class A{
private:
    int n;
public:
    A(int m)
    { n=m;}
    A(const A& c) {n=c.n;}
    void print()
    {
        cout<<n<<endl;
    }
};
int main()
{
    A a(100);
    A a1=a;
    a1.print();
    return 0;
}

 A(const A& c)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体 
一个对象以值传递的方式从函数返回 
一个对象需要通过另外一个对象进行初始化

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝

　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子：

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
class A{
private:
    int n;
    char *s;
public:
    A(int m, char* str)
    {
        n=m;
        s=new char[m];
        strcpy(s,str);
    }
    A(const A& c)
    {
        n=c.n;
        s=new char[n]; //深拷贝
        if(s!=NULL)
            strcpy(s,c.s);
    }
    void print()
    {
        cout<<s<<endl;
    }
    ~A()
    {
        delete s;
    }
};
int main()
{
    A a(100,"string");
    A a1=a;
    a1.print();
    return 0;
}

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

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

    拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程

禁止复制

拷贝构造函数是私有的，将不允许用户代码复制该类类型的对象，但是类的友元和成员仍可以进行复制，如果连类的友元和成员也禁止，可以声明一个private构造函数但是不对其定义