为什么拷贝构造函数的参数类型不是引用 就会变成死循环的递归

Question

实在不理解这个递归的过程
01.#include

02.using namespace std;

03.

04.class CExample

05.{

06.private:

07. int m_nTest;

08.

09.public:

10. CExample(int x) : m_nTest(x) //带参数构造函数

11. {

12. cout << "constructor with argument"<<endl;

13. }

14.

15. // 拷贝构造函数，参数中的const不是严格必须的，但引用符号是必须的

16. CExample(const CExample & ex) //拷贝构造函数

17. {

18. m_nTest = ex.m_nTest;

19. cout << "copy constructor"<<endl;

20. }

21.

22. CExample& operator = (const CExample &ex) //赋值函数(赋值运算符重载)

23. {

24. cout << "assignment operator"<<endl;

25. m_nTest = ex.m_nTest;

26. return *this;

27. }

28.

29. void myTestFunc(CExample ex)

30. {

31. }

32.};

33.

34.int main(void)

35.{

36. CExample aaa(2);

37. CExample bbb(3);

38. bbb = aaa;

39. CExample ccc = aaa;

40. bbb.myTestFunc(aaa);

41.

42. return 0;

43.}

输出结果：
01.constructor with argument // CExample aaa(2);

02.constructor with argument // CExample bbb(3);

03.assignment operator // bbb = aaa;

04.copy constructor // CExample ccc = aaa;

05.copy constructor // bbb.myTestFunc(aaa);

第四个输出： copy constructor // CExample ccc = aaa
构造ccc的时候只调用一次复制构造函数从aaa那里构造出新对象了

但是放到复制构造函数参数里面如果不是引用而是用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;那么又会触发拷贝构造函数，就这下永远的递归下去。
------------------------------ 这是我百度的结果很多都是这样说的但是还是理解不了

为什么2个 CExample ccc = aaa 差不多
一个是放在函数内 就无法构造对象了？而是形成递归？

Answer 1

解释的都太清楚了。都不知道怎么解释了。

如果还不理解，看下面的例子，帮助你理解什么叫无限递归：

 void foo()
{
    foo();
}

int main()
{
    foo();
}

注意，理论上无限递归是死循环，但是实际上不是，因为堆栈的大小是有限的。所以无限递归丢出的是堆栈溢出的错误。