Les éléments std :: vector sont-ils garantis contigus?

Ma question est simple: les éléments std :: vector sont-ils garantis contigus? Dans l'ordre, puis-je utiliser le pointeur vers le premier élément d'un std :: vector comme tableau C?

Si ma mémoire est bonne, le standard C ++ ne faisait pas une telle garantie. Cependant, les exigences std :: vector étaient telles qu'il était pratiquement impossible de les satisfaire si les éléments n'étaient pas contigus.

Quelqu'un peut-il clarifier cela?

Exemple:

std::vector<int> values;
// ... fill up values

if( !values.empty() )
{
    int *array = &values[0];
    for( int i = 0; i < values.size(); ++i )
    {
        int v = array[i];
        // do something with 'v'
    }
}

Cela a été omis de la norme C ++ 98 proprement dite, mais ajouté plus tard dans le cadre d'un TR. Le prochain standard C ++ 0x en contiendra bien sûr une exigence.

À partir de n2798 (brouillon de C ++ 0x):

23.2.6 Vecteur de modèle de classe [vecteur]

1 Un vecteur est un conteneur de séquence qui prend en charge les itérateurs à accès aléatoire. De plus, il prend en charge les opérations d'insertion et d'effacement à temps constant (amorti) à la fin; insérer et effacer au milieu prend un temps linéaire. La gestion du stockage est gérée automatiquement, bien que des conseils puissent être donnés pour améliorer l'efficacité. Les éléments d'un vecteur sont stockés de manière contiguë, ce qui signifie que si v est un vecteur où T est un type autre que booléen, alors il obéit à l'identité & v [n] == & v [0] + n pour tout 0 <= n <v .Taille().

Comme d'autres réponses l'ont souligné, le contenu d'un vecteur est garanti continu (à l'exception de l'étrangeté de bool).

Le commentaire que je voulais ajouter, c'est que si vous effectuez une insertion ou une suppression sur le vecteur, ce qui pourrait provoquer la réallocation du vecteur dans sa mémoire, alors vous invaliderez tous vos pointeurs et itérateurs enregistrés.

La norme garantit en fait que a vectorest continu en mémoire et qu'il &a[0]peut être passé à une Cfonction qui attend un tableau.

L'exception à cette règle est vector<bool> qu'elle n'utilise qu'un bit par bit bool, bien qu'elle ait une mémoire continue, elle ne peut pas être utilisée comme un bool*(ceci est largement considéré comme une fausse optimisation et une erreur).

BTW, pourquoi n'utilisez-vous pas d'itérateurs? C'est à ça qu'ils servent.

Comme d'autres l'ont déjà dit, vector utilise en interne un tableau contigu d'objets. Les pointeurs dans ce tableau doivent être traités comme non valides chaque fois qu'une fonction membre non-const est appelée IIRC.

Cependant, il existe une exception!!

vector<bool>a une implémentation spécialisée conçue pour économiser de l'espace, de sorte que chaque booléen n'utilise qu'un seul bit. Le tableau sous-jacent n'est pas un tableau contigu d'arithmétique booléenne et de tableau sur vector<bool>ne fonctionne pas comme le vector<T>ferait.

(Je suppose qu'il est également possible que cela soit vrai pour toute spécialisation de vecteur, puisque nous pouvons toujours en implémenter une nouvelle. Cependant, std::vector<bool>c'est la seule spécialisation standard erronée sur laquelle l'arithmétique de pointeur simple ne fonctionnera pas.)

J'ai trouvé ce fil parce que j'ai un cas d'utilisation où les vecteurs utilisant une mémoire contiguë sont un avantage.

J'apprends à utiliser des objets de tampon de sommet dans OpenGL. J'ai créé une classe wrapper pour contenir la logique du tampon, donc tout ce que j'ai à faire est de passer un tableau de flotteurs et quelques valeurs de configuration pour créer le tampon. Je veux pouvoir générer un tampon à partir d'une fonction basée sur l'entrée de l'utilisateur, donc la longueur n'est pas connue au moment de la compilation. Faire quelque chose comme ça serait la solution la plus simple:

void generate(std::vector<float> v)
{
  float f = generate_next_float();
  v.push_back(f);
}

Maintenant, je peux passer les flotteurs du vecteur sous forme de tableau aux fonctions liées au tampon d'OpenGL. Cela supprime également le besoin de sizeof pour déterminer la longueur du tableau.

C'est bien mieux que d'allouer un énorme tableau pour stocker les flotteurs et d'espérer que je l'ai fait assez grand, ou de créer mon propre tableau dynamique avec un stockage contigu.

cplusplus.com:

Les conteneurs vectoriels sont implémentés sous forme de tableaux dynamiques; Tout comme les tableaux réguliers, les conteneurs vectoriels ont leurs éléments stockés dans des emplacements de stockage contigus, ce qui signifie que leurs éléments sont accessibles non seulement à l'aide d'itérateurs, mais également en utilisant des décalages sur des pointeurs réguliers vers des éléments.

Oui, les éléments d'un std :: vector sont garantis contigus.