Les Enregistrements

EXERCICE 1 :

a- Définir un type TEMPS qui contient les champs heure, minute, seconde.
b- Ecrire une action paramétrée qui réalise la somme T de deux durées T1 et T2 de type
temps.
c- Ecrire une fonction TRANSFORM qui transforme un temps T de type TEMPS en un
entier S qui exprime ce temps en secondes.
Exemple : pour T=2 heures 10 minutes 37 secondes, S=7837 secondes.
d- Ecrire une procédure DECOMPOS qui décompose un temps S exprimé en secondes
en un temps T de type TEMPS.
Exemple : pour S=7837 secondes, T=2 heures 10 minutes 37 secondes.
e- Etant donnés deux temps T1 et T2 de type TEMPS, écrire un algorithme qui calcule le
temps T somme des temps T1 et T2 (T, T1 et T2 sont de type TEMPS) en utilisant les
actions TRANSFORM et DECOMPOS.
#include <stdio.h>
#include <stdlib.h>

typedef struct
{int heure;
int minute;
int seconde;
} Temps;

int TRANSFORM(Temps t)
{int x;
x=t.heure*3600+t.minute*60+t.seconde;
return x;
}

Temps DECOMPS(int x)
{ Temps T;
T.heure=x/3600;
T.minute=(x%3600)/60;
T.seconde=x%3600%60;
return T;
}

Temps SOMME(Temps T1, Temps T2)

{Temps T;
T.heure=T1.heure+T2.heure;
T.minute=T1.minute+T2.minute;
T.seconde=T1.seconde+T2.seconde;
return T;
}

int main()
 {
Temps t1,t2,t;int v;
printf("donner le temps t1 ");
scanf("%d %d %d",&t1.heure,&t1.minute, &t1.seconde);
printf("donner le temps t2 ");
scanf("%d %d %d",&t2.heure,&t2.minute, &t2.seconde);
t=DECOMPS(TRANSFORM(SOMME(t1,t2)));

printf("le temps est %d %d %d \n",t.heure,t.minute, t.seconde);

system("pause");
return 0;
}

EXERCICE 6 :

Soit un enregistrement E défini par deux informations :

 T un tableau d’entiers pouvant contenir au maximum 100 éléments;
 N le nombre d’éléments du tableau T.
Soit une chaîne de caractères M, écrire une action paramétrée qui retourne un enregistrement
de type E contenant toutes les positions de la chaîne ‘ab‘ dans la chaîne M.
Exemple : M = ‘faabaababbaabrs’

Résultat : 2 5 7 11
4

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{int tab[100];
int n;
}E;

E position(char c[])
{E ee; int i,j=0;
for(i=0;i<strlen(c)-1;i++)
if(c[i]=='a' && c[i+1]=='b') {ee.tab[j]=i;
j++;
}
ee.n=j;
return ee;
}

int main()
{
 E e;
char cc[30];
int n,i;
printf("Donner la cahine de caracteres\n");
scanf("%s",cc);
e=position(cc);
printf("les elms tableau:\n");
for (i=0;i<e.n;i++)printf("%d\n", e.tab[i]);
printf("la taille du tableau: %d\n", e.n);
system("pause");
return(0);
}

Les fichiers

Types de Fichiers en C

Il y’a 2 types de fichiers en C:

- Les Fichiers Texte (avec extension .txt)

- Les Fichiers Binaire (avec extension .dat)

Fichiers Texte (ou ASCII American Standard Code for Information Interchange).

Avantages:

- Fichiers qui peuvent être visualisés,

- Portables (peuvent être utilises dans d’autres ordinateurs).

Inconvénients:

- Nécessitent la conversion pour être utilisés dans un PC donc moins performants.

- Occupe plus d’espace qu’un fichier binaire.

Fichiers Binaire: Contient la même représentation que celle utilisée par la machine.

Avantages:

-     Occupe moins d’espace qu’un fichier texte.

