C++构造函数详解（复制构造函数）

构造函数是干什么的

该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作，故：构造函数的作用：初始化对象的数据成员。

构造函数的种类

class Complex
{

private :
    double m_real;
    double m_imag;

public:

    // 无参数构造函数
    // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
    // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
    Complex(void)
    {
         m_real = 0.0;
         m_imag = 0.0;
    }

    // 一般构造函数（也称重载构造函数）
    // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
    // 例如：你还可以写一个 Complex( int num)的构造函数出来
    // 创建对象时根据传入的参数不同调用不同的构造函数
    Complex(double real, double imag)
    {
         m_real = real;
         m_imag = imag;
     }

    // 复制构造函数（也称为拷贝构造函数）
    // 复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
    // 若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询有关 “浅拷贝” 、“深拷贝”的文章论述
    Complex(const Complex & c)
    {
        // 将对象c中的数据成员值复制过来
        m_real = c.m_real;
        m_img  = c.m_img;
    }

    // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象
    // 例如：下面将根据一个double类型的对象创建了一个Complex对象
    Complex::Complex(double r)
    {
        m_real = r;
        m_imag = 0.0;
    }

    // 等号运算符重载
    // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
    // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
    Complex &operator=(const Complex &rhs)
    {
        // 首先检测等号右边的是否就是左边的对象本，若是本对象本身,则直接返回
        if ( this == &rhs )
        {
            return *this;
        }

        // 复制等号右边的成员到左边的对象中
        this->m_real = rhs.m_real;
        this->m_imag = rhs.m_imag;

        // 把等号左边的对象再次传出
        // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
        // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)
        return *this;
    }
};

下面使用上面定义的类对象来说明各个构造函数的用法：

void main()
{
    // 调用了无参构造函数，数据成员初值被赋为0.0
    Complex c1，c2;

    // 调用一般构造函数，数据成员初值被赋为指定值
    Complex c3(1.0,2.5);
    // 也可以使用下面的形式
    Complex c3 = Complex(1.0,2.5);

    // 把c3的数据成员的值赋值给c1
    // 由于c1已经事先被创建，故此处不会调用任何构造函数
    // 只会调用 = 号运算符重载函数
    c1 = c3;

    // 调用类型转换构造函数
    // 系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
    c2 = 5.2;

    // 调用拷贝构造函数( 有下面两种调用方式)
    Complex c5(c2);
    Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2

}

参考：http://www.cnblogs.com/xkfz007/archive/2012/05/11/2496447.html

复制构造函数

这是清华大学的教程中讲解，参考

=============================================================
对一个简单变量的初始化方法是用一个常量或变量初始化另一个变量，例如：
　　int m = 80；
　　int n = m；
　　我们已经会用构造函数初始化对象，那么我们能不能象简单变量的初始化一样，直接用一个对象来初始化另一个对象呢？答案是肯定的。我们以前面定义的Point类为例：
　　Point pt1(15, 25);
　　Point pt2 = pt1;
后一个语句也可以写成：
　　Point pt2( pt1);
它是用pt1初始化pt2，此时，pt2各个成员的值与pt1各个成员的值相同，也就是说，pt1各个成员的值被复制到pt2相应的成员当中。在这个初始化过程当中，实际上调用了一个复制构造函数。当我们没有显式定义一个复制构造函数时，编译器会隐式定义一个缺省的复制构造函数，它是一个内联的、公有的成员，它具有下面的原型形式：
　　Point:: Point (const Point &);
可见，复制构造函数与构造函数的不同之处在于形参，前者的形参是Point对象的引用，其功能是将一个对象的每一个成员复制到另一个对象对应的成员当中。
　　虽然没有必要，我们也可以为Point类显式定义一个复制构造函数：
　　Point:: Point (const Point &pt)
　　{
　　　xVal=pt. xVal;
　　　yVal=pt. yVal;
　　} 
　　如果一个类中有指针成员，使用缺省的复制构造函数初始化对象就会出现问题。为了说明存在的问题，我们假定对象A与对象B是相同的类，有一个指针成员，指向对象C。当用对象B初始化对象A时，缺省的复制构造函数将B中每一个成员的值复制到A的对应的成员当中，但并没有复制对象C。也就是说，对象A和对象B中的指针成员均指向对象C

复制构造函数遵循以下几个原则：

C++ primer p406 ：复制构造函数是一种特殊的构造函数，具有单个形参，该形参（常用const修饰）是对该类类型的引用。当定义一个新对象并用一个同类型的对象对它进行初始化时，将显示使用复制构造函数。当该类型的对象传递给函数或从函数返回该类型的对象时，将隐式调用复制构造函数。

C++支持两种初始化形式：复制初始化（int a = 5;）和直接初始化（int a(5);）对于其他类型没有什么区别，对于类类型直接初始化直接调用实参匹配的构造函数，复制初始化总是调用复制构造函数，也就是说：

A x(2);　　//直接初始化，调用构造函数
A y = x;　　//复制初始化，调用复制构造函数

必须定义复制构造函数的情况：

只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义复制构造函数也可以复制；有的类有一个数据成员是指针，或者是有成员表示在构造函数中分配的其他资源，这两种情况下都必须定义复制构造函数。

什么情况使用复制构造函数：

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

深拷贝和浅拷贝：

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间

如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝

上面提到，如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针时则会导致两次重复delete而出错。下面是示例：

#include <iostream.h>
#include <string.h>
class Person
{
public :

    // 构造函数
    Person(char * pN)
    {
        cout << "一般构造函数被调用 !
";
        m_pName = new char[strlen(pN) + 1];
        //在堆中开辟一个内存块存放pN所指的字符串
        if(m_pName != NULL)
        {
           //如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
             strcpy(m_pName ,pN);
        }
    }

    // 系统创建的默认复制构造函数，只做位模式拷贝
    Person(Person & p)
    {
        //使两个字符串指针指向同一地址位置
        m_pName = p.m_pName;
    }

    ~Person( )
    {
        delete m_pName;
    }

private :
    char * m_pName;
};

void main( )
{
    Person man("lujun");
    Person woman(man);

    // 结果导致   man 和    woman 的指针都指向了同一个地址

    // 函数结束析构时
    // 同一个地址被delete两次
}


// 下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
Person(Person & chs);
{
     // 用运算符new为新对象的指针数据成员分配空间
     m_pName=new char[strlen(p.m_pName)+ 1];

     if(m_pName)
     {
             // 复制内容
            strcpy(m_pName ,chs.m_pName);
     }

    // 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
}

重载赋值操作符：

通过定义operate=的函数，可以对赋值进行定义。像其他任何函数一样，操作符函数有一个返回值和形参表。形参表必须具有与该操作符操作数书目相同的形参（如果操作符是一个成员，则包括隐式this形参）。赋值是二元运算，所以该操作符函数有两个形参：第一个形参（隐含的this指针）对应着左操作数，第二个形参对应右操作数。

 一个应用了对赋值号重载的拷贝构造函数的例子：

#include <iostream>

using namespace std;

class A
{
public:
    A(int);//构造函数
    A(const A &);//拷贝构造函数
    ~A();
    void print();
    int *point;
    A &operator=(const A &);
};

A::A(int p)
{
    point = new int;
    *point = p;
}

A::A(const A &b)
{
    *this = b;
    cout<<"调用拷贝构造函数"<<endl;
}

A::~A()
{
    delete point;
}

void A::print()
{
    cout<<"Address:"<<point<<" value:"<<*point<<endl;
}

A &A::operator=(const A &b)
{
    if( this != &b)
    {
        delete point;
        point = new int;
        *point = *b.point;
    }
}


int main()
{
    A x(2);
    A y = x;
    x.print();
    delete x.point;
    y.print();

    return 0;
}

参见：C++拷贝构造函数详解： http://blog.csdn.net/lwbeyond/article/details/6202256