Ошибка памяти в деструкторе при обращении связанного списка

Question

Я пишу свой собственный класс связанного списка (для образовательных целей), и вот он:

Узел

#define PRINT(x) #x << " = " << x << " "

struct ListNode {
    int val;
    ListNode *next = nullptr;
    ListNode(int x) : val(x), next(nullptr) {}
};

Класс

class LinkedList{
    private:
        ListNode* _head;
        unsigned long long int _size;
    public:

        LinkedList():_head(nullptr), _size(0) {}

        LinkedList(ListNode* _h):_head(_h), _size(0) {
            ListNode *node = _head;
            while (node != nullptr) {
                _size++;
                node = node -> next;
            }
        }

       ~LinkedList() {
            while (_head != nullptr) {
                remove();
            }
        }

        void add(const int& value) {
             ListNode *node = new ListNode(value);
             node -> next = _head;
             _head = node;
             _size++;
        }

        int remove() {
             int v = _head -> val;
             ListNode *node = _head;
             _head = _head -> next;
             delete node;
             _size--;
             return v;
        }

        void print() {
             if (size() == 0) {
                 cout << "List is empty" << endl;
                 return;
             }
             ListNode *node = _head;
             while (node -> next != nullptr) {
                 cout << node -> val << " -> ";
                 node = node -> next;
             }
             cout << node -> val << endl;
        }

         unsigned long long int size() { return _size; }
         ListNode* head() { return _head; }
};

Я решил решить проблему LeetCode Обратный связанный список , и вот решение, которое работает:

// Returns the head of the reversed list
ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* current = head;
    while(current != nullptr) {
        ListNode* next_elem = current -> next;
        current -> next = prev;
        prev = current;
        current = next_elem;
    }
    return prev;
}

Проблема заключается в следующее: LeetCode не хочет мою main() функцию, поэтому для целей тестирования я, очевидно, использовал свою собственную. Вот оно:

int main() {

    LinkedList L;
    L.add(4);
    L.add(3);
    L.add(2);
    L.add(1);

    L.print();

    LinkedList L2 (reverseList(L.head()));
    cout << PRINT(L2.size()) << endl;
    L2.print();

    return 0;
}

Проблема с этой функцией заключается в том, что я получаю ошибку : IO_FILE(3853,0x7fff75d44000) malloc: *** error for object 0x7f92284031b0: pointer being freed was not allocated

Я не могу понять, в какой момент я пытаюсь освободить указатель, который не был выделен. Где я это делаю?

Answer 1

Это не совсем так, как я сказал в своем комментарии, но правило для трех все еще хорошо читается.

Проблема немного в другом: конструктор

LinkedList(ListNode* _h)

Просто вступает во владение _h. Когда вы инициализируете LinkedList с помощью этого конструктора, как в

LinkedList L2 (reverseList(L.head()));

head то же самое в L1 и L2. Когда эти два списка go выходят из области видимости, оба будут пытаться удалить одни и те же узлы (что работает только один раз по причине).