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

时间:2016-03-01 20:02:59

标签: c++

我正在处理一个文件Deque.hpp,它使用迭代器类和节点来创建一个双端队列,但我收到了错误:

  

"发现错误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

1 个答案:

答案 0 :(得分:0)

要修复的第一个错误是由AlgirdasPreidžius识别的错误:您的构造函数有一个初始化列表但没有正文。

你应该替换

Deque(Deque && rhs) : theSize{ rhs.theSize }, head{ rhs.head }, tail{ rhs.tail };

通过

Deque(Deque && rhs) : theSize{ rhs.theSize }, head{ rhs.head }, tail{ rhs.tail } {};

然后你还会遇到很多其他错误。祝你好运!

编码时的建议:逐步编写代码,定期编译和测试。您不应该立即修复这么多错误!

顺便说一下,有什么理由不使用std :: deque?