Peut-on utiliser unique_ptr avec array?

std::unique_ptr prend en charge les tableaux, par exemple:

std::unique_ptr<int[]> p(new int[10]);

mais est-ce nécessaire? il est probablement plus pratique à utiliser std::vectorou std::array.

Trouvez-vous une utilité pour cette construction?

Certaines personnes n'ont pas le luxe d'utiliser std::vector, même avec des allocateurs. Certaines personnes ont besoin d'un tableau de taille dynamique std::array. Et certaines personnes obtiennent leurs tableaux à partir d'un autre code connu pour renvoyer un tableau; et ce code ne va pas être réécrit pour retourner unvector ou quelque chose.

En permettant unique_ptr<T[]>, vous répondez à ces besoins.

En bref, vous utilisez unique_ptr<T[]>quand vous en avez besoin . Lorsque les alternatives ne fonctionnent tout simplement pas pour vous. C'est un outil de dernier recours.

Il y a des compromis et vous choisissez la solution qui correspond à ce que vous voulez. Du haut de ma tête:

Dimension initiale

• vectoret unique_ptr<T[]>autoriser la taille à spécifier au moment de l'exécution
• array permet uniquement de spécifier la taille au moment de la compilation

Redimensionnement

• arrayet unique_ptr<T[]>ne permettent pas le redimensionnement
• vector Est-ce que

Espace de rangement

• vectoret unique_ptr<T[]>stocker les données en dehors de l'objet (généralement sur le tas)
• array stocke les données directement dans l'objet

Copier

• arrayet vectorautoriser la copie
• unique_ptr<T[]> ne permet pas la copie

Échanger / déplacer

• vectoret unique_ptr<T[]>avoir O (1) temps swapet opérations de déplacement
• arraya O (n) temps swapet opérations de déplacement, où n est le nombre d'éléments dans le tableau

Invalidation du pointeur / référence / itérateur

• array garantit que les pointeurs, les références et les itérateurs ne seront jamais invalidés tant que l'objet est en direct, même sur swap()
• unique_ptr<T[]>n'a pas d'itérateurs; les pointeurs et les références ne sont invalidés swap()que lorsque l'objet est en direct. (Après l'échange, les pointeurs pointent vers le tableau avec lequel vous avez échangé, ils sont donc toujours "valides" dans ce sens.)
• vector peut invalider des pointeurs, des références et des itérateurs sur toute réallocation (et fournit certaines garanties que la réallocation ne peut se produire que sur certaines opérations).

Compatibilité avec les concepts et algorithmes

• arrayet vectorsont les deux conteneurs
• unique_ptr<T[]> n'est pas un conteneur

Je dois admettre que cela ressemble à une opportunité pour une refactorisation avec une conception basée sur des politiques.

Une raison pour laquelle vous pourriez utiliser un unique_ptrest si vous ne voulez pas payer le coût d'exécution de l' initialisation de la valeur du tableau.

std::vector<char> vec(1000000); // allocates AND value-initializes 1000000 chars

std::unique_ptr<char[]> p(new char[1000000]); // allocates storage for 1000000 chars

Le std::vectorconstructeur et std::vector::resize()initialisera la valeur T- mais newne le fera pas s'il Ts'agit d'un POD.

Voir Objets à valeur initialisée en C ++ 11 et constructeur std :: vector

Notez que ce vector::reserven'est pas une alternative ici: L'accès au pointeur brut après std :: vector :: reserve est-il sûr?

C'est la même raison , un programmeur C pourrait choisir mallocplus calloc.

Un std::vectorpeut être copié, tout en unique_ptr<int[]>permettant d'exprimer la propriété unique de la baie. std::array, d'autre part, nécessite que la taille soit déterminée au moment de la compilation, ce qui peut être impossible dans certaines situations.

Scott Meyers a ceci à dire dans Effective Modern C ++

