Discussion :

[wallace27]

Bonjour,

Lorsque j'initialise une liste chaînée, pourquoi dois-je utiliser un double pointeur dans la fonction suivant ?

Fonction :

Code :

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

1
2
3
void initListe (typeElt **ptPrem) {
	*ptPrem = NULL;
}

Exemple d'utilisation de la fonction :

Code :

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

initListe (&premier);

Merci pour votre aide.

[Obsidian]

Bonjour,

Parce que la variable que tu veux initialiser à NULL est un pointeur. Il faut donc que tu passes l'adresse de ce pointeur pour que l'on puisse écrire dedans. Et par conséquent, cette adresse est… « un pointeur sur un pointeur ».

[wallace27]

Merci beaucoup pour la réponse et pour votre aide. Autre question, lorsque j'écris une fonction de création d'un élément de ce type de structure :

Code :

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

1
2
3
4
typedef struct elt {
	typeDonnee val;        
	struct elt *suivant;  
} typeElt;

Pourquoi dois-je mettre un astérisque devant l'intitulé de la fonction "creerElt" comme ceci ? :

Code :

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

typeElt *creerElt(typeDonnee valeur);

[Obsidian]

Pourquoi dois-je mettre un astérisque devant l'intitulé de la fonction "creerElt" comme ceci ? :

Code :

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

typeElt *creerElt(typeDonnee valeur);

Parce que l'astérisque s'applique en fait à ce qui précède et donne « typeElt * ». Ta fonction renvoie en fait un pointeur vers une instance de typeElt, probablement parce qu'elle a alloué elle-même l'espace avec malloc() et procédé ensuite à quelques initialisations pour que cette instance soit utilisable.

Ça ressemble aux questions d'un devoir. Est-ce le cas ?

[wallace27]

Les question c'est moi qui me les crée et qui me les pose. Et c'est effectivement pour préparer un examen. Mille mercis pour votre aide. Merci de laisser le fil ouvert au cas où j'ai d'autres questions svp.

[imperio]

@wallace27: Je pense qu'il vaudrait mieux que tu passes ce sujet en résolu et que tu ouvres d'autres topics si tu as d'autres questions.

[Sve@r]

Lorsque j'initialise une liste chaînée, pourquoi dois-je utiliser un double pointeur dans la fonction suivant ?

Fonction :

Code :

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

1
2
3
void initListe (typeElt **ptPrem) {
	*ptPrem = NULL;
}

Exemple d'utilisation de la fonction :

Code :

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

initListe (&premier);

Bonjour

Quand on manipule des listes chainées, il peut-être intéressant de créer un type pour la liste elle-même. Et accessoirement, nommer ses types "t_xxx" apporte le même avantage que le nommer "typeXXX" mais en plus court.
Exemple

Code c :

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

1
2
3
4
5
6
7
8
typedef struct s_elt {
	typeDonnee val;        
	struct s_elt *suivant;  
} t_elt;
 
typedef struct {
	t_elt *ptPremier;  
} t_liste;

Ca semble tout bête de créer un type ne contenant qu'un seul objet interne mais ça amène ensuite beaucoup d'avantages

1. les fonctions ayant besoin de modifier le premier élément n'ont plus besoin de recevoir un double pointeur. Un simple pointeur sur la liste permet d'accéder à son premier élément. On ne se bat plus avec ces étoiles à tout moment du code.
   

   Code c :

   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
   void initListe(t_liste *l)
   {
   	l->ptPremier=NULL;
   }
    
   int main()
   {
   	t_liste liste;
   	initListe(&liste);
   }
    
   void detruireElt(t_liste *l, t_elt *courant){
   	t_elt *elt;
    
   	if (courant == NULL) {
   		elt = l->ptPrem;                      
   		l->ptPrem = elt->suivant;             
   	}
   	else {
   		elt = courant->suivant;
   		if (elt) courant->suivant = elt->suivant;
   	}
   	free(elt); 
   }

2. Si ensuite on veut rajouter d'autres éléments de gestion, comme par exemple le nombre d'éléments, un pointeur sur le dernier ou autre, suffit de le rajouter dans le type initial et toutes les fonctions y ont alors immédiatement accès.
   

   Code c :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   typedef struct {
   	t_elt *ptPremier;  
   	size_t nbElem;
   } t_liste;
    
   void initListe(t_liste *l)
   {
   	l->ptPremier=NULL;
   	l->nbElem=0;
   }

[wallace27]

Est-ce que les schémas de cette fonction sont justes ? :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
void insereElt(typeElt **ptPrem, typeElt *courant, typeElt *nouveau) {
 
	if (courant == NULL) {
		nouveau->suivant = *ptPrem;
		*ptPrem = nouveau;  			
	}
	else {
		nouveau->suivant = courant->suivant;
		courant->suivant = nouveau;
	}
}

Pour l'insertion avec courant == NUL :



Pour l'insertion avec courant non NULL :

[Sve@r]

Oui
Mais perso je pense que tu devrais faire des schémas avec des éléments entiers, à mon avis tu gagnerais en lisibilité...

Exemple
La liste contient les maillons 0x10, 0x20, 0x30

• Maillon 0x10: Jean, 0x20
• Maillon 0x20: Paul, 0x30
• Maillon 0x30: Pierre, NULL
• (*ptPrem)=0x10

Et arrivée du maillon 0x40 (Luc)

Insertion avec courant=NULL

• nouveau->suivant=(*ptPrem)=0x10
• (*ptPrem)=nouveau=0x40

La liste contient maintenant les maillons 0x40, 0x10, 0x20, 0x30

• Maillon 0x40: Luc, 0x10
• Maillon 0x10: Jean, 0x20
• Maillon 0x20: Paul, 0x30
• Maillon 0x30: Pierre, NULL
• (*ptPrem)=0x40

Insertion avec courant=0x20 (le milieu)

• nouveau->suivant=courant->suivant=0x30
• courant->suivant=nouveau=0x40

La liste contient maintenant les maillons 0x10, 0x20, 0x40, 0x30

• Maillon 0x10: Jean, 0x20
• Maillon 0x20: Paul, 0x40
• Maillon 0x40: Luc, 0x30
• Maillon 0x30: Pierre, NULL
• (*ptPrem)=0x10

[wallace27]

Dans insertion avec courant == NULL, je suis inquiet de voir que dans mon schéma, à la fin l'élément nouveau pointe en fait vers lui-même... Est-ce possible ? et est-ce juste ?

[Sve@r]

Dans insertion avec courant == NULL, je suis inquiet de voir que dans mon schéma, à la fin l'élément nouveau pointe en fait vers lui-même... Est-ce possible ? et est-ce juste ?

Dans le cas "courant == NULL", ton code écrit nouveau->suivant = *ptPrem;. Donc nouveau ne peut pas pointer vers lui-même. Et dans mon schéma ce n'est pas le cas...