Discussion :

[iznogoud36]

bonjour tout le monde, je suis debutant en c en je voudrais faire une file ou liste chainée, j'ai consulté un tuto sur ce site:
http://nicolasj.developpez.com/articles/file/

y a un truc que je comprend pas, c'est les pointeurs avec **

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
#ifndef H_FILE
#define H_FILE
 
typedef struct queue queue_s;
 
queue_s *queue_new (void);
void queue_post (queue_s **, void *);
void *queue_get (queue_s **);
void queue_delete (queue_s **);
 
#endif /* not H_FILE */

c'est réutilisé aprés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void queue_post (queue_s ** pp_queue, void *data)

qu'est ce que ca represente dans cet exemple précisement?
je me fais petit à petit aux pointeurs mais là je ne trouve pas

merci de votre aide

[Gamdwin]

http://cslibrary.stanford.edu/104/

[gege2061]

Bonjour,

y a un truc que je comprend pas, c'est les pointeurs avec **

C'est un pointeur de pointeur. Comme un pointeur permet de modifier la valeur d'une variable dans une fonction, un pointeur de pointeur permet de modifier l'adresse contenue dans le pointeur.

C'est plus clair ? (j'ai un doute )

[Invité(e)]

Bonjour,
Le pointeur c'est une case mémoire qui contient une adresse.
bon , par exemple si on déclare "p" comme pointeur c'est a dire qu'on vas reserver une case mémoire de nom "p" et cet case elle vas contenir une adresse
et si on déclare a comme entier , la case "a" vas contenir un entier
et si on fait p=*a , cad que la case "p" vas contenir l'adresse de la case mémoire de a,
revenat a votre question : *(*p)
c'est le pointeur du pointeur
cad si on dit *p cest comme si on diasait a
mais si on dit **p cest comme si *a cad la valeur ki est dans a elle nous sert comme adresse.

[homeostasie]

et si on fait p=*a , cad que la case "p" vas contenir l'adresse de la case mémoire de a

Euh, tu ne voulais pas plutot dire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
 p=&a;

[Emmanuel Delahaye]

Euh, tu ne voulais pas plutot dire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
 p=&a;

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

*p = a;

[koala01]

Salut,

Les pointeurs et les pointeurs de pointeurs sont AMHA ce qui est le plus bizard à comprendre, bien que ce ne soit que de la pure logique...

Le tout, c'est qu'il faut qu'un déclique se fasse, et, une fois qu'il a eu lieu, leur utilisation ne posera plus jamais de gros problème

Il y a donc lieu de dabord essayer de comprendre ce qu'est un pointeur...

Hé bien, un pointeur (représenté, lors de la déclaration par type * ), c'est une variable spéciale.

En effet, cette variable ne contient pas une valeur "tangible" (i vaut trois dans le code i=3; ), mais "l'adresse à laquelle on va trouver la valeur"...

C'est un peu comme si tu avais un millier de tirroirs devant toi, que tu décidais de mettre la valeur (i=3) dans le tirroir numéroté 200, et que, dans le tirroir numéroté 400, tu décidais de signaler en grand "dans ce tirroir, vous trouverez le tirroir dans lequel trouver la valeur de i" (c'est à dire le numéro 200 )

Un pointeur de pointeur (représenté, lors de la déclaration par type **), quant à lui n'est... qu'un pointeur spécial en cela qu'il contient... l'adresse à laquelle on trouvera un pointeur...

C'est à dire qu'il contient "l'adresse à laquelle on trouvera l'adresse à laquelle se trouve la valeur"

D'accord, mais dans quel but?

Le but de travailler comme cela est relativement simple... Mais il faut d'abord comprendre quelque chose concernant les arguments des fonctions appelées.

Il faut en effet comprendre que, quand tu place un argument dans une fonction, ca revient exactement au meme (en prenant un léger racourcis, quand meme) que si tu déclarais, au sein de cette fonction, une variable locale comme une autre...

dans une procédure du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void MaFonct(int argument)
{
    char Monchar='a';
}

argument et Monchar ont exactement la même portée: Ce sont des variables locales à MaFonct, c'est à dire qu'elles seront créées lors de l'appel de la fonction et détruites lorsque la fonction sera quitée.

La seule différence entre les deux, c'est que l'on sait que Monchar vaudra a lorsqu'on écrit le code, et que l'on décide que la valeur de argument sera fournie par... la fonction qui appelle MaFonct

Il n'est pas rare que l'on souhaite disposer apres l'appel à une fonction de plusieurs valeurs qui seraient modifiées au sein de la fonction...

On peut, par exemple, souhaiter que la fonction modifie une valeur d'un coté, et renvoie une valeur représentant la réussite ou l'échec de la modification de l'autre... Tout en voulant utiliser la valeur modifiée apres la fonction...

Or, au mieux, on ne peut en récupérer qu'une... (en considérant le terme valeur dans son ensemble ici: cela peut très bien etre un structure )