L'existence de std::unique_ptrpour les tableaux devraient être seulement pour vous l' intérêt intellectuel, parce que std::array, std::vector, std::stringsont presque toujours de meilleurs choix de structure de données que les tableaux bruts. À propos de la seule situation que je puisse imaginer quand un std::unique_ptr<T[]>serait logique serait lorsque vous utilisez une API de type C qui renvoie un pointeur brut vers un tableau de tas dont vous assumez la propriété.

Je pense que la réponse de Charles Salvia est pertinente: c'est std::unique_ptr<T[]>le seul moyen d'initialiser un tableau vide dont la taille n'est pas connue au moment de la compilation. Que dirait Scott Meyers de cette motivation à utiliser std::unique_ptr<T[]>?

Contrairement à std::vectoret std::array, std::unique_ptrpeut posséder un pointeur NULL.
Cela est pratique lorsque vous travaillez avec des API C qui attendent un tableau ou NULL:

void legacy_func(const int *array_or_null);

void some_func() {    
    std::unique_ptr<int[]> ptr;
    if (some_condition) {
        ptr.reset(new int[10]);
    }

    legacy_func(ptr.get());
}

J'ai utilisé unique_ptr<char[]>pour implémenter un pool de mémoire préalloué utilisé dans un moteur de jeu. L'idée est de fournir des pools de mémoire préalloués utilisés au lieu d'allocations dynamiques pour renvoyer les résultats des demandes de collision et d'autres choses comme la physique des particules sans avoir à allouer / libérer de la mémoire à chaque trame. C'est assez pratique pour ce type de scénarios où vous avez besoin de pools de mémoire pour allouer des objets à durée de vie limitée (généralement une, 2 ou 3 images) qui ne nécessitent pas de logique de destruction (uniquement la désallocation de mémoire).

Un modèle commun peut être trouvé dans certains appels de l' API Windows Win32 , dans lesquels l'utilisation de std::unique_ptr<T[]>peut être utile, par exemple lorsque vous ne savez pas exactement la taille d'un tampon de sortie lors de l'appel d'une API Win32 (qui écrira des données à l'intérieur ce tampon):

// Buffer dynamically allocated by the caller, and filled by some Win32 API function.
// (Allocation will be made inside the 'while' loop below.)
std::unique_ptr<BYTE[]> buffer;

// Buffer length, in bytes.
// Initialize with some initial length that you expect to succeed at the first API call.
UINT32 bufferLength = /* ... */;

LONG returnCode = ERROR_INSUFFICIENT_BUFFER;
while (returnCode == ERROR_INSUFFICIENT_BUFFER)
{
    // Allocate buffer of specified length
    buffer.reset( BYTE[bufferLength] );
    //        
    // Or, in C++14, could use make_unique() instead, e.g.
    //
    // buffer = std::make_unique<BYTE[]>(bufferLength);
    //

    //
    // Call some Win32 API.
    //
    // If the size of the buffer (stored in 'bufferLength') is not big enough,
    // the API will return ERROR_INSUFFICIENT_BUFFER, and the required size
    // in the [in, out] parameter 'bufferLength'.
    // In that case, there will be another try in the next loop iteration
    // (with the allocation of a bigger buffer).
    //
    // Else, we'll exit the while loop body, and there will be either a failure
    // different from ERROR_INSUFFICIENT_BUFFER, or the call will be successful
    // and the required information will be available in the buffer.
    //
    returnCode = ::SomeApiCall(inParam1, inParam2, inParam3, 
                               &bufferLength, // size of output buffer
                               buffer.get(),  // output buffer pointer
                               &outParam1, &outParam2);
}

if (Failed(returnCode))
{
    // Handle failure, or throw exception, etc.
    ...
}

// All right!
// Do some processing with the returned information...
...

J'ai dû faire face à un cas où je devais utiliser std::unique_ptr<bool[]>, qui se trouvait dans la bibliothèque HDF5 (une bibliothèque pour un stockage efficace des données binaires, beaucoup utilisée en science). Certains compilateurs (Visual Studio 2015 dans mon cas) fournissent une compression destd::vector<bool> (en utilisant 8 bools dans chaque octet), ce qui est une catastrophe pour quelque chose comme HDF5, qui ne se soucie pas de cette compression. Avec std::vector<bool>, HDF5 lisait finalement les ordures à cause de cette compression.

