Comment allouer un tableau 2D de pointeurs en C++

Par la lettre de la loi, voici comment le faire:

//Create 2D array of pointers:
int*** array2d = new (int**)[rows];
for (int i = 0; i < rows; ++i) {
  array2d[i] = new (int*)[cols];
}

//Null out the pointers contained in the array:
for (int i = 0; i < rows; ++i) {
  for (int j = 0; j < cols; ++j) {
    array2d[i][j] = NULL;
  }
}

Être prudent de supprimer le contenu des pointeurs, la ligne des tableaux, et la colonne de la matrice de tous les séparément et dans l'ordre correct.

Cependant, le plus souvent en C++, vous devez créer une classe qui gérées en interne 1D tableau de pointeurs et de la surcharge de l'appel de fonction à l'exploitant de fournir 2D de l'indexation. De cette façon, vous êtes vraiment une ligne de tableau de pointeurs, plutôt qu'un tableau de tableaux de pointeurs.

OriginalL'auteur Drew Hall

Il dépend. Il peut être aussi simple que:

int main()
{
    int*   data1[10][20]; //Fixed size known at compile time

    data1[2][3] = new int(4);
}

Si vous voulez dynamique tailles au moment de l'exécution, vous devez faire un peu de travail.

Mais Stimuler vous a couvert:

int main()
{
   int  x;
   int  y;
   getWidthAndHeight(x,y);

   //declare a 2D array of int*
   boost::multi_array<int*,2>   data1(boost::extents[x][y]);

   data[2][3] = new int(6);
}

Si vous êtes bien avec les tableaux irréguliers qui peut se développer de manière dynamique:

int main()
{
    std::vector<std::vector<int*> >   data1;

    data1.push_back(std::vector<int*>(10,NULL));
    data1[0][3] = new int(7);
}

Remarque: Dans tous les ci-dessus. Je suppose que le tableau n'est pas propriétaire du pointeur. Ainsi, il n'a pas été de faire toute la gestion sur les pointeurs qu'il contient (bien que pour des raisons de concision, j'ai été en utilisant new int() dans les exemples). Faire la gestion de la mémoire correctement, vous devez faire travailler un peu plus.

OriginalL'auteur Martin York

Vous pouvez essayer de Boost::MultiArray.

Découvrez ce page pour plus de détails.

OriginalL'auteur Chip

Vous pouvez définir un vecteur de vecteurs:

typedef my_type *my_pointer;

typedef vector<vector<my_pointer> > my_pointer2D;

Que de créer une classe dérivée de my_pointer2D, comme:

class PointersField: public my_pointer2D
{
  PointsField(int n, int m)
  {
     //Resize vectors....
  }
}

PointsField pf(10,10); //Will create a 10x10 matrix of my_pointer

OriginalL'auteur Elalfer

Voir mon code. Il fonctionne sur mon FC9 x86_64 système:

#include <stdio.h>
template<typename t>
struct array_2d {
struct array_1d {
t *array;
array_1d(void) { array = 0; }
~array_1d()
{
if (array) {
delete[] array;
array = 0;
}
}
t &operator[](size_t index) { return array[index]; }
} *array;
array_2d(void) { array = 0; }
array_2d(array_2d<t> *a) { array = a->array; a->array = 0; }
void init(size_t a, size_t b)
{
array = new array_1d[a];
for (size_t i = 0; i < a; i++) {
array[i].array = new t[b];
}
}
~array_2d()
{
if (array) {
delete[] array;
array = 0;
}
}
array_1d &operator[](size_t index) { return array[index]; }
};
int main(int argc, char **argv)
{
array_2d<int> arr = new array_2d<int>;
arr.init(16, 8);
arr[8][2] = 18;
printf("%d\n",
arr[8][2]
);
return 0;
}

Efforts UPD: une réponse à "N'est-ce pas un tableau de pointeurs vers des tableaux?", ajout de l'exemple de tableau de pointeurs, très simple:

int main(int argc, char **argv)
{
array_2d<int*> parr = new array_2d<int*>;
int i = 10;
parr.init(16, 8);
parr[10][5] = &i;
printf("%p %d\n",
parr[10][5],
parr[10][5][0]
);
return 0;
}

Ai-je encore mal compris votre question?

Et vous pourriez même

typedef array_2d<int*> cell_type;
typedef array_2d<cell_type*> array_type;
int main(int argc, char **argv)
{
array_type parr = new array_type;
parr.init(16, 8);
parr[10][5] = new cell_type;
cell_type *cell = parr[10][5];
cell->init(8, 16);
int i = 10;
(*cell)[2][2] = &i;
printf("%p %d\n",
(*cell)[2][2],
(*cell)[2][2][0]
);
delete cell;
return 0;
}

Il travaille aussi sur mon FC9 x86_64 système.

OriginalL'auteur Test