🚀 go-pugleaf

Thierry B a �crit :
> Bonjour,
> Je voulais savoir si quelqu'un pouvait me citer des exemples o� le
> fait d'utiliser des pointeurs en C est bien utile et plus rapide, par
> rapport � une structure sans pointeurs?
> 
> Car en fait, pour l'instant, je les manipule dans des structures de
> tableaux, et donc je vois pas trop leur interet, et ce que ca peut
> amener de pratique.

Si tu appelles tableau quelque chose comme :

int t[42];

utiliser un pointeur � la place permet une meilleure gestion de la m�moire :

int *t = malloc (42 * sizeof *t);
/* ... */
t = free(t);
t = malloc(143 * sizeof *t);
/* ... */

Au d�but, je peux stocker 42 entiers, et ensuite 143, bref avec les 
pointeurs j'ai un tableau redimensionnable.

Maintenant conceptuellement, les deux sont des tableaux, c'est � dire 
des espaces de stockages o� les �l�ments sont rang�es de mani�res 
contigu�s et successives. Pour stocker certaines choses un tel tableau 
n'est pas pratique ; si l'on a souvent besoin d'ins�rer ou d'�ter un 
�l�ment, par exemple :

/*
  * insere un element � la i�me place d'un tableau de n �l�ments
  */
void tab_insere(int t[], int n, int i, int data)
{
     int j;

     for (j = n + 1; j > i; j--) {
         t[j] = t[j - 1];
     }
     t[i] = data;
}

/*
  * supprime un element � la i�me place d'un tableau de n �l�ments
  */
void tab_supprime(int t[], int n, int i)
{
     int j;

     for (j = i; j < n - 1; j++) {
         t[j] = t[j + 1];
     }
}

Dans les deux cas, on est oblig� de d�placer un nombre d'�l�ments qui 
peut �tre important, ce qui n'est pas tr�s efficace.

Avec les pointeurs, il est +/- facile de cr�er une liste doublement 
chain�e, pour laquelle l'insertion et la suppression d'un �l�ment est 
plus rapide :

struct Element {
     int data;
     struct Element *suivant;
     struct Element *precedent;
};

/*
  * ins�re un �l�ment i apres l'�l�ment e
  */
void list_insere(struct Element *e, struct Element *i) {
      i->precedent = e;
      i->suivant = e->suivant;
      i->suivant->precedent = i;
      i->precedent->suivant = i;
}

/*
  * supprime un �l�ment i
  */
void list_supprime(struct Element *i) {
      i->precedent->suivant = i->suivant;
      i->suivant->precedent = i->precedent;
}

L� la vitesse est constante, et relativement faible, ind�pendamment de 
la taille des listes.

Voil�, c'est juste un exemple o� l'utilisation de pointeurs permet de 
construire des structures de stockage plus efficace qu'un tableau. Les 
pointeurs permettent de faire pleins d'autres choses int�ressantes.

-- 
Richard