Discussion :

[dest]

Bonjour à tous.

Je bloque sur ce qui sera surement pour vous un détail.

Je m'explique, lors d'un ajout en tête ou en queue, j'aimerais insérer un maillon créé précédemment mais je n'y arrive pas.

Voici la structure qui sert pour la liste chaînée:

Code :

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

1
2
3
4
5
6
7
8
9
 
typedef struct pile
{
  char nom_prog[20];
  char pseudo[20];
  char taille_fichier[20];
  char fichier[256];
  struct pile *prec;
}pile;

La fonction d'ajout en tête:

Code :

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

1
2
3
4
5
6
7
8
 
void ajouter_tete(pile **MaPile, pile **m){
	pile *element = malloc (sizeof(pile)); //creation d'un nouveau chainon
 
	strcpy(element->pseudo,(*m)->pseudo);
	element->prec = *MaPile;
	*MaPile = element;
}

Pour charger la liste avec toutes les infos qui sont lues à partir d'un fichier:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
void charg_liste(pile **MaPile){
pile *m;
 
m= malloc (sizeof(pile));
m->prec = NULL;
 
/* puis les champs pseudos, taille_fichier,... sont renseignés */
 
ajouter_tete(MaPile,&m);
 
}

Et enfin le main:

Code :

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

1
2
3
4
5
6
7
8
 
int main(void){
 
pile *MaPile = NULL;
 
charg_liste(&MaPile);
...
}

Ainsi, dans la fonction d'ajout en tête, je suis obligé de faire un strcpy pour renseigner tous les champs nécessaires (ici j'en ai mis qu'un). Et cela fonctionne comme cela. Sauf que du coup, j'ai créé un maillon intermédiaire et j'aurais aimé savoir comment me passer de ce maillon. J'ai vainement tenté de lui passer l'adresse directement mais ça merde.

Voici ce que j'ai tenté:

Code :

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

1
2
3
4
5
 
void ajouter_tete(pile **MaPile, pile **m){
	(*m)->prec = *MaPile;
	*MaPile = *m;
}

Et voilà ma fonction d'affichage de la liste:

Code :

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

1
2
3
4
5
6
7
8
9
 
void aff(pile **MaPile){
	pile *p;
	p = *MaPile;
	while(p!=NULL){
		printf("pseudo:\t%s\n",p->pseudo);
		p = p->prec;
	}
}

Dans le cas du strcpy, ça me retourne exactement ce qu'il faut. Mais quand je passe l'adresse, j'ai une boucle infinie qui affiche le pseudo en tête de liste uniquement.

Merci de votre aide et désolé si le post est un peu long, j'ai essayé d'être assez précis.

Dest.

[cmoibal]

Code :

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

void ajouter_tete(pile **MaPile, pile **m)

Pourquoi t'utilise une nouvelle variable dans la fonction, tu peut traviler directement sur le pointeur MaPile, non ....

et pour le pointeur m, il suffit de le passer directement et non pas l'adress du l'adress, je ne vois pas l'utiliter.

[yorke]

J'ai pas lu tout ton code en detail, mais y'a un truc qui me parait bizar: pourquoi tu utilise des type "pile **" un peu partout ?

Pourquoi pas simplement un "pile *"?

Genre:

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
 
void ajouter_tete(pile *MaPile, pile *m){
	pile *element = malloc (sizeof(pile)); //creation d'un nouveau chainon
 
	strcpy(element->pseudo,m->pseudo);
	element->prec = MaPile;
	MaPile = element;
}
 
void charg_liste(pile *MaPile){
pile *m;
 
m= malloc (sizeof(pile));
m->prec = NULL;
 
/* puis les champs pseudos, taille_fichier,... sont renseignés */
 
ajouter_tete(MaPile,m);
 
}
 
 
void ajouter_tete(pile *MaPile, pile *m){
	m->prec = MaPile;
	MaPile = m;
}
 
....

[souviron34]

Plusieurs choses..

1. D'abord pourquoi séparer l'insertion dans la pile de la création ?
2. Ensuite si c'est ce que tu veux, tu fais 2 allocs, donc ... ya pas un truc dérangeant ?

De 2 choses l'une :

1. Soit tu fais une création, puis tu crées les liens de la pile
2. Soit tu crées et insères.

Donc par exemple :

Manière 1 :

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
 
void ajouter_tete(pile **MaPile,  pile *pm ){
 
             if ( pm == NULL )
                return ;
 
	pm->prec = *MaPile;
	*MaPile = pm ;
}
 
void charg_liste(pile **MaPile){
pile *m=NULL;
 
m= malloc (sizeof(pile));
if ( m == NULL )
   return ;
m->prec = NULL;
 
/* puis les champs pseudos, taille_fichier,... sont renseignés */
 
ajouter_tete(MaPile,&m);
}
 
int main(void){
 
pile *MaPile = NULL;
 
charg_liste(&MaPile);
...
}

Manière 2 :

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
 
void ajouter_tete(pile **MaPile, char *nomproc, char *pseudo, char *fichier, int taille ){
	pile *element = malloc (sizeof(pile)); //creation d'un nouveau chainon
             if ( element == NULL )
                return ;
 
	strcpy(element->pseudo, pseudo);
             ....
	element->prec = *MaPile;
	*MaPile = element;
}
 
void charg_liste(pile **MaPile){
int i ; 
 
 ....
 
 for ( i = 0 ; i < NLignes ; i++ )
    {
        Lire_Ligne ( ...., pseudo, nomprog, fichier, &taille );
....
        ajouter_tete(MaPile, nomprog, pseudo, fichier, taille );
     }
 ....
}
 
int main(void){
 
pile *MaPile = NULL;
 
charg_liste(&MaPile);
...
}

[dest]

Merci à tous pour vos réponses, commentaires et suggestions.

Je n'ai pas eu le temps aujourd'hui de me repencher là-dessus mais j'ai bien l'intention de revenir vous voir que ça marche ou pas.

Dest.

[dest]

Je reviens à la charge après avoir fait quelques essais.

Déjà pourquoi avoir des "**" ?
Pour m'exercer, je me suis inspiré du cours de cette page: http://chgi.developpez.com/pile/

Ensuite, je reconnais que la double allocation n'est pas nécessaire, c'est pourquoi je suis venu vous voir en vous montrant ce qui fonctionne actuellement mais que j'aimerai éviter la double allocation.

Ta manière 1 souviron34 ressemble fortement à mon ébauche de code, mais cela ne fonctionne pas pour autant.
Quant à la manière 2, c'est la double allocation que j'essaie justement d'éviter.

A la question pourquoi avoir séparé l'allocation ? C'était juste pour m'exercer dans un petit coin sans pour autant pourrir ma fonction.

@cmoibal: "et pour le pointeur m, il suffit de le passer directement et non pas l'adress du l'adress, je ne vois pas l'utiliter."

Je vais voir de ce côté.

Merci pour vos interventions et si vous avez d'autres suggestions, n'hésitez pas. Merci.


Edit: En fait, je crois avoir vu ma boulette. J'ai oublié de vous mettre comme information que m changent de valeur dans une boucle et à chaque tour de boucle je fais l'insertion en pile. Sauf que je lui balance la même adresse à chaque coup. Et donc ça merde.

ReEdit: Oui, oui, c'était bien ça. Merci