假设声明两个类A和B，如果需要在A.h中定义B类对象，B b_; 势必要包含# include "B.h"，而B类中需要定义A类对象A a_; 也要包含B.h，但是相互包含是不允许的，称为环形引用，这时候就用到了前向声明。

    在B类中进行前向声明:

1. class A; 

    B.h中就不用包含A.h，但是前提是，不能定义对象，只能定义指针或引用。

A类

1. //A.h 
2.  
3. # ifndef _A_H_ 
4. # define _A_H_ 
5.  
6. # include "B.h" 
7.  
8. class A 
9. { 
10.     A(void); 
11.     ~A(void); 
12.      
13.     B b_;  //要包含B.h 
14. }; 
15.  
16. # endif //_A_H 

B.h

1. //B.h 
2. # ifndef _B_H_ 
3. # define _B_H_ 
4. //前向声明,不能实例化对象 
5. class A;  // 就不需要包含A.h,要求不能定义对象，只能给定义指针和引用 
6. //因为我们不知道类长声明样子，就无法为其分配内存 
7.  
8. class B 
9. { 
10.     B(void); 
11.     ~B(void); 
12.  
13.     void fun(A& a)//只能是指针或引用 
14.     { 
15.         ; 
16.     } 
17.     //前向声明的类不能实例化对象 
18.     A* a_;  // 
19. }; 
20.  
21. # endif //_B_H_ 

B.cpp

1. B.cpp 
2.  
3. # include "B.h" 
4. # include "A.h" 
5.  
6. B::B(void) 
7. { 
8.  
9. } 
10. B::~B() 
11. { 
12.  
13. } 

 总结:

     前向声明的类不能实例化对象。