-     Plus rapide à lire ou à écrire vu qu’aucune conversion n’est nécessaire.
Inconvénients:

-     Ces fichiers ne peuvent pas être visualisés.

-     Ne sont pas portables.

Pour utiliser un fichier en C, il faut tout d'abord déclarer une variable de type FILE *.  

FILE *<variablefichier>;

Exemple : FILE *f;

Operations sur les fichiers (Texte et Binaire)

Ouverture d’un fichier :

fopen :   <variablefichier> = fopen(<nom>, <mode>);

<variablefichier>: variable de type FILE *. 

<nom>: nom du fichier.

Noter qu’on peut inclure le répertoire dans le nom du fichier.

Comme par exemple si le nom du fichier est "c:\\TPALGO\\etud.txt" alors le fichier sera crée
dans le répertoire TPALGO dans le cas d’une création. Il est dans le répertoire TPALGO
dans le cas d’une lecture.

Si le nom du fichier ne contient pas le répertoire comme par exemple "etud.txt", le fichier sera
crée dans le même répertoire ou s’exécute le programme dans le cas d’une création. Il est dans
le même répertoire ou s’exécute le programme dans le cas d’une lecture.

 <mode>: mode d’ouverture du fichier

 "r" : lecture seule. Vous pourrez lire le contenu du fichier, mais pas y écrire. Le
fichier doit avoir été créé au préalable.

 "w" : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire son contenu. Si
le fichier n'existe pas, il sera créé.

 "a" : mode d'ajout. Vous écrirez dans le fichier, en partant de la fin du fichier. Vous
ajouterez donc du texte à la fin du fichier. Si le fichier n'existe pas, il sera créé.

 "r+" : lecture et écriture. Vous pourrez lire et écrire dans le fichier. Le fichier doit
avoir été créé au préalable.
  "w+" : lecture et écriture, avec suppression du contenu au préalable. Le fichier
est donc d'abord vidé de son contenu, vous pouvez y écrire, et le lire ensuite. Si le
fichier n'existe pas, il sera créé.

 "a+" : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la
fin du fichier. Si le fichier n'existe pas, il sera créé.

Remarque : fopen retourne la valeur NULL en cas d’erreur.

ex: FILE *f;

f = fopen(“Donnees.txt”, “rt”);

Fermeture d’un fichier : 

fclose(f) : Fermer le fichier f.

Operations sur les Fichiers Texte

Operation d’Ecriture :

int fprintf(FILE *file, format, variable);

Opération de lecture

int fscanf (FILE *file, format, &variable);

exercice 01 :

Création et Lecture d’un fichier Texte d’étudiants. Le premier programme crée le fichier
«etud.txt» et le deuxième programme lit le fichier etud.txt et affiche le résultat.

  Programme de création du fichier Texte « etud.txt »

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
}etudiant;
int main()
{FILE *f;
char s[100];
etudiant etd;
 int NbrEtuds,i;
f=fopen("etud.txt","w");//ouverture de fichier en mode écriture + creation
if(f==NULL)printf("Erreur de creation de fichier");
else
{printf("donner le nombre des etudiants");scanf("%d",&NbrEtuds);
for (i=0; i < NbrEtuds; i++)
{ printf("Entrer les informations de l’etudiants matricule , nom, prenom,
moyenne \n");
scanf("%d %s %s %f", &etd.mat, etd.nom, etd.prenom, &etd.moyenne);
fprintf(f,"%d %s %s %f\n",etd.mat, etd.nom, etd.prenom,etd.moyenne);
//On doit laisser un espace ou un saut de ligne entre chaque champ
}
fclose(f);
}
system("pause");
}

Programme de Lecture du fichier Texte « etud.txt»

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
}etudiant;
main()
{FILE *f;
char s[100];
etudiant etd;
int i;
f=fopen("etud.txt","r");
if(f==NULL)printf("Erreur de lecture de fichier");
else
{
fscanf(f,"%d %s %s %f",&etd.mat, etd.nom, etd.prenom,&etd.moyenne);
while(!feof(f))
{printf("le matricule est %d le nom est %s le prenom est %s la moyenne
%f\n",etd.nom,etd.prenom,etd.moyenne);
fscanf(f,"%d %s %s %f",&etd.mat,etd.nom, etd.prenom,&etd.moyenne);
}
 fclose(f);
}
system("pause");
}

Operations sur les Fichiers Binaires

Operateur sizeof()

sizeof(<var>) ou sizeof(<type>)

Retourne le nombre d’octets occupé par la variable ou le type

Exemple:

int x, sz;
sz = sizeof(x);  /* sz = 4 sous dev-c++ */
ou bien
sz = sizeof(int); /* sz = 4 sous dev-c++ */

Operations de Lecture

size_t fread(void *ptr, size_t size, size_t n, FILE *file);

fread lit n éléments de données, ou chaque élément a comme taille size  octets, à partir de file,
et met les données lus en mémoire à partir de l’adresse contenu dans le pointeur ptr. Le
nombre total d’octets lus est ¿).

