Tableau 2D vs tableau de tableaux

Quelle est la différence entre un tableau 2D et un tableau de tableaux?

J'ai lu les commentaires, tels que @Dave, qui semblent se différencier entre les deux.

Cela casse si il est en 2d à l'aide de tableaux ou d'un pointeur-à-types tableau, plutôt qu'un tableau de tableaux. – Dave

J'ai toujours pensé que les deux mentionnés:

int arr_arr[][];

EDIT: @FutureReader, vous pouvez voir Comment puis-je utiliser des tableaux en C++?

...J'espère que je n'ai pas dérangé vous, @FutureReader.
Si vous voulez prendre plus raisonnable des avertissements du compilateur ou de détecter les bugs rapidement, préférez toujours des tableaux sur les pointeurs.

OriginalL'auteur Mateen Ulhaq | 2011-10-31

c c++multidimensional-array

8

À 2 dimensions tableau est, par définition, un tableau de tableaux.

Ce que Dave a été dit, c'est que dans ce contexte, il existe différents sémantique entre la définition d'un tableau 2D comme ceci:
```
int x[][];
```
ce:
```
int *x[];
```
ou ceci:
```
int **x;
```
Mais pourquoi alors impliquer les deux sont hétérogènes?
Parfois, vous pourriez voir un tableau 2D défini comme int (*x)[10];, ce qui est une bonne astuce pour transformer un plat de tableau dans un tableau 2D qui peut être indexé avec [x][y] au lieu de [x * width + y].
Qu'entendez-vous par "hétérogène"? Voulez-vous dire "synonyme"?
Non, je voulais dire que certaines personnes sur ALORS impliquent que 2D array != array of arrays. (Et pas seulement de Dave.) À l'origine, seule la première ligne dans cette réponse était présent; les autres trucs plus tard a été édité.
Ok. Je pense que les "différents" aurait exprimé plus clairement.

OriginalL'auteur Jacob Relkin
21

Il existe quatre différents concepts ici.
- Le tableau à deux dimensions: int arr[][]. Il ne peut pas être redimensionnée dans n'importe quelle direction, et est contiguë. L'indexation est le même que ((int*)arr)[y*w + x]. Doit être allouée de manière statique.
- Le pointeur de tableau: int (*arr)[]. Il peut être redimensionné uniquement pour ajouter plus de lignes, et est contiguë. L'indexation est le même que ((int*)arr)[y*w + x]. Doit être alloués dynamiquement, mais peut être libéré free(x);
- Le pointeur de pointeur: int **arr. Il peut être redimensionnée dans tous les sens, et n'est pas nécessairement carrée. Habituellement alloué dynamiquement, pas nécessairement contigus, et de libérer dépend de sa construction. L'indexation est le même que *(*(arr+y)+x).
- Le tableau de pointeurs: int *arr[]. Il peut être redimensionné uniquement pour ajouter plusieurs colonnes, et n'est pas nécessairement carrée. Redimensionnement et de libérer dépend également de la construction. L'indexation est le même que *(*(arr+y)+x).
Chacun de ces éléments peut être utilisé arr[y][x], menant à la confusion.

