嵌套类 局部类
《c++ primer 3th》
C++嵌套类
1、 嵌套类的名字只在外围类可见。
2、 类的私有成员只有类的成员和友元可以访问，因此外围类不可以访问嵌套类的私有成员。嵌套类可以访问外围类的成员（通过对象、指针或者引用）。
3、 一个好的嵌套类设计：嵌套类应该设成私有。嵌套类的成员和方法可以设为 public 。
4、 嵌套类可以直接访问外围类的静态成员、类型名（ typedef ）、枚举值。
嵌套类
一个类可以在另一个类中定义，这样的类被称为嵌套类。嵌套类是其外围类的一个成员。嵌套类的定义可以出现在其外围类的公有、私有或保护区中。
嵌套类的名字在其外围类域中是可见的，但是在其他类域或名字空间中是不可见的，这意味着，嵌套类的名字不会与外围域中声明的相同名字冲突。例如：
class Node { /* ... */ };
class Tree {
public:
// Node 被封装在 Tree 的域中
// 在类域中 Tree::Node 隐藏了 ::Node
class Node {...};
// ok: 被解析为嵌套类: Tree::Node
Node *tree;
};
// Tree::Node 在全局域中不可见
// Node 被解析为全局的 Node 声明
Node *pnode;
class List {
public:
// Node 被封装在 List 的域中
// 在类域 List::Node 中隐藏了 ::Node
class Node {...};
// ok: 解析为: List::Node
Node *list;
};
与非嵌套类一样，嵌套类可以有与自身同样类型的成员：
// Not ideal configuration: evolving class definition
class List {
public:
class ListItem {
friend class List; // 友元声明
ListItem( int val = 0 ); // 构造函数
ListItem *next; // 指向自己类的指针
int value;
};
// ...
private:
ListItem *list;
ListItem *at_end;
};
私有成员是指这样的成员，它只能在该类的成员或友元定义中被访问。除非外围类被声明为嵌套类的友元，否则它没有权利访问嵌套类的私有成员。这就是为什么ListItem 把List声明为友元的原因：为了允许类List的成员定义访问ListItem 的私有成员。嵌套类也没有任何特权访问其外围类的私有成员。如果我们想授权ListItem 允许它访问类List 的私有成员，那么该外围类List 必须把嵌套类ListItem 声明为友元。在前面的例子中ListItem 不是List 的友元，所以它不能引用List 的私有成员。
把类ListItem 声明为List类的公有成员意味着，该嵌套类可以在整个程序中（在类List的友元和成员定义之外）用作类型。例如：
// ok: 全局域中的声明
List::ListItem *headptr;
这超出了我们的本意。嵌套类ListItem 支持List类的抽象，我们不希望让ListItem 类型在整个程序中都可以被访问。那么，比较好的设计是把ListItem 嵌套类定义为类List 的私有成员：
// 不理想的配置: 要改进的类定义
class List {
public:
// ...
private:
class ListItem {
// ...
};
ListItem *list;
ListItem *at_end;
};
现在，只有List 的成员和友元的定义可以访问类型ListItem 。把类ListItem 的所有成员都声明为公有的也不再有任何坏处。因为ListItem 类是List 的私有成员，所以只有List 类的友元和成员可以访问ListItem 的成员。有了这个新的设计，我们就不再需要友元声明了。下面是类List 的新定义：
// 较好的设计!
class List {
public:
// ...
private:
// 现在 ListItem 是一个私有的嵌套类型
class ListItem {
// 它的成员都是公有的
public:
ListItem( int val = 0 );
ListItem *next;
int value;
};
ListItem *list;
ListItem *at_end;
};
在类ListItem 的定义中没有把构造函数定义为inline（内联的），构造的数必须在类定义之外被定义。在哪儿可以定义它呢？ListItem 的构造函数不是类List 的成员，所以我们不能在类List 的体内定义。ListItem 的构造函数必须被定义在全局域中——该域含有其外围类的定义。当我们没有在嵌套类体内以inline 形式定义嵌套类的成员函数时，我们就必须在最外围的类之外定义这些成员函数。下面是ListItem 构造函数的一种可能的定义。但是，对于全局域定义的语法来说这是不正确的：
class List {
public:
// ...
private:
class ListItem {
public:
ListItem( int val = 0 );
// ...
};
};
// 错误: ListItem 不在全局域中
ListItem::ListItem( int val ) { ... }
问题在于，名字ListItem 在全局域中是不可见的。在全局域中使用ListItem必须指明ListItem是类List 中嵌套的类。可以通过用其外围类名List 限定修饰类名ListItem 来做到这一点。下面是正确的语法：
// 用外围类名限定修饰嵌套类名
List::ListItem::ListItem( int val ) {
value = val;
next = 0;
}
注意，只有嵌套类名是限定修饰的。第一个限定修饰符List::指外围类，它限定修饰其后的名字——嵌套类ListItem。第二个ListItem 是指构造函数而不是嵌套类。下列定义中的成员名字是不正确的：
// 错误: 构造函数名是 ListItem 而不是 List::ListItem
List::ListItem::List::ListItem( int val ) {
value = val;
next = 0;
}
如果ListItem 已经声明了一个静态成员，那么它的定义也要放在全局域中。在这样的定义中，静态成员名看起来如下所示：
int List::ListItem::static_mem = 1024;
注意，对于成员函数和静态数据成员而言，不一定只有嵌套类的公有成员，才能在类定义之外被定义。类ListItem 的私有成员也可以被定义在全局域中。
嵌套类也可以被定义在其外围类之外。例如，Lisiltem 的定义也可以在全局域中被给出，如下：
class List {
public:
// ...
private:
// 这个声明是必需的
class ListItem;
ListItem *list;
ListItem *at_end;
};
// 用外围类名限定修饰嵌套类名
class List::ListItem {
public:
ListItem( int val = 0 );
ListItem *next;
int value;
};
在全局定义中，嵌套类ListItem 的名字必须由其外围类List 的名字限定修饰。注意，在类List体内的ListItem 的声明不能省略。如果嵌套类没有先被声明为其外围类的一个成员，则全局域中的定义不能被指定为嵌套类。在全局域中定义的嵌套类不一定是其外围类的公有成员。
在嵌套类的定义被看到之前，我们只能声明嵌套类的指针和引用。即使类ListItem 是在全局域中被定义的，List 的数据成员list 和at_end 仍然是有效的，因为这两个成员都是指针。如果这两个成员中有一个是对象而不是指针，那么类List 的成员声明将会引发一个编译错误。例如：
class List {
public:
// ...
private:
// 这个声明是必需的
class ListItem;
ListItem *list;
ListItem at_end; // 错误: 未定义嵌套类 ListItem
};
为什么会希望在类定义之外定义嵌套类呢？或许嵌套类支持外围类的实现细节，我们不想让List类的用户看到ListItem 的细节。因此，我们不愿把嵌套类的定义放在含有List 类接口的头文件中。于是，我们只能在含有List 类及其成员实现的文本文件中给出嵌套类ListItem的定义。
嵌套类可以先被声明，然后再在外围类体中被定义。这允许多个嵌套类具有互相引用的成员，例如：
class List {
public:
// ...
private:
// List::ListItem 的声明
class ListItem;
class Ref {
ListItem *pli; // pli 类型为: List::ListItem*
};
// List::ListItem 的定义
class ListItem {
Ref *pref; // pref 的类型为: List::Ref*
};
};
如果类ListItem 没有在类Ref 之前先被声明，那么成员pli 的声明就是错的，因为名字ListItem 没有被声明。
嵌套类不能直接访问其外围类的非静态成员，即使这些成员是公有的，任何对外围类的非静态成员的访问都要求通过外围类的指针、引用或对象来完成。例如：
class List {
public:
int init( int );
private:
class ListItem {
public:
ListItem( int val = 0 );
void mf( const List & );
int value;
int memb;
};
};
List::ListItem::ListItem( int val )
{
// List::init() 是类 List 的非静态成员
// 必须通过 List 类型的对象或指针来使用
value = init( val ); // 错误: 非法使用 init
}
使用类的非静态成员时，编译器必须能够识别出非静态成员属于哪个对象。在类ListItem的成员函数中，this 指针只能被隐式地应用在类ListItem 的成员上，而不是外围类的成员上。由于隐式的this 指针，我们知道数据成员value 指向被凋用构造函数的对象。在ListItem 的构造函数中的this 指针的类型是ListItem*。 而要访问成员init()所需的是List 类型的对象或List*类型的指针。
下面是成员函数mf()通用引用参数引用init()。从这里我们能够知道，成员init()是针对函数实参指定的对象而被调用的：
void List::ListItem::mf( const List &il ) {
memb = il.init(); // ok: 通过引用调用 init()
}
尽管访问外围类的非静态数据成员需要通过对象、指针或引用才能完成，但是嵌套类可以直接访问外围类的静态成员、类型名、枚举值（假定这些成员是公有的）。类型名是一个typedef 名字、枚举类型名、或是一个类名。例如：
class List {
public:
typedef int (*pFunc)();
enum ListStatus { Good, Empty, Corrupted };
// ...
private:
class ListItem {
public:
void check_status();
ListStatus status; // ok
pFunc action; // ok
// ...
};
// ...
};
pFunc、ListStatus 和ListItem 都是外围类List的域内部的嵌套类型名。这三个名字以及ListStatus 的枚举值都可以被用在ListItem 的域中，这些成员可以不加限定修饰地被引用：
void List::ListItem::check_status()
{
ListStatus s = status;
switch ( s ) {
case Empty: ...
case Corrupted: ...
case Good: ...
}
}
在ListItem 的域之外，以及在外围类List 域之外引用外围类的静态成员、类型名和枚举名都要求域解析操作符，例如：
List::pFunc myAction; // ok
List::ListStatus stat = List::Empty; // ok
当引用一个枚举值时，我们不能写：
List::ListStatus::Empty
这是因为枚举值可以在定义枚举的域内被直接访问。为什么？因为枚举定义并不像类定义一样维护了自己相关的域。
在嵌套类域中的名字解析
让我们来看看在嵌套类的定义，及其成员定义中的名字解析是怎样进行的。被用在嵌套类的定义中的名字（除了inline 成员函数定义中的名字和缺省实参的名字之外）其解析过程如下：
1、考虑出现在名字使用点之前的嵌套类的成员声明。
2、如果第1 步没有成功，则考虑出现在名字使用点之前的外围类的成员声明。
3、如果第2 步没有成功，则考虑出现在嵌套类定义之前的名字空间域中的声明。
例如：
enum ListStatus { Good, Empty, Corrupted };
class List {
public:
// ...
private:
class ListItem {
public:
// 查找:
// 1) 在 List::ListItem 中
// 2) 在 List 中
// 3) 在全局域中
ListStatus status; // 引用全局枚举
// ...
};
// ...
};
编译器首先在类ListItem 的域中查找ListStatus 的声明。因为没有找到成员声明，所以编译器接着在类List 的域中查找ListStatus 的声明。因为在List 类中也没有找到声明。于是编译器在全局域中查找ListStatus 的声明。在这三个域中，只有位于ListStatus使用点之前的声明才会被编译器考虑。编译器找到了全局枚举ListStatus 的声明，它是被用在Status 声明中的类型。
如果在全局域中，在外围域List 之外定义嵌套类ListItem，则List类的所有成员都已经被声明完毕，因而编译器将考虑其所有声明：
class List {
private:
class ListItem;
// ...
public:
enum ListStatus { Good, Empty, Corrupted };
// ...
};
class List::ListItem {
public:
// 查找:
// 1) 在 List::ListItem 中
// 2) 在 List 中
// 3) 在全局域中
ListStatus status; // List::ListStatus
// ...
};
ListItem的名字解析过程首先在类ListItem 的域中开始查找。因为没有找到成员声明，所以编译器在类List 的域内查找ListStatus 的声明。因为类List 的完整定义都已经能够看得到，所以这一步查找考虑List 的所有成员。于是找到List 中嵌套的enumListStatus， 尽管它是在ListItem 之后被声明的。status 是List 的ListStatus 类型的一个枚举对象。如果List没有名为ListStatus 的成员，则名字查找过程会在全局域中。在嵌套类ListItem 定义之前查找声明。
被用在嵌套类的成员函数定义中的名字其解析过程如下：
1、首先考虑在成员函数局部域中的声明。
2、如果第1 步没有成功，则考虑所有嵌套类成员的声明。
3、如果第2 步没有成功，则考虑所有外围类成员的声明。
4、如果第3 步没有成功，则考虑在成员函数定义之前的名字空间域中出现的声明。
在下面的代码段中，成员函数check_status()定义中的list 引用了哪个声明？
class List {
public:
enum ListStatus { Good, Empty, Corrupted };
// ...
private:
class ListItem {
public:
void check_status();
ListStatus status; // ok
// ...
};
ListItem *list;
// ...
};
int list = 0;
void List::ListItem::check_status()
{
int value = list; // 哪个 list?
}
很有可能程序员想让check_status()中的List 引用全局对象：
1、value 和全局对象List 的类型都是int。List::list 成员是指针类型，在没有显式转换的情况它不能被赋给value。
2、不允许ListItem 访问其外围类的私有数据成员，如List。
3、list 是一个非静态数据成员，在ListItem 的成员函数中必须通过对象、指针或引用来访问它。
但是，尽管有这些原因，在成员check_status()中用到的名字List 仍被解析为类List 的数据成员list。记住，如果在嵌套类ListItem 的域中没有找到该名字；则在查找全局域之前，下一个要查找的是其外围类的域。外围类List 的成员list 隐藏了全局域中的对象。于是产生一个错误消息，因为在check_status()中使用指针list 是无效的。
只有在名字解析成功之后，编译器才会检查访问许可和类型兼容性。如果名字的用法本身就是错误的，则名字解析过程将不会再去查找更适合于该名字用法的声明，而是产生一个错误消息。
为了访问全局对象list， 必须使用全局域解析操作符：
void List::ListItem:: check_status() {
value = ::list; // ok
}
如果成员函数check_status()被定义成位于ListItem 类体中的内联函数，则上面所讲到的最后一步修改会使编译器产生一个错误消息，报告说全局域中的list 没有被声明。
class List {
public:
// ...
private:
class ListItem {
public:
// 错误: 没有可见的 ::list 声明
void check_status() { int value = ::list; }
// ...
};
ListItem *list;
// ...
};
int list = 0;
全局对象list 是在类List 定义之后被声明的，对于在类体中内联定义的成员函数，只考虑在外围类定义之前可见的全局声明。如果check_status()的定义出现在List 的定义之后，则编译器考虑在check_status()定义之前可见的全局声明，于是找到对象list 的全局声明。
局部类
类也可以定义在函数体内，这样的类被称为局部类。局部类只在定义它的局部域内可见。与嵌套类不同的是，在定义该类的局部域外没有语法能够引用局部类的成员。因此，局部类的成员函数必须被定义在类定义中。在实际中，这就把局部类的成员函数的复杂性限制在几行代码中。否则，对读者来说，代码将变得很难理解。
因为没有语法能够在名字空间域内定义局部类的成员，所以也不允许局部类声明静态数据成员。
在局部类中嵌套的类可以在其类定义之外被定义。但是，该定义必须出现在包含外围局部类定义的局部域内。在局部域定义中的嵌套类的名字必须由其外围类名限定修饰。在外围类中，该嵌套类的声明不能被省略，例如：
void foo( int val )
{
class Bar {
public:
int barVal;
class nested; // 嵌套类的声明是必需的
};
// 嵌套类定义
class Bar::nested {
// ...
};
}
外围函数没有特权访问局部类的私有成员。当然，这可以通过使外围函数成为局部类的友元来实现。但是，看起来，局部类几乎从不需要私有成员。能够访问局部类的程序部分只有很少的一部分。局部类被封装在它的局部域中，通过信息隐藏进一步封装好像有点太过了。在实际中，很难找到一个理由不把局部类的所有成员都声明为公有的。
同嵌套类一样，局部类可以访问的外围域中的名字也是有限的。局部类只能访问在外围局部域中定义的类型名、静态变量以及枚举值，例如：
int a, val;
void foo( int val )
{
static int si;
enum Loc { a = 1024, b };
class Bar {
public:
Loc locVal; // ok;
int barVal;
void fooBar( Loc l = a ) { // ok: Loc::a
barVal = val; // 错误: 局部对象
barVal = ::val; // OK: 全局对象
barVal = si; // ok: 静态局部对象
locVal = b; // ok: 枚举值
}
};
// ...
}
在局部类体内（不包括成员函数定义中的）的名字解析过程是：在外围域中查找出现在局部类定义之前的声明。在局部类的成员函数体内的名字的解析过程是：在查找外围域之前，首先直找该类的完整域。
还是一样，如果先找到的声明使该名字的用法无效，则不考虑其他声明。即使在fooBar()中使用val 是错的，编译器也不会找到全局变量val，除非用全局域解析操作符限定修饰val。
