Représentation des matrices par tableaux de pointeurs

La représentation unidimensionnelle des matrices permet d'écrire des fonctions opérant sur des matrices de taille quelconque. Elle présente cependant l'inconvénient d'une écriture moins naturelle du corps des fonctions.

Une autre représentation possible des matrices, qui n'a pas cet inconvénient, utilise un tableau de pointeurs, chqque pointeur étant l'adresse d'un tableau dynamique. On définit d'abord un tableau de pointeurs, sans initialisation de ces pointeurs, en donnant la taille du tableau, ce qui correspond au nombre de lignes de la matrice :

  const int 
    LIGNES=3,
    COLONNES=4;
  double *p[LIGNES];

Il faut initialiser les éléments du tableau, pour que chacun pointe vers un tableau dynamique dont la taille est le nombre de colonnes de la matrice ; l'opérateur new[] est donc appelé pour chacune des lignes de la matrice :

  int i;
  for(i=0; i<LIGNES; i++) {
    p[i] = new double[COLONNES];
  }

Il reste, éventuellement, à initialiser les éléments de la matrice, par exemple :

  int i, j;

  for(i=0; i<LIGNES; i++) {
    for(j=0; j<COLONNES; j++) {
      p[i][j] = double(i+j)/2;
    }
  }

Les fonctions opérant sur une telle matrice doivent alors être déclarées ainsi, avec les tailles des deux dimensions en paramètre :

void f(int colonnes, int lignes, double *p[]);

p[i] étant un pointeur de double, peut être utilisé comme l'adresse d'un tableau, qui sera la $i^{eme}$ ligne de la matrice ; donc p[i][j] est un double, et on peut écrire simplement le corps de la fonction comme si p était une matrice. On écrira par exemple une fonction d'impression des éléments de la matrice :

void matrix_print(int lignes, int colonnes, double *p[]) {
  int i, j;

  for(i=0; i<lignes; i++) {
    for(j=0; j<colonnes; j++) {
      cout << "a[" << i << "][" << j << "] = " << p[i][j] << endl;
    }
  }
}

qui sera appelée par :

  matrix_print(LIGNES, COLONNES, p);

Une fonction de libération spécialisée doit être appelée quand p sera devenue inutile :

  matrix_delete(LIGNES, p);

Cette fonction est définie par :

void matrix_delete(int lignes, double *p[]) {
  int i;

  for (i=0; i<lignes; i++) {
    delete[] p[i];
  }
}

Il est aussi possible de représenter les matrices par des tableaux dynamiques de tableaux dynamiques. Les fonctions de traitement ne doivent pas être modifiées puisque les déclarations double *p[] et double **p sont équivalentes. Seules l'allocation et la dés-allocation de ces tableaux dynamiques seraient à revoir.