C++_类入门3-嵌套类
阅读原文时间:2021年10月28日阅读:12

可以将类B声明在另一个类中。在另一个类A中声明的类B被称为嵌套类(nested class)

类A的成员函数可以创建和使用嵌套类B的对象。

当且仅当声明为公有部分时,才能在类A的外面使用嵌套类。而且必须使用作用域解析运算符。(旧版C++不支持嵌套类概念)

对类进行嵌套和包含并不同。包含意味着将类C对象作为类A的成员。而对类B进行嵌套不创建类成员,而是定义了一种类型,该类型仅仅在包含嵌套类声明的类A中有效。

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

class Queue

{

private:

//classs scope definitions

  //Node is a nested structure definition local to this class

  struct node {Item item; struct Node * next;};

}

结构是其成员在默认情况下公有的类。结构可以理解成一种特殊的类。

所以Node实际上可以看成嵌套类。但该定义没有充分利用类的功能。

具体来说,它没有显式构造函数。接下来进行补救。

Queue的方法enqueue创建了Node:

bool Queue::enqueue(const Item & item)
{
if(isfull())
return false;
Node * add = new Node; //create node
//on failure,new throws std::bad_alloc exception
add->item =item; //set node pointer
add->next =NULL;

}

上述代码创建Node后,显式地给Node成员赋值,这种工作更适合由构造函数来完成。

于是可以改写Node如下:

class Queue
{
//Node is a nested calss definition local to this class
class Node
{
public:
Item item;
Node * next;
Node(const Item & i):item(i),next() { }
};

}

该构造函数节点的item成员被初始化为i,并将next指针置为0,这是C++编写空值指针的方法之一。

接下来,需要使用构造函数重新编写enqueue():

bool Queue::enqueue(const Item & item)
{
if(isfull())
reutrn false;
Node * add = new Node(item); //create, initialize node
//on failure,new throws std::bad_alloc exception

}

这使得enqueue()的代码更短,也更安全,因为它自动进行初始化,无需程序员记住应该做什么。

这个例子在类声明中定义了构造函数。假设想在方法文件中定义构造函数,则定义必须指出Node类,

这是通过两次作用域运算符来完成的;

Queue::Node::Node(const Item & i):item(i),next(0) { }

嵌套类和访问权限

嵌套类的声明位置决定了嵌套类的作用域。即它决定了程序的那些部分可以创建这种类的对象。

其次,和其他类一样,嵌套类的公有部分、保护部分、私有部分控制了对类成员的访问。

在哪些地方可以使用嵌套类以及如何使用嵌套类,取决于作用域和访问控制

1、作用域

如果嵌套类是在类的私有部分声明的:

  则只有类的私有部分知道它,在前一个例子中,被嵌套在Queue声明中的Node类就属于这种情况。

  Queue成员可以使用Node对象和Node对象的指针,但是程序的其他部分甚至不知道存在Node类。

  而对于从Queue派生而来的类,Node也是不可见的。因为派生类不能直接访问积累的私有部分。

如果嵌套类是在类的保护部分声明的:

  则该嵌套类对于后面这个类是可见的,但是对于外部世界则是不可见的。

   在这种情况下,派生类知道嵌套类,病可以直接创建这种类型的对象。  

如果嵌套类是在类的公有部分声明的:

  则后者、后者的派生类以及外部世界使用它,因为它是公有的。

  然而,由于嵌套类的作用域为包含它的类,因此在外部世界使用它时,必须使用类限定符。

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

作用域就是指这个对象(类、枚举)可见的范围,有效的范围。

2、访问控制

类可见之后,起决定作用的就是访问控制

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

在Queue类声明中声明Node并没有赋予Queue类对Node类的访问特权。

因此Queue类对象只能显式地访问Node对象的公有成员。

由于这个原因,在Queue示例中,Node类的所有成员都被声明为公有的。

这样有悖于应将数据成员声明为私有的惯例,但Node类是Queue类内部实现的一项特性,对外部实际不可见,这是因为Queue类是在Queue类的私有部分声明的。

所以,虽然Queue的方法可以直接访问Node成员,但使用Queue类的客户不能这样做。

模板中的嵌套

模板很适合用于诸如实现Queue等容器类。

将Queue类定义转换为模板时,是否会由于它包含嵌套类而带来问题?答案是不会。

//queuetp.h -- queue template with a nested class
#ifndef QUEUETP_H_
#define QUEUETP_H_

template
class QueueTP
{
private:
enum {Q_SIZE =};
//Node is a nested class definition
class Node
{
public:
Item item;
Node * next;
Node(const Item & i): item(i),next() {}
};
Node * front;
Node * rear;
int item; //current number of items in Queue;
const int qsize; //maximum number of items in Queue;
QueueTP(const QueueTP & q): qsize() {}
QueueTP & operator=(const QueueTP & q) {return *this;}
public:
QueueTP(int qs= Q_SIZE);
~QueueTP();
bool isempty() const{
return item==;
};
bool isfull() const{
return item==qsize;
};
int queuecount const{
return item;
};
bool enqueue(const Item & item); //add item to end
bool dequeue(Item & item); //remove item from front
};

#endif

//QueueTP methods
QueueTP::QueueTP(int qs): qsize(qs)
{
front = reart = ;
items = ;
}

template
QueueTP::~QueueTP()
{
Node * temp;
while()
{
temp=front;
front=front->next;
delete temp;
}
}

template
bool QueueTP::enqueue(const Item & item)
{
if(isfull())
return false;
Node * add = new Node(item); //create node
//on failure, new throws std::bad_alloc exception
items++;
if(front ==)
front == add;
else
rear->next == add;
rear = add;
return true;
}

template
bool QueueTP::dequeue(Item & item)
{
if(front == )
return false;
item = front->item;
items--;
Node * temp =front;
front = front->next;
delete temp;
if(items==)
rear = ;
return true;
}

在模板中Node是利用Item类型来定义的。

下面声明将导致Node被定义成用于储存double值:

    QueueTP dq;

而下面的声明将导致Node被定义成用于存储char的值:

  QueueTP dq;

这两个Node类将在两个独立的QueueTP类中定义,因此不会发生名称冲突。

即一个节点的类型为QueueTP::Node

另一个节点的类型为QueueTP::Node

接下来用一个小程序测试一下:

//nested.cpp -- using a queue that has a nested class

#include
#include
#include "queuetp.h"

int main()
{
using std::string;
using std::cin;
using std::cout;

 QueueTP<string> cs();  
 string temp;

 while(!cs.isfull())  
 {  
     cout<<"Please enter your name.Your will be"  
                "served in the order of arrival.\\n"  
                "name:";  
     getline(cin,temp);  
     cs.enqueue(temp);  
 }  
 cout<<"The queue is full.Processing begins!\\n";

 while(!cs.isempty())  
 {  
     cs.dequeue(temp);  
     cout<<"Now processing "<<temp<<"...\\n";  
 }  
 return ;  

}

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器