Discussion :

[Redgard]

Bonjour,

J'ai un exercice qui consiste à lire des données dans un fichier source et à les copier dans un fichier destination, en y incrémentant 2 à chaque note de chaque ligne. Cette note ne devant pas dépasser 20.

Fichier source :

Code :

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

1
2
3
4
15; Aline
12; Bernard
9; Mafalda
19; Eliot

Fichier destination :

Code :

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

1
2
3
4
17; Aline
14; Bernard
11; Mafalda
20; Eliot

Débutant avec toutes les fonctions fget, fread, j'ai encore du mal à me figurer comment elle marche et comment les données sont manipulées.
la situation idéal serait quelles soient récupérés (fget?) et stockés dans un tableau de structure à deux colonnes.
De là, je n'aurais qu'à récupérer la première colonne de chaque ligne (persone[0][i]) et d'incrémenter via une boucle (for (int i = 0; i < nbrPers; i++)), en m'assurant que la note ne dépasse pas 20 (if & else)

Est-ce qu'il ne serait pas une bonne idées de diviser ma fonction Anniversaire()? J'ai l'impression que je veux faire trop de chose dedans...

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
#include <stdio.h>
#include <stdlib.h>
 
 
// ================================= STRUCTURE =================================
// tableau de structure stockant une personne et sa note
struct personne
{
	float note;
	char nom[30];
};
 
//déclaration de ce tableau sous le pointeur tab
struct personne *tab;
 
// ================================= FONCTION APPELEE =================================
// fonction copiant les données d'un fichier dans un autre en y incrémentant deux point
void Anniversaire(FILE *source; FILE *dest) {
 
	// déclaraction de la taille du tableau.
	tab = malloc(nbrPers * sizeof(struct personne));
 
	//copie des données fichier source dans le tableau tab.
 
 
	// incrémentation à la variable note.
	for (int i = 0; i < nbrPers; i++)
	{
		if (tab[i].note < 19) {
			tab[i].note + 2
		}
		else
		{
			tab[i].note + 1
		}
 
	}
 
	// copie des données du tableau tab dans le fichier dest.
 
 
}
 
 
// ================================= FONCTION MAIN =================================
int main() {
	FILE *fo, *fw;
 
	if ((fo = fopen("/note.txt", "r")) == NULL)
	{
		printf("impossible d'ouvrir en lecture le fichier note.txt !\n");
		exit(0);
	}
	if ((fw = fopen("/anniversaire.txt", "w"))) == NULL)
	{
		printf("impossible d'ouvrir en écriture le fichier anniversaire.txt !\n");
		exit(1);
	}
 
	Anniversaire(*fo, *fw);
 
	fclose(fo);
	fclose(fw);
 
	return 0;
}

Merci d'avance,
Red'

[Matt_Houston]

Commence par écrire ton programme en pseudo-code sur une feuille de papier. Ça devrait déjà te donner une assez bonne idée des différentes tâches nécessaires et de leur découpage.

Partage ensuite cet algorithme, puis un squelette de programme qui compile (celui-ci n'est pas du C valide).

L'implémentation effective se fera probablement autour d'appels à fgets puis sscanf. On y viendra dans un second temps.

[Sve@r]

débutant avec toutes les fonctions fget, fread, j'ai encore du mal à me figurer comment elle marche et comment les données sont manipulées.

Bonjour

Ces deux fonctions ont le même rôle, à savoir récupérer des données dans un fichier.
fgets() récupère les données mais se cale sur la ligne. Elle récupère donc de l'octet mais s'arrête dès que le nb d'octets a été atteint, ou bien dès qu'elle atteint la fin de la ligne. Idéal donc pour traiter des fichiers textes. Et quand on veut être sûr de récupérer toute la ligne, on demande alors généralement un nb d'octets assez élevé (1000) => fgets(zone, 1000 + 1, fp) (le "+1" indique qu'on a bien pensé au '\0' qui doit terminer toute chaine).
fread() récupère de l'octet mais ne se préoccupe que du nb d'octets demandé. Plus adapté aux fichiers binaires (images, vidéos, sons, etc).
Dans tous les cas, tu récupères de l'octet à suivre sans que ce que tu récupères soit interprété d'une façon ou d'une autre. Si par exemple ta ligne contient "15; Aline" alors tu récupèreras '1', '5', ';', ' ', 'A', 'l', 'i', 'n', 'e', '\n' et si tu utilises fgets(), alors la fonction te rajoutera un '\0'. A toi ensuite d'analyser la chaine reçue pour convertir '1', '5', ';' en "15"...

Est-ce qu'il ne serait pas une bonne idées de diviser ma fonction Anniversaire()? J'ai l'impression que je veux faire trop de chose dedans...

Ben oui. Tu devrais avoir une fonction pour lire les données et d'autres fonctions pour les traiter (ce qu'on nomme généralement "programmation MVC"). Ca rend ton code beaucoup plus évolutif. Ceci dit, tu ne lui passes pas les bons paramètres. Ta fonction attend du "FILE étoile" et tu lui passes "étoile fo". Alors c'est quoi "étoile fo" ?
Ben puisque "fo" est défini comme un "FILE étoile" (pointeur sur fichier) alors lui passer "étoile fo" c'est lui passer l'élément pointé donc le fichier donc un "FILE". Or un "FILE" n'est certainement pas un "FILE étoile" !!!
Pour résumer, si "fo=FILE étoile", alors "étoile fo=FILE" (l'étoile passe de l'autre côté de l'égalité).
Sinon pour tes notes tu te casses vraiment la tête pour rien. Rajoute systématiquement 2 à ta note et si elle dépasse 20 alors tu lui mets 20. Ca t'évite de devoir gérer les cas "19" et "20" (qui n'a pas été géré)...
Accessoirement les variables en global c'est possible (puisque le C le permet) mais déclarer "tab" en global c'est vraiment faire sa grosse faignasse pour ne pas avoir à le passer aux fonctions (surtout que tab étant un pointeur, une fonction qui voudrait le modifier devrait recevoir un double pointeur). Malheureusement si tu commences à travailler comme ça, tu te libèreras d'un souci immédiat mais tu génèreras en retour cent fois plus de problèmes d'autant plus difficiles à résoudre qu'ils arriveront plus tard quand ton code sera bien plus avancé.

PS: j'ai du mal à faire l'analogie entre le nom de ta fonction ("Anniversaire()") et le but de cette fonction (choper des notes et leur rajouter 2). Mais c'est vrai que si les fonctions devaient porter un nom correspondant à leur rôle, cela faciliterait trop la relecture et la compréhension du code...
PS2: tu travailles souvent à la racine de ton système ("/note.txt", "/anniversaire") ? T'as à ta disposition un tas de dossiers pour bosser ($HOME, $HOME/tmp, /tmp) c'est vraiment malheureux de pourrir ton OS avec tes fichiers à la c. Surtout que ça indique aussi que tu bosses sous root...

[Redgard]

j'ai du mal à faire l'analogie entre le nom de ta fonction ("Anniversaire()")

Juste un manque d'idée du prof lié au fait qu'on fasse cadeau de deux points sur la note à chaque personne ( cadeau > anniversaire). De là j'ai aussi repris le truc pour rester dans le thème même si c'était pas du tout explicite...

L'objectif de l'exercice est de lire un ficher textesource de modifier la note de chaque personne et d'inscrire ces changements dans un fichier TexteDestination

écrire ton programme en pseudo-code

Je débute donc je suis loin d'être parfait, en espérant que ça explique un peu mieux ce que je veux faire :/

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
=========Texte Source=========
15; Aline
12; Bernard
9; Mafalda
19; Eliot
 
 
========= Initialisation du programme=========
	STRUCTURE
		Personne
			Float note
			Tableau nomPersonne[]
 
	FONCTION
		Int NbrsPersonne(FILE Textesource)     //calcule le nombre de ligne dans le fichier texte
			Int nbrsLignes
			Boucle While calculant le nombre de ligne du fichier TexteSource
				nbrsLignes++
			Retourne nbrsLignes
 
		Void Récupérateur(FILE TexteSource, Struct tab)     // copie TexteSource > tab
			???
 
		Void Incrementeur(Struct tab, int nbrpers)     // modifie la première colonne du tableau
			???
 
		Void Envoyeur(Struct tab, FILE TexteDestination)     // copie tab > TexteDestination
			???
 
 
	MAIN
		// déclaration des données
		Struct personne *tab;
		FILE *fileOriginal, *fileDestination;
 
		// association des pointeurs
		Boucle if lisant et associant le pointeur fileOrigine au fichier TexteSource, vérifiant si le fichier existe
		Boucle if écrivant le fichier Texte Destination et l'associant au pointeur fileDestination, vérifiant si le fichier existe.
 
		// déclaration de la taille du tableau tab
		Int nbrsPers = NbrsPersonne(File *fileOrigine)
 
		tab = malloc(nbrPers * sizeof(struct personne));
 
		// copie du contenu du fichier texteSource dans le pointeur
		Récupérateur( *fileOriginal, *tab)
 
		// incrémente 2 à la colonne note du tableau tab
		Incrementateur(*tab, nbrsPers)
 
		//écrit le contenu du tableau tab dans le fichier TexteDestination
		Envoyeur(*tab, *fileDestination)
 
		//fermeture des flux
		Fclose(fileOriginal);
		Fclose(fileDestination);
 
		//retour fonction main
		Return 0;
 
 
