如何让两个文件的两个类相互关联

本文转自 http://blog.csdn.net/xuyuanfan/article/details/10002255 

做项目过程中，一般会遇到两个类相互关联的情况，而这两个类又分别放在两个不同文件中，所以就“情不自禁”地相互包含对方的头文件，然后就“理所应当”地编译错误了。在这里，就讲一下如何让位于不同文件的的两个类相互关联。

 

首先设计类A（包括头文件classA.h和源文件classA.cpp），其中头文件classA.h要#include "classB.h"，而源文件classA.cpp又#include"classA.h。这样，在头文件classA.h和源文件classA.cpp都可以使用类B的东西了。

 

头文件classA.h源码如下：

[cpp] view plain copy print ?

1. #ifndef _CLASSA_H_   
2. #define _CLASSA_H_   
3.    
4. #include "classB.h"   
5.    
6. class A{  
7.       public:  
8.              void display();  
9.              void callB(B *b);  
10. };  
11.    
12. #endif  

#ifndef _CLASSA_H_
#define _CLASSA_H_
 
#include "classB.h"
 
class A{
      public:
             void display();
             void callB(B *b);
};
 
#endif

源文件classA.cpp源码如下：

[cpp] view plain copy print ?

1. #include <iostream>   
2. #include "classA.h"   
3.    
4. using namespace std;  
5.    
6. void A::display(){  
7.      cout<<"this is class A"<<endl;  
8. }  
9.    
10. void A::callB(B *b){  
11.      b->display();    
12. }  

#include <iostream>
#include "classA.h"
 
using namespace std;
 
void A::display(){
     cout<<"this is class A"<<endl;
}
 
void A::callB(B *b){
     b->display();  
}

其次设计类B（包括头文件classB.h和源文件classB.cpp），这里，头文件classB.h是不能#include "classA.h"，因为这样会和头文件classA.h形成相互包含，从而编译错误。那怎么样才能让头文件classB.h和源文件classB.cpp也都可以使用类A的东西呢？可以这样：头文件classB.h中声明类A，源文件classB.cpp中#include "classA.h"。头文件classB.h中声明类A，就是要告诉本模块类A是一个在其他地方声明定义的东西，在这里可以使用这个东西的名字，但由于还不知这个东西的具体定义，所以不能再这里实例化这个东西。

 

头文件classB.h源码如下：

[cpp] view plain copy print ?

1. #ifndef _CLASSB_H_   
2. #define _CLASSB_H_   
3.    
4. class A;  
5. class B{  
6.       public:  
7.              void display();  
8.              void callA(A *a);  
9. };  
10.    
11. #endif  

#ifndef _CLASSB_H_
#define _CLASSB_H_
 
class A;
class B{
      public:
             void display();
             void callA(A *a);
};
 
#endif

源文件classB.cpp源码如下：

[cpp] view plain copy print ?

1. #include <iostream>   
2. #include "classB.h"   
3. #include "classA.h"   
4.    
5. using namespace std;  
6.    
7. void B::display(){  
8.      cout<<"this is class B"<<endl;  
9. }  
10.    
11. void B::callA(A *a){  
12.      a->display();      
13. }  

#include <iostream>
#include "classB.h"
#include "classA.h"
 
using namespace std;
 
void B::display(){
     cout<<"this is class B"<<endl;
}
 
void B::callA(A *a){
     a->display();    
}

到这里，我们可以设计一个场景（main文件），源码如下：

[cpp] view plain copy print ?

1. #ifndef _MAIN_CPP_   
2. #define _MAIN_CPP_   
3.    
4. #include <iostream>   
5. #include "classA.h"   
6. #include "classB.h"   
7.    
8. using namespace std;  
9.    
10. int main(){  
11.     int pause;  
12.      
13.     A *ap = new A();  
14.     B *bp = new B();  
15.      
16.     ap->callB(bp);  
17.     bp->callA(ap);  
18.      
19.     cin>>pause;  
20.     return 0;  
21. }  
22.    
23. #endif  

#ifndef _MAIN_CPP_
#define _MAIN_CPP_
 
#include <iostream>
#include "classA.h"
#include "classB.h"
 
using namespace std;
 
int main(){
    int pause;
   
    A *ap = new A();
    B *bp = new B();
   
    ap->callB(bp);
    bp->callA(ap);
   
    cin>>pause;
    return 0;
}
 
#endif

运行结果如下：

 

可以看出：

类A调用了callB(B *b)，而callB又调用了类B的display()

类B调用了callA(A *a)，而callA又调用了类A的display()