Discussion :

[Magnum8760]

Bonjour, j'arrive à passer un entier (score du joueur) dans une liste chaînée mais avec une chaîne de caractères (nom du joueur), je n'y parviens pas !

list.c

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
/* Prototypes */
p_list new_list(void);
t_Bool is_empty_list(p_list liste);
int list_length(p_list liste);
void print_list(p_list liste);
p_list push_back_list(p_list liste, char *player, int score);
p_list push_front_list(p_list liste, char *player, int score);
p_list pop_back_list(p_list liste);
p_list pop_front_list(p_list liste);
p_list clear_list(p_list liste);
 
void main(void){
      p_list li = new_list();
 
      print_list(li);
      //li = push_back_list(li, chaineAvecEspace, (int) endPlayerScore);
      print_list(li);
      writeScore ("data/score.score", chaineAvecEspace, endPlayerScore) ;
      //readCharByChar2 ("data/score.score") ;
      readData2 ("data/score.score") ;
 
}
 
/**
* Retourne une nouvelle Liste
* @return Une liste vide
*/
p_list new_list(void) {
	return NULL;
}
 
/**
* Vérifie si une List est vide
* @param liste La liste à tester
* @return true si elle est vide, faux sinon
*/
t_Bool is_empty_list(p_list liste) {
  	if(liste == NULL) {
        return VRAI ;
    }
  	return FAUX ;
}
 
/**
* Retourne la taille de la Liste
* @param liste La liste
* @return Le nombre d'élements de la Liste
*/
int list_length(p_list liste) {
	int size = 0;
 
	if(is_empty_list(liste))
		return size;
 
	while(liste != NULL)
	{
		size++;
		liste = liste->next;
	}
 
	return size;
}
 
/**
* Affiche une Liste
* @param liste La liste à afficher
*/
void print_list(p_list liste){
	if(is_empty_list(liste)) /* si la liste est vide, on sort directement. */
	{
		printf("Rien a afficher, la Liste est vide.\n") ;
		return ; /* void */
	}
	while(liste != NULL){
      printf("[%s] ", liste->classement->nom) ;
      printf("[%d] ", liste->classement->score) ;
  		liste = liste->next ;
	}
	printf("\n") ;
}
 
/**
* Ajoute un entier en fin de Liste
* @param liste La liste
* @param x L'entier à insérer
* @return La liste avec le nouvel élement ajouté
*/
p_list push_back_list(p_list liste, char *player, int score) {
  t_classements *nouveau_score ; /* nouveau score de type classements. */
	nouveau_score = malloc(sizeof(*nouveau_score)) ; /* allocation. */
	if(nouveau_score == NULL) {
  		fprintf(stderr, "Erreur : probleme allocation dynamique.\n") ;
  		exit(EXIT_FAILURE) ;
	}
	(*nouveau_score).classement->nom = player ;
  (*nouveau_score).classement->score = score ;
  (*nouveau_score).next = NULL ; /* initialiser l'élément suivant à NULL */
	if(is_empty_list(liste)){
      return nouveau_score ;
  }
  t_classements *temp ;
  temp = liste ;
	while(temp->next != NULL) {
      temp = temp->next ;
  }
	temp->next = nouveau_score ;
	return liste ; /* retourne l'adresse du nouveau_score. */
}
 
/**
* Ajoute un entier en début de Liste
* @param liste La liste
* @param x L'entier à insérer
* @return La liste avec le nouvel élement ajouté
*/
p_list push_front_list(p_list liste, char *player, int score){
	t_classements *nouveau_score;
	nouveau_score = malloc(sizeof(*nouveau_score));
	if(nouveau_score == NULL){
  		fprintf(stderr, "Erreur : probleme allocation dynamique.\n");
  		exit(EXIT_FAILURE);
	}
  (*nouveau_score).classement->nom = player ;
  (*nouveau_score).classement->score = score ;
  (*nouveau_score).next = NULL ;
	if(is_empty_list(liste))
		  (*nouveau_score).next = NULL;
	else
		  (*nouveau_score).next = liste;
	return nouveau_score;
}
 
/**
* Supprime un élément de la fin de la Liste.
* @param liste La liste.
* @return La liste sans l'élément retiré.
*/
p_list pop_back_list(p_list liste){
	if(is_empty_list(liste))
		  return new_list();
	/* Si la liste n'a qu'un seul élément. */
	if(liste->next == NULL){
  		free(liste);
  		liste = NULL;
		return new_list();
	}
	t_classements *temp = liste;
	t_classements *before = liste;
	while(temp->next != NULL){
  		before = temp;
  		temp = temp->next;
	}
	before->next = NULL;
	free(temp);
	temp = NULL;
	return liste;
}
 
/**
* Supprime un élement de la tête de la Liste
* @param li La liste
* @return La liste sans l'élément retiré
*/
p_list pop_front_list(p_list liste){
	t_classements *element;
	element = malloc(sizeof(*element));
	if(element == NULL){
  		fprintf(stderr, "Erreur : probleme allocation dynamique.\n");
  		exit(EXIT_FAILURE);
	}
	if(is_empty_list(liste))
  		return new_list();
	element = liste->next;
	free(liste);
	liste = NULL;
	return element;
}

list.h

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
 
#ifndef _SCORE_H_
#define _SCORE_H_
 
/* Définition d'un Booléen */
typedef enum e_Bool {
		FAUX,		/*0*/
		VRAI			/*1*/
} t_Bool;
 
	/* Définition d'une structure score de joueur */
typedef struct s_score {
      char *nom;
      int score;
} t_score;
 
	/* Définition d'une Liste de score */
