Comment déclarer un tableau 2d en C++ en utilisant new ?

Question

Comment déclarer un tableau 2d en utilisant new ?

Comme, pour un tableau "normal", je le ferais :

int* ary = new int[Size]

mais

int** ary = new int[sizeY][sizeX]

a) ne fonctionne pas/compile et b) n'accomplit pas quoi :

int ary[sizeY][sizeX] 

fait.

Answer 1

Si la longueur de la ligne est une constante de compilation, C++11 autorise

auto arr2d = new int [nrows][CONSTANT];

Ver cette réponse . Les compilateurs comme gcc qui autorisent les tableaux à longueur variable comme une extension de C++ peuvent utiliser new comme indiqué ici pour obtenir une fonctionnalité de dimension de tableau entièrement variable en cours d'exécution comme le permet C99, mais le C++ ISO portable est limité à la première dimension variable.

Une autre option efficace consiste à effectuer manuellement l'indexation 2d dans un grand tableau 1d, comme suit une autre réponse montre permettant les mêmes optimisations du compilateur qu'un vrai tableau 2D (par exemple, prouver ou vérifier que les tableaux ne s'aliasent pas entre eux ou ne se chevauchent pas).

---

Sinon, vous pouvez utiliser un tableau de pointeurs vers des tableaux pour permettre la syntaxe 2D comme les tableaux 2D contigus, même si ce n'est pas une allocation unique efficace. Vous pouvez l'initialiser en utilisant une boucle, comme ceci :

int** a = new int*[rowCount];
for(int i = 0; i < rowCount; ++i)
    a[i] = new int[colCount];

Ce qui précède, pour colCount= 5 y rowCount = 4 produirait ce qui suit :

N'oubliez pas de delete chaque ligne séparément avec une boucle, avant d'effacer le tableau de pointeurs. Exemple dans une autre réponse .

Answer 2

int** ary = new int[sizeY][sizeX]

devrait être :

int **ary = new int*[sizeY];
for(int i = 0; i < sizeY; ++i) {
    ary[i] = new int[sizeX];
}

et ensuite le nettoyage serait :

for(int i = 0; i < sizeY; ++i) {
    delete [] ary[i];
}
delete [] ary;

EDITAR: Comme Dietrich Epp l'a souligné dans les commentaires, ce n'est pas exactement une solution légère. Une approche alternative serait d'utiliser un grand bloc de mémoire :

int *ary = new int[sizeX*sizeY];

// ary[i][j] is then rewritten as
ary[i*sizeY+j]

Answer 3

En C++11, c'est possible :

auto array = new double[M][N]; 

De cette façon, la mémoire n'est pas initialisée. Pour l'initialiser, faites plutôt ceci :

auto array = new double[M][N]();

Exemple de programme (compilé avec "g++ -std=c++11") :

#include <iostream>
#include <utility>
#include <type_traits>
#include <typeinfo>
#include <cxxabi.h>
using namespace std;

int main()
{
    const auto M = 2;
    const auto N = 2;

    // allocate (no initializatoin)
    auto array = new double[M][N];

    // pollute the memory
    array[0][0] = 2;
    array[1][0] = 3;
    array[0][1] = 4;
    array[1][1] = 5;

    // re-allocate, probably will fetch the same memory block (not portable)
    delete[] array;
    array = new double[M][N];

    // show that memory is not initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }
    cout << endl;

    delete[] array;

    // the proper way to zero-initialize the array
    array = new double[M][N]();

    // show the memory is initialized
    for(int r = 0; r < M; r++)
    {
        for(int c = 0; c < N; c++)
            cout << array[r][c] << " ";
        cout << endl;
    }

    int info;
    cout << abi::__cxa_demangle(typeid(array).name(),0,0,&info) << endl;

    return 0;
}

Sortie :

2 4 
3 5 

0 0 
0 0 
double (*) [2]

Answer 4

Je présume, d'après votre exemple de tableau statique, que vous voulez un tableau rectangulaire, et non en dents de scie. Vous pouvez utiliser ce qui suit :

int *ary = new int[sizeX * sizeY];

Vous pouvez alors accéder aux éléments comme :

ary[y*sizeX + x]

N'oubliez pas d'utiliser delete[] sur ary .

Answer 5

Ne le faites pas.

À moins que vous n'ayez une bonne raison, utilisez std::vector<std::vector<int> > à la place. La gestion de la mémoire sera beaucoup moins sujette aux erreurs.

Editar:

Si vous commencez à rencontrer des problèmes avec la mémoire étant non contiguës comme l'a souligné Dietrich Epp dans les commentaires, vous pouvez passer à l'utilisation de l'option std::vector<int> et allouer des éléments (rangées * colonnes).

Vous pouvez alors mettre la main sur le premier élément de ce vecteur ( &v[0] ) et utiliser les techniques dans les autres réponses pour le traiter comme un produit normal. int[][] .

Cependant, je ne le ferais que si vous aviez réellement profilé votre code et constaté que la mémoire non contiguë causait des problèmes de performance. Ce ne serait probablement un problème que si vous aviez un très grand tableau 2D. C'est du moins ce que je pense. Encore une fois, le profilage est le seul moyen de savoir.

Le point principal de ma réponse était de laisser le vecteur faire la gestion de la mémoire pour vous.