嵌套类，这里指的是语法上的嵌套类，实际上是平行的关系。

     外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现且同时可以对用户隐藏该底层实现。

1. # include <iostream> 
2. using namespace std; 
3.  
4. class Outer 
5. { 
6.     class Inner 
7.     { 
8.     public: 
9.         void Fun() 
10.         { 
11.             cout << "Inner::Fun..." << endl; 
12.         } 
13.     }; 
14. public: 
15.     Inner obj_; 
16.  
17.     void Fun() 
18.     { 
19.         cout <<"Outer::Fun..."<< endl; 
20.         obj_.Fun(); 
21.     } 
22.  
23. }; 
24. //嵌套类为外围类提供服务 
25. //外围类的使用到了嵌套类的实现，调用了嵌套类的方法 
26. int main(void) 
27. { 
28.     Outer o; 
29.     o.Fun(); 
30.  
31.     return 0; 
32. } 

     运行结果：

嵌套类中的成员函数可以在它的类体外定义

从作用域的角度看，嵌套类被隐藏在外围类之中，该类名只能

在外围类中使用。如果在外围类的作用域使用该域名时，需要

加名字限定。

嵌套类的成员函数对外围类的成员没有访问权，反之亦然。

嵌套类仅仅只是语法上的嵌入，平行的关系，外部也可以使用对象。

1. # include <iostream> 
2. using namespace std; 
3.  
4. class Outer 
5. { 
6. public: //默认是私有，这里声明为公有，main函数才能    Outer::Inner   i;  
7.     class Inner 
8.     { 
9.       public: 
10.              void Fun(); 
11.                  //{
     
12.                  // cout << "Inner::Fun..." << endl; 
13.                  //}     
14.     }; 
15. public: 
16.       Inner obj_; 
17.       void Fun() 
18.       { 
19.          cout<< "Outer::Fun..." << endl; 
20.          obj_.Fun(); 
21.        } 
22.  
23. }; 
24. //嵌套类中的成员函数可以在它的类体外定义 
25. void Outer::Inner::Fun() 
26. { 
27.     cout << "Inner::Fun..." << endl;     
28. } 
29.  
30. int main(void) 
31. { 
32.     //如果是私有的则不行，如果是公有的则可以 
33.     Outer::Inner  i;  
34.     i.Fun(); 
35.  
36.     return 0; 
37. } 

运行结果：