benutzerdefinierte verknüpfte Liste erstellen RtlValidateHeap Fehler mit den Strukturen mit einer verknüpften Liste

Question

Hier ist meine LinkedList-Implementierung, die ich arbeite. es funktioniert für jeden Datentyp in Ordnung, aber das Problem entsteht, wenn ich versuche, eine verknüpfte Liste von einer Art zu machen, die eine verknüpfte Liste auf Debuggen mit Visual Studio bekam ich zu RtlValidateHeap angegeben Ungültige Adresse (00.790.000, 007B16D0)

der Code wie folgt aussieht:

typedef unsigned long int LENGTH_T; 
template < typename type > 
struct nodes 
{ 
    type _value; 
    nodes<type> * _next_node; 
    nodes() { _next_node = nullptr; } 
}; 

template < typename type > 
class LinkedList 
{ 
    nodes<type> * _elem_nodes; 
    LENGTH_T _size; 
public: 
    nodes<type> * node_at(LENGTH_T at); 
    type& operator[] (LENGTH_T at); 
    void push_back(const type src); 
    LENGTH_T size() const { return _size; } 
    LinkedList(); 
    ~LinkedList(); 
}; 

template<typename type> 
nodes<type>* LinkedList<type>::node_at(LENGTH_T at) { 
    if (at == 0) 
     return _elem_nodes; 
    else if (at > _size - 1 || _size == 0) { 
     PRINT_ERROR("try to access out of range"); 
    } 

    // tmp node for storing sequential nodes 
    nodes<type> * cur_tmp_node_ptr = _elem_nodes->_next_node; 

    for (size_t i = 1; i < at; i++) 
     cur_tmp_node_ptr = cur_tmp_node_ptr->_next_node; 

    return cur_tmp_node_ptr; 
} 

template<typename type> 
type & LinkedList<type>::operator[](LENGTH_T at) 
{ 
    return node_at(at)->_value; 
} 

template<typename type> 
void LinkedList<type>::push_back(const type src) 
{ 
    if (_size == 0) { 
     _elem_nodes->_value = src; 
     _size++; 
    } 
    else { 
     nodes<type> * new_node = new nodes<type> ; 
     new_node->_value = src; 
     new_node->_next_node = nullptr; 
     node_at(_size - 1)->_next_node = new_node; 
     _size++; 
    } 
} 

template<typename type> 
LinkedList<type>::LinkedList() 
{ 
    _size = 0; 
    _elem_nodes = new nodes<type>; 
    _elem_nodes->_value = type(); 
    _elem_nodes->_next_node = nullptr; 
} 

template<typename type> 
LinkedList<type>::~LinkedList() 
{ 
    if (_size > 1) // When size = 0 , so _size-1 = -1 but _size is unsigned; 
     for (LENGTH_T i = _size - 1; i > 0; i--) { 
      delete (node_at(i)); 
     } 
    delete (_elem_nodes); 
} 

hier ein Beispiel für Code, in dem angegebenen Problem fe

struct test { 
    int anything; 
}; 

struct test2 { 
    LinkedList<test> t; 
}; 

int main() 
{ 
    LinkedList<test2> t; 
    t.push_back(test2()); 
    t.push_back(test2()); 
    return 0; 
} 

** EDIT beobachtet werden kann: ich schrieb Benutzerdefinierte Assig nment Operator und Copy-Konstruktor und nicht, dass Fehler immer mehr, aber in dem obigen Beispiel in test2(). t._next_node enthält immer Werte Junk eher dann nullptr, die ich verstehen mich nicht, warum **

template<typename type> 
LinkedList<type>& LinkedList<type>::operator=(const LinkedList<type>& other) 
{ 
    if (&other == this) 
     return *this; 
    this->~LinkedList(); 
    this->_elem_nodes = nullptr; 
    _size = 0; 
    nodes<type> * cur_this_node = this->_elem_nodes; 
    nodes<type> * cur_other_node = other._elem_nodes; 
    while (cur_other_node != nullptr) 
    { 
     cur_this_node = new nodes<type>; 
     cur_this_node->_value = cur_other_node->_value; 
     this->_size++; 
     cur_this_node = cur_this_node->_next_node; 
     cur_other_node = cur_other_node->_next_node; 
    } 
    return *this; 
} 

template<typename type> 
LinkedList<type>::LinkedList(const LinkedList<type>& other) 
{ 
    _size = 0; 
    nodes<type> * cur_this_node = this->_elem_nodes; 
    cur_this_node = nullptr; 
    nodes<type> * cur_other_node = other._elem_nodes; 
    while (cur_other_node != nullptr) 
    { 
     cur_this_node = new nodes<type>; 
     cur_this_node->_value = cur_other_node->_value; 
     cur_this_node->_next_node = nullptr; 
     this->_size++; 
     cur_this_node = cur_this_node->_next_node; 
     cur_other_node = cur_other_node->_next_node; 
    } 
} 

Answer 1

Sie eine Regel haben von drei (oder vier oder fünf) Verstößen. Sie haben einen benutzerdefinierten Destruktor, aber keinen benutzerdefinierten Zuweisungsoperator definiert. In Ihrem Fall führt dies dazu, dass zwei separate LinkedList-Objekte auf dieselben Knoten verweisen.

Weitere Informationen: https://stackoverflow.com/a/4782927/951890