=========Texte Destination=========
17; Aline
14; Bernard
11; Mafalda
20; Eliot

En fait ce que j'aimerais savoir précisément, c'est comment le fichier TexteSource.txt est traité par la machine en utilisant les commandes fgets/freads.

En cherchant sur le net, je suis tombé sur ce tuto > http://www.zentut.com/c-tutorial/c-read-text-file/
Donc si je comprends bien, c'est comme si fgets traitait le fichier .txt comme un tableau. exemple sur base de mes données:

Code :

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

 char tab[4] = ("15; Aline","12; Bernard","9; Mafalda","19; Eliot")

Ce qui voudrait dire qu'il me faudrait une étape supplémentaire pour assigner les nombres à tab[i].note et les lignes de caractère à tab[i].nomPersonne?
Dans ce cas là, il me faudrait un fonction pour extraire les deux parties via boucle while( tab[i]=! ";"). Mais là encore faudrait que je cherche sur le net.

Ta fonction attend du "FILE étoile" et tu lui passes "étoile fo".

J'ai encore du mal avec les pointeurs. Ils se sont concentrés sur comment les pointeurs étaient stocké dans la mémoire, mais n'ont pas trop communiqué sur comment correctement les utiliser. N'hésites pas à me reprendre dessus, ça m'évitera de faire n'importe quoi.

[Sve@r]

En fait ce que j'aimerais savoir précisément, c'est comment le fichier TexteSource.txt est traité par la machine en utilisant les commandes fgets/freads.

Je te l'ai expliqué. Tu ne lis que du caractère et, même si les fonctions te remplissent une zone, ces caractères sont lus un à un. Au final, tu as donc un gros tableau de caractères.

En cherchant sur le net, je suis tombé sur ce tuto > http://www.zentut.com/c-tutorial/c-read-text-file/
Donc si je comprends bien, c'est comme si fgets traitait le fichier .txt comme un tableau. exemple sur base de mes données:

Code :

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

 char tab[4] = ("15; Aline","12; Bernard","9; Mafalda","19; Eliot")

Déjà tu définis un tableau de 4 caractères et tu y mets 4 chaines (sous-entendu avec chaque chaine contenant "n" caractères) !!!

Code :

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

 char *tab[4] = {"15; Aline","12; Bernard","9; Mafalda","19; Eliot"}

