Traitement des données “ notes ” d’une classe
Les données
Personne définie par un nom et un prénom
•	nom : chaînes de caractères sans espace, minimum 2 caractères, maximum 13 caractères
•	prénom : chaînes de caractères sans espace, minimum 2 caractères, maximum 13 caractères
Collection de note par personne
Le nombre de notes est de 2 par personne.
•	note : réel, 2 chiffres après la virgule, valeurs comprises entre 0 et 20.
•	Le nombre de notes est de 2 par personne.

Les données sont stockées dans 2 fichiers. Pour mettre en relation les notes et les personnes, une clef est utilisée. La valeur d’une clef est unique.
Les valeurs de la clef sont comprises entre 1 et  10 000 000
Exemple de contenu des fichiers

fichier personne.txt
897 	Dupond       Pierre
9875	Durant        Françoise
98 	Radupont     Emilie
6  	Duponrat      Simon
32	Casenave     Karine
222	Etcherria     Miguel
14	Cohen         René
15	Pizzarosso    Caroline
65	Legal        Bruno

fichier note.txt
897 	10,50 	15.63
9875	8,50  	10.65
98 	18,60 	11.8
6  	6,50	11
32	12,90	9
222	11,50	9
14	9,50	9
15	2,30	15.5
65	14,80  	11
					
Les opérations sur les fichiers
•	Lire les données du fichier note
•	Lire les données du fichier personne
Les opérations sur les notes
Rechercher
•	L’index de la note la plus grande/petite.
Ordonner
•	Classer par ordre croissant ou décroissant les notes.
Calculer 
•	Calculer la moyenne
•	Rechercher le nombre de notes qui ont une valeur particulière.
•	Rechercher le nombre de notes qui sont supérieures ou inférieures à une valeur.
Amorce du programme en C++
Le programme et organisé autour de 6 fichiers pour traiter les données du fichier note.txt :
•	traitement.* contient les fonctions de traitement sur les notes.
•	fichier.* contient les fonctions pour opérer sur les fichiers.
•	note.* contient la fonction principale main().

Les informations des fichiers note.txt sont rangées dans 3 tableaux clef[-], note1[-] et note2[-] grâce à la fonction lireFichierNote(---) ;

Fichier de définition “ note.h ”
1.	#define MAXI 30				// Note maxi dans le fichier
2.	#define FICHIER_NOTE "note.txt"	// Nom du fichier
Fichier de définition “ fichier.h ”
1.	// Lit les données dans FICHIER_NOTE 
2.	// Retourne le nombre d'enregistrement 
3.	short lireFichierNote(long cle[],float note1[],float note2[],const char name[]);
Fichier de définition “ traitement.h ”
1.		// Afficher les valeurs à l'écran
2.		void afficherLesValeurs(long cle[],float note1[],float note2[],short taille);
3.		void afficherUneNote(float note[],short index);

4.	// Rechercher des valeurs
5.		short indexPlusGrande(float note[],short taille);
6.		// arguments : tableau, taille du tableau
7.		// paramètre de retour l'index de la valeur la plus grande
8.		short indexPlusPetite(float note[],short taille);
9.		// arguments : tableau, taille du tableau
10.		// paramètre de retour l'index de la valeur la plus petite

11.	// Calculer des valeurs
12.		float CalculeMoyenne(float note[],short taille); 
13.		// arguments : tableau, taille du tableau
14.		// paramètre de retour la valeur moyenne

15.		short CompterNbreNote(float note[], float valeur, short taille);
16.		// arguments : tableau, valeur de la note, taille du tableau
17.		// paramètre de retour le nombre de notes

18.		short CompterNbreNoteSuperieure(float note[], float valeur, short taille); 
19.		// arguments : tableau, valeur de la note, taille du tableau
20.		// paramètre de retour le nombre de notes supérieures à valeur

21.		short CompterNbreNoteInferieure(float note[], float valeur, short taille);
22.		// arguments : tableau, valeur de la note, taille du tableau
23.		// paramètre de retour le nombre de notes inférieures à valeur

24.	    // Ordonner des valeurs
Fichier source “ note.cpp ”
1.	#include "note.h"
2.	#include "fichier.h"
3.	#include "traitement.h"

4.	int main(void){

5.		long clef[MAXI];
6.		float note1[MAXI];
7.		float note2[MAXI];
8.		short nbreDeValeurs=0;

9.		// Lit le fichier des notes et renseigne les tableaux
10.		// Le nombre d'enregistrement est porté par nbreDeValeurs
11.	    nbreDeValeurs=lireFichierNote(clef,note1,note2,FICHIER_NOTE);

12.		// Affiche les valeurs des 3 tableaux
13.		for(short i=0; i<nbreDeValeurs; i++){
14.			afficherLesValeurs(clef,note1,note2,i);
15.		}
16.	 	return 0;
17.	}

Fichier source “ traitement.cpp ”
1.	#include <iostream>
2.	using namespace std;

// Afficher les valeurs à l'écran de 3 tableaux
3.	void afficherLesValeurs(long cle[],float note1[],float note2[],short taille){
4.			cout<<" Clef="<<cle[taille]<<"\t"<<"note1="<<note1[taille]
5.				<<"\t"<<"note2="<<note2[taille]<<endl;
6.	}
// Afficher les valeurs à l'écran d'un enregistrement dans un tableau
7.	void afficherUneNote(float note[],short index){
8.			cout<<" Note="<< note[index]<<endl<<endl;
9.	}

10.	// Rechercher des valeurs
11.	short indexPlusGrande(float note[],short taille){
12.			short index=0;
13.	
14.			return index;
15.	}
		
// Rechercher des valeurs
16.	short indexPlusGrande(float note[],short taille){
17.			short index=0;
18.	
19.			return index;
20.	}
		
// Calculer des valeurs
21.	short CompterNbreNote(float note[], float valeur, short taille){
22.			short compte=0;
23.	
24.			return compte;
25.	}

// Ordonner des valeurs 
Fichier source “ fichier.cpp ”
1.	#include <fstream>
2.	using namespace std;

// Lit les données le FICHIER_NOTE
3.	short lireFichierNote(long cle[],float note1[],float note2[],const char name[]){
4.		short index=0;
5.		ifstream fichierNote;

6.		fichierNote.open(name);   //Ouvre le fichier de données en lecture
	//Prélève les valeurs dans le fichier et injecte dans les tableaux
7.		while(fichierNote.good()!=0){
8.			fichierNote>>cle[index]>>note1[index]>>note2[index];
9.			index++ ;
10.		}
11.		fichierNote.close();	// Ferme le fichier de données
12.		return index;			// Retourne le nombre d'enregistrement
13.	}