對象-為什麼拷貝構造函數的參數類型不是引用 就會變成死循環的遞歸

為什麼拷貝構造函數的參數類型不是引用 就會變成死循環的遞歸

實在不理解這個遞歸的過程
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 差不多
一個是放在函數內 就無法構造對象了？而是形成遞歸？

最佳回答：

解釋的都太清楚了。都不知道怎麼解釋了。

如果還不理解，看下面的例子，幫助你理解什麼叫無限遞歸：

 void foo()
{
    foo();
}

int main()
{
    foo();
}

注意，理論上無限遞歸是死循環，但是實際上不是，因為堆棧的大小是有限的。所以無限遞歸丟出的是堆棧溢出的錯誤。