Déclarer un pointeur de tableau multidimensionnel et d'allouer le tableau

J'ai essayé de chercher mais je n'ai pas trouvé quoi que ce soit avec une réponse définitive. Je sais que mon problème ne peut pas être si difficile que ça. Peut-être que c'est juste que je suis fatiguée..

Fondamentalement, je veux déclarer un pointeur vers un 2 dimensions tableau. Je veux faire de cette façon parce que finalement, je vais avoir à redimensionner le tableau. J'ai effectué les opérations suivantes avec succès avec un tableau 1D:

int* array;
array = new int[somelength];

Je voudrais effectuer les opérations suivantes avec un tableau 2D, mais il ne compile pas:

int* array;
array = new int[someheight][somewidth];

Le compilateur me donne un message d'erreur indiquant que "somewidth" ne peut pas apparaître dans une constante de l'expression. J'ai essayé toutes sortes de combinaisons de ** et [], [], mais aucun d'entre eux semblent fonctionner. Je sais que ce n'est pas si compliqué que ça...Toute aide est appréciée.

InformationsquelleAutor vince88 | 2010-10-11
  1. 13

    Je viens de trouver cette ancienne réponse obtient encore lire, ce qui est dommage car c'est faux. Regardez la réponse ci-dessous avec tous les suffrages à la place.

    Lire sur la syntaxe de pointeur, vous avez besoin d'un tableau de tableaux. Qui est la même chose comme un pointeur vers un pointeur.

    int width = 5;
int height = 5;
int** arr = new int*[width];
for(int i = 0; i < width; ++i)
   arr[i] = new int[height];
    • Avez-vous essayé? Il ne compile pas (si la hauteur et la largeur sont les deux variables)
    • Oui j'ai essayé et toujours obtenir la même erreur avec le compilateur. on va dire que "la" largeur "ne peut pas apparaître dans une constante de l'expression"
    • Si je devais accéder à un élément de ce tableau serait-ce seulement arr[largeur][hauteur]?
    • correct.
    • Génial. Merci pour l'aide.
    • Il est très bien spécifié que lors de la déclaration du 2D Matrice de l'argument de ligne peut être une variable , mais l'argument de colonne doit être constant seulement.
    • Non, tableau de tableau et tableau de pointeurs ne sont pas la même chose. Pourquoi est-ce post accepté ? La réponse de Tony Le Lion est le bon, c'est complètement mal.

    InformationsquelleAutor dutt
  2. 43
    const int someheight = 3;
 const int somewidth = 5;

 int (*array)[somewidth] = new int[someheight][somewidth];
    • Contrairement à d'autres réponses ici, celui-ci répond vraiment à la question, qui était de savoir comment déclarer un pointeur vers un tableau multidimensionnel - pas un tableau en escalier. C'est une différenciation importante pour les performances des applications sensibles. Il fonctionne si "somewidth" est une constante, et seuls les "someheight" changements. Si vous regardez comment ce tableau 2D est fixé dans la mémoire - c'est tous ensemble et d'un seul tenant, avec pas plus de la "nouvelle" allocation de mémoire fait. La réponse par Alexandre Rafferty est aussi bonne si la largeur est aussi dynamique. Les autres réponses sont lents parce qu'ils font une tonne de mallocs...
    • Comment voulez-vous détruire correctement ce tableau? delete[] tableau; je suppose car c'est vraiment une pièce contiguë de la mémoire.
    InformationsquelleAutor Tony The Lion
  3. 6

    Prêts à l'emploi exemple de ici, après quelques secondes de recherche sur google avec l'expression "en deux dimensions tableau dynamique":

    int **dynamicArray = 0;

//memory allocated for elements of rows. 
dynamicArray = new int *[ROWS];

//memory allocated for  elements of each column.  
for( int i = 0 ; i < ROWS ; i++ ) {
    dynamicArray[i] = new int[COLUMNS];
}