Devinez qui était là pour le sauvetage, dans un cas où cela std::vectorn'a pas fonctionné, et j'avais besoin d'allouer proprement un tableau dynamique? :-)

En un mot: c'est de loin le plus économe en mémoire.

A std::stringest fourni avec un pointeur, une longueur et un tampon "d'optimisation de chaîne courte". Mais ma situation est que j'ai besoin de stocker une chaîne qui est presque toujours vide, dans une structure dont j'en ai des centaines de milliers. En C, j'utiliserais juste char *, et ce serait nul la plupart du temps. Ce qui fonctionne aussi pour C ++, sauf que a char *n'a pas de destructeur et ne sait pas se supprimer. En revanche, a std::unique_ptr<char[]>se supprimera lorsqu'il sortira du champ d'application. Un vide std::stringprend 32 octets, mais un vide std::unique_ptr<char[]>prend 8 octets, c'est-à-dire exactement la taille de son pointeur.

Le plus gros inconvénient est que chaque fois que je veux connaître la longueur de la chaîne, je dois l'appeler strlen.

Pour répondre aux gens qui pensent que vous "devez" utiliser vectorau lieu de unique_ptrj'ai un cas dans la programmation CUDA sur GPU lorsque vous allouez de la mémoire dans l'appareil, vous devez opter pour un tableau de pointeurs (avec cudaMalloc). Ensuite, lors de la récupération de ces données dans l'hôte, vous devez recommencer pour un pointeur et unique_ptrc'est bien de gérer le pointeur facilement. Le coût supplémentaire de la conversion double*en vector<double>est inutile et entraîne une perte de performance.

Une raison supplémentaire d'autoriser et d'utiliser std::unique_ptr<T[]> , qui n'a pas été mentionnée dans les réponses jusqu'à présent: elle vous permet de déclarer en avant le type d'élément du tableau.

Ceci est utile lorsque vous souhaitez minimiser la chaîne #include instructions dans les en-têtes (pour optimiser les performances de génération.)

Par exemple -

myclass.h:

class ALargeAndComplicatedClassWithLotsOfDependencies;

class MyClass {
   ...
private:
   std::unique_ptr<ALargeAndComplicatedClassWithLotsOfDependencies[]> m_InternalArray;
};

myclass.cpp:

#include "myclass.h"
#include "ALargeAndComplicatedClassWithLotsOfDependencies.h"

// MyClass implementation goes here

Avec la structure de code ci-dessus, n'importe qui peut #include "myclass.h"et peut utiliser MyClass, sans avoir à inclure les dépendances d'implémentation internes requises par MyClass::m_InternalArray.

Si a m_InternalArrayété déclaré à la place comme un std::array<ALargeAndComplicatedClassWithLotsOfDependencies>ou un std::vector<...>respectivement - le résultat serait une tentative d'utilisation d'un type incomplet, ce qui est une erreur au moment de la compilation.

Je ne peux pas être assez en désaccord avec l'esprit de la réponse acceptée. "Un outil de dernier recours"? Loin de là!

Selon moi, l'une des caractéristiques les plus fortes de C ++ par rapport à C et à d'autres langages similaires est la capacité d'exprimer des contraintes afin qu'elles puissent être vérifiées au moment de la compilation et qu'une mauvaise utilisation accidentelle puisse être évitée. Ainsi, lors de la conception d'une structure, demandez-vous quelles opérations elle devrait permettre. Toutes les autres utilisations doivent être interdites, et il est préférable que de telles restrictions puissent être implémentées statiquement (au moment de la compilation) afin qu'une mauvaise utilisation entraîne un échec de compilation.

Ainsi, lorsque l'on a besoin d'un tableau, les réponses aux questions suivantes spécifient son comportement: 1. Sa taille est-elle a) dynamique au moment de l'exécution, ou b) statique, mais uniquement connue au moment de l'exécution, ou c) statique et connue au moment de la compilation? 2. Le tableau peut-il être alloué sur la pile ou non?

