Iterator Class Help

Question

lancevo3 0 Junior Poster

15 Years Ago

I am writing a iterator class which I am having no problem with yet my problem I am having now is I need to declare some methods as Iterator in my List class and I am getting errors from that.

template <class T>
class List
      {
      friend std::ostream& operator<< <>(std::ostream&, const List<T>&);
      friend class Iterator;

      private:
              LNode<T>* head;
              LNode<T>* tail;
      public:
             List();
             ~List();
             List(const List<T>&);
             List<T>& operator=(const List<T>&);
             void clear();
             int size() const;
             bool empty() const;
             const T& front() const;
             T& front();
             const T& back() const;
             T& back();
             void copyList(const List<T>&);
             void push_front(const T&);
             void push_back(const T&);
             void pop_front();
             void pop_back();
             bool operator==(const List<T>&) const;
             bool operator<(const List<T>&) const;
             Iterator<T> begin() const;
             Iterator<T> end() const;
             Iterator<T> insert(Iterator<T>, const T&);
             Iterator<T> erase(Iterator<T> pos);
             void splice(Iterator<T>, List<T>&);
             void remove(const T&);
      };

The problem is with the declaration of these four methods.
Iterator<T> begin() const;
Iterator<T> end() const;
Iterator<T> insert(Iterator<T>, const T&);
Iterator<T> erase(Iterator<T> pos);

List.h:75: error: ISO C++ forbids declaration of âIteratorâ with no type
List.h:75: error: expected â;â before â<â token
List.h:76: error: ISO C++ forbids declaration of âIteratorâ with no type
List.h:76: error: expected â;â before â<â token
List.h:77: error: ISO C++ forbids declaration of âIteratorâ with no type
List.h:77: error: expected â;â before â<â token
List.h:78: error: ISO C++ forbids declaration of âIteratorâ with no type
List.h:78: error: expected â;â before â<â token
List.h:79: error: âIteratorâ has not been declared
List.h:79: error: expected â,â or â...â before â<â token

Those are the errors I am getting.

c++

Edited 15 Years Ago by lancevo3 because: n/a

3 Contributors
5 Replies
104 Views
12 Hours Discussion Span
Latest Post 15 Years Ago Latest Post by mrnutty

daviddoria 334 Posting Virtuoso

15 Years Ago

You don't seem to have posted the whole code - there are errors on line 75 but you've only posted 35 lines!

mrnutty 761 Senior Poster

15 Years Ago

Check if this works. It compiles on Visual studio 2008 express.

/****************************************************************
   FILE:      List.h
   AUTHOR:    Justin R. Smith
   LOGON ID:  Z136340
   DUE DATE:  9/8/09

   PURPOSE:   Contains prototypes and class definitions for a 
              doubly linked list.
****************************************************************/

 
#include <iostream>
template <class T>
class Iterator;

template <class T>
class List;

template <class T>
std::ostream& operator<<(std::ostream&, const List<T>&);


template <class T>
struct LNode
       {
       T data;
       LNode<T>* prev;
       LNode<T>* next;
       
       LNode(const T&);
       };
/****************************************************************
   FUNCTION:   LNode(const T&);
   ARGUMENTS:  newData
   RETURNS:    nothing
   NOTES:      contstructor for the LNode struct, sets data equal
               newdata and prev and next equal to NULL
****************************************************************/

       template <class T>
       LNode<T>::LNode(const T& newdata)
       {
       data = newdata;
       prev = next = NULL;
       }
       
