.hpp 文件上的意外文件结束错误

我正在处理一个文件Deque.hpp，它使用迭代器类和节点进行deque，但我收到错误：

"错误 C1004 发现意外的文件结尾"

我似乎找不到导致这种情况的原因。这是我的代码。

#ifndef DEQUE_H
#define DEQUE_H
#include <iostream>
#include <new>
#include <cstdlib>
#include <algorithm>
//
// 
//
template <typename T>
class Deque
{
public:
    Deque();
    Deque(const Deque & rhs);
    ~Deque();
    Deque & operator= (const Deque & rhs);
    Deque(Deque && rhs) : theSize{ rhs.theSize }, head{ rhs.head }, tail{ rhs.tail };
    Deque & operator= (Deque && rhs);

    T & Deque<T>::operator[](int n);
    Iterator begin();
    const_iterator begin() const;
    Iterator end();
    const_iterator end() const;
    int size() const;
    bool isEmpty() const;
    void clear();
    T & left();
    const T & left() const;
    T & right();
    const T & right() const;
    void pushLeft(const T & x);
    void pushLeft(T && x);
    void pushRight(const T & x);
    void pushRight(T && x);
    T & popLeft();
    T & popRight();
    bool Deque<T>::contains(const T&);
    struct Node
    {
        T data;
        Node *prev;
        Node *next;
        Node(const T & d = T{}, Node * p = NULL, Node * n = NULL) :
            data{ d }, prev{ p }, next{ n } {}
        Node(T && d, Node * p = NULL, Node * n = NULL)
            : data{ std::move(d) }, prev{ p }, next{ n } {}
    };
    class const_iterator
    {
    public:
        const_iterator() : current{ NULL } { }
        const T & operator* () const;
        const_iterator & operator++ ();
        const_iterator & operator-- (); //!
        const_iterator operator++ (int);
        const_iterator operator-- (int); //!

