<j_*******@yahoo.comschrieb im Newsbeitrag
news:11*********************@d57g2000hsg.googlegro ups.com...
Sorry about that.
<code>
#include <cstddef>
#include <new>
class FullQueue{};
class EmptyQueue{};
template<class ItemType>
class Queue
{
private:
int front; // front position
int rear; // rear position
int maxQue; // maximun number of
elements in the queue,
// including one
reserved element
ItemType* items; // it points to a
dynamically-allocated array
public:
Queue(int max); // parameterized class
constructor
Queue(); // default constructor;
queue created empty
Queue(const Queue<ItemType&x); // copy
constructor;implicitly called
// for pass by value
void MakeEmpty(); // queue is made empty
bool IsEmpty(); // test if the queue is
empty
bool IsFull(); // test if the queue is
full
int length(); // return the number of
elements in the queue
void Print(); // print the value of
all elements in the
// queue from the front
to rear
void Enqueue(ItemType x); // insert x to the rear
of the queue
// Pre: the queue is
not empty
void Dequeue(ItemType &x); // delete the element
from the front of the queue
// Pre: the queue is
not empty
~Queue(); // destructor: memory
for dynamic array needs to be deallocated
};
template<class ItemType>
Queue<ItemType>::Queue()
{
items = new ItemType[maxQue];
front = maxQue;
rear = maxQue;
}
template<class ItemType>
Queue<ItemType>::Queue(int max)
{
maxQue = max + 1;
front = maxQue - 1;
rear = maxQue -1;
items = new ItemType[maxQue];
}
template<class ItemType>
Queue<ItemType>::Queue(const Queue<ItemType&x)
{
front = x.front;
rear = x.rear;
int count = x.count;
'count' is not a member of Queue<>. You probably meant maxQue instead.
for(int i=0;i<x.count;++i)
{
items[i] = x.items[i];
this->items is not valid. You hav to allocate some memory for your array of
pointers before you can assign pointers to it.
}
}
Remember the "Rule of Three". If you need a user-defined copy c-tor, you
probably need a user-defined assignment operator, too.
>
template<class ItemType>
void Queue<ItemType>::MakeEmpty()
{
rear = maxQue - 1;
front = maxQue - 1;
}
template<class ItemType>
bool Queue<ItemType>::IsEmpty()
{
return (rear==front);
}
template<class ItemType>
bool Queue<ItemType>::IsFull()
{
return ((rear+1) % maxQue == front);
}
template<class ItemType>
int Queue<ItemType>::length()
{
return 0;
If is rear greater than or equal to front, the length (number of elements in
queue) is rear - front. If it is less, the length is maxQue - front + rear
(or rear - front + maxQue). Also, if rear front than rear - front ==
(rear - front + maxQue) % maxQue. So you the length of the queue is (rear -
front + maxQue) % maxQue.
}
template<class ItemType>
void Queue<ItemType>::Print()
{
int current;
current = rear;
do{
current = (current + 1) % maxQue;
std::cout << items[current] << std::endl;
}while(current != front);
This code doesn't work it the queue is empty. Use a for or pre-emptive while
loop instead. You should also display those data between front and rear, not
those undefined items between rear and front. What about
for (int current = front; current != rear; current = (current + 1) %
maxQue)
{
std::cout << ...;
}
But you have to apply the following changes, too, to use for this way...
}
template<class ItemType>
void Queue<ItemType>::Enqueue(ItemType x)
{
if(IsFull())
throw FullQueue();
else
{
rear = (rear+1)% maxQue;
items[rear]=x;
In C++ (and C) it is more common to put something at the front position of a
container and make the rear position off by one, like it is with arrays,
where
int array[n];
array[0] = ...; /* legal */
array[n] = ...; /* error */
So using
items[rear] = x;
rear = (rear + 1) % maxQue;
is easier to understand for those accustomed to C++ or C.
}
}
template<class ItemType>
void Queue<ItemType>::Dequeue(ItemType &x)
{
if(IsEmpty())
throw EmptyQueue();
else
{
front=(front +1)% maxQue;
x =items[front];
Again, swap assignment and increment:
x = items[front];
front = (front + 1) % maxQue;
}
}
template<class ItemType>
Queue<ItemType>::~Queue()
{
delete[]items;
}
// main file
#include <cstdlib>
#include <cstddef>
#include <new>
#include <iostream>
#include "Queue.h"
using namespace std;
int main()
{
Queue<intIntQueue;
int x;
try{
IntQueue.Dequeue(x);
}
catch(FullQueue exceptionObject)
{
cerr << "FullQueue exception thrown.(int) " << endl;
}
catch(EmptyQueue exceptionObject)
{
cerr << "EmptyQueue exception thrown.(int) " << endl;
}
IntQueue.Enqueue(1);
IntQueue.Enqueue(2);
IntQueue.Enqueue(3);
IntQueue.Enqueue(4);
cout << "int length 3 = " << "4" << endl;//IntQueue.length() <<
endl;
IntQueue.Dequeue(x);
cout << "int length 4 = " << "4" << endl;;//IntQueue.length() <<
endl;
IntQueue.Print();
Queue<floatFloatQueue;
float y;
try{
FloatQueue.Dequeue(y);
}
catch(FullQueue exceptionObject)
{
cerr << "FullQueue exception thrown.(float)" << endl;
}
catch(EmptyQueue exceptionObject)
{
cerr << "EmptyQueue exception thrown.(float)" << endl;
}
cout << endl;
FloatQueue.Enqueue(7.1);
cout << "float length 3 = " << FloatQueue.length() << endl;
FloatQueue.Enqueue(2.3);
cout << "float length 4 = " << FloatQueue.length() << endl;
FloatQueue.Enqueue(3.1);
FloatQueue.Dequeue(y);
FloatQueue.Print();
system("pause");
return 0;
}
</code>
HTH
Heinz
