Question

我正在尝试定义此运算符重载函数。但是，我从编译器收到此错误：

List.hpp:62:1: error: invalid use of template-name ‘cop4530::List’ without an argument list
List& List<T>::operator=(List&& rhs) // move assingment operator

这是我正在研究的全班。它是一个实现双向链表的类：

template <typename T>
class List {
    private:
      struct Node {
         T data;
         Node *prev;
         Node *next;

         Node(const T & d = T{}, Node *p = nullptr, Node *n = nullptr) 
            : data{d}, prev{p}, next{n} {}
         Node(T && d, Node *p = nullptr, Node *n = nullptr)
            : data{std::move(d)}, prev{p}, next{n} {}
      };

   public:
      //nested const_iterator class
      class const_iterator {
         public:
            const_iterator();            // default zero parameter constructor
            const T & operator*() const; // operator*() to return element

            // increment/decrement operators
            const_iterator & operator++();
            const_iterator operator++(int);
            const_iterator & operator--();
            const_iterator operator--(int);

            // comparison operators
            bool operator==(const const_iterator &rhs) const;
            bool operator!=(const const_iterator &rhs) const;

         protected:
            Node *current;              // pointer to node in List
            T & retrieve() const;       // retrieve the element refers to
            const_iterator(Node *p);    // protected constructor

            friend class List<T>;
      };

      // nested iterator class
      class iterator : public const_iterator {
         public:
            iterator();
            T & operator*();
            const T & operator*() const;

            // increment/decrement operators
            iterator & operator++();
            iterator operator++(int);
            iterator & operator--();
            iterator operator--(int);

         protected:
            iterator(Node *p);
            friend class List<T>;
      };

   public:
      // constructor, desctructor, copy constructor
      List();                  // default zero parameter constructor
      List(const List &rhs);   // copy constructor
      List(List && rhs);       // move constructor

      // num elements with value of val
      explicit List(int num, const T& val = T{});

      // constructs with elements [start, end)
      List(const_iterator start, const_iterator end); 

  // constructs with a copy of each of the elements in the initalizer_list
  List (std::initializer_list<T> iList);

      ~List(); // destructor

      // copy assignment operator
      const List& operator=(const List &rhs);

      // move assignment operator
      List & operator=(List && rhs);

  // sets list to the elements of the initializer_list
      List& operator= (std::initializer_list<T> iList);


      // member functions
      int size() const;       // number of elements
      bool empty() const;     // check if list is empty
      void clear();           // delete all elements
      void reverse();         // reverse the order of the elements

      T& front();             // reference to the first element
      const T& front() const;
      T& back();              // reference to the last element
      const T& back() const; 

      void push_front(const T & val); // insert to the beginning
      void push_front(T && val);      // move version of insert
      void push_back(const T & val);  // insert to the end
      void push_back(T && val);       // move version of insert
      void pop_front();               // delete first element
      void pop_back();                // delete last element

      void remove(const T &val);      // remove all elements with value = val

  template <typename PREDICATE>
  void remove_if(PREDICATE pred);   // remove all elements for which Predicate pred
                    //  returns true. pred can take in a function object

      // print out all elements. ofc is deliminitor
      void print(std::ostream& os, char ofc = ' ') const; 

      iterator begin();               // iterator to first element
      const_iterator begin() const;
      iterator end();                 // end marker iterator
      const_iterator end() const; 
      iterator insert(iterator itr, const T& val);  // insert val ahead of itr
      iterator insert(iterator itr, T && val);      // move version of insert
      iterator erase(iterator itr);                 // erase one element
      iterator erase(iterator start, iterator end); // erase [start, end)


   private:
      int theSize;           // number of elements
      Node *head;            // head node
      Node *tail;            // tail node

      void init();           // initialization
};

我想要定义的功能就是这个：

template < typename T>
List& List<T>::operator=(List&& rhs)
{
    std::swap( theSize, rhs.theSize);
    std::swap( head, rhs.head);
    std::swap( tail, rhs.tail);

    return *this;
}

Answer 1

您忘记添加<T>：

template <typenameT>
List<T>& List<T>::operator=(List<T>&& rhs)
//  ^^^                         ^^^
//                              ^ this one is optional but I prefer it
{
    //...
}

嵌套类 - 定义返回对象的函数

1 个答案: