轉載自  ---》 https://blog.csdn.net/xiqingnian/article/details/41214539

一、問題描述

現在有兩個類A和B需要定義，定義A的時候需要用到B，定義B的時候需要用到A。

二、分析

A和B的定義和呼叫都放在一個檔案中肯定是不可以的，這樣就會造成兩個迴圈呼叫的死迴圈。

根本原因是：定義A的時候，A的裡面有B，所以就需要去檢視B的佔空間大小，但是檢視的時候又發現需要知道A的佔空間大小，造成死迴圈。

解決方法：

（1）寫兩個標頭檔案A.h和B.h分別用於宣告類A和B；

（2）寫兩個.cpp檔案分別用於定義類A和B；

（3）在A的標頭檔案中匯入B的標頭檔案；

（4）在B的標頭檔案中不匯入A的標頭檔案，但是用extern 的方式宣告類A，並且，在B中使用A的時候要用指標的形式。

原理：在B中用指標呼叫A，那麼在A需要知道B佔空間大小的時候，就會去找到B的定義檔案，雖然B的定義檔案中並沒有匯入A的標頭檔案，不知道A的佔空間大小，但是由於在B中呼叫A的時候用的指標形式，B只知道指標佔4個位元組就可以，不需要知道A真正佔空間大小，也就是說，A也是知道B的佔空間大小的。

我的理解--》必須得其中一個是指標，通過指標（4位元組） + extern 宣告的方式，來保證編譯B.h的時候，能通過；這樣在編譯A.h的時候，直接就可以通過了

A的標頭檔案A.h：

1. #ifndef _A
2. #define _A
3. <strong>    #include "B.h"//A的標頭檔案匯入了B的標頭檔案</strong>
4. //extern class B;
5. class A
6. {
7. private:
8. int a;
9. B objectb;//A的標頭檔案匯入了B的標頭檔案，在呼叫B的時候就可以不用指標
10. public:
11. A();
12. int geta();
13. void handle();
14. };
15. #endif _A

B的標頭檔案B.h：

1. #ifndef _B
2. #define _B
3. <strong>//#include "A.h"//B的標頭檔案沒有匯入A的標頭檔案，需要有三個地方需要注意！
4. extern class A;//注意1：需要用extern宣告A</strong>
5. class B
6. {
7. private:
8. int b;
9. A* objecta;//注意2：呼叫A的時候需要用指標
10. public:
11. B();
12. int getb();
13. void handle();
14. };
15. #endif _B

A的定義檔案A.cpp：

1. #include <iostream>
2. <strong>#include "A.h"</strong>
3. using namespace std;
4. A::A()
5. {
6. this->a=100;
7. }
8. int A::geta()
9. {
10. return a;
11. }
12. void A::handle()
13. {
14. cout<<"in A , objectb.b="<<objectb.getb()<<endl;
15. }

B的定義檔案B.cpp：

1. #include <iostream>
2. <strong>#include "B.h"
3. #include "A.h"//注意3：在B.cpp裡面匯入A的標頭檔案</strong>
4. using namespace std;
5. B::B()
6. {
7. this->b=200;
8. }
9. int B::getb()
10. {
11. return b;
12. }
13. void B::handle()
14. {
15. objecta=new A();
16. cout<<"in B , objecta->a="<<objecta->geta()<<endl;
17. }

main.cpp:

1. #include <iostream>
2. #include <cstdlib>
3. <strong>#include "A.h"
4. //#include "B.h" //因為A.h裡面已經包含B.h，所以在此不需要匯入B.h了。</strong>
5. using namespace std;
6. void main()
7. {
8. A a;
9. a.handle();
10. B b;
11. b.handle();
12. system("pause");
13. }