Question

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

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

所以请忽略上述两个问题......

错误讯息：

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

的main.cpp

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

Answer 1

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

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

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

重载运算符＆lt;＆lt;用户定义的MyList

1 个答案: