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];
new int[4];
appelle l’opérateur new function () 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:
Pour un tableau à une dimension,
// need to use the delete[] operator because we used the new[] operator delete[] p; //free memory pointed by p;`
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; } }