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 persuadé que ce serait le "0e" élément dans le tableau.
Est-il une fonction que je peux utiliser sera de retour "monobjet"?

Object copy = myList.find_element(0);

?

  • Il n'y a pas de tableau -- c'est une liste. Si vous voulez index en entier, pourquoi n'utilisez-vous pas vector à la place?
  • Si vous souhaitez toujours l'élément 0, utiliser front().
  • Je n'ai pas testé, mais je suppose myList.avant() + num pourrait fonctionner ici
  • non, il n'est pas
InformationsquelleAutor Test | 2011-04-20
  1. 119

    Si vous avez souvent besoin d'accéder à la Nième élément d'une séquence, std::list, qui est implémenté sous la forme d'une liste doublement chaînée, n'est probablement pas le bon choix. std::vector ou std::deque serait probablement mieux.

    Cela dit, vous pouvez obtenir un itérateur vers le n-ième élément à l'aide de 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 appels operator++ sur l'itérateur N fois. Alternativement, si votre Bibliothèque Standard de mise en œuvre fournit à elle, vous pouvez appeler std::next:

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

    std::next est efficacement encapsule un appel à std::advance, le rendant plus facile d'avancer un itérateur N fois avec moins de lignes de code et moins variables mutables. std::next a été ajouté en C++11.

    • Alors que vous payez une pénalité sur les performances de la recherche d'une liste liée en raison de l'absence de l'accès aléatoire, vous payez beaucoup plus de performances si vous avez besoin d'insérer ou de supprimer des données au moyen d'un vecteur ou d'deque. La question ne contiennent pas suffisamment d'informations pour décider s'ils sont en utilisant le conteneur idéal pour parvenir à leurs fins.
    • Il est intéressant de noter que lors de l'utilisation de std::advance ou std::next, il est facile d'invoquer l'UB. Il n'y a pas de vérification des limites.
    InformationsquelleAutor James McNellis
  2. 30

    std::list ne fournit pas de fonction permettant d'obtenir élément donné un indice. Vous pouvez essayer de l'obtenir en écrivant du code, je ne vous le recommande pas, parce que ce serait inefficace si vous avez souvent besoin de le faire.

    Ce que vous avez besoin est : std::vector. Utiliser 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
    InformationsquelleAutor Nawaz
  3. 6
    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
}
    InformationsquelleAutor furas
  4. 2

    Peut-être pas la manière la plus efficace. Mais vous pouvez convertir la liste dans un vecteur.

    #include <list>
#include <vector>

list<Object> myList;

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

    Alors accès du vecteur à l'aide de [x] l'opérateur.

    auto x = MyVector[0];

    Vous placer 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 utiliser l'aide d'une fonction comme ceci:

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