Sinon t'as mal lu. Dans l'exemple fgets() récupère au plus MAXCHAR - 1 caractères (on demande "MAXCHAR" mais il conserve 1 caractère pour y mettre le '\0' => d'où mon exemple où je demandais "1000 + 1"...).
Mais si la ligne se termine avant, il s'arrête alors à la fin de ligne (bref il te récupère donc une ligne du fichier). Et toi, tu n'as au final qu'une grosse chaine "15; Aline\n".

Ce qui voudrait dire qu'il me faudrait une étape supplémentaire pour assigner les nombres à tab[i].note et les lignes de caractère à tab[i].nomPersonne?

Bien que tu aies mal compris ce que tu obtiens, la conclusion est correcte. Oui, il te faut décomposer la chaine reçue.

Dans ce cas là, il me faudrait un fonction pour extraire les deux parties via boucle while( tab[i]=! ";"). Mais là encore faudrait que je cherche sur le net.

Tu peux utiliser strchr() qui recherche un caractère particulier dans une chaine et qui te renvoie l'adresse (qui peut être aussi compris comme étant la position) de ce caractère.
Exemple

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
#include <stdio.h>
#include <string.h>
 
int main() {
	char chaine[]="15 ; Aline";
	char *note;
	char *nom;
	char *pt;
 
	pt=strchr(chaine, ';');
	if (pt != NULL) {
		*pt='\0';
		note=chaine;
		nom=pt+1;
		printf("nom=[%s], note=[%s]\n", nom, note);
	}
}

Reprend cet exemple, compile-le pour que tu vois ce que ça fait. Puis quand tu l'auras compris, tu sauras alors comment récupérer tes noms et tes notes...

J'ai encore du mal avec les pointeurs. Ils se sont concentrés sur comment les pointeurs étaient stocké dans la mémoire, mais n'ont pas trop communiqué sur comment correctement les utiliser.

Mouais. C'est dommage car la bonne compréhension des pointeurs est primordiale à la compréhension du C. N'hésite pas à creuser le sujet et à revenir nous voir si tu as des questions...

[Redgard]

Dis moi si c'est bon

1. Ce que je retiens des pointeur:

"px = &x" == "*px = x" == "px = *x"

Int x = 10
> x = 10
>*x = 28FF1C

Int *px = x
>*px = x = 10
> px = *x = 28FF1C

2. Quelle est l'intérêt de définir ses fonctions en dessous de main et de la déclarer au dessus? La lisibilité?

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
void display_array(int*,const int);
 
int main()
{
…
return 0;
}
 
/*Display an array of integers with predefined size*/
 
void display_array(int* p,const int size)
{
int i;
for(i = 0; i < size; i++)
{
printf("%d ",p[i]);
}
printf("\n");
}

3. Quelle est la différence entre ces deux notations? "Int* pa" et "int *pa"

4. Juste pour être sûr, fopen retourne une adresse, d'où la nécessité de le lier à un pointeur?
Source 1: http://www.zentut.com/c-tutorial/c-read-text-file/
Source 2: http://www.cplusplus.com/reference/cstdio/fopen/

5. Ce que j'en comprend de ton code:

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
#include <stdio.h>
#include <string.h>
*
int main() {
	char chaine[]="15 ; Aline";   // initialisation d'un tableau de charactère
	char *note;     // initialisation d'un pointeur note
	char *nom;     // initialisation d'un pointeur note
	char *pt;     // initialisation d'un pointeur note
*
	pt=strchr(chaine, ';');     //tu fais pointé pt sur ";" / tu enregistres l'adresse de ";" dans le pointeur pt
	if (pt != NULL) {     // tu mets en place une condition pour éviter les bugs, dans le cas ou pt serait null/ quel chaine de caractère ne contiendrait pas ";"
		*pt='\0';     // tu remplaces ";" par "\0" signifiant à la machine que le tableau s'arrête ici
		note=chaine;     // tu attribues le contenu du tableau à au pointeur note, qui prend l'adresse du premier caractère  
		nom=pt+1;     // tu attribues la chaine de caractère orpheline au pointeur nom, qui prend l'adresse du premier caractère
		printf("nom=[%s], note=[%s]\n", nom, note);     // impression écran du résultat
	}
}

[Sve@r]

1. Ce que je retiens des pointeur:

"px = &x" == "*px = x" == "px = *x"

Int x = 10
> x = 10
>*x = 28FF1C

Int *px = x
>*px = x = 10
> px = *x = 28FF1C

Si je reprends ton exemple, tu écris int x=10. Ok. Donc tu définis une variable "x" (située à l'adresse "28FF1C") qui vaut 10. Jusque là ça va.
Ensuite tu écris *x=28FF1C. Peut-être qu'effectivement à l'adresse "10" (ou 0x000a) il y a la valeur "28FF1C" mais 1) ce n'est pas garanti et 2) de toute façon, le C ne saura pas interpréter *x car il ne connait pas la nature de cette valeur (int, char, float, double ?)

Ensuite tu écris int *px=x. C'est peu orthodoxe mais là encore fondamentalement ça peut le faire (en forçant un peu). Donc tu stockes la valeur "10" dans le pointeur "px".
Mais ensuite tu écris px=*x et là ça ne va plus. Tu as écrit px=x donc px vaut la valeur de x et non ce qui y est pointé.

En fait, tu confonds l'écriture int *pt=10 (ici définition de variable) et *pt=10 (ici affectation). Elles sont semblables, mais ne signifient pas la même chose.

En écrivant int *pt=10, tu déclares un pointeur "pt" dont le pointé est de type "int" ; mais tu affectes la valeur "10" à "pt" et non à ce vers quoi il pointe. C'est comme si tu écrivais int *pt; pt=10;.
En écrivant ensuite *pt=10, là tu affectes la valeur 10 à la case pointée par pt (donc à "étoile pt" et non à "pt").

Voici une série d'instructions plus correctes

Code c :

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

1
2
3
4
5
6
7
8
9
int v=123;     // v est une variable, qui aura par exemple l'adresse "0xff01", et qui contient la valeur "123".
int *pt=&v;              // pt est une variable, qui aura par exemple l'adresse "0xff02", et qui contient la valeur "0xff01"
int **dpt=&pt;        // dpt est une variable, qui aura par exemple l'adresse "0xff03", et qui contient la valeur "0xff02"
 
printf("%d\n", v);    // j'affiche la valeur de v => 123
printf("%d\n", *pt);  // j'affiche la valeur de ce qu'il y a à l'adresse "0xff01". Or, à cette adresse il y a la valeur 123
printf("%d\n", **dpt);
/* j'affiche la valeur de ce qu'il y a à l'adresse dont la valeur est ce qu'il y a à l'adresse "0xff02".
Or, à l'adresse "0xff02" il y a la valeur "0xff01"; et à l'adresse "0xff01" il y a la valeur 123 */

2. Quelle est l'intérêt de définir ses fonctions en dessous de main et de la déclarer au dessus? La lisibilité?

Si a() appelle b() alors tu dois d'abord déclarer b() avant que le compilo ne tombe sur l'instruction qui l'appelle (donc avant d'écrire a()).
Si on écrit le code de b() sans l'avoir déclaré alors cela équivaut à une déclaration donc généralement on peut écrire les fonctions sans les déclarer pourvu qu'on les écrive dans le bon ordre.
Mais si on n'a pas envie de se préoccuper de l'ordre, ou bien si c'est impossible (a qui appelle b et b qui appelle a) alors il faut les déclarer au préalable. Perso j'ai choisi cette solution...