        bool operator== (const const_iterator & rhs) const;
        bool operator!= (const const_iterator & rhs) const;
    protected:
        Node *current;
        T & retrieve() const;
        const_iterator(Node *p) : current{ p } { }
        friend class Deque<T>;
    };
    class Iterator : public const_iterator
    {
    public:
        Iterator();
        T & operator* ();
        const T & operator* () const;
        Iterator & operator++ ();
        Iterator & operator-- (); //!
        Iterator operator++ (int);
        Iterator operator-- (int); //!
    protected:
        Iterator(Node *p) : const_iterator{ p } { }
        friend class Deque<T>;
    };
private:
    // Insert x before itr.
    Iterator insert(Iterator itr, const T & x);
    // Insert x before itr.
    Iterator insert(Iterator itr, T && x);
    // Erase item at itr.
    Iterator erase(Iterator itr);
    Iterator erase(Iterator from, Iterator to);
    int theSize;
    Node *head;
    Node *tail;
    void init();
};
template<typename T>
inline const T & Deque<T>::const_iterator::operator*() const
{
    return retrieve();
}
template<typename T>
inline const_iterator & Deque<T>::const_iterator::operator++()
{
    current = current->next;
    return *this;
}
template<typename T>
inline const_iterator & Deque<T>::const_iterator::operator--()
{
    current = current->prev;
    return *this;
}
template<typename T>
inline const_iterator Deque<T>::const_iterator::operator++(int)
{
    const_iterator old = *this;
    ++(*this);
    return old;
}
template<typename T>
inline const_iterator Deque<T>::const_iterator::operator--(int)
{
    const_iterator old = *this;
    --(*this);
    return old;
}
template<typename T>
inline bool Deque<T>::const_iterator::operator==(const const_iterator & rhs) const
{
    return current == rhs.current;
}
template<typename T>
inline bool Deque<T>::const_iterator::operator!=(const const_iterator & rhs) const
{
    return !(*this == rhs);
}
template<typename T>
inline T & Deque<T>::const_iterator::retrieve() const
{
    return current->data;
}
template<typename T>
inline Deque<T>::Iterator::Iterator()
{
}
template<typename T>
inline T & Deque<T>::Iterator::operator*()
{
    return const_iterator::retrieve();
}
template<typename T>
inline const T & Deque<T>::Iterator::operator*() const
{
    return const_iterator::operator*();
}
template<typename T>
inline Iterator & Deque<T>::Iterator::operator++()
{
    this->current = this->current->next;
    return *this;
}
template<typename T>
inline Iterator & Deque<T>::Iterator::operator--()
{
    this->current = this->current->prev;
    return *this;
}
template<typename T>
inline Iterator Deque<T>::Iterator::operator++(int)
{
    Iterator old = *this;
    ++(*this);
    return old;
}
template<typename T>
inline Iterator Deque<T>::Iterator::operator--(int)
{
    Iterator old = *this;
    --(*this);
    return old;
}
template<typename T>
inline Deque<T>::Deque()
{
    init();
}
template<typename T>
inline Deque<T>::~Deque()
{
    clear();
    delete head;
    delete tail;
}
template<typename T>
inline Deque & Deque<T>::operator=(const Deque & rhs)
{
    if (this == &rhs)
        return *this;
    clear();
    for (const_iterator itr = rhs.begin(); itr != rhs.end(); ++itr)
        pushRight(*itr)
        return *this;
}
template<typename T>
inline Deque<T>::Deque(Deque && rhs)
{
    rhs.theSize = 0;
    rhs.head = NULL;
    rhs.tail = NULL;
}
template<typename T>
inline Deque & Deque<T>::operator=(Deque && rhs)
{
    std::swap(theSize, rhs.theSize);
    std::swap(head, rhs.head);
    std::swap(tail, rhs.tail);
    return *this;
}
template<typename T>
inline T & Deque<T>::operator[](int n)
{
    Iterator itr = begin();
    for (int i = 0; i < n; i++)
    {
        itr.current = itr.current->next;
    }
    return itr.current->data;
}
template<typename T>
inline Iterator Deque<T>::begin()
{
    return{ head->next };
}
template<typename T>
inline const_iterator Deque<T>::begin() const
{
    return{ head->next };
}
template<typename T>
inline Iterator Deque<T>::end()
{
    return{ tail->prev };  //changed to -> prev
}
template<typename T>
inline const_iterator Deque<T>::end() const
{
    return{ tail->prev };
}
template<typename T>
inline int Deque<T>::size() const
{
    return theSize;
}
template<typename T>
inline bool Deque<T>::isEmpty() const
{
    return size() == 0;
}
template<typename T>
inline void Deque<T>::clear()
{
    while (!isEmpty())
        popLeft();
}
template<typename T>
inline T & Deque<T>::left()
{
    return *begin();
}
template<typename T>
inline const T & Deque<T>::left() const
{
    return *begin();
}
template<typename T>
inline T & Deque<T>::right()
{
    return *end(); // deleted "--*end"
}
template<typename T>
inline const T & Deque<T>::right() const
{
    return *end();
}
template<typename T>
inline void Deque<T>::pushLeft(const T & x)
{
    insert(begin(), x);
}
template<typename T>
inline void Deque<T>::pushLeft(T && x)
{
    insert(begin(), std::move(x)); // changed std::move(x)) to x
}
template<typename T>
inline void Deque<T>::pushRight(const T & x)
{
    insert(end(), x);
}
template<typename T>
inline void Deque<T>::pushRight(T && x)
{
    insert(end(), std::move(x));
}
template<typename T>
inline T & Deque<T>::popLeft()
{
    return *begin(); erase(begin());
}
template<typename T>
inline T & Deque<T>::popRight()
{
    return *end(); erase(end());  // changed --end to end
}
template<typename T>
inline bool Deque<T>::contains(const T &)
{
    // stuff here
}
template<typename T>
inline Iterator Deque<T>::insert(Iterator itr, const T & x)
{
    Node *p = itr.current;
    theSize++;
    return{ p->prev = p->prev->next = new Node{ x, p->prev, p } };
}
template<typename T>
inline Iterator Deque<T>::insert(Iterator itr, T && x)
{
    Node *p = itr.current;
    theSize++;
    return{ p->prev = p->prev->next = new Node{ std::move(x), p->prev, p } };
}
template<typename T>
inline Iterator Deque<T>::erase(Iterator itr)
{
    Node *p = itr.current;
    Iterator retVal{ p->next };
    p->prev->next = p->next;
    p->next->prev = p->prev;
    delete p;
    theSize--;
    return retVal;
}
template<typename T>
inline Iterator Deque<T>::erase(Iterator from, Iterator to)
{
    for (Iterator itr = from; itr != to; )
        itr = erase(itr);
    return to;
}
template<typename T>
inline void Deque<T>::init()
{
    theSize = 0;
    head = new Node;
    tail = new Node;
    head->next = tail;
    tail->prev = head;
}
template<typename T>
inline Deque<T>::Deque(const Deque & rhs)
{
    init();
    *this = rhs;
}
#endif