拷贝构造函数（C++）

在学习这篇文章之前先来一段小插曲，三者的区别：

按值传递：

形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的（实参->形参），参数的值只能传入，不能传出。当函数内部需要修改参数，并且不希望这个改变影响调用者时，采用值传递。

按地址传递：

形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作

按引用传递：

形参相当于是实参的“别名”，对形参的操作其实就是对实参的操作，在引用传递过程中，被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间，但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

因此只要内存地址的值发生改变,这两个变量的值都会改变.

需要一下引用类型的调用。

然后就是我一直纠结的一个为什么调用对象构造函数里面的要加一个&符号？有个网友这样解释，反面想如果没有&引用符号，那么A（A  a）岂不是一直相当于值的递归无限循环啊。

还有一部分小零碎知识const。回归主题吧

首选看一下构造函数的简单说明：

一、 构造函数是干什么的
class Counter
 {
 public:
          // 类Counter的构造函数
         // 特点：以类名作为函数名，无返回类型
         Counter()
          {
                 m_value = 0;
          }
 private:
           // 数据成员
         int m_value;
 }
        该类对象被创建时，编译系统对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作
eg:    Counter c1;
        编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0
故：
        构造函数的作用：初始化对象的数据成员。
二、 构造函数的种类
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_imag    = c.m_imag;
         }            
         // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象，
     //需要注意的一点是，这个其实就是一般的构造函数，但是对于出现这种单参数的构造函数，C++会默认将参数对应的类型转换为该类类型，有时候这种隐私的转换是我们所不想要的，所以需要使用explicit来限制这种转换。
       // 例如：下面将根据一个double类型的对象创建了一个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;
         }
 };

看一个简单的例子：

#include <iostream>
using namespace std;

class CExample {
private:
    int a;
public:
    //构造函数
    CExample(int b)
    { a = b;}
    
    //拷贝构造函数
    CExample(<a target=_blank href="http://blog.csdn.net/Eric_Jo/article/details/4138548">const</a> CExample& C)
    {
        a = C.a;
    }

    //一般函数
    void Show ()
    {
        cout<<a<<endl;
    }
};

int main()
{
    CExample A(100);
    CExample B = A; // CExample B(A); 也是一样的
     B.Show ();
    return 0;
} 

那拷贝构造函数是怎么工作的？

分三种方式进行实现传递：

1. 对象以值传递的方式传入函数参数

class CExample 
{
private:
 int a;

public:
 //构造函数
 CExample(int b)
 { 
  a = b;
  cout<<"creat: "<<a<<endl;
 }

 //拷贝构造
 CExample(const CExample& C)
 {
  a = C.a;
  cout<<"copy"<<endl;
 }
 
 //析构函数
 ~CExample()
 {
  cout<< "delete: "<<a<<endl;
 }

     void Show ()
 {
         cout<<a<<endl;
     }
};

//全局函数，传入的是对象
void g_Fun(CExample C)
{
 cout<<"test"<<endl;
}

int main()
{
 CExample test(1);
 //传入对象
 g_Fun(test);

 return 0;
}

2. 对象以值传递的方式从函数返回

class CExample 
{
private:
 int a;

public:
 //构造函数
 CExample(int b)
 { 
  a = b;
 }

 //拷贝构造
 CExample(const CExample& C)
 {
  a = C.a;
  cout<<"copy"<<endl;
 }

     void Show ()
     {
         cout<<a<<endl;
     }
};

//全局函数
CExample g_Fun()
{
 CExample temp(0);
 return temp;
}

int main()
{
 g_Fun();
 return 0;
}

3. 对象需要通过另外一个对象进行初始化；

CExample A(100);
CExample B = A; 
// CExample B(A); 

接着看一下复制和赋值符号的区别，上面的‘=’号看起来像赋值符号其实不是。

复制（拷贝）构造函数与赋值操作符之间的区别
复制构造函数又称拷贝构造函数，它与赋值操作符间的区别体现在以下几个方面
1．从概念上区分：
复制构造函数是构造函数，而赋值操作符属于操作符重载范畴，它通常是类的成员函数
2．从原型上来区分：
复制构造函数原型ClassType(const ClassType &);无返回值
赋值操作符原型ClassType& operator=(const ClassType &);返回值为ClassType的引用，便于连续赋值操作
3．从使用的场合来区分：
复制构造函数用于产生对象，它用于以下几个地方：函数参数为类的值类型时、函数返回值为类类型时以及初始化语句，例如(示例了初始化语句，函数参数与函数返回值为类的值类型时较简单，这里没给出示例)
ClassType a;         //
ClassType b(a);     //调用复制构造函数
ClassType c = a;    //调用复制构造函数
而赋值操作符要求‘=’的左右对象均已存在，它的作用就是把‘=’右边的对象的值赋给左边的对象
ClassType e;
Class Type f;
f = e;              //调用赋值操作符
4．当类中含有指针成员时，两者的意义有很大区别
复制构造函数需为指针变量分配内存空间，并将实参的值拷贝到其中；而赋值操作符它实现的功能仅仅是将‘=’号右边的值拷贝至左值，在左边对象内存不足时，先释放然后再申请。当然赋值操作符必须检测是否是自身赋值，若是则直接返回当前对象的引用而不进行赋值操作
看完这一段感觉有点清晰了，我们再看看深拷贝和浅拷贝。

       位拷贝拷贝的是地址（也叫浅拷贝），而值拷贝则拷贝的是内容（深拷贝）。深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

       位拷贝，及"bitwise assignment"是指将一个对象的内存映像按位原封不动的复制给另一个对象，所谓值拷贝就是指，将原对象的值复制一份给新对象。 在用"bitwise assignment"时会直接将对象的内存映像复制给另一个对象，这样两个对象会指向同一个内存区域，当一个对象被释放后，另一个对象的指针会成为野指针（悬垂指针）。这时，就应该编写operator=和copy constructor来实现值拷贝 。

为了防止默认的拷贝构造函数的发生，只需要声明一个私有拷贝构造函数。

// 防止按值传递
class CExample 
{
private:
	int a;

public:
	//构造函数
	CExample(int b)
	{ 
		a = b;
		cout<<"creat: "<<a<<endl;
	}

private:
	//拷贝构造，只是声明
	CExample(const CExample& C);

public:
	~CExample()
	{
		cout<< "delete: "<<a<<endl;
	}

    void Show ()
	{
        cout<<a<<endl;
    }
};

//全局函数
void g_Fun(CExample C)
{
	cout<<"test"<<endl;
}

int main()
{
	CExample test(1);
	//g_Fun(test); 按值传递将出错
	
	return 0;
} 

那我们为什么要使用引用作为一种高效的传递方式呢而不用指针？

一个比较形象的说法就是指针相当于中介，租房子的时候直接和房东谈比较划算还是通过中介划算呢？