introduction au langage c - netuniversity.ma
TRANSCRIPT
Apprendre à programmer avec le langage C
Être capable d’analyser des problèmes simples et écrire les
programmes correspondants
Maîtriser et Avoir plus de facilité à programmer en C
Un maximum d’exercices d’application
Objectif:
3
Plan:
RAPPELS
TYPES DE BASE, OPÉRATEURS ET EXPRESSIONS, LES ENTREES ET SOTIES DE C ET LES
INSTRUCTIONS DU CONTROLE
LES TABLEAUX ET LES CHAÎNES DE CARACTÈRES
LES POINTEURS
LES FONCTIONS
LES STRUCTURES
LES FICHIERS
CONCLUSION
4
Rappels:
Techniques du traitement automatique de l’information au moyen des ordinateurs
Eléments d’un système informatique
Langages (Java,C/C++, Fortran,etc.)
Système d’exploitation (DOS,Windows, Unix, etc.)
Matériel (PC, Macintosh, station SUN, etc.)
Applications (Word, Excel, Jeux, oracle,etc.)
Informatique?
Unité centrale (le boîtier) Processeur ou CPU (Central Processing Unit)
Mémoire centrale
Lecteur disquettes, lecteur CD-ROM
Cartes spécialisées (cartes réseau, son, ...)
Interfaces d'entrée-sortie (Ports série/parallèle, …)
Périphériques
Moniteur (l'écran), clavier, souris
Modem, imprimante, scanner, …
Matériel: Principaux éléments d’un PC
Ensemble de programmes qui gèrent le matériel et contrôlent les applications Gestion des périphériques (affichage à l'écran, lecture du
clavier, pilotage d’une imprimante, …)
Gestion des utilisateurs et de leurs données (comptes, partage des ressources, gestion des fichiers et répertoires, …)
Interface avec l’utilisateur (textuelle ou graphique): Interprétation des commandes
Contrôle des programmes (découpage en taches, partage du temps processeur, …)
Qu’est ce qu’un système d’exploitation?
Un langage informatique est un outil permettant de donner des ordres (instructions) à la machine
A chaque instruction correspond une action du processeur
Intérêt : écrire des programmes (suite consécutive
d’instructions) déstinés à effectuer une tache donnée Exemple: un programme de gestion de comptes bancaires
Contrainte: être compréhensible par la machine
Langages informatiques
Langage binaire: l’information est exprimée et manipulée sous forme d’une suite de bits
Un bit (binary digit) = 0 ou 1 (2 états électriques)
Une combinaison de 8 bits= 1 Octet possibilités qui permettent de coder tous les caractères alphabétiques, numériques, et symboles tels que ?,*,&, … Le code ASCII (American Standard Code for Information Interchange)
donne les correspondances entre les caractères alphanumériques et leurs représentation binaire, Ex. A= 01000001, ?=00111111
Les opérations logiques et arithmétiques de base (addition, multiplication, … ) sont effectuées en binaire
25628
Langage Machine
Problème: le langage machine est difficile à comprendre par l'humain
Idée: trouver un langage compréhensible par l'homme qui sera ensuite converti en langage machine
Assembleur (1er langage): exprimer les instructions élémentaires de façon symbolique
+: déjà plus accessible que le langage machine -: dépend du type de la machine (n’est pas portable) -: pas assez efficace pour développer des applications complexes
Apparition des langages évolués
ADD A, 4
LOAD B
MOV A, OUT
…
traducteur langage machine
L'assembleur
Intérêts multiples pour le haut niveau:
proche du langage humain «anglais» (compréhensible)
permet une plus grande portabilité (indépendant du matériel)
Manipulation de données et d’expressions complexes (réels, objets, a*b/c, …)
Nécessité d’un traducteur (compilateur/interpréteur),
exécution plus ou moins lente selon le traducteur
Code source
en langage évolué
Compilateur ou Langage
machine Interpréteur
Langages haut niveau
Compilateur: traduire le programme entier une fois pour toutes
+ plus rapide à l’exécution + sécurité du code source - il faut recompiler à chaque modification
Interpréteur: traduire au fur et à mesure les instructions du programme à chaque exécution
+ exécution instantanée appréciable pour les débutants - exécution lente par rapport à la compilation
exemple.c Compilateur
fichier source
exemple
fichier exécutable
exécution
exemple.bat
fichier source
Interprétation+exécution
Compilateur/interpréteur
Langages de programmation
Deux types de langages: Langages procéduraux Langages orientés objets
Exemples de langages: Fortran, Cobol, Pascal, C, … C++, Java, …
Choix d’un langage?
Spécification
Analyse
Traduction en langage
Compilation
Tests et modifications
Enoncé du problème
Cahier des charges
Algorithme
Programme source
Programme exécutable
Version finale et résultats
Etapes de réalisation d’un programme
Le terme algorithme vient du nom du mathématicien arabe Al-Khawarizmi (820 après J.C.)
Un algorithme est une description complète et détaillée des actions à effectuer et de leur séquencement pour arriver à un résultat donné
Intérêt: séparation analyse/codage (pas de préoccupation de syntaxe)
Qualités: exact (fournit le résultat souhaité), efficace (temps d’exécution, mémoire occupée), clair (compréhensible), général (traite le plus grand nombre de cas possibles), …
L’algorithmique désigne aussi la discipline qui étudie les algorithmes et leurs applications en Informatique
Une bonne connaissance de l’algorithmique permet d’écrire des algorithmes exacts et efficaces
Algorithmique
16
INTRODUCTION ET NOTIONS DE BASE :
17
Introduction au Langage C
Mon Premier Programme en C
#include <stdio.h>
void main()
{
printf("Bonjour!\n");
}
Inclusion de la bibliothèque contenant la fonction printf
Point d'entré du programme
première instruction
Début du programme
Fin du programme
18
Introduction au Langage C
C
fichier
Code
assembleur
Assembleur
Code
objet Linker
Code
executable
Compilateur C
Exemple: Devcpp www.bloodshed.net
www.codeblocks.org/
19
Introduction au Langage C
Définition d'une variable nom:
Unique pour chaque variable
Commence toujours par une lettre
Différenciation minuscule-majuscule
type: Conditionne le format de la variable en mémoire
Peut être soit un type standard ou un type utilisateur
valeur: Peut évoluer pendant l'exécution
initialisation grâce à l'opérateur d'affectation
20
Introduction au Langage C
Types de variable charcaractères int entiers short [int] entiers courts long [int] entiers longs float nombres décimaux double nombres décimaux de précision
supérieure long double nombres décimaux encore plus
précis unsigned int entier non signé
[..] signifie facultatif
21
Introduction au Langage C
Déclaration d'une variable Type nom_de_la_variable [= valeur]
Exemple: int nb;
float pi = 3.14;
char c = 'a';
long i,j,k;
double r = 6.2879821365;
22
Introduction au Langage C
Type
Bits
Min.
Max.
char
8
-128
127
signed char
8
-128
127
unsigned char
8
0
255
short
16
-32768
32767
unsigned short
16
0
65535
int
32
-2147483648
2147483647
unsigned
32
0
4294967295
long
32
-2147483648
2147483647
unsigned long
32
0
4294967295
float
32
1.17 E-38
3.4 E+38
double
64
2.22 E-308
1.7 E+308
long double
128
3.36 E-4932
1.1 E+4932
23
Introduction au Langage C
Affichage de la valeur d'une variable en C
printf("format de l'affichage", variables) Exemple
int i =8;int j = 10; printf("i vaut: %d j vaut: %d \n",i,j); float r = 6.28; printf("le rayon = %f \n",r);
Autres formats: %x entier en hexadécimal %c caractère %lf double %s chaîne de caractères %e réel en notation scientifique
24
Introduction au Langage C
Acquisition de la valeur d'une variable en C
scanf("format de l'affichage", adresses variables) Exemple
int i;int j; scanf("%d%d",&i,&j); float r; scanf("%f ",&r);
Autres formats: %x entier en hexadécimal %c caractère %lf double %s chaîne de caractères %e réel en notation scientifique
25
Introduction au Langage C
Ecrire un programme qui fait la connaissance de l’ordinateur
avec l’utilisateur pour une première utilisation
Exemple:
Ordinateur : bonjour mon utilisateur.
Utilisateur : bonjour mon ordinateur.
Ordinateur : comment tu t’appelles ?
Utilisateur : …
26
Introduction au Langage C
Solution
#include <stdio.h>
main()
{
char c[100];
printf(“Bonjour mon utilisateur \n");
scanf(“%S",c);
printf(“Comment t appelles tu ? \n");
scanf(“%S",c);
printf(“je suis content de vous connaitre \n");
scanf(“%S",c);
//…
return 0;
}
27
Introduction au Langage C
Instructions de base
opérateurs de base
+,-,*, / opérateurs arithmétique de base
% reste d'une division entière
== test d'égalité
!= test de différence
<, >, <=, >= test de comparaison
! négation
|| ou logique pour évaluer une expression
&& et logique pour évaluer une expression
28
Introduction au Langage C
Instructions de base opérateurs de base
a = 2+3 valeur de a: 5
r = 3%2 valeur de a: 1
a = (3==3) valeur de a: 1
a = (6==5) valeur de a: 0
a = (2!=3) valeur de a: 1
a = (6<=3) valeur de a: 0
a = !1 valeur de a: 0
a =((3==3) || (6<=3)) valeur de a: 1
a =((3==3) && (6<=3)) valeur de a: 0
29
Introduction au Langage C
Instructions de base instruction conditionnelle simple si alors
if (expression) {
instructions; }
expression est évaluée après chaque itération. Si le résultat est vrai alors les instructions sont exécutées sinon on sort de la boucle.
exemple int i =5; int n; if (i<=20) {
n =0; }
30
Introduction au Langage C
Instructions de base instruction conditionnelle simple si alors sinon
if (expression) { instructions1;} sinon { instrutions2; }
expression est évaluée après chaque itération. Si le résultat est vrai alors les instructions1 sont exécutées sinon on exécute l'ensemble instructions2
exemple int i =5;int n; if (i<=20) n =0; else n=5;
31
Introduction au Langage C Instructions de base
instruction conditionnelle multiple switch (expression) { case valeur1: instructions1;break; case valeur2: instructions2;break; . . . case valeur3: instruction3;break; default: instruction4;break; } expression est évaluée. Si le résultat vaut valeur1, alors
instruction1 est exécutée et on quitte le switch, sinon si expression vaut valeur2, ……, sinon on va dans default.
32
Introduction au Langage C
Instructions de base instruction conditionnelle multiple
exemple int c='a'; switch (c) { case 'a': file();break; case 'b': save();break; case 'q': quitter();break; default: beep();break; }
33
Introduction au Langage C
Instructions de base boucle tant que
while (expression) {
instructions; }
expression est évaluée avant chaque itération. Si le résultat est vrai alors les instructions sont exécutées sinon on sort de la boucle
exemple i =0; n = 20; while (i<n) {
i++; }
34
Introduction au Langage C
Instructions de base boucle répéter
do {
instructions; } while (expression);
expression est évaluée après chaque itération. Si le résultat est vrai alors les instructions sont exécutées sinon on sort de la boucle
exemple i =0; n = 20; do {
i++; } while(i<n);
35
Introduction au Langage C
Instructions de base boucle pour
for(expr1;expr2;expr3)
{
instructions
}
expr1: évaluée 1 seule fois en début de boucle
expr2: évaluée avant chaque itération. Si vrai alors les instructions de la boucle sont exécutées sinon la boucle est terminée
expr3: évaluée à la fin de chaque itération
36
Introduction au Langage C
Instructions de base boucle pour
exemple // somme des 100 premiers entiers
int i,s;
s= 0
for(i=0;i<=100;i = i+1)
{
s = s+i; / / ou s+=i;
}
printf("s = \n",s);
37
Introduction au Langage C
l'instruction break, continue, goto permet d'interrompre prématurément une
boucle et de se brancher vers la première instruction n'appartenant pas à la boucle
exemple: int i;int n=20;
for (i=0;i<100;i++)
{
if (n==31) break;
n=n+1;
}
printf("%d\n",n);
Quand n vaut 31 alors la boucle est
interrompue
38
Introduction au Langage C
l'instruction break,continue, goto permet d’aller à l’itération suivante
prématurément (sans exécuter les instruction qui viennent après elle)
exemple: int i;int n=20;
for (i=0;i<100;i++)
{
if (n==31) continue;
n=n+1;
}
printf("%d\n",n);
Quand n vaut 31 alors la boucle
passe à l’itération suivante
39
Introduction au Langage C
l'instruction break,continue, goto permet d’aller prématurément une boucle et
de se brancher vers la première instruction n'appartenant pas à la boucle
exemple: int i;int n=20;
for (i=0;i<100;i++)
{
if (n==31) goto etiq;
n=n+1;
}
etiq:
printf("%d\n",n);
Quand n vaut 31 alors
l’exécution saute vers etiq
/* exemple de programme C : -somme des nb de 1 à 10 et affichage de la valeur*/
#include <stdio.h> int main (void) { int n; int somme; int i; printf("donner un entier n :"); scanf("%d", &n); somme = 0; for (i = 1; i <= 10; i++) { somme = somme + i; } printf ("%d\n", somme); }
Fichier C (extension .c)
1
En C le programme principal s'appelle toujours main
1
déclarations de variables de type entier (cases mémoire pouvant contenir un entier)
2
2
3 Acquisition des données 3
4 Traitement 4
affiche à l'écran la valeur de l'entier contenu dans somme
5 5
0
41
Introduction au Langage C
Les tableaux statiques à 1 dimension définition
Ensemble de variables de même type, de même nom caractérisées par un index.
déclaration type nom_tableau[dimension]
exemples: char buffer[80];
int mat[10];
doit être une
constante
42
Introduction au Langage C
Les tableaux statiques à 1 dimension
accès aux éléments du tableau
Nom_tableau[indice]
exemples:
buffer[5] = 'c';
mat[6] = 10;
le premier élément commence à l'indice 0 !!
Les valeurs ne sont pas initialisées !!
Les débordements ne sont pas vérifiés
43
En général, les tableaux sont initialisés par l'indication de la liste des éléments du
tableau entre accolades:
char CHAINE[] = {'H','e','l','l','o','\0'};
Pour le cas spécial des tableaux de caractères, nous pouvons utiliser une initialisation
plus confortable en indiquant simplement une chaîne de caractère constante:
char CHAINE[] = "Hello";
Lors de l'initialisation par [], l'ordinateur réserve automatiquement le nombre d'octets
nécessaires pour la chaîne, c.-à-d.: le nombre de caractères + 1 (ici: 6 octets).
Initialisation de chaînes de caractères
44
Les fonctions de <string>
La bibliothèque <string> fournit une multitude de fonctions pratiques pour le traitement de
chaînes de caractères
strlen(s) fournit la longueur de la chaîne sans compter le '\0' final
strcpy(s, t) copie t vers s
strcat(s, t) ajoute t à la fin de s
strcmp(s, t) compare s et t lexicographiquement et fournit un résultat:
Négatif : si s précède t
zéro : si s est égal à t
Positif : si s suit t
strncpy(s, t, n) copie au plus n caractères de t vers s
strncat(s, t, n) ajoute au plus n caractères de t à la fin de s
45
Introduction au Langage C
Les tableaux statiques à 2 dimensions et plus
définition
Il s'agit d'un tableau de tableaux
déclaration
type nom_tableau[dim1][dim2]…[dimn]
exemples:
char buffer[20][80];
int mat[6][10];
char livres[100][60][80];
46
Introduction au Langage C
47
Introduction au Langage C
IleMaurice.pgm (800x529)
exemple:
int i,j;
int ima[800][529];
for (i=0;i<800;i++)
for (j=0;j<529;j++)
{
ima[i][j]=255-ima[i][j];
if(ima[i][j]>100)
ima[i][j]=0;
else
ima[i][j]=255;
}
48
Introduction au Langage C
Les tableaux statiques à 2 dimensions et plus
accès aux éléments
nom_tableau[ind1][ind2]…[indn]
exemples:
livre[30][15][20] = 'c';
mat[5][6] =13;
printf("%d\n",mat[5][6]);
49
Introduction au Langage C
Les Pointeurs
Deux manières d'utiliser une variable
Par son nom adressage direct
compilateur réserve de la mémoire pour la variable
exemple:
int x =17;
50
Introduction au Langage C Les Pointeurs
Par son adresse adressage indirect
une variable de type pointeur contient l'adresse d'une autre variable
Le lien entre pointeur et la variable pointée est géré par le programmeur
exemple:
int x =17;
int * px = &x;
px pointe vers x
51
Introduction au Langage C
Les Pointeurs
déclaration d'un pointeur
type * nom_du_pointeur
exemples
char *buffer;
int *pf;
float *ppi;
C'est au programmeur d'initialiser le pointeur
52
Introduction au Langage C initialisation d'un pointeur
Il faut lui fournir l'adresse d'une variable existant en mémoire
Il doit pointer vers une zone mémoire réservée par le compilateur comme étant une variable
utilisation de l'opérateur d'adressage & int f;
int *pf,*pg;
pf = &f;
pg =(int*)malloc(sizeof(int));
.
.
free(gf);
création du lien entre le
pointeur et la variable allocation
dynamique d'une variable
de type int
création du lien entre pg
et l'espace mémoire réservé
libération de l'espace réservé
53
Introduction au Langage C
Les Pointeurs utilisation de l'opérateur d'indirection *
travaille la valeur de la variable pointée
exemples
int i =8;
int *pi;
pi = &i;
printf("%d\n",*pi);
*pi = 19;
printf("%d\n",i);
8
19
54
Introduction au Langage C
Lien entre le nom d'un tableau à 1 dimension et les pointeurs
Nom du tableau = adresse du premier élément du tableau
nom_tableau[i] peut s'écrire *(nom_tableau+i)
exemples:
char buffer[80];
*buffer = 'C'; accès au premier caractère
*(buffer + 5) = 'V'; accès au 6 ème caractère
55
Introduction au Langage C
Lien entre le nom d'un tableau à 2 dimension et les pointeurs un tableau 2d est un tableau de tableau de
dimension 1 On peut donc dire que le nom d'un tableau 2d est
l'adresse d'un tableau d'adresse de tableaux de dimension 1
On dit aussi qu'il s'agit d'un pointeur de pointeur
exemple: int TAB[6][7];
int **p; déclaration d'un pointeur de pointeur
p = TAB; initialisation du pointeur de pointeur
56
Introduction au Langage C
Lien entre le nom d'un tableau à 2 dimension et les pointeurs
TAB
0
1
2
3
4
5
0 1 2 3 4 5 6
tableaux de pointeurs vers des tableaux
d'entiers
tableaux d'entiers
57
Introduction au Langage C
Initialisation dynamique d'un tableau
Tableau une dimension
int * t;
t = (int*)malloc(20*sizeof(int));
nom du
tableau
fonction de calcul
automatique de la
taille d'un entier en
octet fonction d'allocation dynamique
de la mémoire
nombre d'éléments dans le tableau
58
Introduction au Langage C
Initialisation dynamique d'un tableau
Tableau à deux dimensions n*m
déclaration dynamique du tableau de n pointeurs et des n tableaux à une dimension de m éléments
quelques lignes de code sont nécessaires (voir transparent suivant)
59
Introduction au Langage C
Initialisation dynamique d'un tableau Tableau à deux dimensions n*m
int **TAB,l; TAB = (int**)malloc(n*sizeof(int*)); for (l=0;l<n;l++) { TAB[l] = (int*)malloc(m*sizeof(int)); } désallocation: for (l=0;l<n;l++) free(TAB[l]); free(TAB);
#include <stdio.h> void main (void) // calcul de la moyenne d’un tableau { int N, somme, i, T[100]; printf("donner la taille du tableau N < 100 :"); scanf("%d", &N); printf("donner les elements du tableau d’entiers :");
for (i = 1; i <= N; i++) scanf("%d", &T[i]); for (i = 1; i <= N; i++) //affichage du tableau printf("%d ", T[i]);
somme = 0; for (i = 1; i <= N; i++) //calcul de la somme somme = somme + T[i]; printf ("\nla moyenne des elements du tableau est %d\n", somme/N); }
Fichier C (extension .c)
61
Introduction au Langage C
Les fonctions définition
Ensemble d'instructions pouvant être appelés de manière répétitive par un nom
déclaration type arg_ret nom_f( type arg1,type arg2, …type argn)
{
ensemble instructions
}
- arg_ret est l'argument renvoyé par la fonction (instruction return
- nom_f est le nom de la fonction
- arg1 …argn sont les arguments envoyés à la fonction
62
Introduction au Langage C
Les fonctions
règles d'utilisation
L'ordre, le type et le nombre des arguments doivent être respectés lors de l'appel de la fonction
L'appel d'une fonction doit être située après sa déclaration ou celle de son prototype (voir exemple transp suivant)
Si la fonction ne renvoie rien alors préciser le type void
63
Introduction au Langage C
Les fonctions exemple:
int min(int a, int b);
void main()
{ int a,b;
printf(‘‘le min est %d’’,min(a,b));
}
int min(int a, int b)
{ if (a <b) return a;
else return b;
}
Prototype de la fonction
min
Programme principal
Fonction min et son bloc d'instruction
s
64
Introduction au Langage C
Les fonctions
Les paramètres se passent par valeur
Recopie en mémoire des paramètres dans des paramètres temporaires.
Toute modification des paramètres dans la fonction est sans effet sur les paramètres originelles
Quand on quitte la fonction, les paramètres temporaires sont effacés de la mémoire
Recopie dans le sous programme appelant de la valeur du paramètre retourné par la fonction return.
65
Introduction au Langage C
Les fonctions exemple:
void permutter(int x, int y) { int temp; temp = a; a = b; b= temp; } void main() { int x=3;int y =5; permutter(x,y); printf("x=%d y=%d \n",x,y); }
x=3 y=5
Aucune action sur
les paramètres x et y
66
Introduction au Langage C
Les fonctions
Passage d'arguments par adresse
On passe non pas la valeur de la variable mais son adresse
Il est donc possible par les pointeurs de modifier le contenu de l'adresse, donc la variable originelle
Permet de modifier plusieurs arguments à la fois dans une fonction
Permet de passer des tableaux en argument
67
Introduction au Langage C
Les fonctions exemple:
void permutter(int *pa, int *pb) { int temp; temp = *pa; *pa = *pb; *pb= temp; } void main() { int x=3;int y =5; permutter(&x,&y); printf("x=%d y=%d \n",x,y); }
Action sur les paramètres
x et y
x=5 y=3
68
Introduction au Langage C
La fonction récursive exemple:
int fact(int n) { if(n==0) return 1; else return n*fact(n-1); } main() { printf("factoriel de 5 =%d \n",fact(5)); }
La fonction fact appelle
elle même
#include <stdio.h> int somme (int N) // calcul de la somme d’un tableau
{ int som, i, T[100]; printf("donner les elements du tableau d’entiers :"); for (i = 1; i <= N; i++) scanf("%d", &T[i]); som= 0; for (i = 1; i <= N; i++) //calcul de la somme som = som + T[i]; return som; } void main (void) // calcul de la moyenne d’un tableau
{ int N; printf("donner la taille du tableau N < 100 :"); scanf("%d", &N); printf ("\nla moyenne des elements du tableau est %d\n", somme(N)/N); }
Fichier C (extension .c)
70
Structure
Les structures de données Il est possible de créer des ensembles de variables regroupées
sous le même nom, on parle de variables agglomérées.
Exemple : struct individu { char nom[30]; char prenom[50]; int age;
}
Utilisation : struct individu etudiant, professeur; etudiant.nom = « einstein »; etudiant.prenom = « albert »; etudiant.age = 25;
71
intérêt
Rassembler des données hétérogènes caractérisant une entité pour en faire un type utilisateur.
exemple:
point dans l'espace 3 entiers
nœud d'un arbre binaire 2 adresses vers les fils, 3 entiers pour les données du nœud
noms et références des pièces mécaniques constituant une voiture 600 tableaux de caractères + 600 entiers pour la référence
Structure
Les structures de données
déclaration
struct nom_structure
{
type1 nomchamps1;
type2 nomchamps2; . . .
typeN nomchampsN;
};
Structure
Les structures de données
exemple et utilisation struct pt { int x; int y; int z; char nom; }; main() { struct pt p; }
Structure
Les structures de données
simplification de l'écriture struct pt { int x; int y; int z; char nom; }; typedef struct pt point; main() { point p; }
typedef struct pt
{
int x; int y; int z; char nom;
} point;
Notations équivalentes
Structure
Les structures de données
accès aux données
Deux cas de figure
On dispose du nom de la variable
Accès par: NomVariable.NomChamps
exemple
main()
{
point p1;
p1.x = 8; p1.y = 9; p1.z = 10;
printf(’’x=%d y=%d z=%d’’, p1.x,p1.y,p1.z);
}
Structure
Les structures de données accès aux données
Deux cas de figure On dispose de l'adresse de la variable (pointeur)
Accès par: NomPointeurVariable->NomChamps
exemple
main()
{
point *pp1, p1, P2[5];
pp1 = &p1;
pp1->x = 8; pp1->y = 9; pp1->z = 10;
printf(’’x=%d y=%d z=%d’’, pp1->x,pp1->y,pp1->z;
}
Structure
77
Comme sur un écran on peut réaliser des entrées et des sorties sur un fichier
Les fichiers sont soit:
binaires (un float sera stocké comme il est codé en mémoire , d'où gain de place mais incompatibilité entre logiciels) formaté ASCII (un float binaire sera transformé en décimal puis on écrira le caractère correspondant à chaque chiffre).
Fichiers
78
FILE *fic;
char nom_fic[20]=“c:\travail\smi\a5_7\info1\liste1.txt”;
// ouverture du fichier fic = fopen(nom_fic, "r"); // ouvrir en lecture if(fic == NULL){ printf("Impossible d'ouvrir le fichier %s\n", nom_fic); exit(1); } printf(".............. Ouverture du fichier %s\n", nom_fic);
Fichiers
Ouverture d'un fichier La fonction FILE *fopen(char *nomfic, char *mode) ouvre le fichier dont le nom est donné comme premier argument, selon le mode d'ouverture précisé (w = écriture, r = lecture, a = ajout en fin de fichier) et l'assigne à un flux, i.e. à une variable de type FILE *. Dans le programme ci-dessous, nom_fic est une chaîne de caractères qui contient le nom du fichier à ouvrir, et fic est une variable de type FILE *.
79
Fermeture d'un fichier La fonction int fclose(FILE *) ferme le fichier dont le nom est une variable de type FILE *. Dans le programme ci-dessous, nom_fic est une chaîne de caractères qui contient le nom du fichier ouvert, et fic est une variable de type FILE *.
// fermeture du fichier if(fclose(fic) == EOF){ printf("Probleme de fermeture du fichier %s", nom_fic); exit(1); } printf(".............. Fermeture du fichier %s\n", nom_fic);
Fichiers
80
Lecture des données d'un fichier Fgets La fonction char *fgets(char *chaine, int max, FILE *fichier) lit une chaîne de caractères sur le fluxfichier et la stocke dans la chaîne chaine. Elle lit au maximum max - 1 caractères, elle s'arrête dès qu'elle rencontre un caractère de passage à la ligne et place un \0 à la fin de la chaîne.
exemple Prenons un programme qui affiche le contenu d'un fichier et compte le nombre de lignes de ce fichier :
Fichiers
81
#include <stdio.h> #include <string.h> #include <stdlib.h> void verif_et_recup_arg(int nb, char *arguments[], int nb_souhaite, char *chaine) { if(nb != nb_souhaite){ printf("Usage : lignes nom_fichier\n"); exit(1); } strcpy(chaine, arguments[1]); } int main(int argc, char *argv[]) { FILE *fic; int nb_lignes; char ligne_lue[512]; char nom_fic[255]; verif_et_recup_arg(argc, argv, 2, nom_fic); // ouverture du fichier fic = fopen(nom_fic, "r"); // ouvrir en lecture if(fic == NULL){ printf("Impossible d'ouvrir le fichier %s\n", nom_fic); exit(1); } printf(".............. Ouverture du fichier %s\n", nom_fic); // compter et afficher les lignes du fichier nb_lignes = 0; while(fgets(ligne_lue, 512, fic) != NULL){ printf("\t%s", ligne_lue); nb_lignes++; } printf("le fichier %s comporte %d lignes\n", nom_fic, nb_lignes); // fermeture du fichier if(fclose(fic) == EOF) { printf("Probleme de fermeture du fichier %s", nom_fic); exit(1); } printf(".............. Fermeture du fichier %s\n", nom_fic); return 0; }
fgets
82
Lecture des données d'un fichier fscanf La fonction int fscanf(FILE *fichier, char *format, adr_var_1, adr_var_2, ...) prend comme premier argument le flux dans lequel elle doit lire et stocke les données lues selon le format défini par la chaîne format dans les variables adr_var_ passées par adresse.
exemple
Le programme ci-dessous utilise la fonction scanf pour stocker dans des variables les informations d'un fichier annuaire qui comporte sur chaque ligne un nom, un prénom, le numéro de téléphone et l'adresse mail d'une personne. NB : on suppose que le nom de la personne ne comporte pas d'espace.
Fichiers
83
#include <stdio.h> #include <string.h> #include <stdlib.h> void verif_et_recup_arg(int nb, char *arguments[], int nb_souhaite, char *chaine) { if(nb != nb_souhaite){ printf("Usage : annuaire nom_fichier\n"); exit(1); } strcpy(chaine, arguments[1]); } int main(int argc, char *argv[]) { FILE *fic; int nb_lignes, t1, t2, t3, t4, t5; char nom_fic[255], nom[255], prenom[255], mail[255]; verif_et_recup_arg(argc, argv, 2, nom_fic); fic = fopen(nom_fic, "r"); // ouvrir en lecture if(fic == NULL){ printf("Impossible d'ouvrir le fichier %s\n", nom_fic); exit(1); } printf(".............. Ouverture du fichier %s\n\n", nom_fic); // recuperer les donnees de l'annuaire nb_lignes = 0; while(fscanf(fic, "%s %s %d %d %d %d %d %s", nom, prenom,\ &t1, &t2, &t3, &t4, &t5, mail) != EOF){ printf("\tnom = %s\n \tprenom = %s\n \ttel = %.2d %.2d %.2d %.2d %.2d\n \tmail = %s\n\n",\ nom, prenom, t1, t2, t3, t4, t5, mail); nb_lignes++; } printf("le fichier %s comporte %d lignes\n", nom_fic, nb_lignes); if(fclose(fic) == EOF){ // fermeture du fichier printf("Probleme de fermeture du fichier %s", nom_fic); exit(1); } printf(".............. Fermeture du fichier %s\n", nom_fic); return 0; }
fscanf
84
Écriture de données dans un fichier fputs La fonction int fputs(char *chaine, FILE *fic) écrit la chaîne de caractères chaine sur le flux fic. Elle retourne le dernier caractère de la chaîne en cas de succès (EOF en cas d'erreur).
exemple Prenons un programme qui écrit dans un fichier résultat ligne par ligne :
Fichiers
85
#include <stdio.h> #include <string.h> #include <stdlib.h> int main(int argc, char *argv[]) { FILE *fic; int nb_lignes; char ligne_lue[512]; // ouverture du fichier fic = fopen("resultat.txt", "w"); // ouvrir en ecriture if(fic == NULL){ printf("Impossible d'ouvrir le fichier resultat.txt\n"); exit(1); } do{ fgets(ligne_lue, 512, stdin); fputs(ligne_lue, fic); } while(strcmp(ligne_lue, "FIN\n") != 0); // fermeture du fichier if(fclose(fic) == EOF) { printf("Probleme de fermeture du fichier resultat.txt\n"); exit(1); } printf("les donnees ont ete stockees dans resultat.txt\n"); return 0; }
fputs
86
Écriture de données dans un fichier
fprintf La fonction int fprintf(FILE *fic, char *format, var_1, var_2, ...) écrit les données var_ dans le flux fic en respectant le format spécifié par la chaîne format. Elle retourne le nombre de caractères écrits sur le flux.
exemple Le programme ci-dessous ajoute une entrée dans l'annuaire :
Fichiers
87
#include <stdio.h> #include <stdlib.h> #include <string.h> int main(int argc, char *argv[]) { FILE *fic; char nom_fic[255], nom[255], prenom[255], mail[255]; int t1, t2, t3, t4, t5; // stockage des donnees issues de la ligne de commandes if(argc != 10){ //10 car num. tel. = 5 blocs d'entiers printf("Usage : annuaire nom_fichier nom prenom tel mail\n"); exit(1); } strcpy(nom_fic, argv[1]); strcpy(nom, argv[2]); strcpy(prenom, argv[3]); strcpy(mail, argv[9]); t1 = atoi(argv[4]); t2 = atoi(argv[5]); t3 = atoi(argv[6]); t4 = atoi(argv[7]); t5 = atoi(argv[8]); // ouverture du fichier fic = fopen(argv[1], "a"); // ouvrir en ajout if(fic == NULL){ printf("Impossible d'ouvrir le fichier %s\n", nom_fic); exit(1); } // ajouter les donnees dans l'annuaire fprintf(fic, "\n%s %s %.2d %.2d %.2d %.2d %.2d %s", nom, prenom, t1, t2, t3, t4, t5, mail); // fermeture du fichier if(fclose(fic) == EOF){ printf("Probleme de fermeture du fichier %s", nom_fic); exit(1); } printf("Les informations ont ete stockees dans l'annuaire\n"); return 0; }
fprintf
88
FILE *fic;
char nom_fic[20]=“c:\travail\smi\a5_7\info1\liste1.txt”;
// ouverture du fichier fic = fopen(nom_fic, "rb"); // ouvrir en lecture if(fic == NULL){ printf("Impossible d'ouvrir le fichier %s\n", nom_fic); exit(1); } printf(".............. Ouverture du fichier %s\n", nom_fic);
Fichiers
Ouverture d'un fichier mode binaire La fonction FILE *fopen(char *nomfic, char *mode) ouvre le fichier dont le nom est donné comme premier argument, selon le mode d'ouverture précisé (wb = écriture, rb = lecture, ab = ajout en fin de fichier) et l'assigne à un flux, i.e. à une variable de type FILE *. Dans le programme ci-dessous, nom_fic est une chaîne de caractères qui contient le nom du fichier à ouvrir, et fic est une variable de type FILE *.
89
Écriture et lecture de données dans un fichier en mode binaire
Fread Syntaxe: fwrite(&n,taille d'un bloc,nombre de blocs,fichier_pt); ou fread(&n,taille d'un bloc,nombre de blocs,fichier_pt); fwrite et fread fournissent respectivement le nombre de blocs écrits ou lus. - n est la variable lue ou écrite - taille d'un bloc est la taille en octets de la variable sizeof(n). - nombre de blocs est le nombre de variables que l'on désire lire ou écrire - fichier_pt est le pointeur de flux
Fichiers
90
#include<stdio.h> main(void) { char nomfich[20]; int n; FILE *entree; printf("nom du fichier"); scanf("%20s",nomfich); entree=fopen(nomfich,"rb"); if(!entree){printf("erreur d ouverture"); exit();} do{ fread(&n,4,1,entree); if(!feof(entree))printf("\n%d",n); }while(!feof(entree)); fclose(entree); Return 0;}
fread
Détection de la fin d’un fichier
feof Syntaxe: feof(fichier_pt) Retourne une valeur non nulle (vraie) si une fin de fichier a été trouvée sinon zéro (faux)
91
Accès direct à un fichier En mode séquentiel ,après chaque opération, le pointeur du fichier est incrémenté du nombre d'octets transférés, on peut également accéder au fichier en n'importe quel point: accès direct. Fseek fseek(fichier_pt,taille*(num-1),par); - taille est le nombre d'octets de la variable - num numéro de la variable où on veut se placer. Exemple: 2*(num-1) pour des entiers courts. - par est un paramètre: 0 déplacement depuis le début du fichier 1 déplacement a partir de la position courante 2 déplacement à partir de la fin du fichier fteel(fichier_pt) ; /*position courante du pointeur en octets*/ Les instructions suivantes donnent la taille d'un fichier: fseek(fichier_pt,0,2); taille=fteel(fichier_pt);
Fichiers
92
Nous avons vu ici des fonctions de base du langage C permettant de
solutionner un grand nombre de problèmes et projets de programmation.
La maîtrise de ce langage (comme pour d’autre) nécessite de la curiosité
la volonté et passe par la multiplication des exercices et des problèmes
tels que ceux vus en séries de TD et d’autres que vous pouvez trouvez sur
Internet :
À titre d’exemple:
www.lamsade.dauphine.fr/~manouvri/C/PolyExoC_MM.pdf D’autre références pour cours et exercices:
http://c.developpez.com/ lien général et en particulier:
http://c.developpez.com/livres/le-c-20-heures/ …
Conclusion