typedef struct s_classements {
      t_score *classement;
      struct s_classements *next;
} t_classements, *p_list; /* On crée un pointeur dans la définition. Dans character.c,
* toute la fonction " Character *initializeCharacter " est un pointeur */
 
 /* Prototypes */
p_list new_list(void);
t_Bool is_empty_list(p_list liste);
int list_length(p_list liste);
void print_list(p_list liste);
p_list push_back_list(p_list liste, char *player, int score);
p_list push_front_list(p_list liste, char *player, int score);
p_list pop_back_list(p_list liste);
p_list pop_front_list(p_list liste);
void main (void) ;
 
#endif

[Bousk]

Parce que copier un entier c'est trivial, mais copier une chaîne de caractères non.
Une chaîne de caractère c'est pas juste le pointeur à copier. C'est un tableau de caractères. Il faut l'allouer puis y copier le contenu.

[pjlan]

Bonjour,

Lesfonctions push_back_list() et push_front_list() copient le pointeur mais ne copie pas la donnée.
Ce n'est peut être pas le comportement que tu veux ?
Peut être que tu veux allouer la mémoire pour le champ nom puis copier la chaine de caractère reçue en paramétre ?
Dans ce cas il ne faudra pas oublier de libérer la mémoire.

[Magnum8760]

Code :

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

1
2
(*nouveau_score).classement->nom = player;
(*nouveau_score).classement->score = score;

devient :

Code :

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

1
2
3
(*nouveau_score).classement = malloc(sizeof(t_score));
strcpy(nouveau_score->classement->nom, player);
nouveau_score->classement->score = score;

Merci le problème est résolu

[pjlan]

Euh non désolé ça risque de planter si la chaine de caractères est plus grande que sizeof(t_score)
En plus je ne comprend pas tu alloue classement et pas nom ?

ça c'est correct : (il manque quand même la vérif au cas ou l'allocation foire)

Code :

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

1
2
(*nouveau_score).classement.nom = malloc(strlen(player)+1); // sizeof(char) == 1 garanti par la norme
strcpy(nouveau_score->classement->nom, player);

PS : Effectivement tu n'avais pas non plus alloué classement il faut donc faire les deux mais du coup je suis plutôt étonné que ça ne plantais pas avant

[Magnum8760]

voici la fonction push, j'alloue déjà et je quitte en cas de problème. Je dois allouer la taille de mes deux structures . Tout n'est pas rose car je paramètre ma variable char* chaineAvecEspace qui contient des blancs, des espaces ...

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
 
p_list push_back_list(p_list liste, char *player, int score) {
  	t_classements *nouveau_score ; /* nouveau score de type classements. */
	  nouveau_score = malloc(sizeof(*nouveau_score) + sizeof(t_score)) ; /* allocation. */
	  if(nouveau_score == NULL) {
      	fprintf(stderr, "Erreur : probleme allocation dynamique.\n") ;
      	exit(EXIT_FAILURE) ;
	  }
    strcpy(nouveau_score->classement->nom, player);
    nouveau_score->classement->score = score ;
  	(*nouveau_score).next = NULL ; /* initialiser l'élément suivant à NULL */
	  if(is_empty_list(liste)){
        return nouveau_score ;
    }
    t_classements *temp ;
    temp = liste ;
  	while(temp->next != NULL) {
        temp = temp->next ;
    }
  	temp->next = nouveau_score ;
  	return liste ; /* retourne l'adresse du nouveau_score. */
}

[pjlan]

Je ne sais pas ce que tu essayes de faire mais ce code est faux je ne pense pas que ça fonctionne correctement ?
Je pense que l'allocation dynamique n'est pas une notion claire pour toi.
Cette ligne :

Code :

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

  nouveau_score = malloc(sizeof(*nouveau_score) + sizeof(t_score))

Ne va pas allouer nouveau_score et nouveau_score->classement. En fait tu est en train d'allouer de l'espace mémoire inutile pour nouveau_score
Il y a 3 allocations à faire :

1) allouer nouveau_score
2) allouer nouveau_score->classement
3) allouer nouveau_score->classement->nom

[Magnum8760]

Je suis d'accord.

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
/**
* Ajoute un player/score en début de Liste.
* @param liste, la liste.
* @param player, pointeur vers une chaîne de characters.
* @param score, un entier à insérer.
* @return La liste avec le nouvel élement ajouté.
*/
p_list push_front_list(p_list liste, char *player, int score){
	t_classements *nouveau_score;
	nouveau_score = malloc(sizeof(*nouveau_score));
  nouveau_score->classement = malloc(sizeof(*nouveau_score->classement));
	if(nouveau_score == NULL || nouveau_score->classement == NULL){
  		fprintf(stderr, "Erreur : probleme allocation dynamique.\n");
  		exit(EXIT_FAILURE);
	}
	strcpy(nouveau_score->classement->nom, player);
  nouveau_score->classement->score = score ;
	if(is_empty_list(liste))
		  (*nouveau_score).next = NULL;
	else
		  (*nouveau_score).next = liste;
 
  free(nouveau_score);
  free(nouveau_score->classement);
  return nouveau_score;
}

Enfin la dernière allocation est ajoutée dans la main.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
      unsigned int taille_chaine = strlen(chaineAvecEspace);
      char *chaine = malloc(sizeof(*chaine) * taille_chaine);
      if (chaine == NULL){
          fprintf(stderr, "Erreur : probleme allocation dynamique.\n") ;
          exit(EXIT_FAILURE) ;
      }
      strcpy(chaine, chaineAvecEspace);
 
      li = push_back_list(li, chaine, endPlayerScore);
      print_list(li);
 
free ...

C'est déjà plus propre, merci.