Is my linked list implementation leaking memory?

Question

Code:

struct LinkedList {
    int someData;
    LinkedList* next;

    LinkedList() : next(0) {}
    ~LinkedList() {delete next;}
};

void someFunction() {
    LinkedList list;

    list.next = new LinkedList;
    list.next->next = new LinkedList;
    list.next->next->next = new LinkedList;
    // And so on...
}

Am i correct to say that this code does not leak memory? When list scopes, it should call its destructor, which calls the destructor of next, which calls the destructor of next, and so on, until delete 0 is called.

Toss a memory profiler at it and check. Valgrind is a good one. — Edward Strange, Apr 22 '16 at 16:40
Is fine until you put so many items onto your list that the destructor calls exceed the stack size. — Richard Critten, Apr 22 '16 at 16:40

score 5 · Answer 1 · answered Apr 22 '16 at 16:42

No your code doesn't leak memory. When list goes out of scope, it'll be deleted, and the chain reaction will delete every next element until the last.

However, your code doesn't respect the rule of 3. So as soon as you will copy construct or copy assign a LinkedList, its next pointer will get shallow copied. The first of the two copies that get deleted/destroyed will delete it. The other then works with a pointer that is no longer valid and will sonner or later delete it as well, causing UB.

score 0 · Answer 2 · answered Apr 22 '16 at 16:43

If you call delete as many times as new is being called, then you are fine. In this case, this happens.

If you are in the current node, then you should keep a pointer to the next one, and then delete the current one.

_{See an example I have in List (C), where you can "think" malloc() as new and free() as delete.}

Is my linked list implementation leaking memory?

2 Answers2