How to access an element inside a list?

Although all the stl containers have certain similarities in terms of use, the truth is that each one internally works differently, so not all methods will be available in all containers.

• std::vectorrepresents an unordered list of elements. Its main characteristic is that all the elements are contiguous in memory, which allows random access. It is the default container for most situations.

• std::listrepresents a linked list. Being a linked list Its elements do not have to be contiguous in memory but to access the second element before you have to access the first. It is for this last reason that it does not support random access although it does support sequential access.

Traditionally STL containers can be traversed universally using iterators:

for( auto it = contenedor.begin(); it != contenedor.end(); ++it )
{
  // ...
}

There are also functions within the STL that try to encapsulate this mechanic a bit:

• std::foreach: Iterates through a container and, for each element, executes a function passed by parameter
• std::transform: Iterates through a container and, for each element, executes an operation passed by parameter. The result of said operation is stored in a new container
• std::find: Loop through a container looking for an element passed by parameter. Returns an iterator to the element or, if not found, the iterator given bycontenedor.end()
• std::find_if: Similar to the previous one but it admits a pointer to a function that implements the search criteria
• std::reverse: Inverts the values ​​that are between the iterators passed as a parameter (eye, in ordered containers, since setthey will not work)
• ...

Since C++11 a new type of loop is also available that allows you to easily iterate over containers avoiding the use of iterators:

std::vector<int> lista(10);
std::iota(lista.begin(), lista.end(), 1);

for( auto item : lista )
  std::cout << item << std::endl;

Also, since C++11, std::beginand are available std::end. These two functions allow to obtain the corresponding iterators both in STL containers and in fixed-size arrays (their size can be calculated at compile time):

std::vector<int> v = {1,2,3,4,5};
int arreglo[] = {6,7,8,9,10};

for( auto it = std::begin(v); it != std::end(v); ++it )
  std::cout << *it;
for( auto it = std::begin(arreglo); it != std::end(arreglo); ++it )
  std::cout << *it;

Other mechanisms for working with iterators are:

• std::distance: Calculates the number of elements between two iterators
• std::next: Allows to advance an iterator n positions
• std::advance: Similar to the previous one, it modifies the iterator passed as parameter

Well, all of the above was a bit of theory about the containers and their possibilities. Now answering your question, yes, it is possible to access a specific position both in a std::listand in any other container using iterators and std::nextor std::advance.

In the specific case of std::list, it is not possible to access a specific element using the indexing operator []because its elements are not in consecutive memory locations. Accessing a random element implies traversing a part of the nodes of the list and this task is carried out by iterators and has to be done explicitly.

All the best.

I have wandered through the documentation stland some SO questions , I have come across std::advance()and std::next():

• std::next(Vector, Numero): Returns a pointer within the index (Parameter) Numero in an assignable way, returns an element of the same type of the vector. Documentation , it is worth mentioning that without the parameter Numerothis function advances to the next element of the Vector, so this parameter is optional.

• std::advance(Vector, Cantidad): It works practically the same as std::next()except that it directly modifies the parameter Vectorby the element located in the position Cantidadand does not return any value. Documentation

Example with std::next(V,N):

int main() 
{
    std::list<int> v{ 2, 8, 5, 6 };

    auto Iterator = v.begin(); // El valor inicial (begin) es: 2
    auto Siguiente = std::next(Iterator); // El valor de Siguiente es: 8
    auto SaltaTres = std::next(Iterator, 3); // El valor es: 6

    std::cout << *Iterator << ' ' << *Siguiente << ' ' << *SaltaTres;
    return 0;
}

Example with std::advance(V,N):

int main() 
{
    std::list<int> v{ 2, 8, 5, 6 };
    auto Param = v.begin();

    std::advance(Param, 2); 
    // El valor de Param fué alterado por el nuevo valor que le asignó advance(); 
    // Por lo que ahora Param tiene el valor de: 5

    std::advance(Param);  // Error.
    std::cout << *Param;
    return 0;
}

It is worth mentioning that the parameter Cantidadthat I have named in std::advance()is mandatory.

 for(std::list<int>::iterator list_iter = int_list.begin(); 
        list_iter != int_list.end(); list_iter++){

        std::cout<<*list_iter<<endl;

}

int_list.begin()place a pointer at the beginning of the list

int_list.end()is a pointer to the end of the list

The pointer at the start of the list is moved to the next element with pointer arithmetic:list_iter++