do not understand the errors

[yotic]

There are errors in this code that im having, i believe i have narrowed it down to a node of the variable Type pointing to the value int, there is no conversion for this. BUT according to my teacher this is how the code works and my error is somewhere else in my code.

The purpose of the program is to take the function count and make it return the number of elements in the queue using nodes in some complicated way.

header file

//Header file QueueAsArray

#ifndef H_HEADER
#define H_HEADER
  
#include <iostream>
#include <cassert>

using namespace std;

template <class Type>
struct nodeType
{
    Type info;
    nodeType<Type> *link;
};

template <class Type>
class queueType
{
public:
    const queueType<Type>& operator=(const queueType<Type>&); 
            // overload the assignment operator
    void initializeQueue();
    int isEmptyQueue() const;
    int isFullQueue() const;

    Type front() const;

    Type back() const;
	int queueCount();
    void addQueue(const Type& newElement);
    void deleteQueue();

    queueType(int queueSize = 100); 
    queueType(const queueType<Type>& otherQueue); // copy constructor
    ~queueType(); //destructor

private:
    int maxQueueSize;
    int queueFront;
    int queueRear;
	int count;
    Type *list;  //pointer to array that holds queue elements 
};


template<class Type>
int queueType<Type>::queueCount()
{
    return count;
}

template<class Type>
void queueType<Type>::initializeQueue()
{
    nodeType<Type> *temp;
 
    while (queueFront!= NULL)   //while there are elements left
                                //in the queue
    {
        temp = queueFront;    //set temp to point to the current node
        queueFront = queueFront->link;  //advance first to the
                                                       //next node
        delete temp;       //deallocate memory occupied by temp
    }
    queueRear = NULL;  //set rear to NULL
    count = 0;
} //end initializeQueue

template<class Type>
int queueType<Type>::isEmptyQueue() const
{
    return (queueFront == queueRear);
}

template<class Type>
int queueType<Type>::isFullQueue() const
{
    return ((queueRear + 1) % maxQueueSize == queueFront);
}

template <class Type>
void queueType<Type>::addQueue(const Type& newElement)
{
       nodeType<Type> *newNode;
 
       newNode = new nodeType<Type>;  //create the node
 
       newNode->info = newElement;    //store the info
    newNode->link = NULL;         //initialize the link field to NULL
      
       if (queueFront == NULL)          //if initially the queue is empty
    {
          queueFront = newNode;
          queueRear = newNode;
    }
    else                          //add newNode at the end
    {
          queueRear->link = newNode;
          queueRear = queueRear->link;
    }
       count++;
}//end addQueue

template<class Type>
void queueType<Type>::deleteQueue()
{
   nodeType<Type> *temp;
  
   if (!isEmptyQueue())
   {
	   temp = queueFront;       //make temp point to the first node
	   queueFront = queueFront->link; //advance queueFront
	   delete temp;                  //delete the first node
	   
	   if (queueFront == NULL)   //if after deletion the queue is empty
	   {
		   queueRear = NULL;    //set queueRear to NULL
		   count--;
	   }
   }
   else
cout << "Cannot remove from an empty queue." << endl;
}//end deleteQueue

template<class Type>
Type queueType<Type>::front() const
{
       assert(queueFront != NULL);
       return queueFront->info;
}

template<class Type>
Type queueType<Type>::back() const
{
    assert(!isEmptyQueue());
    return list[(queueRear + 1) % maxQueueSize];
}

template<class Type>
queueType<Type>::queueType(int queueSize)   //constructor
{
    if (queueSize <= 0)
    {
        cout << "Size of the array to hold the queue must "
             << "be positive."<<endl;
        cout << "Creating an array of size 100." << endl;

        maxQueueSize = 100;
    }
    else
        maxQueueSize = queueSize;  //set maxQueueSize to queueSize

    queueFront = maxQueueSize - 1;  //initialize queueFront
    queueRear = maxQueueSize - 1;   //initiaize queueRear
    list = new Type[maxQueueSize];  //create the array to
				                    //hold queue elements
}

template<class Type>
queueType<Type>::~queueType()   //destructor
{
    delete [] list;
}

