队列

const数据成员无法被赋值

有const限定的字符不能改变其值,只能在被创建的时候进行初始化,比如

const int qsize;
qsize = 10;
cout << qsize << endl;

错误结果如下:

引用数据类型无法被赋值

例如 :

int size = 10;
int & qsize;
qsize = 11 ;
cout << size << endl;

报错 :

修改如下 :

int & qsize = size;

成员初始化列表

如果Queue类中的成员含有const类型和引用类型如下

class Queue
{
private:
	const int qsize;
	int & Qsize;
	...
};

构造函数如下 :

Queue :: Queue(int m = 10)
{
	qsize = m;
	Qsize = m;
	...
}

这是种不正确的初始化的方法,qsize和Qsize都是不能被赋值的,C++中有一种特殊语法成员初始化列表解决.

例如Classy是一个类,mem1,mem2,mem3是这个类的数据成员,则类构造函数可以使用如下语法来初始化数据成员:

Classy :: Classy(int n , int m ) : mem1(n),mem2(0),mem3(n * m + 2)
{
	//...
};

在函数名之后加入mem1(n),mem2(0),mem3(n * m + 2),相当于把mem初始化为参数n,mem2初始化为0,mem3初始化为参数n和m的式子:n * m + 2,可以直接对const类型和引用数据成员使用,这种方法只现定于构造函数.

• 成员初始化类表只适用于构造函数
• 必须用这种格式来初始化const类型和引用类型变量

这种方法也适用于常规初始化,例如:

int games(162);
int games = 162;

double games(162.0);
oduble talk(162.0);

c++11中支持类中可以进行初始化,比如

class Classy
{
	int mem1 = 10;
	const int mem2 = 20;
	...
};

这跟

Classy :: Classy(int n , int m ) : mem1(n),mem2(0),mem3(n * m + 2)
{
	//...
};

所完成的事情等效,前提是你的编译器支持c++11标准.

队列类及实现

class Customer
	{
	private:
	    long arrive;        // 何时进入队列
	    int processtime;    // 客户交易所需时间
	public:
	    Customer()
	    {
	        arrive = processtime = 0;
	    }
	    void set(long when);
	    long when() const
	    {
	        return arrive;
	    }
	    int ptime() const
	    {
	        return processtime;
	    }
	};
	
	typedef Customer Item;
	
	class Queue
	{
	private:
	    struct Node
	    {
	        Item item;
	        struct Node * next;
	    };
	    enum {Q_size = 10};
	
	    Node * front;
	    Node * rear;
	    int items;
	    const int qsize;
	    // 赋值构造函数和赋值重载函数为了防止用已有对象赋值新对象或已有对象
	    Queue(const Queue & q) : qsize(0)
	    {
	    }
	    Queue & operator=(const Queue & q)
	    {
	        return *this;
	    }
	public:
	    Queue(int qsize = Q_size);
	    ~Queue();
	    bool isempty() const;
	    bool isfull() const;
	    int queuecount() const;
	    bool enqueue(const Item & item);     // 进队
	    bool dequeue(Item & item);      // 出队
	};

	Queue :: Queue(int qs) : qsize(qs)
	{
	    front = rear = NULL;
	    items = 0;
	}
	
	Queue :: ~Queue()
	{
	    Node * temp;
	    while(front != NULL)
	    {
	        temp = front;
	        front = front->next;
	        delete temp;
	    }
	}
	
	bool Queue :: isempty() const
	{
	    return items == 0;
	}
	
	bool Queue :: isfull() const
	{
	    return items == qsize;
	}
	
	int Queue :: queuecount() const
	{
	    return items;
	}
	
	bool Queue :: enqueue(const Item &item)
	{
	    if(isfull())
	        return false;
	    Node * add = new Node;
	    add->item = item;
	    add->next = NULL;
	    items++;
	    if(front == NULL)
	        front = add;
	    else
	        rear->next = add;
	    rear = add;
	    return true;
	}
	
	bool Queue :: dequeue(Item &item)
	{
	    if(front == NULL)
	        return false;
	    item = front->item;
	    items--;
	    Node * temp = front;
	    front = front->next;
	    delete temp;
	    if(items == 0)
	        rear = NULL;
	    return true;
	}
	
	void Customer :: set(long when)
	{
	    processtime = std :: rand() % 3 + 1;
	    arrive = when;
	}

星期日, 05. 一月 2020 03:34下午 

星期日, 05. 一月 2020 03:34下午