Double (à deux dimensions) tableau à l'aide de std::unique_ptr

J'ai un double tableau alloué par pointeur de pointeur.

  //pointer to pointer
  int **x = new int *[5];   //allocation
  for (i=0; i<5; i++){
      x[i] = new int[2];
  }

  for (i=0; i<5; i++){      //assignment
      for (j=0; j<2; j++){
          x[i][j] = i+j;
      }
  }

  for (i=0; i<5; i++)   //deallocation
      delete x[i];
  delete x;

Je suis en train de faire cela à l'aide de unique_ptr:

std::unique_ptr<std::unique_ptr<int>[]> a(new std::unique_ptr<int>[5]);
  for (i=0; i<5; i++)
      a[i] = new int[2];

mais a gardé une erreur en disant que no operator = matches these operands. Ce que je fais de mal ici?

OriginalL'auteur Evan | 2012-03-20

  1. 16

    Vous ne pouvez pas affecter un int* à un std::unique_ptr<int[]>, qui est la cause de votre erreur. Le code correct est 

          a[i] = std::unique_ptr<int[]>(new int[2]);

    Cependant, piokuc est correct, qu'il est très rare d'utiliser des unique_ptr pour les tableaux, c'est ce que std::vector et std::array sont, en fonction de si la taille est connue à l'avance.

    //make a 5x2 dynamic jagged array, 100% resizable any time
