拷贝构造函数的参数为什么必须使用引用类型（避免无限递归拷贝，但其实编译器已经强制要求了）

在C++中， 构造函数，拷贝构造函数，析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识。 但是如果我问你“拷贝构造函数的参数为什么必须使用引用类型？”这个问题， 你会怎么回答？ 或许你会回答为了减少一次内存拷贝？ 很惭愧的是，我的第一感觉也是这么回答。不好还好，我有理性这个好品质。思索一下以后，发现这个答案是不对的。让我来撕开(有点暴力，但是我喜欢，嘿嘿--龇牙)那件隐藏在真理外的小裤衩，让它袒露在“登徒子”们的眼前吧。

先从一个小例子开始：（自己测试一下自己看看这个程序的输出是什么？）

 view plaincopy to clipboardprint?
#include <iostream.h>   
  
class CExample   
{   
    int m_nTest;   
public:   
       
    CExample(int x):m_nTest(x) //带参数构造函数   
    {    
       cout << "constructor with argument/n";   
    }   
       
    CExample(const CExample & ex) //拷贝构造函数   
    {   
        m_nTest = ex.m_nTest;   
        cout << "copy constructor/n";   
    }   
       
    CExample& operator = (const CExample &ex)//赋值函数(赋值运算符重载)   
    {      
        cout << "assignment operator/n";   
        m_nTest = ex.m_nTest;   
        return *this;   
    }   
       
    void myTestFunc(CExample ex)   
    {   
    }   
};   
  
int main()   
{   
    CExample aaa(2);   
    CExample bbb(3);   
    bbb = aaa;   
    CExample ccc = aaa;   
    bbb.myTestFunc(aaa);   
       
    return 0;      
}  
#include <iostream.h>

class CExample
{
 int m_nTest;
public:
 
 CExample(int x):m_nTest(x) //带参数构造函数
 { 
    cout << "constructor with argument/n";
 }
 
 CExample(const CExample & ex) //拷贝构造函数
 {
  m_nTest = ex.m_nTest;
  cout << "copy constructor/n";
 }
 
 CExample& operator = (const CExample &ex)//赋值函数(赋值运算符重载)
 { 
  cout << "assignment operator/n";
  m_nTest = ex.m_nTest;
  return *this;
 }
 
 void myTestFunc(CExample ex)
 {
 }
};

int main()
{
 CExample aaa(2);
 CExample bbb(3);
 bbb = aaa;
 CExample ccc = aaa;
 bbb.myTestFunc(aaa);
 
 return 0; 
}
 

看这个例子的输出结果：

constructor with argument      // CExample aaa(2);
constructor with argument      // CExample bbb(3);
assignment operator                // bbb = aaa;
copy constructor                      // CExample ccc = aaa;
copy constructor                      //  bbb.myTestFunc(aaa);

如果你能一眼看出就是这个结果的话， 恭喜你，可以站起来扭扭屁股，不用再往下看了。

如果你的结果和输出结果有误差， 那拜托你谦虚的看完。

第一个输出： constructor with argument      // CExample aaa(2);

如果你不理解的话， 找个人把你拖出去痛打一顿，然后嘴里还喊着“我是二师兄，我是二师兄.......”

第二个输出：constructor with argument      // CExample bbb(3);

分析同第一个

第三个输出： assignment operator                // bbb = aaa;

第四个输出： copy constructor                      // CExample ccc = aaa;

这两个得放到一块说。 肯定会有人问为什么两个不一致。原因是， bbb对象已经实例化了，不需要构造，此时只是将aaa赋值给bbb，只会调用赋值函数，就这么简单，还不懂的话，撞墙去！ 但是ccc还没有实例化，因此调用的是拷贝构造函数，构造出ccc，而不是赋值函数，还不懂的话，我撞墙去！！

第五个输出： copy constructor                      //  bbb.myTestFunc(aaa);

实际上是aaa作为参数传递给bbb.myTestFunc(CExample ex)， 即CExample ex = aaa；和第四个一致的， 所以还是拷贝构造函数，而不是赋值函数， 如果仍然不懂， 我的头刚才已经流血了，不要再让我撞了，你就自己使劲的再装一次吧。

通过这个例子， 我们来分析一下为什么拷贝构造函数的参数只能使用引用类型。

看第四个输出： copy constructor                      // CExample ccc = aaa;

构造ccc，实质上是ccc.CExample(aaa); 我们假如拷贝构造函数参数不是引用类型的话， 那么将使得 ccc.CExample(aaa)变成aaa传值给ccc.CExample(CExample ex)，即CExample ex = aaa，因为 ex 没有被初始化， 所以 CExample ex = aaa 继续调用拷贝构造函数，接下来的是构造ex，也就是 ex.CExample(aaa)，必然又会有aaa传给CExample(CExample ex), 即 CExample ex = aaa;那么又会触发拷贝构造函数，就这样永远的递归下去。

所以绕了那么大的弯子，就是想说明拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝， 而是避免拷贝构造函数无限制的递归下去。

所以， 拷贝构造函数是必须要带引用类型的参数的， 而且这也是编译器强制性要求的

http://blog.csdn.net/yiruirui0507/article/details/5987254