C++嵌套类介绍

        包含类的成员函数可以创建和使用被嵌套类的对象，而且当声明位于公有部分，才能在包含类的外卖使用嵌套类，而且必须使用作用域解析运算符。对类进行嵌套定义了一种类型，该类型仅在包含嵌套类声明的类中有效。

        对类进行嵌套通常是为了帮助实现另一个类，并避免名称冲突。

1. 嵌套类和访问权限

        有两种访问权限适合于嵌套类。首先，嵌套类的声明位置决定了嵌套类的作用域，即它决定了程序的哪些部分可以创建这种类的对象。其次，和其他的类一样，嵌套类的公有部分、保护部分和私有部分控制了对类成员的访问。在哪些地方可以使用嵌套类以及如何使用嵌套类，取决于作用域和访问控制。

1.1 作用域

        如果嵌套类是在另一个类的私有部分声明的，则只有后者知道它。

        如果嵌套类是在另一个类的保护部分声明的，则它对于后者来说是可见的，但是对于外部世界是不可见的。然而这种情况下，派生类将知道嵌套类，并可以直接创建这种类型的对象。

        如果嵌套类是在另一个类的公有部分声明的，则允许后者、后者的派生类以及外部世界使用它，因为它是公有的。然而，由于嵌套类的作用域为包含它的类，因此在外部世界使用它时，必须使用类限定符。例如：

class Team
{
public:
    class Coach {};
// ...
};

//外部世界使用它：
Team::Coach forhire;  // create a Coach object outside the Team class

        嵌套结构和枚举的作用域与此相同。很多程序员都用公有枚举来提供客户程序员使用的类常数。

1.2 访问控制

        对嵌套类访问权的控制规则与对常规类相同。

总之，类声明的位置决定了类的作用域或可见性。类可见后，访问控制规则（公有、保护、私有、友元）将决定程序对嵌套类成员的访问权限。

2. 模板中的嵌套

// 程序清单1 queuetp.h -- queue template with a nested class
#ifndef QUEUETP_H_
#define QUEUETP_H_

template<class Item>
class QueueTP
{
private:
    enum {Q_SIZE = 10};
    // Node is a nested class definition
    class Node
    {
    public:
        Item item;
        Node* next;
        Node(const Item& i): item(i), next(0) {}
    };
    Node* front;           // poniter to front of Queue
    Node* rear;            // poniter to rear of Queue
    int items;
    const int qsize;
    QueueTP(const QueueTP& q): qsize(0) {}
    QueueTP& operator=(const QueueTP& q) { return *this; }

public:
    QueueTP(int qs = Q_SIZE);
    ~QueueTP();
    bool isempty() const { return items == 0; }
    boo isfull() const { return items == qsize; }
    int queuecount() const { return items; }
    bool enqueue(const Item& item);    // add item to end
    bool dequeue(Item& item);          // remove item from front
};

// QueueTP methods
template<class Item>
QueueTP<Item>::QueueTP(int qs): qsize(qs)
{
    front = rear = 0;
    items = 0;
}
template<class Item>
QueueTP<Item>::~QueueTP()
{
    Node* temp;
    while(front != 0)
    {
        temp = front;
        front = front->next;
        delete temp;
    }
}
// Add item to queue
template<class Item>
bool QueueTP<Item>::enqueue(const Item& item)
{
    if(isfull())
        return false;
    Node* add = new Node(item);
    // on failure, new throws std::bad_alloc exception
    items++;
    if(front == 0)
        front = add;
    else
        rear->next = add;
    rear = add;
    return true;
}
// Place front item into item variable and remove from queue
template<class Item>
bool QueueTP<Item>::dequeue(Item& item)
{
    if(front == 0)
        return false;
    item = front->item;
    items--;
    Node* temp = front;
    front = front->next;
    delete temp;
    if(items == 0)
        rear = 0;
    return true;
}

#endif

        上述示例中，Node是利用通用类型Item来定义的。