template <class T>
class List
      {
      friend std::ostream& operator<< <>(std::ostream&, const List<T>&);	
      friend class Iterator<T>;      

      private:
              LNode<T>* head;
              LNode<T>* tail;
      public:
             List();
             ~List();
             List(const List<T>&);
             List<T>& operator=(const List<T>&);
             void clear();
             int size() const;
             bool empty() const;
             const T& front() const;
             T& front();
             const T& back() const;
             T& back();
             void copyList(const List<T>&);
             void push_front(const T&);
             void push_back(const T&);
             void pop_front();
             void pop_back();
             bool operator==(const List<T>&) const;
             bool operator<(const List<T>&) const;
	     Iterator<T> begin() const;
	     Iterator<T> end() const;
	     Iterator<T> insert(Iterator<T>, const T&);
	     Iterator<T> erase(Iterator<T> pos);
	     void splice(Iterator<T>, List<T>&);
	     void remove(const T&);
      };
      
      /****************************************************************
      FUNCTION:  List();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     default constructor sets head and tail pointers to NULL
      ****************************************************************/
      template <class T>
      List<T>::List()
      {
      head = NULL;
      tail = NULL;
      }
      
      /****************************************************************
      FUNCTION:  ~List();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     destructor calls the clear function to clear list
      ****************************************************************/
      template <class T>
      List<T>::~List()
      {
      clear();
      }
      
      /****************************************************************
      FUNCTION:  List(const List<T>&);
      ARGUMENTS: oldList
      RETURNS:   nothing
      NOTES:     copy constructor for List class
      ****************************************************************/
      template <class T>
      List<T>::List(const List<T>& oldList)
      {
      head = tail = NULL;
      copyList(oldList);
      }
      
      /****************************************************************
      FUNCTION:  copyList(const List<T>&);
      ARGUMENTS: listToCopy
      RETURNS:   nothing
      NOTES:     method to copy contents of a list
      ****************************************************************/
      template <class T>
      void List<T>::copyList(const List<T>& listToCopy)
      {
      LNode<T>* ptr;

      for (ptr = listToCopy.head; ptr != NULL; ptr = ptr->next)
        push_back(ptr->data);
      }
      
      /****************************************************************
      FUNCTION:  List<T>& operator=(const List<T>&)
      ARGUMENTS: rightOp
      RETURNS:   *this
      NOTES:     overloads the assignment operator
      ****************************************************************/     
      template <class T>
      List<T>& List<T>::operator=(const List<T>& rightOp)
      {
         if (this != &rightOp)
         {
         clear();
         copyList(rightOp);;
         }	
      return *this;
      }
      
      /****************************************************************
      FUNCTION:  void clear();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     calls pop_front to delete from the list while its not
                 empty
      ****************************************************************/ 
      template <class T>
      void List<T>::clear()
      {
      while(!empty())
          pop_front();
      }
      
      /****************************************************************
      FUNCTION:  int size() const;
      ARGUMENTS: none
      RETURNS:   count
      NOTES:     counts the number of nodes in the list and returns that
                 count
      ****************************************************************/ 
      template <class T>
      int List<T>::size() const
      {
      LNode<T>* ptr = head;
      int count = 0;

      while(ptr != NULL)
      {
      	count++;
	    ptr = ptr->next;
      }
      return count;
      }      
      
      /****************************************************************
      FUNCTION:  bool empty() const;
      ARGUMENTS: none
      RETURNS:   true or false
      NOTES:     returns whether list is empty or not
      ****************************************************************/                    
      template <class T>
      bool List<T>::empty() const
      {
      if(head == NULL or tail == NULL)
          return true;
      else
          return false;
      }
      
      /****************************************************************
      FUNCTION:  const T& front() const;
                 T& front()
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     both return head->data
      ****************************************************************/ 
      template <class T>
      const T& List<T>::front() const
      {
      return head->data;
      }
      
      template <class T>
      T& List<T>::front()
      {
      return head->data;
      }
      
      /****************************************************************
      FUNCTION:  const T& back() const;
                 T& back();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     both return tail->data
      ****************************************************************/ 
      template <class T>
      const T& List<T>::back() const
      {
      return tail->data;
      }
      
      template <class T>
      T& List<T>::back()
      {
      return tail->data;
      }
      
      /****************************************************************
      FUNCTION:  void push_front(const T&);
      ARGUMENTS: item
      RETURNS:   nothing
      NOTES:     inserts item at front of list
      ****************************************************************/ 
      template <class T>
      void List<T>::push_front(const T& item)
      {
      LNode<T>* newNode;
      newNode = new LNode<T>(item);

      newNode->prev = NULL;
      newNode->next = head;
      if(empty())
            tail = newNode;
      else
	        head->prev = newNode;
      head = newNode;
      }
      
      /****************************************************************
      FUNCTION:  void push_back(const T&);
      ARGUMENTS: item
      RETURNS:   nothing
      NOTES:     inserts item at rear of list
      ****************************************************************/ 
      template <class T>
      void List<T>::push_back(const T& item)
      {
      LNode<T>* newNode;
      newNode = new LNode<T>(item);      

      newNode->next = NULL;
      newNode->prev = tail;
      if(empty())
            head = newNode;
      else
            tail->next = newNode;
      tail = newNode;
      }
      
      /****************************************************************
      FUNCTION:  void pop_front();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     removes item at front of list
      ****************************************************************/ 
      template <class T>
      void List<T>::pop_front()
      {
      LNode<T>* delNode = head;
      head = delNode->next;
      
      if(!empty())
            head->prev = NULL;
      else
            tail = NULL;
      
      delete delNode;
      }
      
      /****************************************************************
      FUNCTION:  void pop_back();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     removes item at rear of list
      ****************************************************************/ 
      template <class T>
      void List<T>::pop_back()
      {
      LNode<T>* delNode = tail;
      tail = delNode->prev;
      
      if(!empty())
            tail->next = NULL;
      else
            head = NULL;
      
      delete delNode;
      }
      
      /****************************************************************
      FUNCTION:  bool operator==(const List<T>&) const;
      ARGUMENTS: rightOp
      RETURNS:   true or false
      NOTES:     overloads the equality operator
      ****************************************************************/
      template <class T>
      bool List<T>::operator==(const List<T>& rightOp) const
      {
      LNode<T>* p1;
      LNode<T>* p2;

      p1 = this->head;
      p2 = rightOp.head;
      
      while(p1 != NULL and p2 != NULL)
            {
            if(p1->data != p2->data)
                  return false;
            p1 = p1->next;
            p2 = p2->next;
            }
      if(p1 == NULL and p2 == NULL)
            return true;
      else
            return false;
      }
      
      /****************************************************************
      FUNCTION:  bool operator<(const List<T>&) const;
      ARGUMENTS: rightOp
      RETURNS:   true or false
      NOTES:     overloads the less than operator
      ****************************************************************/
      template <class T>
      bool List<T>::operator<(const List<T>& rightOp) const
      {
      LNode<T>* p1;
      LNode<T>* p2;
      
      p1 = this->head;
      p2 = rightOp.head;
      
      while(p1 != NULL and p2 != NULL)
             {
             if(p1->data < p2->data)
                         return true;
             if(p1->data > p2->data)
                         return false;
             p1 = p1->next;
             p2 = p2->next;
             }
      if(p2 == NULL)
            return false;
      else
            return true;
      }
      
      /****************************************************************
      FUNCTION:  std::ostream& operator<< <>(std::ostream&, const List<T>&);
      ARGUMENTS: leftOp, rightOp
      RETURNS:   leftOp
      NOTES:     overloads << for output
      ****************************************************************/
      template <class T>
      std::ostream& operator<<(std::ostream& leftOp, const List<T>& rightOp)
      {
      LNode<T>* current;
	
      for (current=rightOp.head; current != NULL; current = current->next)
		std::cout << current->data << " ";
	  return leftOp;
      }

      template <class T>
      Iterator<T> List<T>::begin() const
      {
      return Iterator<T>(head);
      }

      template <class T>
      Iterator<T> List<T>::end() const
      {
      return Iterator<T>(NULL);
      }

