C++学习之嵌套类和局部类

局部类

在一个函数体内定义的类称为局部类。局部类中只能使用它的外围作用域中的对象和函数进行联系，因为外围作用域中的变量与该局部类的对象无关。在定义局部类时需要注意：局部类中不能说明静态成员函数，并且所有成员函数都必须定义在类体内。在实践中，局部类是很少使用的。下面是一个局部类的例子。

int a;

void fun()

{

　 static int s;

class A

{

　　public:

　　void init(int i) { s = i; }

};

A m;

　 m.init(10);

}

嵌套类理解

在一个类中定义的类称为嵌套类，定义嵌套类的类称为外围类。定义嵌套类的目的在于隐藏类名，减少全局的标识符，从而限制用户能否使用该类建立对象。这样可以提高类的抽象能力，并且强调了两个类 (外围类和嵌套类) 之间的主从关系。

class A

{

public:

　　　　class B　

{　　　

public:

　　　　　　…

　　　　private:

　　　　　　…

　　　　};

　　　　void f();

private:

　　　　int a;

}

其中，类B是一个嵌套类，类A是外围类，类B定义在类A的类体内。

对嵌套类的若干说明：

1、从作用域的角度看，嵌套类被隐藏在外围类之中，该类名只能在外围类中使用。如果在外围类的作用域内使用该类名时，需要加名字限定。

2、从访问权限的角度来看，嵌套类名与它的外围类的对象成员名具有相同的访问权限规则。不能访问嵌套类的对象中的私有成员函数，也不能对外围类的私有部分中的嵌套类建立对象。

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

4、嵌套类中说明的成员不是外围类中对象的成员，反之亦然。嵌套类的成员函数对外围类的成员没有访问权，反之亦然。

在分析嵌套类与外围类的成员访问关系时，往往把嵌套类看作非嵌套类来处理。这样，上述的嵌套类可写成如下格式：

class A

{　　public:

　　　　void f();

　　private:

　　　　int a;

};

class B

{

　public:

　　　…

private:

　　…

}; [ 嵌套类的理解形式 ]

5、在嵌套类中说明的友元对外围类的成员没有访问权。

6、如果嵌套类比较复杂，可以只在外围类中对嵌套类进行声明，关于嵌套的详细的内容可在外围类体外的文件域中进行定义。（理解这句话）

嵌套类规则详细分析

1、嵌套类的名字只在外围类可见。

在一个类的内部定义另一个类，我们称之为嵌套类（nested class），或者嵌套类型。之所以引入这样一个嵌套类，往往是因为外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现。

虽然嵌套类在外围类内部定义，但它是一个独立的类，基本上与外围类不相关。它的成员不属于外围类，同样，外围类的成员也不属于该嵌套类。嵌套类的出现只是告诉外围类有一个这样的类型成员供外围类使用。并且，外围类对嵌套类成员的访问没有任何特权，嵌套类对外围类成员的访问也同样如此，它们都遵循普通类所具有的标号访问控制。

若不在嵌套类内部定义其成员，则其定义只能写到与外围类相同的作用域中，且要用外围类进行限定，不能把定义写在外围类中。例如，嵌套类的静态成员就是这样的一个例子。（如何完成？）

前面说过，之所以使用嵌套类的另一个原因是达到底层实现隐藏的目的。为了实现这种目的，我们需要在另一个头文件中定义该嵌套类，而只在外围类中前向声明这个嵌套类即可。当然，在外围类外面定义这个嵌套类时，应该使用外围类进行限定。使用时，只需要在外围类的实现文件中包含这个头文件即可。

另外，嵌套类可以直接引用外围类的静态成员、类型名和枚举成员，即使这些是private的。一个好的嵌套类设计：嵌套类应该设成私有。嵌套类的成员和方法可以设为public。

嵌套类名字的解析过程

嵌套类定义的名字解析过程：

出现在名字使用点前的嵌套类的声明。

出现在名字使用点前外围类的声明。

嵌套类定义前名字空间域的声明。

嵌套类的成员定义中的名字解析过程：

成员函数局部声明。

嵌套类成员的声明。

外围类成员的声明。

成员函数定义前名字空间域中出现的声明。

参考实例

#include <iostream>

using namespace std;

class A

{

private:

int n;

public:

A(int n)

{

this->n=n;

cout<<"Aconstructor"<<endl;

}

voidshow();

class B

{

public:

B( )

{

cout<<"B constructor"<<endl;

}

voiddisp()

{

cout<<"B disp"<<endl;

}

};

Bb;

};

voidA::show()

{

cout<<n<<endl;

}

void main()

{

A a(1);

a.show();

a.b.disp();

}

class Outter

{

// friend class Inner 加了这行也白搭

（理解为什么）正确写法应该是;

protected:

voidFoo(){}

private:

voidFoo2(){}

public:

voidFoo3(){}

private:

classInner

{

Inner(Outter*pFather)

{

pFather->Foo();// Error, compiler complain !!

pFather->Foo2();//Error, compiler complain !!

pFather->Foo3();//OK !

}

};

嵌套的结构(当然包括类)并不能自动获得访问private成员的权限，要获得的话，必须遵守特定的规则：首先声明(不是定义)一个嵌套结构，然后声明它是全局范围使用的一个friend,最后定义这个结构。结构的定义必须与friend声明分开，否则不会把它看做成员。

改成这样，就可以通过编译了

class Outter

{

protected:

voidFoo(){};

private:

voidFoo2(){};

public:

voidFoo3(){};

private:

class Inner; // 声明 （是否可以省略声明？不可以）

friend Inner; // 声明为友元

classInner

{

Inner(Outter*pFather)

{

pFather->Foo();

pFather->Foo2();

pFather->Foo3();

}

};