//free the allocated memory 
for( int i = 0 ; i < ROWS ; i++ ) {
    delete [] dynamicArray[i];
}
delete [] dynamicArray;
    • C'est un tableau de tableaux, pas vraiment un 2D.
    • Rafferty: je vois -- quelle est la différence entre "tableau de tableaux" et "2D des baies?
    • c'est vieux, mais pour répondre à votre question et à toute autre personne qui trébuche à travers cela, un tableau 2d est contiguë en mémoire; un tableau dynamique de tableaux dynamiques est contiguë à la première dimension, mais chaque tableau dans la deuxième dimension est stockée séparément
    • Lin: remercie de votre explication! Disons qu'il y a aussi int staticArray[ ROWS ][ COLUMNS ];. Supposons également qu'il existe une fonction printArray( int arr[ ROWS ][ COLUMNS ] ) dont l'accès et imprime tous les éléments que arr[ i ][ j ]. On pourrait passer staticArray ou dynamicArray à cette fonction et qu'il allait travailler, correct? Il n'y a de différence structurelle et votre point est valide. Cependant, puisqu'il n'y a pas de différence de comportement, j'ai tendance à considérer la différence comme un détail d'implémentation.
    • non c'est le point, vous pouvez passer int[N] (tableau de N entiers) comme int * (pointeur d'entier), mais vous ne pouvez pas passer int[R][C] (tableau de R de la matrice de C des entiers) comme un int ** (pointeur de pointeur d'entier); il n'y a pas de conversion implicite et si vous le lancez pour le faire fonctionner, vous aurez corruption de la mémoire; int [R][C] se désintègre à int (*)[C] (pointeur de tableau de C entiers) au lieu de...voir cette réponse
    • il suffit de penser comment l'élément staticArray[x][y] seraient consultés contre dynamicArray[x][y] par le compilateur...la première est *(&staticArray[0][0] + (x * C + y)), mais le second est *(*(&dynamicArray[0] + x) + y); pas équivalent à tous les
    • Lin: j'ai accepté et admis qu'il y a en effet une différence structurelle, la disposition de la mémoire est certainement différente. Le point que je essaie de dire, c'est que, à partir d'un client (par exemple,printArray()), il n'y a pas de différence. (En d'autres termes, la différence est prélevée out). D'accord ou pas d'accord? [Je considère que le même genre de situation que quand j'ai créer un Array2d classe, et de fournir une fonction membre getElement( int i, int j), l'utilisateur n'est pas censés savoir comment getElement() est mis en œuvre.]
    • ce que je dis, c'est que la différence n'est pas abstraite, le types ne sont pas équivalentes et en passant un tableau dynamique int** comme int[R][C] ne fonctionnera pas.

    InformationsquelleAutor Arun
  4. 6

    Je suggère d'utiliser une méthode beaucoup plus simple qu'un tableau de tableaux:

    #define WIDTH 3
#define HEIGHT 4

int* array = new int[WIDTH*HEIGHT];
int x=1, y=2, cell;
cell = array[x+WIDTH*y];

    Je pense que c'est une meilleure approche que d'un tableau d'un tableau, comme il y a beaucoup moins de l'allocation. Vous pouvez même écrire une aide macro:

    #define INDEX(x,y) ((x)+(WIDTH*(y)))

int cell = array[INDEX(2,3)];
    InformationsquelleAutor Alexander Rafferty
  5. 2

    Personnellement, ma préférence est d'utiliser un syntaxiques astuce pour déclarer un pointeur vers l'dynamiquement la taille d'un tableau multi-dimensionnel. Cela fonctionne dans les compilateurs que le soutien de Longueur Variable Tableaux (Blaise), qui tous les compilateurs C++ doit, et le plus actuel des compilateurs C.

    L'idée de base est capturée dans cette:

    void bar (int *p, int nz, int ny, int nx) {
  int (*A)[ny][nx] = (int(*)[ny][nx]) p;

    "p" points à l' (contiguë) bloc de l'espace que vous désirez traiter comme un tableau multidimensionnel. "A" a la même valeur que "p", mais la déclaration rend le compilateur de traiter les références à la "Une" dans le multi-dimensionnel de la façon dont vous le souhaitez.
    Par exemple:

    #include <iostream>
using namespace std;

void bar (int *p, int nz, int ny, int nx)
{
  int (*A)[ny][nx] = (int(*)[ny][nx]) p;

  for (int ii = 0; ii < nz; ii++) {
    for (int jj = 0; jj < ny; jj++) {
      for(int kk = 0; kk < nx; kk++) {
          A[ii][jj][kk] = ii*1000000 + jj*1000 + kk;
      }
    }
  }
}


void out (int *p, int nz, int ny, int nx)
{
  int (*A)[ny][nx] = (int(*)[ny][nx]) p;
  cout << A[11][22][33] << endl;
}


int main (void)
{
  int NX = 97;
  int NY = 92;
  int NZ = 20;
  int *space = new int [NZ * NY * NX];

  bar (space, NZ, NY, NX);
  out (space, NZ, NY, NX);
  return 0;
}

    L'exécution de ce produit à la sortie "11022033"

    La déclaration de la "Une" alias est un peu bizarre à regarder, mais il vous permet d'accéder directement et simplement utiliser l'souhaité un tableau multi-dimensionnel de la syntaxe

    InformationsquelleAutor Bron Nelson
  6. 1

    Je pense que cela va faire 

    int r, c ;
std::cin>>r>>c ;
int *array = new int[r*c] ;

    Vous pouvez saisir les valeurs en faisant quelque chose comme ce 

    for (int i = 0 ; i < r ; i++){
    for (int j = 0 ; j < c ; j++){
        std::cin>>array[i *c + j] ; 
    }
}
    InformationsquelleAutor Tasdik Rahman