0

我不能使用 std::list。目标是创建一个用户定义的 MyList 可以处理任何数据类型。我的问题在于我的嵌套迭代器类，可能还有我用于重载运算符<<的函数。我已经有一段时间了，我被困住了。由于截止日期很近，我想我应该冒险在这里问这个问题。如果有人可以帮助我，那就太好了。

我意识到我的代码中存在内存泄漏，但这不是我目前主要关心的问题。我也意识到有这么多的朋友函数不是一个好的编程习惯，我打算稍后使用 getData() 和 setData() 函数来获取/设置节点内的私有变量。

所以请忽略以上2个问题...

错误信息：

"MyList.h", line 67: Error: iterator is not defined.

我将包含整个头文件，以便人们需要查看它。我将在第 67 行包含错误所在的注释。然后，我还将包含我的 main 函数的一部分，它使用迭代器来展示我如何尝试设置迭代器并遍历列表。

#include<iostream>
#include<cstddef>

template<class T>
class Node
{
   friend void MyList<T>::push_front(T aData);
   friend void MyList<T>::push_back(T aData);
   friend void MyList<T>::pop_front();
   friend T MyList<T>::front();
   friend void MyList<T>::print();
   friend MyList<T>::~MyList();
   friend std::ostream& operator<<(std::ostream&, Node<T>&);
   private:
      T data;
      Node *next;
      Node *prev;
   public:
      Node(T aData);

};

template<class T>
class MyList
{
   Node<T> *head;
   Node<T> *tail;
   public:
      MyList();
      ~MyList();
      void push_front(T aData);
      void push_back(T aData);
      T front();
      void pop_front();
      void operator=(MyList<T>& another_List);

      void print();  //Test function. Delete later.

      class iterator
      {
         private:
            MyList& object;
            Node<T> *current;
         public:
            iterator(MyList<T>&, Node<T>*);     // iterator a(*this, head);
                                                // MyList<int>::iterator a = list.Begin();
            iterator operator++();          // a++
            iterator operator++(int);           // ++a
            iterator operator--();
            bool operator!=(iterator);
            friend std::ostream& operator<<(std::ostream&, iterator&);
      };

      iterator Begin();
      iterator End();
};

template<class T>
std::ostream& operator<<(std::ostream& out, Node<T>& n)
{
   out << *n.current << ' ';

   return out;
}

template<class T>
std::ostream& operator<<(std::ostream& out, iterator& i)  //ERROR
{
   out << i->current << ' ';

   return out;
}

template<class T>
Node<T>::Node(T aData)
{
   data = aData;
}

template<class T>
MyList<T>::MyList()
{
   head = NULL;
}

template<class T>
MyList<T>::~MyList()
{
   Node<T> *temp;

   while(head != NULL)
   {
      temp = head;
      head = head->next;
      delete temp;
   }
   head = NULL;
}

template<class T>
void MyList<T>::push_front(T aData)
{
   if(head == NULL)
   {
      head = new Node<T>(aData);
      head->next = tail;
      head->prev = NULL;
      tail->prev = head;
   }
   else
   {
      head->prev = new Node<T>(aData);
      head->prev->prev = NULL;
      head->prev->next = head;
      head = head->prev;
   }
}

template<class T>
void MyList<T>::push_back(T aData)
{
   if(head == NULL)
   {
      head = new Node<T>(aData);
      head->prev = NULL;
      head->next = tail;
      tail->prev = head;
   }
   else
   {
      tail->prev->next = new Node<T>(aData);
      tail->prev->next->prev = tail->prev;
      tail->prev->next->next = tail;
      tail->prev = tail->prev->next;
   }
}

template<class T>
T MyList<T>::front()
{
   return head->data;
}

template<class T>
void MyList<T>::pop_front()
{
   if(head == NULL)
      std::cout << "The List is empty!" << endl;
   else
   {
      head = head->next;
      head->prev = NULL;
   }
}

template<class T>
void MyList<T>::print()
{
   while(head != NULL)
   {
      std::cout << "Test print function" << std::endl;
      std::cout << '[' << head->data << ']' << std::endl;
      head = head->next;
   }
   std::cout << "End of test print function" << std::endl;
}

template<class T>
MyList<T>::iterator::iterator(MyList<T>& list, Node<T>* p)
{
   object = list;
   current = p;
}

template<class T>
typename MyList<T>::iterator MyList<T>::iterator::operator++()
{
   if(current == object.tail)
   {
   }
   else
      current = current->next;
   return this;
}

template<class T>
typename MyList<T>::iterator MyList<T>::iterator::operator++(int)
{
   if(current == object.tail)
   {
   }
   else
      current = current->next;
   return this->prev;
}

template<class T>
typename MyList<T>::iterator MyList<T>::iterator::operator--()
{
   if(current == object.head)
   {
   }
   else
      current = current->prev;
   return this;
}

template<class T>
bool MyList<T>::iterator::operator!=(iterator b)
{
   return (this.current == b.current);
}

template<class T>
typename MyList<T>::iterator MyList<T>::Begin()
{
   return iterator(object, head);
}

template<class T>
typename MyList<T>::iterator MyList<T>::End()
{
   return iterator(object, tail);
}

主文件

   MyList<int>::iterator i = aList.Begin();
   while(i != aList.End())
   {
      cout << i;
      i++;
   }
4

1 回答 1

1

由于您的iterator类的定义嵌套在您的MyList类模板的定义中，因此对于 out 之外的所有代码MyList，其名称为MyList<whatever>::iterator.

也许您希望在包含错误的代码中稍有不同。虽然您已将其定义为模板：

template<class T>
std::ostream& operator<<(std::ostream& out, iterator& i)  //ERROR
{
   out << i->current << ' ';

   return out;
}

您似乎根本没有使用它的模板参数 ( T)。也许您真的打算更像：

template<class iterator>
std::ostream& operator<<(std::ostream& out, iterator& i)  //ERROR
{
   out << i->current << ' ';

   return out;
}

在这种情况下，您不需要提供限定符，因为iterator这里只是指模板参数。当您使用它时，编译器通常会推断您实际传递的迭代器的类型。

请注意，像这样在模板参数中指定迭代器类别是不必要的，但有些传统，因此您通常会使用类似的东西OutIterator而不是仅iterator用于模板参数。

不过，这并不是很通用——特别是，这->current意味着它只适用于您的特定迭代器类型。更典型的代码会重载operator *迭代器类型，因此客户端代码只会取消引用迭代器。另请注意，迭代器通常被假定为足够“轻量级”，以至于它们通常按值传递，而不是按引用传递。

class iterator {
    // ...
    T operator*() { return *current; }
};

// ...
template<class OutIt>
std::ostream& operator<<(std::ostream& out, OutIt i)
{
    out << *i << ' ';
    return out;
}
于 2013-06-11T13:56:33.650 回答