template <class T>
class Iterator
      {
      friend class List<T>;
      private:
             LNode<T>* nodePtr;
      public:
             Iterator();
	     Iterator(LNode<T>*);
             Iterator<T>& operator++();
             Iterator<T> operator++(int);
             Iterator<T>& operator--();
             Iterator<T> operator--(int);
             T& operator*() const;
             T& operator->() const;
             bool operator==(const Iterator<T>&) const;
             bool operator!=(const Iterator<T>&) const;
      };

	template <class T>
	Iterator<T>::Iterator()
	{
	nodePtr = NULL;
	}

	template <class T>
	Iterator<T>::Iterator(LNode<T>* p)
	{
	nodePtr = p;
	}

	template <class T>
	Iterator<T>& Iterator<T>::operator++()
	{
	nodePtr = nodePtr->next;

	return *this;
	}

	template <class T>
	Iterator<T> Iterator<T>::operator++(int u)
	{
	Iterator<T> temp;
	temp = *this;

	nodePtr = nodePtr->next;
	
	return temp;
	}
	
	template <class T>
	Iterator<T>& Iterator<T>::operator--()
	{
	nodePtr = nodePtr->prev;

	return *this;
	}
	
	template <class T>
	Iterator<T> Iterator<T>::operator--(int u)
	{
	Iterator<T> temp;
	temp = *this;

	nodePtr = nodePtr->prev;

	return temp;
	}

	template <class T>
	T& Iterator<T>::operator*() const
	{
	return nodePtr->data;
	}

	template <class T>
	T& Iterator<T>::operator->() const
	{
	return this->data;
	}

	template <class T>
	bool Iterator<T>::operator==(const Iterator<T>& rightOp) const
	{
	if(this->nodePtr == rightOp.nodePtr)
		return true;
	else
		return false;
	}

	template <class T>
	bool Iterator<T>::operator!=(const Iterator<T>& rightOp) const
	{
	if(this->nodePtr != rightOp.nodePtr)
		return true;
	else
		return false;
	}	

