使用链表会导致内存泄漏吗？

Question

I am programming a template for singly linked lists in C++ and I am getting confused about what would be the right way of returning the information of the first node when deleting it.

I am getting some help from a book where there are written two methods, one that returns the value of the head node, and other that deletes it. Let's call that methods front() and pop(), where front() returns the value with a "const T&" type. One of my questions is, if I do something like this:

T object = list.front();
list.pop();

Wouldn't that result in an object reference pointing to nothing? Is there any problem if I continue using that object after calling pop()?

A second question is, what's the correct way of using the front() method and what's the difference between:

T object = list.front();
// or
T& object = list.front();
// or
const T& object = list.front();

Answer 1

If you do

T object = list.front();

and front() returns T& , then object becomes a copy of the initial element of the list, not a reference to it.

If, on the other hand, you write

const T& ref = list.front();

then the call to list.pop() would make ref a dangling reference, which is different from memory leak.

This should explain the difference between your first and third example; your second example, ie

T& object = list.front();

would not compile, because non- const reference cannot be constructed from a const reference.

Answer 2

For T object = list.front(); , object is a copy of list.front() and then has nothing to do with the original element. So list.pop() doesn't have any influence on it at all.

For T& object = list.front(); , you can't do that. const T& can't be implicitly converted to T& .

For const T& object = list.front(); , object is a reference to the element in list . So after list.pop() it will be dangled.