Urgent help: print elements in queue

Discussion in 'C++' started by j_depp_99@yahoo.com, Apr 16, 2007.

  1. Guest

    Thanks to those guys who helped me out yesterday. I have one more
    problem; my print function for the queue program doesnt work and goes
    into an endless loop. Also I am unable to calculate the length of my
    queue. I started getting compilation errors when I included a length
    function.
    <code>

    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; // I dont know what to put here
    }

    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);
    }

    // Main function items

    IntQueue.Enqueue(1);
    IntQueue.Enqueue(2);
    IntQueue.Enqueue(3);
    IntQueue.Enqueue(4);
    cout << "int length 3 = " << IntQueue.length() << endl;
    IntQueue.Dequeue(x);
    cout << "int length 4 = " << IntQueue.length() << endl;
    IntQueue.Print();

    </code>

    my length function has no code and I dont know what to put in there.
     
    , Apr 16, 2007
    #1
    1. Advertising

  2. mlimber Guest

    On Apr 16, 3:39 pm, wrote:
    > Thanks to those guys who helped me out yesterday. I have one more
    > problem; my print function for the queue program doesnt work and goes
    > into an endless loop. Also I am unable to calculate the length of my
    > queue. I started getting compilation errors when I included a length
    > function.
    > <code>
    >
    > 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; // I dont know what to put here
    >
    > }
    >
    > 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);
    >
    > }
    >
    > // Main function items
    >
    > IntQueue.Enqueue(1);
    > IntQueue.Enqueue(2);
    > IntQueue.Enqueue(3);
    > IntQueue.Enqueue(4);
    > cout << "int length 3 = " << IntQueue.length() << endl;
    > IntQueue.Dequeue(x);
    > cout << "int length 4 = " << IntQueue.length() << endl;
    > IntQueue.Print();
    >
    > </code>
    >
    > my length function has no code and I dont know what to put in there.


    You haven't posted sufficient code here to allow us to give a sensible
    answer. Help us help you. Read and obey this FAQ:

    http://www.parashift.com/c -faq-lite/how-to-post.html#faq-5.8

    Cheers! --M
     
    mlimber, Apr 16, 2007
    #2
    1. Advertising

  3. Guest

    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;
    for(int i=0;i<x.count;++i)
    {
    items = x.items;
    }
    }

    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;
    }

    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);


    }

    template<class ItemType>
    void Queue<ItemType>::Enqueue(ItemType x)
    {
    if(IsFull())
    throw FullQueue();
    else
    {
    rear = (rear+1)% maxQue;
    items[rear]=x;

    }
    }

    template<class ItemType>
    void Queue<ItemType>::Dequeue(ItemType &x)
    {
    if(IsEmpty())
    throw EmptyQueue();
    else
    {
    front=(front +1)% maxQue;
    x =items[front];

    }
    }

    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<int> IntQueue;

    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<float> FloatQueue;
    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>
     
    , Apr 16, 2007
    #3
  4. Heinz Ozwirk Guest

    <> schrieb im Newsbeitrag
    news:...
    > 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 = x.items;


    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<int> IntQueue;
    >
    > 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<float> FloatQueue;
    > 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
     
    Heinz Ozwirk, Apr 16, 2007
    #4
  5. Howard Guest

    <> wrote in message
    news:...
    > Sorry about that.


    Sorry about what? Please include what you're responding to.


    > 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);
    >
    >
    > }
    >


    That is the print function you're having problems with, right? So, what
    happens? (Use your debugger and see!) If it's going into an infinite loop,
    then that means that current never equals front, right? So, what's front
    equal to?

    Also, earlier you stated:
    "Also I am unable to calculate the length of my queue. I started getting
    compilation errors when I included a length function."
    What does that mean? We can't tell what's wrong with code you don't show
    us.

    -Howard
     
    Howard, Apr 16, 2007
    #5
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Sachin Jagtap

    URGENT !! QUEUE STL PROBLEM URGENT!!

    Sachin Jagtap, Apr 28, 2005, in forum: C++
    Replies:
    4
    Views:
    1,064
    Mark Stijnman
    Apr 29, 2005
  2. Paul L. Du Bois

    Queue.Queue-like class without the busy-wait

    Paul L. Du Bois, Mar 24, 2005, in forum: Python
    Replies:
    29
    Views:
    1,110
    Antoon Pardon
    Apr 4, 2005
  3. Russell Warren

    Is Queue.Queue.queue.clear() thread-safe?

    Russell Warren, Jun 22, 2006, in forum: Python
    Replies:
    4
    Views:
    724
    Russell Warren
    Jun 27, 2006
  4. Replies:
    0
    Views:
    1,237
  5. Kris
    Replies:
    0
    Views:
    535
Loading...

Share This Page