template<class Type>
const queueType<Type>& queueType<Type>::operator=(const queueType<Type>& otherQueue)
{
    int j;

    if (this != &otherQueue) //avoid self-copy
    {
        maxQueueSize = otherQueue.maxQueueSize;
        queueFront = otherQueue.queueFront;
        queueRear = otherQueue.queueRear;	

        delete [] list;
        list = new Type[maxQueueSize];

        if (queueFront != queueRear)						//if other queue is not empty
        for (j = (queueFront + 1) % maxQueueSize; j <= queueRear; 
                                j = (j + 1) % maxQueueSize)  //copy other queue in this queue
            list[j] = otherQueue.list[j];
    } //end if

    return *this;
}

template<class Type>
queueType<Type>::queueType(const queueType<Type>& otherQueue)
{
	maxQueueSize = otherQueue.maxQueueSize;
	queueFront = otherQueue.queueFront;
	queueRear = otherQueue.queueRear;

	list = new Type[maxQueueSize];

	if (queueFront != queueRear)	//if other queue is not empty
		for (int j = (queueFront + 1) % maxQueueSize; j <= queueRear; 
								   j = (j + 1) % maxQueueSize)  //copy other queue in this queue
			list[j] = otherQueue.list[j];
	
}

#endif 

main file

#include <iostream>
#include "header.h"

using namespace std;
 
void testCopyConstructor(queueType<int> otherQueue);
 
int main()
{
	queueType<int> queue1, queue2;
	int x, y;

	x = 4;
	y = 5;
	queue1.addQueue(x);
	queue1.addQueue(y);
	x = queue1.front();
	queue1.deleteQueue();
	queue1.addQueue(x + 5);
	queue1.addQueue(16);
	queue1.addQueue(x);
	queue1.addQueue(y - 3);
	queue1.addQueue(343);

	testCopyConstructor(queue1);	

	queue2 = queue1;

	queue2.addQueue(222);

	cout << "queue1: ";

	while (!queue1.isEmptyQueue())
	{
		cout << queue1.front() << " ";
		queue1.deleteQueue();
	}

	cout << endl << "the number of elements in queue 1 is " << queue1.queueCount() << endl;

	cout << "queue2: ";

	while (!queue2.isEmptyQueue())
	{
		cout << queue2.front() << " ";
		queue2.deleteQueue();
	}

	cout << endl << "the number of elements in queue 2 is " << queue2.queueCount() << endl;

	cin.get();
	return 0;
}

void testCopyConstructor(queueType<int> otherQueue)
{
	if (!otherQueue.isEmptyQueue())
	{
		cout << "Other Queue is not empty" << endl;
		cout << "Front element of Other Queue : " 
			 << otherQueue.front() << endl;
		otherQueue.deleteQueue();
	}
}

[Shinigami]

And where the error message?

I get this errors:
header.h
1) line 59 while (queueFront!= NULL) //while there are elements left
warning is "NULL used in arithmetic".

2) line 63 queueFront = queueFront->link; //advance first to the
queueFront->link is not a pointer. So it do not have "->link". It is "int queueFront;"

3) line 93 if (queueFront == NULL) //if initially the queue is empty
warning is "NULL used in arithmetic".

4) line 100 queueRear->link = newNode;
queueRear->link is not a pointer. So it do not have "->link". It is int queueRear;"

And here are more... like this.

[yotic]

okay let me rephrase my question, my teacher has the code the way she wants it, and i have to figure ways around these errors but how do you go about fixing errors?

[Peter87]

When I fix errors I often start fixing the error that is reported first. Later errors could be caused by earlier errors so often it's enough fixing the first error and most of the other errors will be gone.

[coder777]

As Shinigami hint you confuse indices with pointers.

Since queueType does not contain a variable that can hold nodeType<Type> i don't see why you do as if.

So remove all (remain) references to nodeType and treat queueFront/queueRear as what they are: indices into an array of 'Type'

Looking at back() front() would be:

template<class Type>
Type queueType<Type>::front() const
{
       assert(!isEmptyQueue());
       return list[queueFront]; // I don't see why % is necessary?
}