Comment dois-je allouer de la mémoire pour un tableau 2d?

D'autres réponses couvrir d'avoir un tableau de pointeurs pour vos lignes, avec un pointeur vers un int tableau par ligne. Une autre option est de simplement attribuer un 1-D tableau assez grand pour contenir toutes les 2-D éléments du tableau:

int* p = new int [3 * 4];

Alors au lieu d'utiliser le p[r][c] syntaxe, vous utilisez p[r * kNumCols + c]. Dans cet exemple, kNumCols = 4. C'est généralement ce qui est fait dans LAPACK style de nombreux calculs, car il garde les choses contiguës en mémoire et vous n'avez pas besoin d'allouer donc de nombreux blocs de mémoire.

Remarque: en général, Cela est pas plus lent que l'autre dans la pratique, parce que le décalage de lignes de calcul est déplacé hors de la boucle par la commune de la sous-expression de l'optimisation. Aussi, de nombreux référenceurs savent à regarder pour ce modèle. En outre, en gardant vos données co-situé dans un unique bloc de mémoire, les données sont plus susceptibles de rester dans le cache.

En C++, vous pourriez mettre en œuvre les p[][] notation avec un assistant de classe de modèle:

template<class T>
class Array2DPtrRow
{public:
    Row(T* row_): row(row_) {}
    operator T*() { return row; }
    T& operator [](size_t c) { return row[c]; }
private:
    T* row;
};

template<class T, size_t NC>
class Array2DPtr
{public:
    Array2DPtr(T* buf_): buf(buf_) {}
    operator T*() { return buf; }
    Array2DPtrRow<T> operator [](size_t r)
        { return Array2DPtrRow<T>(buf + NC * r); }
private:
    T* buf;
};

Cela permet d'optimiser le bas pour le même code que ci-dessus, mais vous permet d'utiliser [][] notation et nécessite de connaître vos dimensions du tableau au moment de la compilation. Exemple d'utilisation:

Array2DPtr<int, 4> p(new int[3 * 4]);
p[1][2];

Ce pourrait être converti pour faire des NC dans un membre de la classe au lieu d'un paramètre du modèle, mais alors l'objet final n'est pas seulement un pointeur plus:

template<class T>
class Array2DPtr
{public:
    Array2DPtr(T* buf_, size_t nc_): buf(buf_), nc(nc_) {}
    operator T*() { return buf; }
    Array2DPtrRow<T> operator [](size_t r)
        { return Array2DPtrRow<T>(buf + nc * r); }
private:
    T* buf;
    size_t nc;
};

Array2DPtr<int> p(new int[3 * 4], 4);
p[1][2];

Noter qu'aucun de ces classes besoin de copier les constructeurs, les opérateurs d'assignation, ou destructeurs, car ils ne prennent pas la propriété de la pointe-de mémoire, pas plus que d'un pointeur normal. Donc, pour libérer de la mémoire, il vous reste à faire:

delete[] p;

Ou si votre compilateur ne peut pas le comprendre:

delete[] (int*)p;

OriginalL'auteur Mike DeSimone

Pour réellement répondre à la question:

Se rappeler qu'un tableau est équivalent à un pointeur vers le premier élément du tableau, de sorte que, par exemple, vous pouvez écrire:

char str[14] = "Hello, world!";
char *ptr = str;

Cela fonctionne pour un tableau à deux dimensions.

int (*p)[4];

déclare un pointeur vers le premier élément d'un tableau à deux dimensions. p peut ensuite être rappelé à tout tableau à deux dimensions, aussi longtemps que son deuxième dimension est 4, donc par exemple, vous pourriez écrire

int arr[3][4];
int (*p)[4] = arr;

Bien sûr, vous pouvez également allouer de la mémoire dynamiquement:

int (*p)[4] = new int[3][4];

Encore une fois, la deuxième dimension est d'être 4, mais vous pouvez varier la première dimension.

OriginalL'auteur Neil