C'est à ce stade qu'entrent en jeu les pointeurs (de pointeurs)...

On va demander de créer une variable qui soit en mesure de contenir une adresse mémoire (un pointeur, quoi )... et on va donner l'adresse de la varaible que dont on veut profiter de la modification par la suite.

Evidemment, au sein de la fonction, il s'agira de ne pas oublier de dire de "modifier ce qui se trouve à l'adresse" contenue dans le pointeur...

Et si, pour une raison ou une autre (et il y en a beaucoup), on veut faire modifier l'adresse d'un pointeur par une fonction, et pouvoir utiliser l'adresse modifiée après l'appel de la fonction, hé bien, on passera alors... un pointeur de pointeur, en fournissant alors... l'adresse mémoire à laquelle se trouve le pointeur

Pour le code que tu donnes, ou bien il n'est pas complet, ou bien, il n'est pas tout à fait juste...

D'abord parce que le type void (hé oui, c'est un type, au meme titre que char int ou float ), qui signifie "vide" en anglais, a ici la singification de "indéterminé"... Du moins, quand il est pris comme type... et qu'il y a parfaitement moyen de mettre au point toute une série d'utilisation de ce type, mais que ca passe par le transtypage (dont il faut généralement se méfier comme de la peste...)

Ensuite, parce que tu définis une structure (queue), et un type qui va avec (queue_s)... sans rien mettre dedans, ce qui n'est pas des plus malin...

Une strucutre "classique" pour une file ou une liste (la seule différence entre les deux est sémantique, si on parle de liste simplement chainée: une file n'est pas triable alors qu'une liste l'est ) est du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
typedef struct SListe
{
    type Donnee;
    struct SListe *Suivant;
}Liste;

Ce code pourrait se lire sous la forme de

créons une structure (nommée SListe) qui sera composée de deux éléments:

-un élément du type (type) et nommé Donnee
et
-un élément de type "pointeur sur une strucutre SListe" et nommé Suivant.

Et créons un type nommé Liste pour cette structure.

Si c'est un pointeur, c'est "simplement" parce qu'on veut juste avoir l'adresse où l'on trouvera la structure suivante... ca ne nous intéresse pas d'avoir la strucure suivante inclue dans la première

L'erreur suivante se situe au niveau de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

queue_s *queue_new (void);

qui ne veut strictement rien dire...

La premiere déclaration serait du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Liste *LaListe=NULL;

Pour les autres fonctions et procédures (une fonction étant une procédure... qui renvoie une valeur, ou, une procédure étant une fonction... qui n'en renvoie pas) il y aura une multitude de solutions permettant d'arriver à un meme résultat...Mais tout dépendra de la manière dont tu t'y prendra au début...

Si tu déclares LaListe en tant que variable globale, c'est à dire en dehors de toute fonction (ce qui n'est généralement pas conseillé), ce sera déjà une valeur que tu ne devra plus passer en parametre, car elle sera connue de toutes les fonctions...

Sinon, une fonction qui créerais le premier noeud de la liste, nommée, P.E: CreateFirst, pourrait prendre trois formes différentes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
void CreateFirst(Liste **argument);
//    OU---OU---OU---OU---OU---OU---OU
Liste* CreateFirst();
//    OU---OU---OU---OU---OU---OU---OU
int CreateFirst(Liste **argument);

La troisième permettrait d'obtenir une valeur de réussite ou d'échec
et leur utilisation serait du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
int main (char argc, char *argv[])
{
    // déclaration d'un pointeur de type Liste
    // que l'on initialise, pour la sécurité à NULL
    Liste *LaListe=NULL;
//appel en utilisant un pointeur de pointeur (c'est à dire, en passant
// l'adresse du pointeur  nommé LaListe)
    CreateFirst(&LaListe);
//    OU---OU---OU---OU---OU---OU---OU
// cela aura le meme résultat
    LaListe=CreateFirst();
//    OU---OU---OU---OU---OU---OU---OU
// cela aura le meme résultat
    reussite=CreateFirst(&LaListe);
    if(reussite==1)
    {
// Génial, ca a marché :D
    }
    else
    {
// BOUHHH, je n'ai meme pas pu avoir le premier élément de la liste :'(
    }
}

Pour conclure (parce qu'une fois n'est pas coutume, je me suis laissé emporter par ma verve), j'aurais personnellement tendance à dire dans un premier temps qu'il est préférable, quand tu prévois le prototype d'une fonction, à condition que tu aies le choix, bien évidemment, de choisir de passer un argument sous forme de variable plutot que sous celle d'un pointeur ou sous forme de pointeur plutot que sous celle d'un pointeur de pointeur...

Le choix incluant, entre autre, la possibilité de récupérer (ou non) la valeur renvoyée, la possibilité (ou non) de faire sans pointeur (il est difficile de se passer des pointeurs...si on a déjà un pointeur dans la fonction appelante) et la recherche (ou non) d'une rapidité d'exécution et/ou d'une utilisation minimale des ressources...

[iznogoud36]

merci de votre aide a tous, j'ai compris maintenant ce qu'est un pointeur de pointeur, mais je ne comprend pas encore son interêt.
A quoi ca sert vraiment? dans cet tutorial par exemple
pourquoi ne pas utilisé le pointeur simple car il permet de faire ce qu'on veux deja ...?

[DaZumba]

pourquoi ne pas utiliser le pointeur simple car il permet de faire ce qu'on veux deja ...?

Relis les reponses que l'on t'a donnees. La fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
void queue_post (queue_s ** pp_queue, void *data);

modifie tres certainement le pointeur *pp_queue, alors il est necessaire d'envoyer un pointeur vers *pp_queue, soit l'argument **pp_queue.
Entraines-toi sur des excellentes simples avant de t'enerver sur les listes chainees. Par exemple, essaie de comprendre pourquoi le programme suivant plante, et essaie de le corriger pour qu'il fonctionne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
#include <stdio.h>
#include <stdlib.h>
 
int open_toto(FILE *f)
{
  f = fopen("toto.txt", "w");
  if (f == NULL)
  {
     return -1;
  }
  else
  {
    return 0;
  }
}
 
int main(void)
{
   FILE *f;
   int ret = open_toto(f);
   if (ret != -1)
   {
      fprintf(f, "Test.\n");
      fclose(f);
      ret = EXIT_SUCCESS;
   }
   else
   {
      fprintf(stderr, "Could not create toto.txt.\n");
      ret = EXIT_FAILURE;
   }
 
   return ret;
}

[gege2061]

merci de votre aide a tous, j'ai compris maintenant ce qu'est un pointeur de pointeur, mais je ne comprend pas encore son interêt.
A quoi ca sert vraiment? dans cet tutorial par exemple
pourquoi ne pas utilisé le pointeur simple car il permet de faire ce qu'on veux deja ...?

Parce que pour représenter la liste chainée, j'utilise une structure de donnée mais elle n'est pas visible pour l'utilisateur (le fichier d'en tête ne contient que le typedef) donc il est impossible d'écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