int main()
{


}

Reply to this topic

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.

lancevo3 0 Junior Poster · Answer 1 · 2009-09-08T23:14:53+00:00

Ok well here is my whole code then.

/****************************************************************
   FILE:      List.h
   AUTHOR:    Justin R. Smith
   LOGON ID:  Z136340
   DUE DATE:  9/8/09

   PURPOSE:   Contains prototypes and class definitions for a 
              doubly linked list.
****************************************************************/


#ifndef LIST_H
#define LIST_H

#include <iostream>

template <class T>
class List;

template <class T>
std::ostream& operator<<(std::ostream&, const List<T>&);

template <class T>
struct LNode
       {
       T data;
       LNode<T>* prev;
       LNode<T>* next;
       
       LNode(const T&);
       };
/****************************************************************
   FUNCTION:   LNode(const T&);
   ARGUMENTS:  newData
   RETURNS:    nothing
   NOTES:      contstructor for the LNode struct, sets data equal
               newdata and prev and next equal to NULL
****************************************************************/

       template <class T>
       LNode<T>::LNode(const T& newdata)
       {
       data = newdata;
       prev = next = NULL;
       }
       
template <class T>
class List
      {
      friend std::ostream& operator<< <>(std::ostream&, const List<T>&);	
      friend class Iterator;      

      private:
              LNode<T>* head;
              LNode<T>* tail;
      public:
             List();
             ~List();
             List(const List<T>&);
             List<T>& operator=(const List<T>&);
             void clear();
             int size() const;
             bool empty() const;
             const T& front() const;
             T& front();
             const T& back() const;
             T& back();
             void copyList(const List<T>&);
             void push_front(const T&);
             void push_back(const T&);
             void pop_front();
             void pop_back();
             bool operator==(const List<T>&) const;
             bool operator<(const List<T>&) const;
	     Iterator<T> begin() const;
	     Iterator<T> end() const;
	     Iterator<T> insert(Iterator<T>, const T&);
	     Iterator<T> erase(Iterator<T> pos);
	     void splice(Iterator<T>, List<T>&)
	     void remove(const T&);
      };
      
      /****************************************************************
      FUNCTION:  List();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     default constructor sets head and tail pointers to NULL
      ****************************************************************/
      template <class T>
      List<T>::List()
      {
      head = NULL;
      tail = NULL;
      }
      
      /****************************************************************
      FUNCTION:  ~List();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     destructor calls the clear function to clear list
      ****************************************************************/
      template <class T>
      List<T>::~List()
      {
      clear();
      }
      
      /****************************************************************
      FUNCTION:  List(const List<T>&);
      ARGUMENTS: oldList
      RETURNS:   nothing
      NOTES:     copy constructor for List class
      ****************************************************************/
      template <class T>
      List<T>::List(const List<T>& oldList)
      {
      head = tail = NULL;
      copyList(oldList);
      }
      
      /****************************************************************
      FUNCTION:  copyList(const List<T>&);
      ARGUMENTS: listToCopy
      RETURNS:   nothing
      NOTES:     method to copy contents of a list
      ****************************************************************/
      template <class T>
      void List<T>::copyList(const List<T>& listToCopy)
      {
      LNode<T>* ptr;

      for (ptr = listToCopy.head; ptr != NULL; ptr = ptr->next)
        push_back(ptr->data);
      }
      
      /****************************************************************
      FUNCTION:  List<T>& operator=(const List<T>&)
      ARGUMENTS: rightOp
      RETURNS:   *this
      NOTES:     overloads the assignment operator
      ****************************************************************/     
      template <class T>
      List<T>& List<T>::operator=(const List<T>& rightOp)
      {
         if (this != &rightOp)
         {
         clear();
         copyList(rightOp);;
         }	
      return *this;
      }
      
      /****************************************************************
      FUNCTION:  void clear();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     calls pop_front to delete from the list while its not
                 empty
      ****************************************************************/ 
      template <class T>
      void List<T>::clear()
      {
      while(!empty())
          pop_front();
      }
      
      /****************************************************************
      FUNCTION:  int size() const;
      ARGUMENTS: none
      RETURNS:   count
      NOTES:     counts the number of nodes in the list and returns that
                 count
      ****************************************************************/ 
      template <class T>
      int List<T>::size() const
      {
      LNode<T>* ptr = head;
      int count = 0;

      while(ptr != NULL)
      {
      	count++;
	    ptr = ptr->next;
      }
      return count;
      }      
      
      /****************************************************************
      FUNCTION:  bool empty() const;
      ARGUMENTS: none
      RETURNS:   true or false
      NOTES:     returns whether list is empty or not
      ****************************************************************/                    
      template <class T>
      bool List<T>::empty() const
      {
      if(head == NULL or tail == NULL)
          return true;
      else
          return false;
      }
      
      /****************************************************************
      FUNCTION:  const T& front() const;
                 T& front()
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     both return head->data
      ****************************************************************/ 
      template <class T>
      const T& List<T>::front() const
      {
      return head->data;
      }
      
      template <class T>
      T& List<T>::front()
      {
      return head->data;
      }
      
      /****************************************************************
      FUNCTION:  const T& back() const;
                 T& back();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     both return tail->data
      ****************************************************************/ 
      template <class T>
      const T& List<T>::back() const
      {
      return tail->data;
      }
      
      template <class T>
      T& List<T>::back()
      {
      return tail->data;
      }
      
      /****************************************************************
      FUNCTION:  void push_front(const T&);
      ARGUMENTS: item
      RETURNS:   nothing
      NOTES:     inserts item at front of list
      ****************************************************************/ 
      template <class T>
      void List<T>::push_front(const T& item)
      {
      LNode<T>* newNode;
      newNode = new LNode<T>(item);

      newNode->prev = NULL;
      newNode->next = head;
      if(empty())
            tail = newNode;
      else
	        head->prev = newNode;
      head = newNode;
      }
      
      /****************************************************************
      FUNCTION:  void push_back(const T&);
      ARGUMENTS: item
      RETURNS:   nothing
      NOTES:     inserts item at rear of list
      ****************************************************************/ 
      template <class T>
      void List<T>::push_back(const T& item)
      {
      LNode<T>* newNode;
      newNode = new LNode<T>(item);      

      newNode->next = NULL;
      newNode->prev = tail;
      if(empty())
            head = newNode;
      else
            tail->next = newNode;
      tail = newNode;
      }
      
      /****************************************************************
      FUNCTION:  void pop_front();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     removes item at front of list
      ****************************************************************/ 
      template <class T>
      void List<T>::pop_front()
      {
      LNode<T>* delNode = head;
      head = delNode->next;
      
      if(!empty())
            head->prev = NULL;
      else
            tail = NULL;
      
      delete delNode;
      }
      
      /****************************************************************
      FUNCTION:  void pop_back();
      ARGUMENTS: none
      RETURNS:   nothing
      NOTES:     removes item at rear of list
      ****************************************************************/ 
      template <class T>
      void List<T>::pop_back()
      {
      LNode<T>* delNode = tail;
      tail = delNode->prev;
      
      if(!empty())
            tail->next = NULL;
      else
            head = NULL;
      
      delete delNode;
      }
      
      /****************************************************************
      FUNCTION:  bool operator==(const List<T>&) const;
      ARGUMENTS: rightOp
      RETURNS:   true or false
      NOTES:     overloads the equality operator
      ****************************************************************/
      template <class T>
      bool List<T>::operator==(const List<T>& rightOp) const
      {
      LNode<T>* p1;
      LNode<T>* p2;

      p1 = this->head;
      p2 = rightOp.head;
      
      while(p1 != NULL and p2 != NULL)
            {
            if(p1->data != p2->data)
                  return false;
            p1 = p1->next;
            p2 = p2->next;
            }
      if(p1 == NULL and p2 == NULL)
            return true;
      else
            return false;
      }
      
      /****************************************************************
      FUNCTION:  bool operator<(const List<T>&) const;
      ARGUMENTS: rightOp
      RETURNS:   true or false
      NOTES:     overloads the less than operator
      ****************************************************************/
      template <class T>
      bool List<T>::operator<(const List<T>& rightOp) const
      {
      LNode<T>* p1;
      LNode<T>* p2;
      
      p1 = this->head;
      p2 = rightOp.head;
      
      while(p1 != NULL and p2 != NULL)
             {
             if(p1->data < p2->data)
                         return true;
             if(p1->data > p2->data)
                         return false;
             p1 = p1->next;
             p2 = p2->next;
             }
      if(p2 == NULL)
            return false;
      else
            return true;
      }
      
      /****************************************************************
      FUNCTION:  std::ostream& operator<< <>(std::ostream&, const List<T>&);
      ARGUMENTS: leftOp, rightOp
      RETURNS:   leftOp
      NOTES:     overloads << for output
      ****************************************************************/
      template <class T>
      std::ostream& operator<<(std::ostream& leftOp, const List<T>& rightOp)
      {
      LNode<T>* current;
	
      for (current=rightOp.head; current != NULL; current = current->next)
		std::cout << current->data << " ";
	  return leftOp;
      }

      template <class T>
      Iterator<T> List<T>::begin() const
      {
      return Iterator<T>(head);
      }

      template <class T>
      Iterator<T> List<T>::end() const
      {
      return Iterator<T>(NULL);
      }

