L'accès aux éléments d'une liste de listes en C++

double item = *std::next(std::begin(*std::next(std::begin(list), 3)), 3);

À l'aide d'un vecteur d'habitude ont de bien meilleures performances, bien que l'accès à l'élément n d'une liste est O(n).

Si vous êtes inquiet au sujet de la performance de l'épissage de l'intérieur du conteneur, vous pouvez utiliser deque, qui a operator[], amorti constant de l'insertion et de la suppression de la fin, et le temps linéaire de l'insertion et de la suppression de l'intérieur.

Pour C++03 compilateurs, vous pouvez mettre en œuvre begin et next vous-même:

template<typename Container>
typename Container::iterator begin(Container &container)
{
    return container.begin();
}
template<typename Container>
typename Container::const_iterator begin(const Container &container)
{
    return container.begin();
}
template<typename T, int n>
T *begin(T (&array)[n])
{
    return &array[0];
}

template<typename Iterator>
Iterator next(Iterator it, typename std::iterator_traits<Iterator>::difference_type n = 1)
{
    std::advance(it, n);
    return it;
}

Strictement répondre à votre question, Joachim Pileborg de l' réponse est le chemin à parcourir:

std::list<std::list<double> >::iterator it = list.begin();
std::advance(it, 3);
std::list<double>::iterator it2 = (*it).begin();
std::advance(it2, 3);
double d = *it2;

Maintenant, à partir de votre question et d'autres commentaires, il n'est pas clair si vous avez toujours ajouter des éléments à la fin de la liste ou ils peuvent être ajoutés n'importe où. Si vous ajoutez toujours à la fin, vector<double> fonctionnera mieux. Un vector<T> ne doivent pas être copiés à chaque fois sa taille augmente; seulement à chaque fois que son capacité augmente, ce qui est une chose très différente.

En plus de cela, en utilisant reserve(), comme d'autres ont dit avant, ce sera beaucoup plus avec la redistribution. Vous n'avez pas besoin de réserver pour la taille combinée de tous les vecteurs, mais seulement pour chaque vecteur. Donc:

std::vector<std::vector<double> > v;
v.reserve(512); //If you are inserting 400 vectors, with a little extra just in case

Et vous serait également en réserve pour chaque vector<double> à l'intérieur de v. C'est tout.

Prendre en compte le fait que la liste de vos listes de prendre beaucoup plus d'espace. Pour chaque double dans la liste interne, il devra consacrer au moins deux autres pointeurs, et aussi deux des pointeurs supplémentaires pour chaque liste à l'intérieur du mondial des moins. Cela signifie que le total de la mémoire prises par votre conteneur sera environ trois fois plus que le vecteur. Et tout cela, d'attribution et de gestion prend également supplémentaire de l'exécution.