La bonne façon d’initialiser un pointeur dynamic sur un tableau multidimensionnel?

J’ai eu de la malchance avec les pointeurs dynamics lorsque je les ai placés sur 2 dimensions et plus. Par exemple, je veux un pointeur sur un tableau 2D. Je le sais:

int A[3][4]; int (*P)[4] = A; 

Est complètement légitime (même si je ne comprends pas complètement pourquoi). Considérant que:

 int *P = new int[4]; 

fonctionne, j’ai imaginé que:

 int **P = new int[5][7]; 

Cela fonctionnerait aussi, mais ce n’est pas le cas. Ce code indique l’erreur:

 Error: A value of type "(*)[7]" cannot be used to initialize an entity of type "int **" 

En voyant cela, la nouvelle partie devient un pointeur sur un tableau de 7 entiers que j’ai créés:

 int (*P)[4] = new int[7][4]; 

Et cela fonctionne, mais ce n’est pas ce que je veux accomplir. En procédant ainsi, je suis limité à au moins l’utilisation d’une valeur constante pour toute dimension ultérieure, mais je souhaite qu’elle soit entièrement définie au moment de l’exécution et donc “dynamic”.

Comment pourrais-je aller faire fonctionner ce pointeur multidimensionnel?

Commençons par quelques exemples de base.

Quand vous dites int *P = new int[4];

  1. new int[4]; appelle l’opérateur new function ()
  2. alloue une mémoire pour 4 entiers.
  3. renvoie une référence à cette mémoire.
  4. pour lier cette référence, vous devez avoir le même type de pointeur que celui de référence de retour afin que vous fassiez

     int *P = new int[4]; // As you created an array of integer // you should assign it to a pointer-to-integer 

Pour un tableau multi-dimensionnel, vous devez allouer un tableau de pointeurs, puis remplir ce tableau avec des pointeurs sur des tableaux, comme ceci:

 int **p; p = new int*[5]; // dynamic `array (size 5) of pointers to int` for (int i = 0; i < 5; ++i) { p[i] = new int[10]; // each i-th pointer is now pointing to dynamic array (size 10) // of actual int values } 

Voici à quoi cela ressemble:

entrez la description de l'image ici

Libérer la mémoire

  1. Pour un tableau à une dimension,

      // need to use the delete[] operator because we used the new[] operator delete[] p; //free memory pointed by p;` 
  2. Pour 2d Array,

     // need to use the delete[] operator because we used the new[] operator for(int i = 0; i < 5; ++i){ delete[] p[i];//deletes an inner array of integer; } delete[] p; //delete pointer holding array of pointers; 

Évitez les memory leaks et les pointeurs qui pendent !

Vous voulez quelque chose comme:

 int **P = new int*[7]; p[0] = new int[5]; p[1] = new int[5]; ... 

Une autre approche consisterait à utiliser un tableau 1D en tant que tableau 2D. De cette façon, il vous suffit d’allouer la mémoire une fois (un bloc continu);

 int *array; size_t row=5,col=5; array = (int*)malloc(row*col*sizeof(int)) //or new int[row*col] 

Cela donnerait le même résultat que “int array [5] [5]”.

pour accéder aux champs que vous venez de faire:

 array[1 //the row you want * col //the number of columns +2//the column you want ] = 4; 

Ceci est égal à:

 array[1][2]; 

Ceci effectue la vérification des limites sur certains compilateurs de débogage, utilise la taille dynamic et se supprime automatiquement. La seule chose possible est x et y est le contraire.

 std::vector> array2d(y_size, std::vector(x_size)); for (int y = 0; y < y_size; y++) { for (int x = 0; x < x_size; y++) { array2d[y][x] = 0; } }