从小白开始学C++ 类与对象九（嵌套类，队列设计实战）定义访问权限模板中的嵌套类

86 阅读 0 评论 57 点赞

我是靠谱客的博主鳗鱼背包，最近开发中收集的这篇文章主要介绍从小白开始学C++ 类与对象九（嵌套类，队列设计实战）定义访问权限模板中的嵌套类，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

C++类与对象九（嵌套类）

定义
访问权限
模板中的嵌套类

真·最最最后一篇C++类与对象、

关于C++中类与对象的内容实在是太多了，我也只是学了九牛一毛（还是很多）

今天我们来看嵌套类

定义

将类声明放在另一个类中。则这个在另一个中声明的类被称为嵌套类

它通过提供新的类型类作用域来避免名称混乱，包含类的成员函数可以创建和使用被嵌套类的对象；

而仅当声明位于公有部分，才能在包含类的外面使用嵌套类，而且必须使用作用域解析操作符

访问权限

嵌套类，结构，枚举的作用域
在这里插入图片描述

模板中的嵌套类

我们举个简单的例子来看看如何在模板中使用嵌套类

我们设计一个队列，里面嵌套一个关于结点的类

全部代码：

#include <iostream>
#include <string>

using namespace std;

template<class I>
class Queue
{
private:
    enum {Q_SIZE = 10};
    class Node
    {
    public:
        I item;
        Node *next;
        Node(const I &i):item(i),next(0){}
    };
    Node *front;
    Node *rear;
    int items;
    const int qsize;
    Queue &operator=(const Queue &q){return *this;}
public:
    Queue(int qs = Q_SIZE);
    ~Queue();
    bool isempty()const
    {
        return items==0;
    }
    bool isfull()const
    {
        return items==qsize;
    }
    int queuecount()const
    {
        return items;
    }
    bool enter(const I &item);
    bool out( I &item);
};

template<class I>
Queue<I>::Queue(int qs):qsize(qs)
{
    front = rear = 0;
    items = 0;
}

template<class I>
Queue<I>::~Queue()
{
    Node*temp;
    while(front!=0)
    {
        temp = front;
        front = front->next;
        delete temp;
    }
    cout << "The queue was cleaned!"<<endl;
}

template<class I>
bool Queue<I>::enter(const I&item)
{
    if(isfull())
        return false;
    Node *add = new Node(item);
    if(add == NULL)
        return false;
    items++;
    if(front==0)
        front=add;
    else
        rear->next=add;
    rear = add;
    return true;
}

template<class I>
bool Queue<I>::out(I &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;
}

int main()
{
    Queue<string> cs(5);
    string temp;
    while(!cs.isfull())
    {
        cout << "please enter your name to get your information :n";
        getline(cin, temp);
        cs.enter(temp);
    }
    cout << "nthe queue is full! Now we show the information:n";
    while(!cs.isempty())
    {
        cs.out(temp);
        cout << "Now show : "<<temp<<endl;
    }
    return 0;
}

简单来说,类模板Queue嵌套了一个用于生成队列的类Node，通过调用类方法来生成链接队列，并最后使用析构函数将链表的内存释放

输出结果：

please enter your name to get your information :
Mike Chen
please enter your name to get your information :
Kobe Bryant
please enter your name to get your information :
Eddie Van
please enter your name to get your information :
Chris Bird
please enter your name to get your information :
Nancy Liye

the queue is full! Now we show the information:
Now show : Mike Chen
Now show : Kobe Bryant
Now show : Eddie Van
Now show : Chris Bird
Now show : Nancy Liye
The queue was cleaned!

我们将程序分开来看

首先是类模板声明的private部分（有点长，因为有的函数直接写在声明里面了，所以拆成两部分）：

template<class I> // 类模板声明
class Queue
{
private:
    enum {Q_SIZE = 10}; //枚举变量
    class Node //嵌套的类Node
    {
    public:
        I item; // 这里将item声明为I 类型，所以下面实例化时，itme的类型根据I的类型而定
        Node *next; // 链接
        Node(const I &i):item(i),next(0){} //成员初始化列表方法
    };
    Node *front; // 定义类型为Node的private成员
    Node *rear;
    int items;//队列所含的结点个数
    const int qsize;//队列的大小
    Queue &operator=(const Queue &q){return *this;}//操作符重载

然后是public部分

public:
    Queue(int qs = Q_SIZE);//构造函数
    ~Queue();//析构函数
    
    bool isempty()const//判断队列是否为空
    {
        return items==0;//为空则返回1，否则返回0
    }
    
    bool isfull()const//判断队列是否满
    {
        return items==qsize;
    }
    
    int queuecount()const//返回队列的大小
    {
        return items;
    }
    
    bool enter(const I &item);//入队出队的函数声明（注意这里的类型都是I）
    bool out( I &item);
};

注意到一点：这里的class Node里面包含两个成员——结点item和用来连接的*next，这非常像我们在C中学习的结构体

实际上结构体是一种成员默认为公有的类，但是我们写结构体的时候不会提供构造函数，这里我们构造队列实际上是使用的类似结构体的链表结构来构建，但是我们使用类来实现

然后我们看到具体的函数：

template<class I> //类模板函数开头必须声明
Queue<I>::Queue(int qs):qsize(qs)//构造函数 首先使用列表法初始化qsize
{
    front = rear = 0;//两个Node类型的成员赋值0（NULL）
    items = 0; //初始化链表大小为0
}

template<class I>
Queue<I>::~Queue()//析构函数——很重要！当对象过期时，我们需要释放掉链表所占的内存
{
    Node*temp;
    while(front!=0)
    {
        temp = front;
        front = front->next;
        delete temp;//释放内存
    }
    cout << "The queue was cleaned!"<<endl;//当程序结束时自动执行析构函数我们将会看到这行输出
}

template<class I>
bool Queue<I>::enter(const I&item)//入队函数（生成新结点并连接至链表）
{
    if(isfull())
        return false;
    Node *add = new Node(item);//动态分配空间
    if(add == NULL)//分配出错时返回false
        return false;
    items++;//队列成员加一
    if(front==0)//当队列中无成员时
        front=add;
    else
        rear->next=add;
    rear = add;//总是指向最后一个元素
    return true;
}

template<class I>
bool Queue<I>::out(I &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;
}

最后我们看看main函数：

int main()
{
    Queue<string> cs(5);//创建实例对象并将I的类型定义为String
    //所以我们的嵌套类Node中item的类型也为string
    string temp;
    while(!cs.isfull())//当不满时（bool函数返回值充当条件）
    {
        cout << "please enter your name to get your information :n";
        getline(cin, temp);//输入字符串
        cs.enter(temp);//入队
    }
    cout << "nthe queue is full! Now we show the information:n";
    while(!cs.isempty())//当不空时（所以最后会输出队列中的所有成员）
    {
        cs.out(temp);//入队
        cout << "Now show : "<<temp<<endl;//展示信息
    }
    return 0;
}

输出结果：

please enter your name to get your information :
Mike Chen
please enter your name to get your information :
Kobe Bryant
please enter your name to get your information :
Eddie Van
please enter your name to get your information :
Chris Bird
please enter your name to get your information :
Nancy Liye

the queue is full! Now we show the information:
Now show : Mike Chen
Now show : Kobe Bryant
Now show : Eddie Van
Now show : Chris Bird
Now show : Nancy Liye
The queue was cleaned!