c++头文件相互包含

一，问题提出：

1. class B;  
2.   
3. class A  
4. {   
5. public:  
6.         B b;  
7. };   
8.   
9. class B  
10. {   
11. public:  
12.         A a;  
13. };  

以上写法会造成头文件相互包含，是错误的。

 因为在A对象中要开辟一块属于B的空间，而B中又有A的空间，是一个逻辑错误，无法实现的。

我们只需要把其中的一个A类中的B类型成员改成指针形式 就可以避免这个无限延伸的怪圈了。

为什么要更改A而不是B？因为存在先后顺序问题-->因为C++编译器自上而下编译源文件的时候，对每一个数据的定义，总是需要知道定义的数据的类型的大小。在预先声明语句classB;之后，编译器已经知道B是一个类，但是其中的数据却是未知的，因此B类型的大小也不知道。这样就造成了编译失败， 

：

二，前置声明：

Cpp代码

1. //文件A.h中的代码  
2. #pragma once  
3. #include "B.h"  
4. class A  
5. {   
6. public:  
7.         B* b;  
8. };   
9.   
10. //文件B.h中的代码  
11. #pragma once  
12. #include "A.h"  
13. class B  
14. {   
15. public:  
16.         A* a;  
17. };  

   这里两者都使用了指针成员，因此嵌套本身不会有什么问题，在主函数前面使用#include "A.h"之后，主要编译错误如下：

error C2501: 'A' : missing storage-class or typespecifiers   

仍然是类型不能找到的错误。其实这里仍然需要前置声明。分别添加前置声明之后，可以成功编译了。代码形式如下：

Cpp代码 

1. //文件A.h中的代码  
2. #pragma once  
3. #include "B.h"  
4. class B;  //前置声明
5.   
6. class A  
7. {   
8. public:  
9.         B* b;  
10. };   
11.   
12. //文件B.h中的代码  
13. #pragma once  
14. #include "A.h"  
15. class B;  
16.   
17. class B  
18. {   
19. public:  
20.         A* a;  
21. };  

[由上可见]:

    头文件包含代替不了前置声明。另外，在有了前置声明后，可以去掉A.h和B.h中的#include行.

三、两点原则
   头文件包含其实是一想很烦琐的工作，不但我们看着累，编译器编译的时候也很累，再加上头文件中常常出现的宏定义。感觉各种宏定义的展开是非常耗时间的，远不如自定义函数来得速度。这里仅就不同头文件、源文件间的句则结构问题提出两点原则，仅供参考：
   第一个原则，如果可以不包含头文件，那就不要包含了。这时候前置声明可以解决问题。如果使用的仅仅是一个类的指针或引用，没有使用这个类的具体对象（非指针），也没有访问到类的具体成员，那么前置声明就可以了。因为指针这一数据类型的大小是特定的，编译器可以获知。
   第二个原则，尽量在CPP文件中包含头文件，而非在头文件中。假设类A的一个成员是一个指向类B的指针，在类A的头文件中使用了类B的前置声明并编译成功，那么在A的实现中我们需要访问B的具体成员，因此需要包含头文件，那么我们应该在类A的实现部分（CPP文件）包含类B的头文件而非声明部分（H文件）。(由上段文字可以看出：如果类A要用到类B的具体成员时，需要用头文件，而非前置声明)

转自 http://blog.sina.com.cn/s/blog_5daeefb30100n19z.html