web-dev-qa-db-fra.com

Comment obtenir un certain élément dans une liste, compte tenu de la position?

Donc j'ai une liste:

list<Object> myList;
myList.Push_back(Object myObject);

Je ne suis pas sûr mais je suis convaincu que ce serait le "0ème" élément du tableau. Existe-t-il une fonction utilisable qui renvoie "myObject"?

Object copy = myList.find_element(0);

?

c++liststl
86
Test

Si vous devez fréquemment accéder au Nième élément d'une séquence, std::list, implémenté sous forme de liste à double liaison, n'est probablement pas le bon choix. std::vector ou std::deque serait probablement mieux.

Cela dit, vous pouvez obtenir un itérateur sur le Nième élément en utilisant std::advance:

std::list<Object> l;
// add elements to list 'l'...

unsigned N = /* index of the element you want to retrieve */;
if (l.size() > N)
{
    std::list<Object>::iterator it = l.begin();
    std::advance(it, N);
    // 'it' points to the element at index 'N'
}

Pour un conteneur qui ne fournit pas d'accès aléatoire, comme std::list, std::advance appelle operator++ sur l'itérateur N fois. Sinon, si votre implémentation Standard Library le fournit, vous pouvez appeler std::next:

if (l.size() > N)
{
    std::list<Object>::iterator it = std::next(l.begin(), N);
}

std::next encapsule efficacement un appel à std::advance, ce qui facilite l'avancement d'un itérateur N fois avec moins de lignes de code et moins de variables mutables. std::next a été ajouté en C++ 11.

120
James McNellis

std::list ne fournit aucune fonction pour obtenir un élément à partir d'un index. Vous pouvez essayer de l'obtenir en écrivant du code, ce que je ne recommanderais pas, car ce serait inefficace si vous en avez souvent besoin.

Ce dont vous avez besoin, c'est: std::vector. Utilisez-le comme:

std::vector<Object> objects;
objects.Push_back(myObject);

Object const & x = objects[0];    //index isn't checked
Object const & y = objects.at(0); //index is checked
31
Nawaz
std::list<Object> l; 
std::list<Object>::iterator ptr;
int i;

for( i = 0 , ptr = l.begin() ; i < N && ptr != l.end() ; i++ , ptr++ );

if( ptr == l.end() ) {
    // list too short  
} else {
    // 'ptr' points to N-th element of list
}
6
furas

Peut-être pas le moyen le plus efficace. Mais vous pouvez convertir la liste en un vecteur.

#include <list>
#include <vector>

list<Object> myList;

vector<Object> myVector(myList.begin(), myList.end());

Accédez ensuite au vecteur à l’aide de l’opérateur [x].

auto x = MyVector[0];

Vous pouvez mettre cela dans une fonction d'assistance:

#include <memory>
#include <vector>
#include <list>

template<class T>
shared_ptr<vector<T>> 
ListToVector(list<T> List) {
shared_ptr<vector<T>> Vector {
        new vector<string>(List.begin(), List.end()) }
return Vector;
}

Ensuite, utilisez la fonction d'assistance comme ceci:

auto MyVector = ListToVector(Object);
auto x = MyVector[0];
2
Bill Moore