嵌套类/内部类/外部类

  

 

  一个类可以在另一个类中定义这样的类被称为嵌套类（nested class）——《C++ primer 3rd》。外面的类成为外围类（outer class），内部的称为内部类（inner class）。从定义上来说内部类的作用让人迷惑，为什么要定义在内部，定义在内部有什么作用？

 

1. 含义

    域，在C++中经常会用到这个概念， 也称为作用域，也成为块。把一个类称为到另一类中，其实就是使内部类的域被限制在外部类的域之中，可以认为是内部类增加了一个命名空间，外部类相当于一个namespace 名。对于防止命名冲突很有用处。外部类的作用域就不用多说了，保持原貌。内部类必须通过外部类才能对外界可见， 即外界必须通过外部类访问内部类。举个例子。

/* *@file test1InnerClass.cpp */ #include<iostream> class OutClass { public: class InnerClass { public: InnerClass(int a): m_a(){ std::cout<<"innerclass constructor"<<endl; } virtual ~InnerClass(){ std::cout<<"innerclass destroy"<<endl;} }; public: OutClass(){std::cout<<"outclass constructor"<<endl; } virtual ~OutClass(){ std::cout<<"outclass destroy"<<endl;} }; int main() { OutClass o; OutClass::InnerClass i; return 0; }  

 

2. 访问控制符（public, protected,private）的作用

    对三个访问控制符的讲解各种资料都很详细，但是在内部类这部分不是很多。如果以前有一定基础了，在这部分就很容易明白。 public 允许外界不受限制访问它（public）所控制的域。 protected 允许子类和类的非静态成员函数访问。private 只允许类的非静态成员访问。举个例子。

 

class OutClass { public: class InnerClass1 { public: InnerClass1(){ std::cout<<"innerclass1 constructor"<<endl; } virtual ~InnerClass1(){ std::cout<<"innerclass1 destroy"<<endl;} }; protected: class InnerClass2 { public: InnerClass2(){ std::cout<<"innerclass2 constructor"<<endl; } virtual ~InnerClass2(){ std::cout<<"innerclass2 destroy"<<endl;} }; private: class InnerClass3 { public: InnerClass3(){ std::cout<<"innerclass3 constructor"<<endl; } virtual ~InnerClass3(){ std::cout<<"innerclass3 destroy"<<endl;} }; public: OutClass(){std::cout<<"outclass constructor"<<endl; } virtual ~OutClass(){ std::cout<<"outclass destroy"<<endl;} }; class OutSubClass: public OutClass { InnerClass1 a //子类可以访问父类的public域 InnerClass2 b; //子类可以访问父类的protected域 //InnerClass3 c; //子类不能访问父类的private域 }; int main() { OutClass o; OutClass::InnerClass1 i1; //public域外界可访问 //OutClass::InnerClass2 i2;//protected域外界不能访问 //OutClass::InnerClass3 i3;//private域外界不能访问 return 0; }

 

通过上面的例子我想，对访问控制符理解不是很清楚的应该有一个很清楚的了解。

 

3. 嵌套类（内部类）作用

    嵌套类的一个作用是防止命名冲突，前面也提到了，比较容易理解不再举例。另一用处就是）《C++ primer 3rd》提到的可以避免使用friend操作。

 

class List { public: class ListItem { friend class List; // 友元声明 ListItem( int val = 0 ); // 构造函数 ListItem *next; // 指向自己类的指针 int value; }; // ... private: ListItem *list; ListItem *at_end; }; //和下面的代码意义相类似， 外部类可以访问内部类成员， 但是又限制外界访问这个内部类成员 // 较好的设计! class List { public: // ... private: // 现在 ListItem 是一个私有的嵌套类型 class ListItem { // 它的成员都是公有的 public: ListItem( int val = 0 ); ListItem *next; int value; }; ListItem *list; ListItem *at_end; };

 

这个部分可以参考C++ primer的相应部分。

 

  总结，嵌套类看似很复杂其实并没有增加新的规则， 只是C++一般特性的体现。包括 域， 访问控制， 继承等等。

 

思考： 有兴趣朋友可以考虑下面这种情况, 这个会出错吗？ 为什么？ 有什么用？。

class Outer

{

private:

    class Inner

    {};//具体简略

public:

    Inner get(){return Inner();}

};

 

 转载请注明来源。