std::dynarray vs std::vector

Question

C++14 présente std::dynarray :

std::dynarray est un conteneur de séquence qui encapsule les tableaux avec une taille qui est fixée lors de la construction et qui ne change pas tout au long de la vie de l'objet.

std::dynarray doivent être alloués à l'exécution de la même manière que std::vector .

Quels sont donc les avantages et l'utilisation de std::dynarray alors que nous pouvons utiliser std::vector qui est plus dynamique (et également redimensionnable) ?

Answer 1

Quels sont donc les avantages et l'utilisation de std::dynarray alors que nous pouvons utiliser std::vector lequel est le plus dynamique (redimensionnable) ?

dynarray est plus petit et plus simple que vector car il n'a pas besoin de gérer des valeurs de taille et de capacité distinctes, ni de stocker un allocateur.

Toutefois, le principal avantage en termes de performances est censé provenir du fait que les implémentations sont encouragées à allouer les ressources suivantes dynarray sur la pile lorsque cela est possible, en évitant toute allocation au tas. par exemple

std::dynarray<int> d(5);   // can use stack memory for elements
auto p = new std::dynarray<int>(6);  // must use heap memory for elements

Cette optimisation nécessite la coopération du compilateur, elle ne peut pas être mise en œuvre en tant que type de bibliothèque pur, et la magie nécessaire du compilateur n'a pas été mise en œuvre et personne ne sait si elle est facile à réaliser. En raison du manque d'expérience en matière de mise en œuvre, il a été décidé, lors de la réunion du comité C++ qui s'est tenue à Chicago la semaine dernière, de retirer les types de bibliothèque de la liste des types de bibliothèque. std::dynarray à partir de C++14 et de publier un document TS (technical specification) séparé sur les extensions de tableau définissant std::experimental::dynarray et des matrices d'exécution (ARB, similaires aux VLA de C99). Cela signifie que std::dynarray ne sera presque certainement pas dans C++14.

Answer 2

Comme vous l'avez dit vous-même, std::dynarray est pour un taille fixe réseau dynamique. Il n'est pas redimensionnable. Il s'agit en gros d'une amélioration par rapport à new T[N] et plus std::unique_ptr<T[]>(new T[N]) .

Le fait de ne pas avoir à redimensionner ou à gérer la capacité signifie que vous pouvez mettre en œuvre la structure de données avec moins de complexité et dans moins d'espace.

De plus, std::dynarray est un animal bizarre qui permet à l'implémentation de l'implémenter de différentes manières non spécifiques, par exemple, il est possible de mettre le tableau sur la pile. L'appel à une fonction d'allocation est "facultatif". Vous pouvez spécifier un allocateur pour construire les éléments du tableau, mais cela ne fait pas partie du type.

Vous pouvez aussi vous demander pourquoi nous avons besoin std::dynarray et les tableaux à longueur variable. Les VLA en C++14 sont beaucoup plus restrictifs ; ils ne peuvent être que des variables locales et automatiques et n'offrent aucun moyen de spécifier une politique d'allocation, et bien sûr ils n'ont pas d'interface de conteneur standard.

---

Quelques exemples tirés de 23.3.4.2 d'un "projet actuel" (prenez ça, Google cache) :

explicit dynarray(size_type c);

Effets : Attribue un espace de stockage pour c éléments. Peut ou non invoquer l'option globale operator new .

template <class Alloc>
dynarray(size_type c, const Alloc& alloc);

Effets : Equivalent aux constructeurs précédents sauf que chaque élément est construit avec la construction uses-allocator .

Que vous soyez ou non peut utiliser un allocateur donné pour construire les éléments du tableau est un trait global :

modèle struct uses_allocator, Alloc> : true_type { } ;

Exige : Alloc doit être un allocateur (17.6.3.5). [ Note : La spécialisation de ce trait informe les autres composants de la bibliothèque que dynarray peut être construit avec un allocateur, même s'il n'a pas de type allocateur imbriqué].

Edit : La réponse de Jonathan Wakely fera certainement autorité et sera plus perspicace.