Question

我创建了这个链接列表类以在我的工作中使用它但是我有这个异常'在game.exe中的0x003216D2的第一次机会异常：0xC0000005：访问冲突写入位置0x00000004。'并且它来自擦除功能可以有人告诉我如何解决它并解释它是什么问题

#ifndef LINKEDLIST_HPP
#define LINKEDLIST_HPP


#include <vector>
#include <cassert>

template<typename T>
class Linkedlist
{
private:    
    // The basic doubly linked Linkedlist node.
    // Nested inside of Linkedlist, can be public
    // because the Node is itself private
    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 ) { }


        // Rvalue   
        Node(Node && n)
        {
            _data = std::move(n._data);
            _prev = std::move(n._prev);
            _next = std::move(n._next);
        }

        // = operator
        Node& operator =(Node && n)
        {
            _data = std::move(n._data);
            _prev = std::move(n._prev);
            _next = std::move(n._next);
            return *this;
        }
    };
public:
    class LinkedListIter : public std::iterator<std::forward_iterator_tag , T , int>
    {
        Node* _node;
    public:
        LinkedListIter(Node* p=nullptr) : _node(p){}
        ~LinkedListIter(){}

        Node* getNode(){return _node;}

        T operator * () { return _node->_data; }
        LinkedListIter & operator ++()
        {
            _node = _node->_next;
            return *this; 
        }

        LinkedListIter operator ++(int)
        {
            LinkedListIter  retVal = *this;
            ++this;
            return retVal;
        }
        bool operator < (LinkedListIter const& rhs) const
        { 
            return _Node < rhs._Node; 
        }
        bool operator != (LinkedListIter const& rhs) const
        {
            return _Node != rhs._pNode;
        }
        bool operator == (LinkedListIter const& rhs) const 
        {
            return _Node == rhs._Node;
        }
    };



    Linkedlist( )
    { init(); }

    ~Linkedlist()
    {
        clear();
        delete _head;
        delete _tail;
    }

    Linkedlist(const Linkedlist & rhs)
    {
        init( );
        *this = rhs;
    }

    const Linkedlist & operator= (const Linkedlist & rhs)
    {
        if( this == &rhs )
            return *this;
        clear( );
        for(const_iterator itr = rhs.begin(); itr != rhs.end( ); ++itr)
            push_back(*itr);
        return *this;
    }

    // Return iterator representing beginning of Linkedlist.
    // Mutator version is first, then accessor version.
    LinkedListIter begin()
    { return LinkedListIter(_head->_next);}


    // Return iterator representing endmarker of Linkedlist.
    // Mutator version is first, then accessor version.
    LinkedListIter end()
    { return LinkedListIter(_tail); }


    // Return number of elements currently in the Linkedlist.
    int size() const
    { return _size; }

    // Return true if the Linkedlist is empty, false otherwise.
    bool empty() const
    { return size() == 0; }

    void clear()
    {
        while( !empty() )
            pop_front();
    }

    // front, back, push_front, push_back, pop_front, and pop_back
    // are the basic double-ended queue operations.
    T & front()
    //{ return *begin( ); }
    {return _head->_next.data}
    const T & front() const
    { return *begin(); }

    T & back( )
    { return *--end(); }

    const T & back() const
    { return *--end(); }

    void push_front(const T & x)
    { insert( begin(), x ); }

    void push_back(const T & x)
    { insert( end(), x ); }

    void pop_front()
    { erase(begin()); }

    void pop_back()
    { erase(--end()); }

    // Insert x before itr.
    LinkedListIter insert(LinkedListIter& itr, const T & x)
    {
        Node *p = new Node(x,itr.getNode()->_prev,itr.getNode());
        _size++;
        return LinkedListIter(p->_prev = p->_prev->_next = new Node(x, p->_prev, p));
    }

    // Erase item at itr.
    LinkedListIter  erase(LinkedListIter itr)
    {
        Node *p = itr.getNode();
        LinkedListIter retVal(p->_next);
        p->_prev->_next = p->_next;
        p->_next->_prev = p->_prev;
        delete p;
        _size--;

        return retVal;


    }

    LinkedListIter erase(LinkedListIter start, LinkedListIter end)
    {
        for(iterator itr = start; itr != end;)
            itr = erase(itr);

        return end;
    }

private:
    int   _size;
    Node *_head;
    Node *_tail;




    void init()
    {
        _size = 0;
        _head = new Node;
        _tail = new Node;
        _head->_next = _tail;
        _tail->_prev = _head;
    }
};

#endif

Answer 1

访问冲突（在Windows中，或unices中的分段错误）表示您尝试错误地访问内存。您试图访问进程空间之外的内存，或者您尝试了错误的访问类型。

错误消息还告诉您尝试访问的地址是什么以及您尝试的访问类型。您尝试写入内存地址0x00000004，即从第0个地址开始写入4个字节。看起来你试图通过空指针进行写操作，并且写操作是从对象开头起4个字节的成员。

虽然并不总是能够确定真正原因是什么，但这就是它的样子。调试问题的最简单方法是在调试器中运行应用程序，让调试器告诉您访问冲突的位置。然后检查程序的状态，并尝试确定它在这种情况下的结果。

Answer 2

你应该检查你的指针。尝试仔细调试erase函数。

当你的指针指向“外来”内存区域（即你的应用程序没有保存的内存）时，通常会发生Access violation错误。

Answer 3

您可能试图删除尾节点。尾节点的next指针为NULL（来自默认构造函数）。

0xC0000005：访问冲突写入位置0x00000004。

3 个答案: