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.

Edited 7 Years Ago by lancevo3: n/a

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

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*/

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

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.

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()
{


}
This article has been dead for over six months. Start a new discussion instead.