用类实现的队列

Question

I recently came to queue data struture. In order to practise and learn something new i decided to implement it without STL library. The thing is , i have quite hard time to actually tell difference between typical array , and queue.

I defined simple class

class Queue{

public:

    Queue();
    Queue(int);


    void enqueue(int);
    int dequeue();
    int  first_out() ;
    int  last_out() ;
    bool isEmpty();
    bool isFull();

private:

    int current;
    int maxi;
    int *arr;
    int frontt;
    int rear;

};

its constructor

Queue::Queue(int maxo){
    this -> current = 0;
    this -> maxi = maxo;
    this -> arr = new int[maxi];
    this -> frontt = 0;
    this -> rear = 0;
}

enqueue method, which reallocate the array inside , when it tries to access index which is bigger than max index.

void Queue::enqueue(int a){
    if( this -> rear == this -> maxi){

        int *temp;
        int tmp = maxi;
        while( this -> rear >= this -> maxi){
            this -> maxi *= 2;
        }
        temp = new int[maxi];
        for( int i = 0; i < tmp ; i++){
            temp[i]=arr[i];
        }
        rear = maxi;
        delete[] arr;
        arr = temp;

    }
    this -> arr[rear++] = a;


}

Dequeue which increment front index.

int Queue::dequeue(){



return arr[frontt++];

    }
    int Queue::first_out(){

        return arr[frontt];

    }

    int Queue::last_out(){

        return arr[rear-1];

    }

    bool Queue::isEmpty(){

        if( this -> frontt == this -> rear){
            cout << "Queue is empty" << endl;
            return 1;
        }
        return 0;
    }
    bool Queue::isFull(){

        if( this -> frontt == (this -> rear+1) % this -> maxi){


            return 1;

        }
        return 0;
    }

Main function to test it

Queue tst(5);
    cout << "Write numbers" << endl;
    int n;
    while( cin >> n){
        tst.enqueue(n);
    }
    tst.dequeue();
    cout << "The firt out element is " << tst.first_out() << endl;
    cout << "The last out element is " << tst.last_out() << endl;
    return 0;

My question is quite trivial. Is this how to implement queue? Can i understand it as queue is just generator/iterator of values? Why to use queue instead of array then? Also what is the point of circle queue?

Thanks for answers.

Answer 1

At least in C and C++, an array is defined in concrete terms. Specifically, it's defined in terms of memory layout--objects at consecutive memory locations. How you use it, what you do with it, etc., are determined entirely by that definition.

A queue is defined much more abstractly: it has to support a couple of specific operations (adding and retrieving items) and an order relationship between the two (first in, first out). A few secondary operations such as checking whether the queue is empty, or checking its current size are often provided as well (but aren't normally seen as part of the definition).

You can certainly use an array to implement a queue. You can also use a linked list. Although it may not make a whole lot of sense, you could also use a binary tree, a multi-way tree, a hybrid such as a linked list of arrays, or essentially anything else you can think of, as long as it supports the required operations.

Going the other direction, you could use an array to implement not only a queue, but also a stack, a deque, a heap/priority queue, a circular buffer, or any number of other abstractions.

As to your specific question of: "Is this how to implement a queue"? I'd say in general, no. Just for one example, you're ignored the law of the big three, so assignment, copying, and destruction don't really work for your queue (but you haven't prevented assignment or copying either). You've also used new[] to allocate the queue's space, which constructs objects into that space immediately upon allocation. That's fine for a queue of primitive objects like int s, but not so fine in general. Likewise, your queue can print out a message in response to isEmpty() . Assuming it exists at all, isEmpty should just return a value to indicate whether the queue is empty or not--if a printed message is needed, that should be handled by other code.