std::vector<std::vector<int>> container1(5, std::vector<int>(2)); 
//make a 5x2 dynamic rectangular array, can resize the 5 but not the 2
std::vector<std::array<2, int>> container1(5); 
//make a 5x2 automatic array, can't resize the 2 or 5 but is _really fast_.
std::array<5, std::array<2, int>> container;

    Tous ces éléments peuvent être initialisé et utilisé exactement la même chose que le code que vous avez déjà eu, sauf qu'elles sont plus faciles à construire, et vous n'avez pas à les détruire.

    Bien sûr, std::unique_ptr<int>(new int[2]); aura du mal deleter, ça devrait être std::unique_ptr<int[]>(new int[2]);. De préemption +1 en supposant que vous allez résoudre ce problème. ;-]
    Je n'ai jamais utilisé unique_ptr de tableaux, je suis floue sur la syntaxe. Merci!
    Je vous remercie pour vos contributions!
    Assurez-vous de upvote toutes les réponses que vous avez trouvé utile (avec la flèche vers le haut sur la gauche), et marque l'un à la réponse "correcte" (avec la coche juste sous les flèches).

    OriginalL'auteur Mooing Duck

  2. 5

    Si vous n'avez pas le luxe de l'aide d'un std::array ou un std::vector au lieu d'un tableau alloué dynamiquement, vous pouvez utiliser un unique_ptr pour un tableau à deux dimensions en C++11 comme suit:

    std::unique_ptr<int*, std::function<void(int**)>> x(
    new int*[10](),
    [](int** x) {
        std::for_each(x, x + 10, std::default_delete<int[]>());
        delete[] x;
    }
);

    La unique_ptr déclaration prend soin de l'allocation de l' ligne dimension de la matrice. La fuite () dans new int*[10]() veille à ce que chaque colonne pointeur est initialisé à nullptr.

    D'une boucle for puis alloue la colonne des tableaux:

    for (size_t row = 0; row < 10; ++row) {
    (x.get())[row] = new int[5];
}

    Lorsque le unique_ptr est hors de portée, ses personnalisé deleter fonction lambda prend soin de la suppression de la colonne des tableaux avant de supprimer la ligne de la matrice. Le for_each expression utilise le default_delete foncteur.

    Cela pourrait-il être étendu à l'aide d' _mm_malloc et comment?
    Utilisation __mm_malloc pour allouer de la mémoire et de l'utilisation _mm_free dans la deleter.
    Merci, j'ai obtenu ce travail. Vous avez oublié votre deuxième morceau, c'est à dire à allouer les lignes individuelles (sans cela, j'ai une erreur de segmentation). Travail sur un exemple d'utilisation de variadic templates, où je peux créer des multi-dimensions des tableaux, sans accéder aux données à l'aide de .get().

    OriginalL'auteur sakra

  3. 2

    Votre code est effectivement la manipulation d'un tableau de tableaux de int.

    En C++ vous voulez normalement pour la mettre en œuvre comme:

    std::vector<std::vector<int> > x;

    Ce n'est pas une bonne affaire pour les unique_ptr. Aussi, vous ne devriez pas avoir besoin d'utiliser des pointeurs pour unique_ptr et d'allouer les unique_ptr objets dynamiquement. Le point de l'ensemble de unique_ptr est d'éliminer l'utilisation de pointeurs et de fournir automatique de l'allocation et la désallocation de l'objet.

    Je vous remercie pour vos contributions. La façon dont je le comprends unique_ptr est qu'il garantit que l'instance qu'il points a seulement 1 de référence. Donc, en utilisant unique_ptr à point à un unique_ptr pour créer une matrice doit être fine à usage unique, étant donné qu'il n'y aura pas une autre référence à l'instance. Aussi, je ne comprends pas la raison derrière la dernière phrase. Merci.
    tout RAII classe doit offrir la même garantie unique. La plupart des classes C++ sont RAII. Donc, vous devez utiliser le bon outil pour le travail. vecteur et matrice devrait être préféré à unique_ptr ici.
    la raison pour unique ptrs est surtout de tenir allouée dynamiquement des objets uniques. Je ne peux pas immédiatement penser à une raison pour stocker un tableau dans un unique_ptr.
    Il y a quelques cas d'utilisation (sûrement!) depuis qu'il est pris en compte spécifiquement dans la norme: le premier modèle unique_ptr< T > et de la spécialisation unique_ptr< T[] >. Je suppose que c'est pas juste pour être complet, car il n'y a pas une telle spécialisation pour shared_ptr.

    OriginalL'auteur piokuc

  4. 2
    for (i=0; i<5; i++)   //deallocation
      delete x[i];
  delete x;

    NON NON NON NON

    delete [] x[i];
delete [] x;

    //yo

    OriginalL'auteur amigo

  5. 1

    Les seules raisons que je peux penser à utiliser std::unique_ptr (ou dire boost::scoped_array) sur std::vector pour la tenue de tableaux ne sont généralement pas applicables...

    1) il permet d'économiser 1 ou 2 pointeurs de la valeur de la mémoire, en fonction de si vous savez ce que la taille de tous les tableaux est [pas pertinent, sauf si vous avez un grand nombre de très petits tableaux]

    2) dans le cas où vous êtes juste de passage du tableau dans une fonction qui attend un style C tableau ou pointeur brut, il peut se sentir comme un ajustement plus naturel. std::vector EST la garantie d'être sur séquentielle de stockage, donc en passant (a.empty() ? nullptr : &a[0], a.size()) dans une telle fonction est 100% legit.

    3) des conteneurs standard dans MSVC mode de débogage sont "contrôlés" par défaut et très lente, ce qui peut être gênant lors d'émissions scientifiques sur de grands ensembles de données.

    Un avantage de unique_ptr<int[]> plus de vector<int>, c'est que vous pouvez éviter d'initialisation, dont le coût peut être important dans certains cas. Ref stackoverflow.com/questions/96579/... et stackoverflow.com/questions/7546620/...

    OriginalL'auteur yonil

  6. 0

    Un exemple plus haut, m'a inspiré pour cette solution

    size_t k = 10;
std::unique_ptr<int*, std::function<void(int**)>> y(new int*[k](),
    [](int** x) {delete [] &(x[0][0]);
                 delete[] x;});

//Allocate the large array
y.get()[0] = new int[k*10];

//Establish row-pointers
for (size_t row = 0; row < k; ++row) {
  (y.get())[row] = &(y.get()[0][0]);
}

    Ici toutes les dimensions peuvent être dynamiques et vous pouvez l'envelopper à l'intérieur d'une classe et d'exposer un opérateur[]. Aussi la mémoire est allouée de manière contiguë et vous pouvez facilement introduire un allocateur, qui alloue aligné mémoire.

    OriginalL'auteur Jens Munk

  7. 0
    for (i=0; i<5; i++)   //deallocation
      delete x[i];
  delete x;

    C'est une erreur courante ici.
    x[i] est un tableau, donc vous devez supprimer chaque tableau de la première utilisation de delete[]
    Ensuite, vous pouvez supprimer vous tableau de int* en utilisant delete[]

    Corriger desallocation serait:

    for (i=0; i<5; i++)   
      delete[] x[i]; //desallocate each array of int
delete[] x; //desallocate your array of int*
x = nullptr; //good practice to be sure it wont cause any dmg

    OriginalL'auteur Romain Bosq