3. Quelle est la différence entre ces deux notations? "Int* pa" et "int *pa"

Aucune.

4. Juste pour être sûr, fopen retourne une adresse, d'où la nécessité de le lier à un pointeur?
Source 1: http://www.zentut.com/c-tutorial/c-read-text-file/
Source 2: http://www.cplusplus.com/reference/cstdio/fopen/

Exactement. Le terme "pointeur" signifie "variable apte à recevoir une adresse"
Une adresse étant un nombre, tu pourrais penser qu'écrire int pt=&truc fonctionnerait. Et (à la base) tu n'aurais pas tort. Le seul souci c'est qu'en l'écrivant ainsi, le C ne connait pas la nature de*pt (y a-t-il un char d'un octet ou un double de 8 octets ???).
Tu es donc obligé de déclarer à la fois que tu vas recevoir une adresse, et à la fois la nature de ce qu'il y a à cette adresse. Si tu veux déclarer par exemple un pointeur sur un double, alors tu écriras double *pt=&truc (ou bien en décomposé double *pt; pt=&truc;). Cela signifie "pt est une variable qui recevra une adresse" et "étoile pt est de type double" et "je stocke l'adresse de truc dans pt".
Grace à cette façon de déclarer "pt", si tu écris ensuite int var=*pt * 2 le C sait analyser *pt, en extraire les 8 octets qui appartiennent à ce double et le multiplier par 2...

5. Ce que j'en comprend de ton code:

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
#include <stdio.h>
#include <string.h>
*
int main() {
	char chaine[]="15 ; Aline";   // initialisation d'un tableau de charactère - Exact
	char *note;     // initialisation d'un pointeur note
	char *nom;     // initialisation d'un pointeur nom
	char *pt;     // initialisation d'un pointeur pt
// Exact mais vaut mieux parler de déclaration plutôt qu'initialisation

	pt=strchr(chaine, ';');     //tu fais pointé pt sur ";" / tu enregistres l'adresse de ";" dans le pointeur pt - Exact
	if (pt != NULL) {     // tu mets en place une condition pour éviter les bugs, dans le cas ou pt serait null/ quel chaine de caractère ne contiendrait pas ";" - Exact
		*pt='\0';     // tu remplaces ";" par "\0" signifiant à la machine que le tableau s'arrête ici - Pas vraiment à la machine, mais plutôt à toute fonction du C qui voudrait utiliser ce tableau comme une chaine de caractères
		note=chaine;     // tu attribues le contenu du tableau à au pointeur note, qui prend l'adresse du premier caractère  - Pas tout le contenu du tableau, juste son adresse (ou plus exactement l'adresse de son premier élément)
		nom=pt+1;     // tu attribues la chaine de caractère orpheline au pointeur nom, qui prend l'adresse du premier caractère - Le pointeur "nom" se positionne sur l'adresse du caractère qui suit immédiatement le ";"
		printf("nom=[%s], note=[%s]\n", nom, note);     // impression écran du résultat
/*
Exact. Et comme le tableau "nom" (qui correspond aussi au tableau "chaine") s'arrête au premier '\0', le printf() s'arrêtera à celui que j'ai mis (au ";").
Et comme le tableau "note" (dont le point de départ commence dans le tableau "chaine" mais après le ";") et que ce tableau "chaine" contenait déjà un '\0' initial qui n'a pas été enlevé, le second printf() s'arrêtera à ce second '\0'
*/
	}
}

Mes remarques en rouge dans ton code