Et sur la base des réponses, voici ce que je considère comme la meilleure structure de données pour un tel tableau:

       Dynamic     |   Runtime static   |         Static
Stack std::vector      unique_ptr<T[]>          std::array
Heap  std::vector      unique_ptr<T[]>     unique_ptr<std::array>

Oui, je pense unique_ptr<std::array> devrait également être pris en considération, et ni l'un ni l'autre n'est un outil de dernier recours. Pensez simplement à ce qui correspond le mieux à votre algorithme.

Tous ces éléments sont compatibles avec les API C simples via le pointeur brut vers le tableau de données ( vector.data()/ array.data()/ uniquePtr.get()).

PS En dehors des considérations ci-dessus, il y a aussi une propriété: std::arrayet std::vectoront une sémantique de valeur (ont un support natif pour la copie et le passage par valeur), alors unique_ptr<T[]>qu'elles ne peuvent être déplacées (applique la propriété unique). Les deux peuvent être utiles dans différents scénarios. Au contraire, les tableaux statiques simples ( int[N]) et les tableaux dynamiques simples ( new int[10]) n'offrent ni l'un ni l'autre et doivent donc être évités si possible - ce qui devrait être possible dans la grande majorité des cas. Si cela ne suffisait pas, les tableaux dynamiques simples n'offrent également aucun moyen d'interroger leur taille - une opportunité supplémentaire pour les corruptions de mémoire et les failles de sécurité.

Ils peuvent être la meilleure réponse possible lorsque vous ne piquez qu'un seul pointeur via une API existante (pensez à un message de fenêtre ou à des paramètres de rappel liés au threading) qui ont une certaine durée de vie après avoir été "pris" de l'autre côté de la trappe, mais qui n'est pas lié au code appelant:

unique_ptr<byte[]> data = get_some_data();

threadpool->post_work([](void* param) { do_a_thing(unique_ptr<byte[]>((byte*)param)); },
                      data.release());

Nous voulons tous que les choses soient agréables pour nous. C ++ est pour les autres fois.

unique_ptr<char[]>peut être utilisé là où vous voulez les performances de C et la commodité de C ++. Considérez que vous devez opérer sur des millions (ok, des milliards si vous ne faites pas encore confiance) de chaînes. Le stockage de chacun d'eux dans un objet stringou un élément distinct vector<char>serait un désastre pour les routines de gestion de la mémoire (tas). Surtout si vous devez allouer et supprimer plusieurs fois différentes chaînes.

Cependant, vous pouvez allouer un seul tampon pour stocker autant de chaînes. Vous char* buffer = (char*)malloc(total_size);n'aimeriez pas pour des raisons évidentes (si ce n'est pas évident, recherchez "pourquoi utiliser des ptr intelligents"). Vous préférezunique_ptr<char[]> buffer(new char[total_size]);

Par analogie, les mêmes considérations de performances et de commodité s'appliquent aux non- chardonnées (considérons des millions de vecteurs / matrices / objets).

• Vous avez besoin que votre structure contienne juste un pointeur pour des raisons de compatibilité binaire.
• Vous devez vous interfacer avec une API qui renvoie la mémoire allouée avec new[]
• Votre entreprise ou votre projet a une règle générale contre l'utilisation std::vector, par exemple, pour empêcher les programmeurs imprudents d'introduire accidentellement des copies
• Vous voulez empêcher les programmeurs imprudents d'introduire accidentellement des copies dans cette instance.

Il existe une règle générale selon laquelle les conteneurs C ++ doivent être préférés au roulage avec des pointeurs. C'est une règle générale; il a des exceptions. Il y a plus; ce ne sont que des exemples.

Si vous avez besoin d'un tableau dynamique d'objets qui ne sont pas constructibles par copie, alors un pointeur intelligent vers un tableau est le chemin à parcourir. Par exemple, que faire si vous avez besoin d'un tableau d'atomes.