How to access the first element of std::list?

Question

I have a list std::list<T *> *l;. this list is not null and has some values. My problem is how to access items properly? i do not need to iterate over the list. i just want the first item only.

std::list<T*>::iterator it = l->begin();

if (it != l->end())
{
    // accessing T
    int value = (*it)->value(); // Is this safe?
}

or should i check for null also?

if (it != l->end() && (*it))
{
    // accessing T
    int value = (*it)->value();
}

You are holding pointers, so check for `NULL`. Or use an `std::list`. — juanchopanza, Mar 01 '13 at 10:21
What made you decide to use `std::list` instead of `std::list` ? — LihO, Mar 01 '13 at 10:21
You don't need an iterator to access the first element only. You need this only when you want to access all the list elements. And the first suggestion is the correct one. — Houssam Badri, Mar 01 '13 at 10:22
1st rule of modern C++ programming - don't use *****ing pointers. — Bartek Banachewicz, Mar 01 '13 at 10:25
@LihO Actually it is not a my decision. The API that i'm using, returns a pointer of a list of pointers — shan, Mar 01 '13 at 10:26
@shan: Well then authors of the API are the ones to blame then :) Although it's not good to judge the interface before you know the reasons behind decisions of its authors ;) Check my answer now. — LihO, Mar 01 '13 at 12:49

score 19 · Accepted Answer · edited May 23 '17 at 12:01

If you are forced to use std::list<T*> myList; and let's say that T is defined as:

struct T
{
    T(const char* cstr) : str(cstr){ }
    std::string str;
};

then just use std::list::front to access first element:

std::string firstStr = myList.front()->str;

Note that in this case myList.front() returns a reference to first element in your list, which is reference to pointer in this case. So you can treat it just like a pointer to the first element.

And to your question about the NULL: When you work with the container of pointers, the pointer should be removed from the container once the object is destructed. Once you start using pointers, it usually means that you are the one who becomes responsible for the memory management connected with objects that these pointers point to (which is the main reason why you should prefer std::list<T> over std::list<T*> always when possible).

Even worse than NULL pointers are dangling pointers: When you create an object, store its address in your container, but you will not remove this address from your container once the object is destructed, then this pointer will become invalid and trying to access the memory that this pointer points to will produce undefined behavior. So not only that you should make sure that your std::list doesn't contain NULL pointers, you should also make sure it contains only pointers to valid objects that still exist.

So by the time you will be cleaning up these elements, you will find yourself removing pointers from your list and deleting objects they point to at once:

std::list<T*> myList;

myList.push_back(new T("one"));
myList.push_back(new T("two"));
myList.push_back(new T("three"));
myList.push_back(new T("four"));

while (!myList.empty())
{
    T* pT = myList.front();                     // retrieve the first element
    myList.erase(myList.begin());               // remove it from my list
    std::cout << pT->str.c_str() << std::endl;  // print its member
    delete pT;                                  // delete the object it points to
}

It's also worth to read these questions:
Can you remove elements from a std::list while iterating through it?
Doesn't erasing std::list::iterator invalidates the iterator and destroys the object?

isnt .front() a deleted function at present ? if so what to use instead ? — serup, Jan 03 '17 at 07:49

score 0 · Answer 2 · answered Mar 01 '13 at 10:23

0

The need for a null-check of the list element depends entirely on what can be put into the list in the first place.

If it is possible that the list contains null pointers, then you most definitely should check for for NULL before accessing the element.
If it is not possible, then there is also no reason to check.

answered Mar 01 '13 at 10:23

Bart van Ingen Schenau

15,488
4
32
41

I disagree, you should always check for NULL, especially in DEBUG/development builds. If it's not suppose to be NULL, throw an exception. – Alex Chamberlain Mar 01 '13 at 10:35
@AlexChamberlain: In that case, why not also check that the pointer still refers to a valid, live object? – Bart van Ingen Schenau Mar 01 '13 at 10:39
If I could think of a way, I would in a DEBUG build. – Alex Chamberlain Mar 01 '13 at 10:41

How to access the first element of std::list?

2 Answers2