template <class T>
class Iterator
      {
      friend class List<T>;
      private:
             LNode<T>* nodePtr;
      public:
             Iterator();
	     Iterator(LNode<T>*);
             Iterator<T>& operator++();
             Iterator<T> operator++(int);
             Iterator<T>& operator--();
             Iterator<T> operator--(int);
             T& operator*() const;
             T& operator->() const;
             bool operator==(const Iterator<T>&) const;
             bool operator!=(const Iterator<T>&) const;
      };

	template <class T>
	Iterator<T>::Iterator()
	{
	nodePtr = NULL;
	}

	template <class T>
	Iterator<T>::Iterator(LNode<T>* p)
	{
	nodePtr = p;
	}

	template <class T>
	Iterator<T>& Iterator<T>::operator++()
	{
	nodePtr = nodePtr->next;

	return *this;
	}

	template <class T>
	Iterator<T> Iterator<T>::operator++(int u)
	{
	Iterator<T> temp;
	temp = *this;

	nodePtr = nodePtr->next;
	
	return temp;
	}
	
	template <class T>
	Iterator<T>& Iterator<T>::operator--()
	{
	nodePtr = nodePtr->prev;

	return *this;
	}
	
	template <class T>
	Iterator<T> Iterator<T>::operator--(int u)
	{
	Iterator<T> temp;
	temp = *this;

	nodePtr = nodePtr->prev;

	return temp;
	}

	template <class T>
	T& Iterator<T>::operator*() const
	{
	return nodePtr->data;
	}

	template <class T>
	T& Iterator<T>::operator->() const
	{
	return this->data;
	}

	template <class T>
	bool Iterator<T>::operator==(const Iterator<T>& rightOp) const
	{
	if(this->nodePtr == rightOp.nodePtr)
		return true;
	else
		return false;
	}

	template <class T>
	bool Iterator<T>::operator!=(const Iterator<T>& rightOp) const
	{
	if(this->nodePtr != rightOp.nodePtr)
		return true;
	else
		return false;
	}	

	
#endif /*LIST_H*/

lancevo3 0 Junior Poster · Answer 2 · 2009-09-09T00:20:22+00:00

Any suggestions on this? Am I just typing out the prototypes wrong?

lancevo3 0 Junior Poster · Answer 3 · 2009-09-09T02:27:14+00:00

Does anyone have any Idea what it could be? I been looking through my books and stuff online and it looks like my definitions are right I don't know why the compiler doesn't agree.