C: Fonction de permuter les valeurs dans le tableau 2D

Il suffit de déclarer le tableau de paramètres. Mieux encore, utiliser un typedef pour la déclaration initiale et de la fonction du paramètre formel.

Le problème est que sans le savoir la taille de la ligne, c'est à dire, le nombre de colonnes, il n'a aucun moyen de calculer le pointeur de réglage pour obtenir les lignes suivantes. Fait intéressant, il n'a pas besoin de connaître le nombre de lignes que vous avez.

Par exemple, cela fonctionne:

void swap(int surface[][20], int x1, int y1, int x2, int y2) {
  int temp = surface[x1][y1];
    surface[x1][y1] = surface[x2][y2];
    surface[x2][y2] = temp;
}

Mais il serait mieux d'attacher de l'appelant types et la fonction de type de l'ensemble.

---

Chaque indice d'accès nécessitera une multiplication, mais cela fonctionne (seulement C99-conforme aux compilateurs) ...

int f(int, int, int a[*][*]);

int f(int r, int c, int a[r][c])
{
  return a[99][100];
}

Un autre exemple, qui serait dans le même pré-C89 environnements:

typedef int surface_t[][20];

surface_t therealthing = {
  { 1, 2, 3},
  { 4, 5, 6}
};

void swap(surface_t x) {
  x[0][2] = 'q';
}

void f1(void) {
  swap(therealthing);
}

Et enfin, parce que la longueur variable des tableaux sont quelque chose d'assez récent, le traditionnel et toujours le plus rapide de la technique est de passer int *a[]. Cela ne nécessite pas une connaissance quelconque de la ligne ou de la colonne longueurs, mais vous avez besoin pour construire le pointeur de vecteur.

En C seule la première dimension du tableau est autorisé à rester indéterminée, parce qu'il a besoin de savoir comment calculer les décalages. Si vous avez besoin de travailler avec une taille variable tableau 2D passe dans notre tableau comme un int*, passez à la taille de votre deuxième dimensions et le pointeur de mathématiques de vous-même:

void swap(int *surface, int ySize, int x1, int y1, int x2, int y2) {
    int temp = *(surface + ySize * x1 + y1) ;
    *(surface + ySize * x1 + y1) = *(surface + ySize * x2 + y2);
    *(surface + ySize * x2 + y2) = temp;
}

C'est la même chose que le [][] syntaxe est en train de faire, comme les tableaux en C sont vraiment juste des pointeurs.

Passant tableaux multidimensionnels comme arguments de la fonction présente des maux de tête. Rappelez-vous que dans la plupart des contextes, une expression de type tableau sera implicitement converti en un type pointeur, et sa valeur est l'adresse du premier élément du tableau. Ainsi, par exemple, un 10x20 tableau de int est converti en pointeur vers un 20-élément de tableau de int:

void swap(int (*surface)[20], size_t rows, size_t x1, size_t x2, 
          size_t y1, size_t y2)
{
  int temp;
  assert(x1 < rows && x2 < rows);
  temp = surface[x1][y1];
  surface[x1][y1] = surface[x2][y2];
  surface[x2][y2] = temp;
}
int main(void)
{
  int surface[10][20];
  ...
  swap(surface, 10, 1, 1, 2, 2);
  ...
}

C'est là un grand problème s'affiche. Basé sur son prototype, swap() ne peut traiter que Nx20 des tableaux de int; le nombre de lignes peut varier, mais le nombre de colonnes ne peuvent pas, parce que T (*)[N] est un autre type de T (*)[M] où N != M. Idéalement, vous souhaitez une fonction qui permet de traiter un nombre arbitraire de lignes et colonnes. Une façon de faire qui consiste à traiter le tableau comme un tableau 1D de T, et de calculer en ligne et en colonne les décalages manuellement:

void swap(int *surface, size_t rows, size_t cols, size_t x1, 
          size_t x2, size_t y1, size_t y2)
{
  int temp;
  assert(x1 < rows && x2 < rows && y1 < cols && y2 < cols);
  temp = surface[x1*cols+y1];
  surface[x1*cols+y1] = surface[x2*cols+y2];
  surface[x2*cols+y2] = temp;
}
int main(void)
{
  int surface[10][20];
  ...
  swap(&surface[0][0], 10, 20, 1, 1, 2, 2);
}

Ici nous transmettre l'adresse du premier élément (&surface[0][0]) et de la traiter comme un simple pointeur vers int. De cette façon, nous pouvons traiter avec n'importe quel nombre de lignes et de colonnes. Notez que cela ne fonctionne que pour de véritables tableaux 2D (pas de tableaux de pointeurs), puisque swap suppose que les éléments du tableau sont disposés de manière contiguë.