fread  retourne le nombre d’éléments lus avec succès. Si ce nombre est différent de n alors, ou
bien il y’a eu erreur ou bien la fin de fichier est atteinte.

Operations d’Ecriture

size_t fwrite(const void *ptr, size_t size, size_t n, FILE *file);

fwrite ajoute n éléments de données dans le fichier, où chaque élément a size octets. Les
données écrites démarrent de l’adresse ptr. Le nombre total d’octets écrits est ¿ ptr est un
pointeur qui peut pointer vers n’importe quel objet (void *).

fwrite retourne le nombre d’éléments écrits avec succès. Si ce nombre est différent de n alors
il y’a eu erreur.

Exercice 02 :
Création et Lecture d’un fichier Binaire d’étudiants. Le premier programme crée le fichier
binaire « etud.dat » et le deuxième programme lit les éléments de ce fichier et affiche le
résultat sur écran.  

Programme de création du fichier binaire «etud.dat » 

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
}etudiant;
main()
{FILE *f;
etudiant etd;
int NbrEtuds,i;
f=fopen("etud.dat","w");
if(f==NULL)printf("Erreur de creation de fichier");
else
{printf("donner le nombre des etudiants");scanf("%d",&NbrEtuds);
for (i=0; i < NbrEtuds; i++)
{ printf("Entrer Donnees etudiants matricule , nom, prenom
moyenne\n");
scanf("%d %s %s %f", &etd.mat, etd.nom, etd.prenom,
etd.moyenne);
fwrite(&etd,sizeof(etd),1,f);
}
fclose (f);
}
system("pause");
}

 Programme de Lecture du fichier Binaire «etud.dat » 

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
 }etudiant;