queue_s q;

On est obligé d'utiliser un pointeur, ce qui oblige l'utilisateur à passer par les fonctions pour manipuler la structure.

Si la définition de la structure avait été visible (donc dans le fichier d'en tête), on aurai pu se contenter de créer l'objet et de passer un simple pointeur au fonction.

Voilà c'est un peu plus compliqué, mais on se raproche plus d'un mécanisme objet et c'est surtout plus sûr.

[Médinoc]

Pour des fonctions qui ont besoin de modifier un pointeur et de retourner un résultat:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int ReallocChar(char **ppDonnees, size_t nTaille)
{
	char *pTmp = realloc(*ppDonnees, nTaille)
	if(pTmp == NULL)
		return -1;
	else
	{
		*ppDonnees = pTmp;
		return 0;
	}
}

Ici, on modifie le pointeur pointé par ppDonnees, et on retourne 0 ou -1...

Et ça peut s'utiliser ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/*
Fonction qui entre des chaînes et les concatène au fur et à mesure.
*/
char *EntrerChaines(void)
{
	/* Un buffer initial de 100 chars, qu'on agrandit par la suite. */
	size_t nTaille = 100;
	char *pDonnees = malloc(nTaille * sizeof(*pDonnees));
	size_t nLongueurEcrite=0;

	if(pDonnees == NULL)
		return NULL;

	/* Au début, le buffer contient une chaîne vide. */
	pDonnees[0] = '\0';

	/* On ajoute des chaînes jusqu'à ce que l'utilisateur 
	   ait tapé une chaîne vide. */
	for(;;)
	{
		char buf[80];
		int bChange = 0;
		int nLongueurAjoutee = 0;

		fgets(buf, 80, stdin);
		nLongueurAjoutee = strlen(buf);

		if(nLongueurAjoutee == 0)
			break;

		/* Si la nouvelle taille sera trop grande,
		   on essaie d'agrandir le buffer. */
		while(nLongueurEcrite + nLongueurAjoutee >= nTaille)
		{
			nTaille += (nTaille/2);
			bChange = 1;
		}

		if(bChange)
		{
			if(ReallocChar(&pDonnees,nTaille*sizeof(*pDonnees))<0)
			{
			/* Erreur : On arrete d'agrandir et on retourne
			   la suite de chaînes déja en mémoire */
			break;
			}
		}

		/* On ajoute la chaîne au buffer. */
		strcat(pDonnees, buf);
		nLongueurEcrite += nLongueurAjoutee;
	}//for
	return pDonnees;
}

Dans ce programme, on passe donc l'adresse du pointeur pour qu'il puisse être modifié...