Quelle est la différence entre std :: array et std :: vector? Quand utilisez-vous l'un sur l'autre?
Quelle est la différence entre std::array et std::vector? Quand utilisez-vous l'un sur l'autre?
J’ai toujours utilisé et considéré std:vector comme moyen C++ d’utiliser les tableaux C, quelle est la différence?
std::array est juste une version de classe du tableau C classique. Cela signifie que sa taille est fixée au moment de la compilation et qu'il sera alloué en un seul bloc (par exemple, en prenant de la place sur la pile). L'avantage qu'il a est légèrement plus performant car il n'y a pas d'indirection entre l'objet et les données en réseau.
std::vector est une petite classe contenant des pointeurs dans le tas. (Ainsi, lorsque vous allouez un std::vector, il appelle toujours new.) Ils sont légèrement plus lents à accéder car ces pointeurs doivent être chassés pour accéder aux données de la matrice ... Mais en échange, ils peuvent être redimensionnés et ne prennent que une quantité insignifiante d'espace de pile, peu importe leur taille.
[modifier]
Pour ce qui est de savoir quand utiliser l'un par rapport à l'autre, honnêtement, std::vector est presque toujours ce que vous voulez. La création d'objets volumineux sur la pile est généralement mal vue et le niveau supplémentaire d'indirection est généralement indifférent. (Par exemple, si vous parcourez tous les éléments, l'accès supplémentaire à la mémoire ne se produit qu'une fois au début de la boucle.)
Les éléments du vecteur sont garantis comme étant contigus, vous pouvez donc passer &vec[0] à n'importe quelle fonction attend un pointeur sur un tableau; par exemple, les routines de la bibliothèque C. (En passant, std::vector<char> buf(8192); est un excellent moyen d'allouer un tampon local pour les appels à read/write ou similaire sans invoquer directement new.)
Cela dit, l'absence de ce niveau supplémentaire d'indirection, plus la taille constante au moment de la compilation, peut rendre std::array considérablement plus rapide pour un très petit tableau qui est créé/détruit/auquel on accède beaucoup.
Donc, mon conseil serait: Utilisez std::vector à moins que (a) votre profileur ne vous dise que vous avez un problème et (b) le tableau est minuscule.
Je suppose que vous savez que std :: array est de taille fixe pour la compilation, tandis que std :: vector est de taille variable. De plus, je suppose que vous savez que std :: array ne fait pas d'allocation dynamique. Donc, au lieu de cela, je vais répondre pourquoi vous utiliseriez std :: array au lieu de std :: vector.
Vous êtes-vous déjà trouvé à faire ceci:
std::vector<SomeType> vecName(10);
Et puis vous n’augmentez jamais réellement la taille de std :: vector? Si c'est le cas, alors std :: array est une bonne alternative.
Mais en réalité, std :: array (associé aux listes d’initialisation) existe pour rendre les tableaux de style C presque entièrement sans valeur. Ils ne sont généralement pas en concurrence avec std :: vectors; ils rivalisent davantage avec les tableaux de style C.
Pensez-y que le comité C++ fait de son mieux pour éliminer presque toute utilisation légitime des tableaux de style C.
std::array
- est un agrégat
- est de taille fixe
- requiert que ses éléments soient constructibles par défaut (vs copy (C++ 03) ou move (C++ 0x) constructibles)
- est linéairement permutable (vs temps constant)
- est mobile linéairement (vs temps constant)
- potentiellement paye un indirection de moins que
std::vector
Un bon cas d'utilisation est de faire des choses «proches du métal», tout en gardant les subtilités de C++ et en gardant toutes les mauvaises choses des tableaux bruts.
Même raisonnement lorsque vous utilisez un tableau static de style C plutôt qu'un std::vector. Et pour cela, je vous renvoie gentiment à ici .
std::array a une taille fixe (temps de compilation), alors que std::vector peut augmenter.
En tant que tel, std::array équivaut à utiliser un tableau C, tandis que std::vector équivaut à allouer dynamiquement de la mémoire.
J'utilise ma propre classe de modèle Array<> codée à la main, qui possède une API plus simple que celle de std::array ou std::vector Par exemple:
Pour utiliser un tableau dynamique:
Array<> myDynamicArray; // Note array size is not given at compile time
myDynamicArray.resize(N); // N is a run time value
...
Pour utiliser un tableau statique, taille fixe au moment de la compilation:
Array<100> myFixedArry;
Je crois que sa syntaxe est meilleure que std::array ou std::vector. Aussi extrêmement efficace.
L'un des avantages des vecteurs par rapport aux tableaux est qu'il est possible de trouver la taille actuelle d'unà l'aide de nom_vecteur.size () .
Comme vous pouvez l’imaginer, cela peut nous être très utile dans diverses situations, où vous pouvez extraire facilement le nombre d’éléments de la liste array_list.