main()
{FILE *f;
etudiant etd;
f=fopen("etud.dat","r");
if(f==NULL)printf("Erreur d’ouverture");
else
{fread(&etd,sizeof(etd),1,f);
while(feof(f)==0)
{ printf("le mat est %d les nom est %s le prenom est %s et la moyenne
est %f\n",etd.mat, etd.nom, etd.prenom, etd.moyenne);
fread(&etd,sizeof(etd),1,f);
}
fclose (f);
}
system("pause");}

Operations sur les pointeurs de fichier

Ces opérations s'appliquent aux fichiers binaires ainsi qu'aux fichiers textes.

fseek()   : Met la position du pointeur de fichier à une position donnée dans le fichier.

 int fseek(FILE *file, long int offset, int whence);

fseek met pointeur de fichier a une position donnée dans le fichier file. Cette position est un
offset (en octets) à partir de la position du fichier déterminée par whence.

'whence doit avoir une de ces valeurs: 0, 1, 2.

SEEK_SET (0) : Début du fichier

SEEK_CUR (1) : Position courante dans le fichier

SEEK_END (2) : Fin de fichier

Apres fseek, la prochaine opération peut être soit une lecture soit une écriture. fseek retourne
0 si le pointeur est déplacé avec succès et retourne une valeur différente de zéro  en cas
d’échec.

rewind(file)  :  Met la position du pointeur de fichier au début du fichier.

rewind(file) est equivalent à fseek(stream, O, SEEK_SET),

EXERCICE  3 :  
Considérons le type enregistrement suivant :

Type Étudiant = Enregistrement

    Matricule : entier 
    Nom, Prénom : chaîne [20] 
   Moyenne : réel 
Fin

Soit T un tableau d’au plus 100 étudiants.

Écrire un algorithme permettant de recopier tous les étudiants admis appartenant à T dans un
fichier ADMIS de type étudiant. Un étudiant est admis si sa moyenne est supérieure ou égale
10.

En utilisant un fichier texte :

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
}etudiant;
int main()
{FILE *f;
etudiant etd, T[100];
int NbrEtuds,i;
f=fopen("Admis.txt","w+");/*ouverture de fichier en mode lecture ecriture
+ creation de fichier s'il n'existe pas sinon
son contenu sera ecrasé*/
if(f==NULL)printf("Erreur de creation de fichier");
else
{printf("donner le nombre des etudiants");scanf("%d",&NbrEtuds);
for (i=0; i < NbrEtuds; i++)
{printf("Entrer les informations de l'etudiant: matricule , nom, prenom,
moyenne \n");
scanf("%d %s %s %f", &T[i].mat, T[i].nom, T[i].prenom,&T[i].moyenne);
if(T[i].moyenne>=10)
fprintf(f,"%d %s %s %f\n",T[i].mat, T[i].nom, T[i].prenom,T[i].moyenne);
}

//Affichage des noms des admis

rewind(f);/*mettre la tête au debut du fichier puisque le fichier est
 ouvert en mode lecture ecriture*/
fscanf(f,"%d %s %s %f",&etd.mat, etd.nom, etd.prenom,&etd.moyenne);
while(feof(f)==0)
{ printf("le nom est %s \n", etd.nom);
fscanf(f,"%d %s %s %f",&etd.mat, etd.nom, etd.prenom,&etd.moyenne);
}
fclose (f);
}
system("pause");
}

En utilisant les fichiers binaires

#include<stdio.h>
#include<stdlib.h>
typedef struct
{int mat;
char nom[20];
char prenom [20];
float moyenne;
}etudiant;
int main()
{FILE *f;
etudiant etd, T[100];
int NbrEtuds,i;
f=fopen("Admis.dat","w+");/*ouverture de fichier en mode lecture ecriture
+ creation de fichier s'il n'existe pas sinon son contenu sera ecrasé*/
if(f==NULL)printf("Erreur de creation de fichier");
else
{printf("donner le nombre des etudiants");scanf("%d",&NbrEtuds);
for (i=0; i < NbrEtuds; i++)
{printf("Entrer les informations de l'etudiant: matricule , nom, prenom,
moyenne \n");
scanf("%d %s %s %f", &T[i].mat, T[i].nom, T[i].prenom,&T[i].moyenne);
}
for (i=0; i < NbrEtuds; i++)
if(T[i].moyenne>=10)
fwrite(&T[i],sizeof(etudiant),1,f);
}
//Affichage des noms des admis
rewind(f);/*mettre la tête au debut puisque le fichier est ouvert en mode
lecture ecriture*/
fread(&etd,sizeof(etd),1,f);
 while(feof(f)==0)
{ printf("le nom est %s \n", etd.nom);
fread(&etd,sizeof(etd),1,f);
}
fclose (f);
system("pause");
return 0;

EXERCICE  4 :

Soit F un fichier d’entiers représentant des séquences de nombres séparées par un ou plusieurs
zéro. Écrire un algorithme qui réalise les traitements suivants :

1. A partir de F (fichier existant), crée un fichier G contenant pour chaque séquence, la

moyenne des nombres qui la constituent.
2. Puis, Supprimer les valeurs nulles du fichier G.

Exemple :
F :  0  0  1   4   3   7   0   0   0   6   -9   2   7   -6   0   -10   3  0   0
G :                 3,75                            0,00                  -3,50
G :                 3,75                                                     -3,50

Fichier Binaire :

#include <stdio.h>
#include <stdlib.h>
main()
{FILE *f, *g;
int i,n,v,nbr=0;
float s=0,t[100];
g=fopen("moyenne.dat","w+");
f=fopen("entier.dat","w+");
if((g==NULL) || (f==NULL))printf("Erreur de creation des fichiers");
else
{printf("Remplir f");
printf("Donner n");scanf("%d",&n);
for(i=0;i<n;i++)
{ printf("Donner une valeur\n");
scanf("%d",&v);
 fwrite(&v,sizeof(v),1,f);
}
rewind(f);//remettre la tete au debut
do
{fread(&v,sizeof(v),1,f);
if(v!=0)
{s=0;nbr=0;
while(!feof(f)&& v!=0)
{s=s+v;nbr++;fread(&v,sizeof(v),1,f);}
s=s/nbr;
fwrite(&s,sizeof(s),1,g);
}
} while(!feof(f));

printf("*************Affichage du fichier moyenne \n");

rewind(g);
fread(&s,sizeof(s),1,g);
while(!feof(g))
{printf(" %f\n",s);
fread(&s,sizeof(s),1,g);
}

//suppression des valeurs nulles du meme fichier g

rewind(g);n=0;
fread(&s,sizeof(s),1,g);
while(!feof(g))
{
if(s!=0){t[n]=s;n++;}
fread(&s,sizeof(s),1,g);
}
fclose(g);
g=fopen("resultat.dat","w+");// j'ecrase le contenu du fichier
for(i=0;i<n;i++)
{fwrite(&t[i],sizeof(t[i]),1,g);
printf("la val est %f\n",t[i]);
}
printf("*************Affichage du fichier moyenne apres suppression
des 0\n");
rewind(g);
fread(&s,sizeof(s),1,g);
while(!feof(g))
{printf(" %f\n",s);
fread(&s,sizeof(s),1,g);
}
fclose(g);fclose(f);
}
system("pause");
}

Fichier Texte :
#include <stdio.h>
#include <stdlib.h>

main()
{FILE *f, *g;
int i,n,v,nbr=0;
float s=0,t[100];
g=fopen("moyenne.txt","w+");
f=fopen("entier.txt","w+");
if((g==NULL) || (f==NULL))printf("Erreur de creation des fichiers");
else
{printf("Remplir f");
printf("Donner n");
scanf("%d",&n);
for(i=0;i<n;i++)
{ printf("Donner une valeur \n");
scanf("%d",&v);fprintf(f,"%d ",v);
}
rewind(f);

do
{fscanf(f,"%d",&v);
if(v!=0)
 {s=0;nbr=0;
while(!feof(f)&& v!=0)
{s=s+v;nbr++;fscanf(f,"%d",&v);}
s=s/nbr;
fprintf(g,"%f ",s);
}

}while(!feof(f));
printf("*************Affichage moyenne \n");

rewind(g);
fscanf(g,"%f",&s);
while(!feof(g))
{printf(" %f\n",s);
fscanf(g,"%f",&s);
}

//supp nul
rewind(g);n=0;
fscanf(g,"%f",&s);
while(!feof(g))
{
if(s!=0){t[n]=s;n++;}
fscanf(g,"%f",&s);
}
fclose(g);
g=fopen("resultat.txt","w+t");

for(i=0;i<n;i++){fprintf(g,"%f ",t[i]);printf("la val est

%f\n",t[i]);}
printf("*************Apres suppression \n");
rewind(g);
fscanf(g,"%f",&s);
while(!feof(g))
 {printf(" %f\n",s);
fscanf(g,"%f",&s);
}
fclose(g);fclose(f);
}
system("pause");
return 0;
}