C++的前向声明、嵌套类、局部类

 先看看什么是前向声明。在C++中，类需要先定义，而后才能被实例化，但是实际存在一种场景是：两个类需要相互引用或相互成为类中的子对象成员时，就无法先定义使用，在编译环节就出现错误导致编译失败，这时就需要用到前向声明，此外，前向声明的类不能被实例化。下面是例子：

        

[cpp]  view plain copy

1. //此段代码在A.h文件中  
2. #ifndef  _A_H  
3. #define _A_H  
4.   
5. #include "B.h"  
6. class A  
7. {  
8. public:  
9.     A(void);  
10.     ~A(void);  
11.     B b_; //A类中包含B类对象  
12. };  
13.   
14. #endif  
15.   
16. //下面代码在B.h文件中  
17. #ifndef  _B_H  
18. #define _B_H  
19.   
20. /*B类包含A类对象，A类又包含B类对象时，头文件也互相包含，这是不允许的，需要前向声明： 
21. 在B.h中将A类前向声明，此时就不再需要包含A.h头文件，且B中不能有A类的对象，因为前向声明的类不能被实例化，但是可以是A类的指针或者引用*/  
22. //#include "A.h"    
23.   
24. class A;  
25.   
26. class B  
27. {  
28. public:  
29.     B(void);  
30.     ~B(void);  
31.     //A a_;  //前向声明后，B类中不能含有A的对象  
32.     A *a_;   //可以是指针  
33.   
34.     void Fun(A &a )  //可以是引用  
35.      {  
36.   
37.     }  
38. };  
39.   
40. #endif  

        嵌套类

        顾名思义，嵌套类就是在类体中再定义另外一个类，形成类中类的情况。我们将最外层定义的类称为外围类，外围类内部再定义的类称为嵌套类。嵌套类的主要作用是为外围类提供服务的，外围类可以使用嵌套类对象作为外围类的底层实现，同时可以对用户隐藏该底层的实现。

        嵌套类需要注意的几点：

        (1) 作用域上，嵌套类是定义在外围类内部的，所以该类名只能在外围类内部使用，如果在外围类外部使用该类名时，需要加名字限定，如Out::Inner i;

        (2) 嵌套类中的成员函数可以在它的外部定义。

        (3) 嵌套类的成员函数对外围类的数据成员没有访问权，反之亦然。因为嵌套类仅仅是语法上的嵌入，它与外围类实际上是平级的。

        下面是嵌套类的简单例子：

        

[cpp]  view plain copy

1. class Outer  //外围类  
2. {  
3. public:  
4.     class Inner  
5.     {  
6.     public:  
7.         void Fun()  //也可以定义在外部  
8.         //{  
9.         //    cout << "Inner::Fun()"<<endl;  
10.         //}  
11.     };  
12.   
13. public:  
14.     Inner obj_;  
15.     void Fun()  
16.     {  
17.         cout << "Outer::Fun() "<<endl;  
18.         obj_.fun(); //嵌套类为外围类提供服务，对用户隐藏。  
19.     }  
20. };  
21.   
22. //Inner::Fun() //Error, 注意作用域。Inner对外部不可见  
23. void Outer::Inner::Fun()  
24. {  
25.     cout << "Inner::Fun() << endl;  
26. }  
27.   
28. int main()  
29. {  
30.     Outer o;  
31.     Outer::Inner i; //注意作用域，可以像使用其它类一样使用嵌套类，它仅仅是语法上的嵌入.  
32.     o.Fun();  
33.     i.Fun();  
34.   
35.     return 0;  
36. }  

        局部类.

        局部类是指在函数内部定义的类，这样的类称为局部类local class.局部类只在定义它的局部域内是可见的。此外，局部类的成员函数必须定义在类体中，并且不能有静态成员。下面是例子：

[cpp]  view plain copy

1. void Fun()  
2. {  
3.     //局部类，只在函数内部有效  
4.     class LocalClass  
5.     {  
6.     public:  
7.         int a_;  
8.         void Init(int &a ) //只能在类体中定义.  
9.         {  
10.             a_ = a;  
11.         }  
12.   
13.          //static int b_;  //Error,局部类不能定义static静态数据成员.  
14.     };  
15.   
16.     LocalClass lc;  
17.     lc.Init(10);  
18. }  
19.   
20. int main()  
21. {  
22.     Fun();  
23.     LocalClass lc; //Error, 局部类在函数外部不可用。  
24. }