Un tableau à deux dimensions peuvent être allouées comme un objet de n'importe quel autre type, soit automatiquement ("sur la pile", c'est à dire, déclaré comme un objet local) ou dynamiquement (via malloc()), ou de manière statique (défini par le static mot-clé ou à l'extérieur de toute fonction). Je pense que ce que tu veux dire, c'est que la taille est fixe au moment de la compilation -- mais avec C99 de longueur variable tableaux qui n'est pas entièrement vrai non plus.
Strictement parlant, seule la première de ces deux dimensions de tableau; les autres sont des structures de données qui peut émuler 2-d des tableaux. Mais pour tous les quatre formes, une fois que tout a été alloué (ce qui peut être compliqué), vous pouvez utiliser le même arr[x][y] syntaxe pour accéder aux éléments individuels. La différence est que le préfixe de chaque [] opérateur est un pointeur expression ou un tableau d'expression que désintégrations un pointeur. Il y a 4 combinaisons. (Pour le 3-d de la matrice comme les structures, il y a 8 combinaisons; pour N dimensions, il y a 2**N.)
Comment voulez-vous allouer un tableau en 2 dimensions avec malloc()? Vous avez besoin d'un pointeur de tableau.
Oui, vous auriez besoin d'un pointeur de tableau. int (*p)[10][10] = malloc(sizeof *p);. Ou, peut-être plus lisible: typedef int matrix[10][10]; matrix *p = malloc(sizeof *p);.

OriginalL'auteur Dave
10

Ici, la réponse est un peu plus subtil.

Un tableau de tableaux, est définie comme suit:
```
int array2[][];
```
Un pointeur vers tableau des types est défini:
```
int (*array2)[];
```
Un tableau de type pointeur est défini:
```
int* array2[];
```
Le compilateur traite à la fois de ces un peu différemment, et en effet, il existe une option de plus:
```
int** array2;
```
Beaucoup de gens apprennent que ces trois sont identiques, mais si vous en savez plus sur les compilateurs, vous savez sûrement que la différence est faible, mais il est là. Beaucoup de programmes d'exécution si vous substituer l'un à l'autre, mais dans le compilateur et l'ASM niveau, les choses ne sont PAS les mêmes. Un manuel sur les compilateurs C devrait fournir un beaucoup plus en profondeur de réponse.

Aussi, si l'on s'intéresse à la mise en œuvre d'un tableau 2D il existe plusieurs méthodes qui varient en efficacité en fonction de la situation. Vous pouvez mapper un tableau 2D à un tableau 1D, qui assure la localité spatiale lorsque vous traitez avec linéarisé de données. Vous pouvez utiliser le tableau de tableaux si vous voulez la facilité de programmation, et si vous avez besoin de manipuler des lignes/colonnes séparément. Il y a certaines bloqué types et d'autres dessins de fantaisie qui sont en cache intelligente, mais rarement avez-vous besoin de connaître la mise en œuvre si l'utilisateur.

Espère que j'ai aidé!

Non, c'est un tableau de pointeurs. int (*tableau)[n] est un pointeur vers un tableau.
La différence n'est pas "très petit". C'est la différence entre les tableaux et les pointeurs, qui est une distinction très importante (et qu'un trop grand nombre de programmeurs C miss).
Quelle importance d'une distinction peut-elle être si de nombreuses C les programmeurs peuvent utiliser la langue de façon efficace tout en manquant?
Je ne suis pas convaincu qu'elles ne l'utiliser efficacement. Ne pas comprendre la distinction rend certains types d'erreurs très facile.
Merci pour les commentaires, j'ai édité la réponse à fournir plus de profondeur et fixe le pointeur de tableau de faute de frappe.

OriginalL'auteur foslock
1

Ce qui suit est un tableau 2D qui peut être appelé un tableau de tableaux:
```
int AoA[10][10];
```
Le suivant est un pointeur vers un pointeur qui a été configuré pour fonctionner comme un tableau 2D:
```
int **P2P = malloc(10 * sizeof *P2P);
if(!P2P) exit(1);
for(size_t i = 0; i < 10; i++)
  {
    P2P[i] = malloc(10 * sizeof **P2P);
    if(!P2P[i])
      {
        for(; i > 0; i--)
            free(P2P[i - 1]);
        free(P2P); 
      }
  }
```
Les deux peuvent être accessibles via AoA[x][y] ou P2P[x][y], mais les deux sont incompatibles. En particulier, P2P = AoA est quelque chose que les débutants parfois s'attendre à travailler, mais qui ne sera pas - P2P s'attend à point pour les pointeurs, mais quand AoA se désintègre en un pointeur, c'est un pointeur à un tableau, spécifiquement int (*)[10], qui n'est pas le int ** que P2P est censé être.

OriginalL'auteur Chris Lutz
0

Tableau 2d pouvez inclure cette:
```
int x[width * height]; //access: x[x + y * width];
```
De Wikipedia:

Pour un tableau à deux dimensions, l'élément avec les indices i,j aurais
adresse B + c · i + d · j, où les coefficients c et d sont la ligne
et adresse de colonne incréments, respectivement.

Ou si vous voulez montrer, int arr_[width * height]; int (*arr)[width] = (void *)arr_; arr[x][y] = 0;
Ce n'est pas vraiment un tableau en 2 dimensions; c'est un 1-d tableau (qui peut être utilisé pour émuler un tableau 2d).
En fait c'est l'inverse. C'est la forme la plus authentique de tableau 2d, avec tableau de tableaux être une représentation. en.wikipedia.org/wiki/Array_data_structure
Vous vous êtes trompé. L'article de Wikipedia que vous citez ne fait pas l'appui de votre demande. Et de l'article 6.5.2.1 de la C standard fait référence à des tableaux de tableaux de tableaux multidimensionnels.
indice de x[7*3] est le même que l'indice de x[3*7] de sorte que vous stockez juste la moitié du possible, les données et perdra de l'autre moitié ou à l'écrasement de la première moitié. Donc envisager de l'utiliser comme x[7*widthIndexlength+3].

OriginalL'auteur Pubby

Vous devez vous connecter pour publier un commentaire.