2015 10 11 Cours-C

Programmation C
J.-F. Lalande
15 novembre 2012
Ce cours est mis disposition par Jean-Franois Lalande selon les termes de la licence
Creative Commons Attribution - Pas dUtilisation Commerciale - Partage lIdentique 3.0 non transpos.
Rsum
Ce cours tente de couvrir tous les aspects lis au dveloppement en langage C. Le cours dbute par ltude du
langage C en lui mme et se poursuit par ltude des aspects spcifiques des tableaux et pointeurs. Ensuite, lintro-
duction des structures combine la notion de pointeurs permet dtudier limplmentation de structures de donnes
complexes. Le cours termine par quelques lments priphriques (compilateur, ncurses, ...).
Livre de rfrence
Disponible la bibliothque :
Langage C, Claude DELANNOY, Eyrolles, 2005.
Table des matires

1 Introduction 3
1.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Premier principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Types et variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Oprateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Langage 14
2.1 Entres/Sorties de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Instructions de contrle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3 Les tableaux et pointeurs 24

3.1 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2 Les pointeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.3 Consquences sur les tableaux, fonctions, chaines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.4 Les chanes de caractres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.5 Lallocation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4 Notions avances du C 31
4.1 Structures dencapsulationes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3 Prprocessing et compilation spare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.4 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.5 Pointeurs de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
1
Programmation C TABLE DES MATIRES
5 Divers 47
5.1 gcc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2 Ncurses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.3 Oprations binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
5.4 Cest tout cass, ca marche pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
J.-F. Lalande 2/56 Ensi de Bourges

Programmation C
1 Introduction
1.1 Historique
Faits marquants
Quelques faits marquants :

Introduction Historique
cr en 1972 par Dennis Richie et Ken Thompson Faits marquants

but : dvelopper le systme dexploitation UNIX
particularit : li aucune architecture
Quelques faits marquants :
1973 Alan Snyder crit un compilateur C cr en 1972 par Dennis Richie et Ken Thompson
but : dvelopper le systme dexploitation UNIX
1989 : norme ANSI X3-159 particularit : li aucune architecture
1990 : norme ISO/IEC 9899 1973 Alan Snyder crit un compilateur C

1989 : norme ANSI X3-159
1990 : norme ISO/IEC 9899
Les anctres, extrait de [?]

J.-F. Lalande Programmation C 6/204
C a trois anctres : les langages CPL, BCPL et B.

CPL : 1960, conu par les universits de Cambridge : trop complexe, personne Les anctres, extrait de [7]
na pu crire de compilateur...
C a trois anctres : les langages CPL, BCPL et B.
BCPL : Basic CPL, crit par Martin Richards (Cambridge) : langage proche CPL : 1960, conu par les universits de Cambridge : trop
complexe, personne na pu crire de compilateur...
du mot machine BCPL : Basic CPL, crit par Martin Richards (Cambridge) :
langage proche du mot machine
B : Ken Thompson, 1970 Belle et AT&T : simplification du BCPL aprs avoir B : Ken Thompson, 1970 Belle et AT&T : simplification du BCPL
aprs avoir crit un UNIX en assembleur
crit un UNIX en assembleur C : dvelopp par Dennis Ritchie en 72 : une sorte de nouveau B
avec en plus les tableaux, les pointeurs, les nombres virgule
C : dvelopp par Dennis Ritchie en 72 : une sorte de nouveau B avec en plus flottante, les structures...
En 1973, C fut suffisamment au point pour que 90% de UNIX puisse
les tableaux, les pointeurs, les nombres virgule flottante, les structures... tre rcrit avec. En 1974, les laboratoires Bell ont accord des licences
UNIX aux universits et cest ainsi que C a commenc tre distribu.
En 1973, C fut suffisamment au point pour que 90% de UNIX puisse tre rcrit J.-F. Lalande Programmation C 7/204
avec. En 1974, les laboratoires Bell ont accord des licences UNIX aux universits
et cest ainsi que C a commenc tre distribu.
Historique, extrait de [?]
1978 - K&R C : La plus ancienne version de C encore en usage a t for-

malise en 1978 lorsque Brian Kernighan et Dennis Ritchie ont publi la pre- Historique, extrait de [7] I
mire dition du livre The C Programming Language. Ce livre dcrit ce quon
appelle actuellement le K&R C, C traditionnel, voire vieux C. Peu aprs sa 1978 - K&R C : La plus ancienne version de C encore en usage a
t formalise en 1978 lorsque Brian Kernighan et Dennis Ritchie
publication, de trs nombreux compilateurs C ont commenc apparatre. ont publi la premire dition du livre The C Programming
Language. Ce livre dcrit ce quon appelle actuellement le K&R C,
1983 - C++ : A partir de 1980, Bjarne Stroustrup a tendu C avec le concept C traditionnel, voire vieux C. Peu aprs sa publication, de trs
nombreux compilateurs C ont commenc apparatre.
1983 - C++ : A partir de 1980, Bjarne Stroustrup a tendu C avec
de classe. Ce langage tendu a dabord t appel C with Classes, puis C++ le concept de classe. Ce langage tendu a dabord t appel C
with Classes, puis C++ en 1983.
en 1983. 1983 - Objective C : Objective C a t cr par Brad Cox. Ce
langage est un strict sur-ensemble de C. Il lui apporte un support
1983 - Objective C : Objective C a t cr par Brad Cox. Ce langage est de la programmation oriente objet inspir de Smalltalk.
un strict sur-ensemble de C. Il lui apporte un support de la programmation J.-F. Lalande Programmation C 8/204
oriente objet inspir de Smalltalk.

1989 - ANSI C : Un comit de standardisation a t cr en 1983 pour viter
que les quelques ambiguts et insuffisances du K&R C ne conduisent des
divergences importantes entre les compilateurs. Il a publi en 1989 le standard
appel ANSI C.
1998 - Standard C++ : C++ a volu trs longtemps. Ce nest quen 1998, 8
ans aprs la cration dun comit, que le standard ISO C++ a t officiellement
publi. Ce standard est tellement complexe (et lgrement incohrent), quen
2003, le compilateur GCC ne le met pas compltement en oeuvre, et ce nest
pas le seul.
1999 - C99 : Le dernier n de lhistoire est C99 (standard ISO de 1999) qui
est une petite volution de lANSI C de 1989. Les volutions ne sont pas
compatibles avec C++ et nont pas attir beaucoup dintrt.

Programmation C 1.2 Premier principes
1.2 Premier principes
Premier programme
Un programme est produit partir dun fichier source dont un compilateur se

Introduction Premier principes
sert pour produire un fichier excutable : Premier programme

Le langage est compil (cc)
Un programme est produit partir dun fichier source dont un
Fichier source : texte compilateur se sert pour produire un fichier excutable :
Le langage est compil (cc)
Fichier de sortie : binaire Fichier source : texte
Fichier de sortie : binaire
Listing 1 Exemple de premier programme : Hello world !

Listing 1 Exemple de premier programme : Hello world ! #include <stdio.h>
int main(int argc, char argv)

#include <stdio.h> 1 {
printf("Hello world!\n");
2 return 0;
}
int main(int argc, char argv) 3
{ 4 J.-F. Lalande Programmation C 10/204
printf("Hello world!\n"); 5
return 0; 6
} 7
Premiers principes
Ce quil faut remarquer propos de ce premier programme :

Instructions dlimites par un ; Premiers principes

Parenthses et accolade (notion de paramtre et de bloc)
Directive include (pas de ; la fin !)
Ce quil faut remarquer propos de ce premier programme :
Dfinition dun programme spcificit du mot clef main Instructions dlimites par un ;
Retour du programme : return Parenthses et accolade (notion de paramtre et de bloc)

Directive include (pas de ; la fin !)
Dfinition dun programme spcificit du mot clef main
Utilisation de printf (fait partie de stdio) Retour du programme : return
Utilisation de printf (fait partie de stdio)
Lalphabet du C
Lalphabet du C est bas sur la langue anglaise laquelle on ajoute un cer-

tain nombre de symboles de ponctuation. Cela permet dviter un certain nombre Lalphabet du C
de problmes, notamment lors de la transmission de programmes (Telex !, e-mail,
etc...). Lalphabet du C est bas sur la langue anglaise laquelle on ajoute un
certain nombre de symboles de ponctuation. Cela permet dviter un
certain nombre de problmes, notamment lors de la transmission de
programmes (Telex !, e-mail, etc...).
Listing 2 Alphabet issu de [?] Listing 2 Alphabet issu de [3]
a b c d e f g h i j k l m n o p q r s t u v w x y z
a b c d e f g h i j k l m n o p q r s t u v w x y z 1 A B C D E F G H I J K
0 1 2 3 4 5 6 7 8 9
L M N O P Q R S T U VWX Y Z
A B C D E F G H I J K L M N O P Q R S T U VWX Y Z 2 ! " # % & ( ) + ,

: ; < = > ? [ \ ] ^ _
. /
{ | } ~
space , h o r i z o n t a l and v e r t i c a l tab
0 1 2 3 4 5 6 7 8 9 3 form feed , n e w l i n e
! " # % & ( ) + , . / 4
: ; < = > ? [ \ ] ^ _ { | } ~ 5 J.-F. Lalande Programmation C 12/204
space , h o r i z o n t a l and v e r t i c a l tab 6

form feed , n e w l i n e 7
Compilation
gcc options fichier1.c fichier2.c ...

Compilation en deux phases : Compilation

gnration des .o
gnration du programme gcc options fichier1.c fichier2.c ...
Compilation en deux phases :
gcc -c fichier.c gnration des .o
gnration du programme
gcc -o prog fichier.o gcc -c fichier.c

gcc -o prog fichier.o
ou en une seule fois :

gcc -o prog fichier.c

1.3 Types et variables Programmation C
ou en une seule fois :
gcc -o prog fichier.c
Compilation (2)
Attention, les espaces importent !

Compilation (2)
gcc -o prog fichier.o
Attention, les espaces importent !

Options courantes : norme ANSI (respecte ISO C), pedantic (rejet des extensions gcc -o prog fichier.o
non ISO C), Warnings activs Options courantes : norme ANSI (respecte ISO C), pedantic (rejet des
extensions non ISO C), Warnings activs
gcc -Wall -ansi -pedantic foo.c
gcc -Wall -ansi -pedantic foo.c Excution du fichier prog :
./prog
Excution du fichier prog :

./prog
Compilation
Les diffrentes phases de compilation sont :

Le traitement par le prprocesseur : le fichier source est analys par un Compilation

programme appel prprocesseur qui effectue des transformations purement
Les diffrentes phases de compilation sont :
textuelles (remplacement de chanes de caractres, inclusion dautres fichiers Le traitement par le prprocesseur : le fichier source est analys
source, etc.) par un programme appel prprocesseur qui effectue des
transformations purement textuelles (remplacement de chanes
de caractres, inclusion dautres fichiers source, etc.)
La compilation : le fichier engendr par le prprocesseur est traduit en assem- La compilation : le fichier engendr par le prprocesseur est
traduit en assembleur i.e. en une suite dinstructions associes
bleur i.e. en une suite dinstructions associes aux fonctionnalits du micro- aux fonctionnalits du microprocesseur (faire une addition, etc.)
Lassemblage : transforme le code assembleur en un fichier objet
processeur (faire une addition, etc.) i.e. en instructions comprhensibles par le processeur
Ldition de liens : assemblage des diffrents fichiers objets
Lassemblage : transforme le code assembleur en un fichier objet i.e. en in-
structions comprhensibles par le processeur J.-F. Lalande Programmation C 15/204
Ldition de liens : assemblage des diffrents fichiers objets
1.3 Types et variables

Variables : quest ce que cest ?
Cest la fois :
Introduction Types et variables
Un espace dans la mmoire ou de linformation est stocke Variables : quest ce que cest ?
Un identifiant (label) dans le code source pour manipuler cette donne
Cest la fois :
Un espace dans la mmoire ou de linformation est stocke
int a; 1 Un identifiant (label) dans le code source pour manipuler cette
int b = 0; 2 donne
char d, ma_variable; 3 int a;

int b = 0;
char d, ma_variable;
a = 12; 4 a = 12;
ma_variable = r;
ma_variable = r; 5 Dclaration :
type label;
type label = constante;
Dclaration : J.-F. Lalande Programmation C 16/204
type label;
type label = constante;
Identifiants de variables

Programmation C 1.3 Types et variables
Rgle sur les identifiants (labels) des variables : Identifiants de variables

Commencent par une lettre
Des caractres ASCII portables (pas de ...) Rgle sur les identifiants (labels) des variables :
Commencent par une lettre
Pas despace ! Des caractres ASCII portables (pas de ...)
Pas despace !
Le _ est le bienvenue... Le _ est le bienvenue...
Piti : un identifiant parlant ! !
Piti : un identifiant parlant ! ! int temperature;
int vitesse_de_l_objet=0;
char nom_de_l_objet, ma_taille, vitesse_initiale;
int temperature; 1 temperature = 12;
nom_de_l_objet = r;
int vitesse_de_l_objet=0; 2
char nom_de_l_objet, ma_taille, vitesse_initiale; 3 J.-F. Lalande Programmation C 17/204
temperature = 12; 4
nom_de_l_objet = r; 5
La gestion des espaces blancs et le format libre
Le compilateur sappuie sur les espaces blancs pour sparer les mots du langage,
des variables, sauf lorsquun sparateur (, ; { etc...) indique la dlimitation. Ainsi : La gestion des espaces blancs et le format libre
intx,y; // Impossible parser 1 Le compilateur sappuie sur les espaces blancs pour sparer les mots
du langage, des variables, sauf lorsquun sparateur (, ; { etc...)
int x,y; // ok 2 indique la dlimitation. Ainsi :
int x,y,z; // ok 3 intx,y; // Impossible parser
int x,y; // ok
int x, y, z; // ok 4 int x,y,z; // ok
int x, y, z; // ok
Chaque instruction du langage est dlimit par le point virgule. Le

programmeur est libre de ltaler sur plusieurs lignes.
Chaque instruction du langage est dlimit par le point virgule. Le programmeur int x
,
est libre de ltaler sur plusieurs lignes. int x

y; // ok
y; // Pas ok
int x 1 J.-F. Lalande Programmation C 18/204
, 2
y; // ok 3
int x 4
y; // Pas ok 5
Printf
Linstruction printf permet denvoyer des caractres sur la sortie standard.

Cela savre notamment trs utile pour jouer avec les variables... Printf
Permet dimprimer lcran
Linstruction printf permet denvoyer des caractres sur la sortie
Imprime du texte ou des code de format standard. Cela savre notamment trs utile pour jouer avec les
variables...
Texte : "Hello world ! \n" Permet dimprimer lcran
Imprime du texte ou des code de format
Code de format commencant par % Texte : "Hello world ! \n"
Code de format commencant par %
int x = 0; 1 int x = 0;
printf("Affichage de texte\n");
printf("Affichage de texte\n"); 2 printf("Affichage de %i\n", x);
Son prototype gnral dutilisation est donc :

printf("Affichage de %i\n", x); 3 printf(chaine de caracteres, variable1, variable2, ...);
Son prototype gnral dutilisation est donc :

printf(chaine de caracteres, variable1, variable2, ...); 1
Printf (2)
Code de formats autoriss dans la chane :

%i : integer, %d : double Printf (2)

%f : float, %10.5f : 10 chiffres avant la virgule, 5 aprs
%c : caractre Code de formats autoriss dans la chane :
%i : integer, %d : double
%f : float, %10.5f : 10 chiffres avant la virgule, 5 aprs
%c : caractre
J.-F. Lalande 6/56 Variables : Ensi de Bourges
Variables de type scalaire (integer, double, . . . )
Si mauvais code de format : catastrophe !
int x = 0; float u = 45.8;
printf("Affichage de %f et de %i catastrophique !\n", x, u);

Variables :
Variables de type scalaire (integer, double, . . . )
Si mauvais code de format : catastrophe !
int x = 0; float u = 45.8; 1
printf("Affichage de %f et de %i catastrophique !\n", x, u); 2
Les entiers
Les entiers :
Entier court sign : short, short int, signed short, signed
Les entiers
short int : -32 767 32 767
Entier sign : int, signed int Les entiers :
Entier court sign : short, short int, signed short,
Entier long sign : long, long int, signed long : 0 4 294 967 295 signed short int : -32 767 32 767
Entier sign : int, signed int
Toutes combinaison de (un)signed~(short)~type Entier long sign : long, long int, signed long : 0 4 294
967 295
Exemples : Toutes combinaison de (un)signed~(short)~type
Exemples :
int a; int b=3;
int a; int b=3; 1 unsigned long int u;
signed short int w = 2;
unsigned long int u; 2
signed short int w = 2; 3 J.-F. Lalande Programmation C 21/204
Les flottants
Le type flottant (rels) :

Notation mantisse/exposant : 0.453 E 15 Les flottants

i.e. s.m.be : signe, mantisse, base, exposant
Reprsentation
P approche des flottants car : Le type flottant (rels) :
Notation mantisse/exposant : 0.453 E 15
m = k=1 fk bk i.e. s.m.be : signe, mantisse, base, exposant
Reprsentation approche des flottants car :
float, double ; long double P
m = k =1 fk bk
float, double ; long double
Exemples : Exemples :
float x = 0.1;
float x = 0.1; 1 double y = .38;
double z = 4.25E4;
double y = .38; 2
double z = 4.25E4; 3 J.-F. Lalande Programmation C 22/204
Les flottants (2)
Consquence de cette approximation :

#include <stdio.h> 1 Les flottants (2)
int main() { 2
float x = 0.1; 3 Consquence de cette approximation :
#include <stdio.h>
printf("x avec 1 decimale: %.1e\n", x); 4 int main() {
float x = 0.1;
printf("x avec 1 decimale: %.10e\n", x); 5 printf("x avec 1 decimale: %.1e\n", x);
printf("x avec 1 decimale: %.10e\n", x);
return 0; 6 }
return 0;
} 7 ce qui donne :
jf@lalande:cours/prog> ./prog
x avec 1 decimale: 1.0e-01
ce qui donne :
jf@lalande:cours/prog> ./prog

Comparaisons difficiles !

Non respect des rgles de lalgbre : Comparaisons difficiles !
float x = 0.1; 1
Non respect des rgles de lalgbre :
float y = 0.2; 2 float x = 0.1;
3x == 0.3 // Vrai ou faux ! 3 float y = 0.2;
3x == 0.3 // Vrai ou faux !
x + y == 0.2 // Vrai ou faux ! 4 x + y == 0.2 // Vrai ou faux !
On prfrera (avec eps tq eps + 1 == eps) :

float x = 0.1;
float y = 0.2;
On prfrera (avec eps tq eps + 1 == eps) : float eps = 0.000001;

|3x 0.3| <= eps; // Vrai
|x + y 0.2| <= eps // Vrai
float x = 0.1; 1
float y = 0.2; 2 J.-F. Lalande Programmation C 24/204
float eps = 0.000001; 3

|3x 0.3| <= eps; // Vrai 4
|x + y 0.2| <= eps // Vrai 5
Les constantes
Ecriture des constantes :

octale : commence par 0 : 014 (vaut 12) Les constantes

hexa : commence par 0x : 0xa9b
rels : 0.56, 1.4e10 Ecriture des constantes :
octale : commence par 0 : 014 (vaut 12)
Constantes : hexa : commence par 0x : 0xa9b
rels : 0.56, 1.4e10
constante entire : 10 ; Constantes :
constante entire : 10 ;
constante flottante : 121.34 ; constante flottante : 121.34 ;
caractre simple : a ; caractre simple : a ;

chane de caractres : "message".
chane de caractres : "message".
Exercice 1 (tir de [?]) Dfinir les variables : J.-F. Lalande Programmation C 25/204
i entier
f flottant
l long
c caractre
tc tableau de caractres.
en les initialisant de la manire suivante :
i la valeur hexadcimale 50 ;
f 3.14 ;
l la valeur octale 40 ;
c z;
tc qwertyuiop.
Taille des types
Taille des types [?] :

sizeof(short)< sizeof(int)< sizeof(long)
Taille des types

sizeof(float)< sizeof(double)< sizeof(long double)
Taille des types [2] :
Type PDP 11 Intel 486 Sparc Pentium Alpha sizeof(short)< sizeof(int)< sizeof(long)
sizeof(float)< sizeof(double)< sizeof(long
Anne 1970 1989 1993 1993 1994 double)
Type PDP 11 Intel 486 Sparc Pentium Alpha
char 8 bits 8bits 8bits 8bits 8bits Anne 1970 1989 1993 1993 1994
char 8 bits 8bits 8bits 8bits 8bits
short 16 bits 16 bits 16 bits 16 bits 16 bits short 16 bits 16 bits 16 bits 16 bits 16 bits
int 16 bits 16 bits 32 bits 32 bits 32 bits
int 16 bits 16 bits 32 bits 32 bits 32 bits long
float
32 bits
32 bits
32 bits
32 bits
32 bits 32 bits
32 bits 32 bits
64 bits
32 bits
long 32 bits 32 bits 32 bits 32 bits 64 bits double
long
64 bits
double 64 bits
64 bits
64 bits
64 bits 64 bits 64 bits
64 bits 64 bits 128 bits
float 32 bits 32 bits 32 bits 32 bits 32 bits J.-F. Lalande Programmation C 26/204
double 64 bits 64 bits 64 bits 64 bits 64 bits

long double 64 bits 64 bits 64 bits 64 bits 128 bits
Exercice 2 A laide dun printf et de loprateur sizeof, imprimez les tailles des diffrents types de base ci-dessus.

Les caractres
Un caractre (char) est cod sur un domaine numrique de 256. (sign, de -127
127, non sign de 0 255). Il y a donc peu de caractres disponibles, ce qui explique Les caractres
pourquoi les caractre nationaux peuvent ne pas tre reprsents suivant le systme
Un caractre (char) est cod sur un domaine numrique de 256.
o lon compile : (sign, de -127 127, non sign de 0 255). Il y a donc peu de
caractres disponibles, ce qui explique pourquoi les caractre
nationaux peuvent ne pas tre reprsents suivant le systme o lon
compile :
#include <stdio.h> jf@radotte:$ gcc -o prog

#include <stdio.h> 1 int main() { caractere.c
char c1 = a; warning: multi-character character
int main() { 2 printf("%c\n", c1); constant
char c1 = a; 3 jf@radotte:$ gcc -o prog caractere.c char c2 = ;

printf("%c\n", c2);
warning: overflow in implicit
constant conversion
warning: multi-character character constant

jf@radotte:~$ ./prog
printf("%c\n", c1); 4 return 0; a
} ?
5 warning: overflow in implicit constant conversion
char c2 = ;
6 jf@radotte:~$ ./prog
printf("%c\n", c2); 7
a
8
return 0; 9 ?
} 10
Les caractres chapps
Certains caractres non imprimables peuvent tre reprsents par une convention
laide de lanti-slash. Les caractres chapps

\n : saut de ligne
Certains caractres non imprimables peuvent tre reprsents par une
\t : tabulation convention laide de lanti-slash.
\ : apostrophe \n : saut de ligne

\t : tabulation
\" : guillemet \ : apostrophe

\" : guillemet
\? : point dinterrogation \? : point dinterrogation
Utiliser lanti-slash pour prfixer le caractre sappelle utiliser une
Utiliser lanti-slash pour prfixer le caractre sappelle utiliser une squence squence dchappement. Lanti-slash peut-tre imprim en
chappant lanti-slash (\\).
dchappement. Lanti-slash peut-tre imprim en chappant lanti-slash (\\). Attention ne pas confondre le slash / qui na pas besoin dtre
chapp, et lanti-slash \.
Attention ne pas confondre le slash / qui na pas besoin dtre chapp, et J.-F. Lalande Programmation C 28/204
lanti-slash \.
Vie et porte des variables
Lors de la dclaration de la variable :

1. dfinition du domaine de valeur Vie et porte des variables
2. rservation de lespace mmoire Lors de la dclaration de la variable :

1 dfinition du domaine de valeur
3. initialisation de la variable 2 rservation de lespace mmoire
3 initialisation de la variable
association dune dure de vie
4. association dune dure de vie 4
#include <stdio.h>
int main(void) {
int choix = 4;
#include <stdio.h> 1 printf("Choix numro %i \n", choix);
return 0; // destruction de choix
2 }
int main(void) { 3
int choix = 4; 4 J.-F. Lalande Programmation C 29/204
printf("Choix numro %i \n", choix); 5

return 0; // destruction de choix 6
} 7
Porte temporelle
Une variable nexiste qu partir dun instant donn (sa dclaration) et jusqu
un instant donn de la vie du programme (par exemple, la fin du programme). Porte temporelle
Contre exemple :
Une variable nexiste qu partir dun instant donn (sa dclaration) et
jusqu un instant donn de la vie du programme (par exemple, la fin
du programme).
J.-F. Lalande 9/56 Contre exemple : Ensi de Bourges

#include <stdio.h>
int main(void)
{
printf("Choix numro %i \n", choix); // Impossible !
int choix = 4;
return 0;
}

#include <stdio.h> 1
2
int main(void) 3
{ 4
printf("Choix numro %i \n", choix); // Impossible ! 5
int choix = 4; 6
return 0; 7
} 8
Porte spatiale
Une variable nexiste que dans la porte spatiale courante et dans les "sous
portes spatiales" incluses. Porte spatiale
Une variable nexiste que dans la porte spatiale courante et dans les
"sous portes spatiales" incluses.
#include <stdio.h>
int main(void)
{
int a = 8;
{
int choix = 4;
printf("Choix numro %i et %i \n", choix, a); // Possible !
} // destruction de a
printf("Choix numro %i et %i \n", choix, a); // Impossible !
return 0;
}
#include <stdio.h> 1 J.-F. Lalande Programmation C 31/204
2
int main(void) 3
{ 4
int a = 8; 5
{ 6
int choix = 4; 7
printf("Choix numro %i et %i \n", choix, a); // Possible ! 8
} // destruction de a 9
printf("Choix numro %i et %i \n", choix, a); // Impossible ! 10
return 0; 11
} 12
Exercice 3 A tester soi-mme chez soi. Quel affichage ce programme produit-il ?
Affectation
Laffectation dune variable permet de raliser le stockage dune valeur dans

une case mmoire un instant donn du programme (au moment de lexcution de Affectation
laffectation).
Laffectation dune variable permet de raliser le stockage dune valeur
dans une case mmoire un instant donn du programme (au
moment de lexcution de laffectation).
a = 45;
Modification de la valeur stocke dans a
Il ne sagit pas dune assertion mathmatique 45 = a;
Linstruction est :
Temporelle (se produit linstant de lexcution)
Temporaire (peut-tre chang plus tard)
a = b = 12; est possible
a = 45;

Modification de la valeur stocke dans a
Il ne sagit pas dune assertion mathmatique 45 = a;
Linstruction est :
Temporelle (se produit linstant de lexcution)
Temporaire (peut-tre chang plus tard)
a = b = 12; est possible
Conversion implicite

1.4 Oprateurs Programmation C
Une conversion implicite a lieu lorsque le programme doit appliquer une opra- Conversion implicite
tion sur deux oprandes de types diffrents.
Une conversion implicite a lieu lorsque le programme doit appliquer
une opration sur deux oprandes de types diffrents.
Exemple de conversion :
#include <stdio.h>
int a; double b; long c;

b = a c;
Rgle :
Exemple de conversion : 1 Convertir les lments de la partie droite de laffectation dans le
type le plus riche.
2 Faire les calculs
#include <stdio.h> 1 3 Convertir dans le type de la variable de gauche
2 J.-F. Lalande Programmation C 33/204
int a; double b; long c; 3

b = a c; 4
Rgle :
1. Convertir les lments de la partie droite de laffectation dans le type le plus
riche.
2. Faire les calculs
3. Convertir dans le type de la variable de gauche
Exercice 4 Testez la conversion implicite dun float en int.
Conversion explicite : le cast
Il est plus prudent de toujours "caster" ses variables. On exprime alors explicite-
ment les conversions ncessaires laide loprateur "()" : Conversion explicite : le cast
On prcise explicitement les variables/expressions convertir
Il est plus prudent de toujours "caster" ses variables. On exprime alors
On vite les erreurs de calcul explicitement les conversions ncessaires laide loprateur "()" :
On prcise explicitement les variables/expressions convertir
Notation : On vite les erreurs de calcul
(type)variable Notation :
(type)variable
(type)(variable ou expression) (type)(variable ou expression)

Exemple de cast :
Exemple de cast : #include <stdio.h>
int a; double b; long c;

b = (int)(a (int)c);
int a; double b; long c; 3

b = (int)(a (int)c); 4
Exercice 5 Expliquer comment se comporte ce calcul.
Dclaration et dfinition
Attention ne pas confondre :

Dfinir : dclarer et initialiser la variables Dclaration et dfinition

Dclarer : rserver de lespace mmoire
Une variable dclare nest PAS initialise ! Attention ne pas confondre :
Dfinir : dclarer et initialiser la variables
Dclarer : rserver de lespace mmoire
Une variable dclare nest PAS initialise !
#include <stdio.h> 1 jf@linotte:~/swap> gcc -o truc truc.c #include <stdio.h> jf@linotte:~/swap> gcc -o truc
int main(void) { 2 jf@linotte:~/swap> ./truc
int main(void) {
int a;
truc.c
jf@linotte:~/swap> ./truc
int a; 3 printf("%i",a); -1208587072%
-1208587072% return 0; }
printf("%i",a); 4
return 0; } 5
1.4 Oprateurs
Oprateurs

Programmation C 1.4 Oprateurs
Introduction Oprateurs
Oprateurs dfinis : Oprateurs

arithmtiques : + - * / %
Oprateurs dfinis :
unaires arithmtiques : + - * / %
unaires
binaires binaires
relationnels : > >= < <= ==
relationnels : > >= < <= == logiques boolens : && || !
logiques boolens : && || ! daffectation : =

daffectation compose : += -= /= *= %=
daffectation : = dincrmentation : ++ --
conditionnel ternaire : foo = x >= 0 ? x : -x;
daffectation compose : += -= /= *= %= de conversion de type
dincrmentation : ++ -- J.-F. Lalande Programmation C 36/204
conditionnel ternaire : foo = x >= 0 ? x : -x;

de conversion de type
Exercice 6 Pourquoi x *= y + 1 nest pas quivalent x = x * y + 1 ?
Exercice 7 crire la ligne qui permet daffecter 45 dans a et de stocker dans b le rsultat de cette affectation.
Exercice 8 crire le programme qui : affecte 45 dans a et dans b, lincrmente, puis compare a et b en enregistrant le
rsultat dans c.
Exercice 9 crire le programme qui initialise a et b, enregistre dans q le quotient de la division entire et dans r le
reste.
Exercice 10 crire en C le test "a est plus grand que b ou c est gal d et d est infrieur e". Le placement de
parenthse peut il influencer le sens de cette proposition logique ?
Exercice 11 crire le programme qui permet denregistrer dans res le fait que a est plus grand que b, puis laide
dune condition ternaire de stocker x la valeur -1 si a est infrieur a b, sinon 12. Peut-on encore compresser ce pro-
gramme crit en deux tapes ?
Exercice 12 crire un programme qui permet de convertir un double en entier. Stocker dans non_arrondie la
valeur VRAIE si cette variable na pas t arrondie.
Effet de bord
Loprateur daffectation produit un effet de bord :

heureusement, sinon pas de programmation possible... Effet de bord

pas deffet de bord avec ==
retourne aussi la valeur affecte Loprateur daffectation produit un effet de bord :
heureusement, sinon pas de programmation possible...
bar = foo = 2; 1 pas deffet de bord avec ==

retourne aussi la valeur affecte
bar = foo = 2;
Position temporelle de leffet de bord :

Position temporelle de leffet de bord : foo = ++bar : effet de bord, affectation
foo = ++bar : effet de bord, affectation foo = bar++ : affectation, effet de bord
foo = bar++ : affectation, effet de bord J.-F. Lalande Programmation C 37/204
Exercice 13 Vrifiez dans un programme test linfluence de la position de loprateur ++ sur le nom de lidentifiant.
Exercice 14 Quand linstruction conditionnelle if aura t vue, crivez un test qui vrifie lgalit entre une variable
et une valeur. Insrez dans ce test un ++ et vrifiez linfluence de sa place. Que pensez-vous de cela ?
Constantes boolennes
Le VRAI et FAUX en C :
pas de type boolen mais int Constantes boolennes

faux : 0
vrai : 1 (ou mme k si k 6= 0) Le VRAI et FAUX en C :
Do la fameuse erreur : if (a = 10) pas de type boolen mais int

faux : 0
vrai : 1 (ou mme k si k 6= 0)
Laffectation renvoie le chiffre affect Do la fameuse erreur : if (a = 10)
Cette valeur est donc "vrai" Laffectation renvoie le chiffre affect
Cette valeur est donc "vrai"
i.e. if (1) i.e. if (1)
Exercice 15 Promettez doffrir un caf votre voisin chaque fois o vous ferez cette erreur.

1.4 Oprateurs Programmation C
Oprateurs logiques OU et ET
En C, le OU et ET logique svaluent ainsi :

expr1 && expr2 Oprateurs logiques OU et ET

expr1 est value
Si expr1 est fausse, alors retourner FAUX En C, le OU et ET logique svaluent ainsi :
Si expr1 est vraie alors expr2 est value expr && expr 1 2
expr1 est value
Si expr2 est fausse, alors retourner FAUX sinon retourner VRAI Si expr1 est fausse, alors retourner FAUX
Si expr1 est vraie alors expr2 est value
Si expr2 est fausse, alors retourner FAUX sinon retourner VRAI
expr1 || expr2 expr || expr 1 2
Si expr1 est VRAI, alors retourner VRAI
Si expr1 est VRAI, alors retourner VRAI Si expr2 est VRAI, alors retourner VRAI
Retourner FAUX
Si expr2 est VRAI, alors retourner VRAI

Retourner FAUX J.-F. Lalande Programmation C 39/204
Exercice 16 Lorsque vous aurez vu en algorithmique les structures conditionnelles et itratives, crire en pseudo-
langage algorithmique les algorithmes qui permettent dvaluer :
expr1 && expr2 && . . . && exprn
expr1 || expr2 || . . . || exprn

Programmation C
2 Langage
2.1 Entres/Sorties de base
printf, scanf
Syntaxe de printf :
printf(format, liste_expressions)
Langage Entres/Sorties de base
printf, scanf
format : chaine de caractres entr " "
liste_expresions : variables utiliser Syntaxe de printf :
printf(format, liste_expressions)
Exemple : format : chaine de caractres entr " "
liste_expresions : variables utiliser
Exemple :
printf("energie : %f\n", e) 1 printf("energie : %f\n", e)
printf("%s%f\n", "energie : ", e) 2 printf("%s%f\n", "energie : ", e)
Renvoie :
Le nombre de caractres crits
Une valeur ngative en cas derreur
Renvoie :
Le nombre de caractres crits J.-F. Lalande Programmation C 41/204
Une valeur ngative en cas derreur

Exercice 17 A laide de deux variables entires a=1 et b=12, affichez "a=1 et b=12".
Format du scanf
%d entier dcimal
%f flottant
Langage Entres/Sorties de base
Format du scanf
%f double
%c caractre (1 seul) %d entier dcimal
%s chane de caractres %f flottant
%f double
Lire au clavier : %c caractre (1 seul)
%s chane de caractres
scanf("%d",&i); 1 Lire au clavier :

scanf("%d",&i);
Caractre & : expliqu plus tard... (pointeurs)
Caractre & : expliqu plus tard... (pointeurs)

Exercice 18 Demandez lutilisateur de rentrer les valeurs a et b de lexercice prcdent au clavier, avant de les
afficher.
2.2 Instructions de contrle

Conditionnelle
Conditionnelle par bloc :

Langage Instructions de contrle
if (condition) 1 Conditionnelle
{ 2
// Instructions si condition vraie 3 Conditionnelle par bloc :
if (condition)
} 4 {
// Instructions si condition vraie
else // Optionnel 5 }
else // Optionnel
{ 6 {
// Instructions si condition fausse
}
// Instructions si condition fausse 7
Conditionnelle rapide :
} 8 if (condition)
// 1 seule instruction
Conditionnelle rapide : J.-F. Lalande Programmation C 43/204
if (condition) 1
// 1 seule instruction 2
Exemples :

2.2 Instructions de contrle Programmation C
Exemples : Exemples :
if (a == 5) 1
b = 12; 2 Exemples :
if (a > 5) 3 if (a == 5)
b = 12;
b = 13; 4 if (a > 5)
b = 13;
if (a > 5 || a < 0) 5 if (a > 5 || a < 0)
{
printf("condition runnie !");
{ 6 c = 12;
printf("condition runnie !"); 7 }
c = 12; 8
} 9 J.-F. Lalande Programmation C 44/204
Exercice 19 crire un programme qui permet de dterminer si un nombre entre 1 et 10 est pair, puis sil est premier
( laide de tests).
Exercice 20 crire un programme qui permet dafficher lcran, dans lordre, trois entiers a, b et c.
Imbrications de conditionnelles
Limbrication de conditionnellles "rapides" peut tre dangereux :

if(expression) 1 Imbrications de conditionnelles
if(expression) 2
statement; 3 Limbrication de conditionnellles "rapides" peut tre dangereux :
if(expression)
if(expression)
statement;
En C, lintroduction dun else fait rfrence au dernier if rapide

mentionn :
if(expression)
if(expression)
statement
else
statement
En C, lintroduction dun else fait rfrence au dernier if rapide mentionn :

if(expression) 1
if(expression) 2
statement 3
else 4
statement 5
Branchement
Branchement selon la valeur dune variable :

switch (variable) { 1 Branchement
case value1 : 2
inst 10; 3 Branchement selon la valeur dune variable :
switch (variable) {
inst 12; 4 case value1 :
inst 10;
break; 5 inst 12;
break;
case value2 : 6 case value2 :
inst 20;
inst 20; 7 inst 21;

break;
inst 21; 8 default:

inst d1;
inst d2;
break; 9 break; }
default: 10
inst d1; 11 J.-F. Lalande Programmation C 46/204
inst d2; 12
break; } 13
Exercice 21 crire un programme qui imprime le type de lettre (voyelle ou consonne) entre au clavier.
Itrations : POUR

Programmation C 2.2 Instructions de contrle
POUR X de Y Z FAIRE Itrations : POUR

FIN POUR
Syntaxe du for par bloc : POUR X de Y Z FAIRE
FIN POUR
for (initialisation ; condition de continuation ; instruction de boucle) 1 Syntaxe du for par bloc :
for (initialisation ; condition de continuation ; instruction de boucle)
{ 2 {
// Instructions
}
// Instructions 3
for rapide :
} 4
for (initialisation ; condition de continuation ; instruction de boucle)
// 1 seule instruction
for rapide : J.-F. Lalande Programmation C 47/204
for (initialisation ; condition de continuation ; instruction de boucle) 1

Exemples :
int i,j,k; 1 Langage Instructions de contrle
2 Exemples :
// Boucle itrative de 1 15 3
for (i = 0; i <= 15; i++} 4
int i,j,k;
{ 5
// Boucle itrative de 1 15
printf("Ligne %i !", i); 6 for (i = 0; i <= 15; i++}
{
} 7 }
printf("Ligne %i !", i);
8 // Boucle itrative partant de 6

// et dcrmentant de 2
// Boucle itrative partant de 6 9 for (j = 6; j > 20; j = j 2)
i = i + j;
// et dcrmentant de 2 10
for (j = 6; j > 20; j = j 2) 11
i = i + j; 12 J.-F. Lalande Programmation C 48/204
Exemples (2) :
int i,j,k; 1 Langage Instructions de contrle
2 Exemples (2) :
i = 1; 3
for ( ; i <= 15; i++} 4
printf("Ligne %i !", i); 5 int i,j,k;
i = 1;
6 for ( ; i <= 15; i++}
printf("Ligne %i !", i);
for (j = 6; j > 20; ) 7
for (j = 6; j > 20; )
printf("Ligne %i !", j); 8 printf("Ligne %i !", j);
9 for (i = 6, j = 2, k = 3; j > 20 && k < 30 ; k++, j = j+1)

printf("Ligne %i !", j);
for (i = 6, j = 2, k = 3; j > 20 && k < 30 ; k++, j = j+1) 10

printf("Ligne %i !", j); 11
Exemples (3) :
Le for suivant est dangereux :

Exemples (3) :
float x; int i; 1
// Dangereux ! 2
for (x=0; x<1.0; x+=0.1) 3 Le for suivant est dangereux :
printf("x=%i", x); 4 float x; int i;

// Dangereux !
for (x=0; x<1.0; x+=0.1)
printf("x=%i", x);
Construction non portable :

Construction non portable : 11 tours de boucle (x < 1)
10 tours de boucle (x > 1)
11 tours de boucle (x < 1) for (i=0, x=0; i<10; i++, x+=0.1)
printf("x=%i", x);
10 tours de boucle (x > 1)

for (i=0, x=0; i<10; i++, x+=0.1) 1

printf("x=%i", x); 2
Exercice 22 Parcourez tous les nombres pairs et affichez les multiples de 3.
Itrations : TANT QUE
TANT QUE ... FAIRE

FIN TANT QUE Itrations : TANT QUE

Syntaxe du while par bloc :
TANT QUE ... FAIRE
while (condition) 1 FIN TANT QUE
{ 2 Syntaxe du while par bloc :
while (condition)
// Instructions 3 {
// Instructions
} 4 }
while rapide :
while (condition)
while rapide : // 1 seule instruction
while (condition) 1 J.-F. Lalande Programmation C 51/204
Exercice 23 Affichez la suite Un = Un2 + 2Un1 jusqu Un > 1000 en choisissant U0 et U1 .
Exemples :
Exemples :
int i,j,k; 1 Exemples :
2
i = 1; 3 Exemples :
while (i < 15} { 4 int i,j,k;
printf("Ligne %i !", i++); 5 i = 1;

while (i < 15} {
printf("Ligne %i !", i++);
} 6 }
7 j = 6;
while (j > 20) {
j = 6; 8 i = i + j;
j = j 2;; }
while (j > 20) { 9
i = i + j; 10
j = j 2;; } 11 J.-F. Lalande Programmation C 52/204
Itrations : FAIRE
FAIRE ... JUSQUA ...

Syntaxe du do ... while :
Itrations : FAIRE
do 1
FAIRE ... JUSQUA ...
{ 2
Syntaxe du do ... while :
// Instructions 3 do
{
} 4 // Instructions
}
while (condition); 5 while (condition);
do ... while rapide :

do
do ... while rapide : // 1 seule instruction

while (condition);
do 1 J.-F. Lalande Programmation C 53/204
while (condition); 3
Exercice 24 crire un programme qui somme les 150 premiers entiers.

Exercice 25 crire un programme qui somme les 150 premiers entiers pairs.

Programmation C 2.2 Instructions de contrle
Exercice 26 crire un programme qui somme les premiers entiers jusqu ce que le carr de lentier courant soit plus
grand que 10 fois la somme.
Exercice 27 crire une boucle for laide dune boucle while.
Exercice 28 crire une boucle while laide dune boucle for.
Problmes frquents
for (i=0; i < 10; i+1) 1 Langage Instructions de contrle
printf("i vaut %i\n",i); 2 Problmes frquents
for (i=0; i < 10; i+1)

for (i=0; i = 10; i++) 1 printf("i vaut %i\n",i);
printf("i vaut %i\n",i); 2 for (i=0; i = 10; i++)

printf("i vaut %i\n",i);
for (i=0; i < 10; i++);

for (i=0; i < 10; i++); 1 while (i < 50);

printf("i vaut %i\n",i); 2
3
while (i < 50); 4 J.-F. Lalande Programmation C 54/204
printf("i vaut %i\n",i); 5
Exercice 29 Testez ces codes et expliquez ce qui se produit.
Rupture de squence
"La rupture de squence est le mal incarn." Rupture de squence
Les pas beaux : "La rupture de squence est le mal incarn."
break ; // sort directement de la boucle Les pas beaux :

break ; // sort directement de la boucle
continue // passe litration suivante de la boucle continue // passe litration suivante de la boucle
goto lab1 ; // aller un label lab1 :
goto lab1 ; // aller un label lab1 : Le tolrable :
return ; ou return X ; // sort de la fonction courante en renvoyant le
Le tolrable : rsultat X
return ; ou return X ; // sort de la fonction courante en renvoyant le rsultat X Ce slide doit tre OUBLI la fin du cours !
Ce slide doit tre OUBLI la fin du cours !
Exemple :
#include "stdio.h" 1 Langage Instructions de contrle
2 Exemple :
int main (int argc, char argv[]) { 3
int i, j, c; 4 #include "stdio.h"
for (i = j = 0; (c = getchar ()) != EOF; i++) { 5 int main (int argc, char argv[]) {
if (c == r) 6 int i, j, c;
for (i = j = 0; (c = getchar ()) != EOF; i++) {
if (c == r)
break; 7 break;
if (c == )
if (c == ) 8 continue;
j++;
continue; 9 }
printf ("Caracteres lus : %d dont non blancs %d\n", i, j);
j++; 10 return 0; }
printf ("Caracteres lus : %d dont non blancs %d\n", i, j); 11

return 0; } 13
Pourquoi cest mal :

Boucles dapparence infinie : Pourquoi cest mal :
for ( ; ; ; ) 1
Boucles dapparence infinie :
{ 2
for ( ; ; ; )
// Instructions contenant un moment 3 {
// Instructions contenant un moment
// un break 4 }
// un break
} 5 while (1)
{
6 // Instructions contenant un moment
// un break
while (1) 7 }
{ 8
// Instructions contenant un moment 9 J.-F. Lalande Programmation C 57/204
// un break 10
} 11
Pourquoi cest dangereux :
Sortie du niveau le plus interne :

Pourquoi cest dangereux :

for (...) 1
{ 2
while (...) 3 Sortie du niveau le plus interne :
for (...)
{ 4 {
while (...)
... 5 {
...
if (...) 6 if (...)
break; / Fin du while /
break; / Fin du while / 7 }
...
... / on arrive ici /

... 8 }
... / et non l, bien quon y vienne plus tard /
} 9
... / on arrive ici / 10
} 11
... / et non l, bien quon y vienne plus tard / 12
Programmation structure
Rgles gnrales de programmation :

Utiliser des structures de contrle (pas des goto !) Programmation structure

Dlimiter par bloc les parties du programme
Rgles gnrales de programmation :
Eclater le code au besoin en sous parties Utiliser des structures de contrle (pas des goto !)
Dlimiter par bloc les parties du programme
Chaque partie ou bloc possde ses variables (locales) Eclater le code au besoin en sous parties
Chaque partie ou bloc possde ses variables (locales)
Une partie possde un point dentre unique Une partie possde un point dentre unique
Une partie possde un point de sortie unique Une partie possde un point de sortie unique
Ces rgles permettent :
Ces rgles permettent : damliorer la robustesse du code
damliorer la lisibilit et la maintenance du programme
damliorer la robustesse du code de rduire les bugs potentiels
damliorer la lisibilit et la maintenance du programme J.-F. Lalande Programmation C 59/204
de rduire les bugs potentiels
Programmation structure (2)
Utiliser au mieux les structures de contrle :

Slection : if ou case
Programmation structure (2)

Itration : for ou while (2 faons)
Instructions de sortie exit ou return Utiliser au mieux les structures de contrle :
Minimiser limbrications de ses structures : Slection : if ou case

Itration : for ou while (2 faons)
Pas plus de 3 niveaux dimbrications Instructions de sortie exit ou return
Minimiser limbrications de ses structures :
Sinon, repenser votre code ! Pas plus de 3 niveaux dimbrications
Sinon, repenser votre code !
... ou utiliser des fonctions ! ... ou utiliser des fonctions !

Programmation C 2.3 Fonctions
2.3 Fonctions
Fonctions
Une fonction se dfinit par :

Langage Fonctions
la dclaration du type de retour Fonctions

du nom de la fonction
une parenthse ouvrante Une fonction se dfinit par :
la dclaration du type de retour
la dclaration des types et des noms des paramtres du nom de la fonction
une parenthse ouvrante
une parenthse fermante la dclaration des types et des noms des paramtres
une parenthse fermante
type identificateur(paramtres) 1 type identificateur(paramtres)

{
{ 2 ... / Instructions de la fonction. /
}
... / Instructions de la fonction. / 3
Pourquoi et o ?
Deux objectifs principaux :

Langage Fonctions
Sparer le code, structurer le programme Pourquoi et o ?

Factoriser le code
Deux objectifs principaux :
O placer la fonction ? Sparer le code, structurer le programme
Factoriser le code
Pas dans le main ! O placer la fonction ?
Au dessus du main o on lutilise Pas dans le main !

Au dessus du main o on lutilise
Au dessous du main, mais dclarer le prototype de la fonction Au dessous du main, mais dclarer le prototype de la fonction
int ma_fonction()
int ma_fonction() 1 { ... }
int main()
{ ... } 2 { ... }
int main() 4
{ ... } 5
Retour de la fonction
Une fonction retourne un rsultat :

Langage Fonctions
Typ correctement, suivant la dclaration de la fonction Retour de la fonction

Renvoy grce linstruction return rencontre
Une fonction retourne un rsultat :
Si rien nest renvoy : type void Typ correctement, suivant la dclaration de la fonction
Renvoy grce linstruction return rencontre
Une seule valeur de retour (parfois problmatique) Si rien nest renvoy : type void
Exemples dinstructions de retour : Une seule valeur de retour (parfois problmatique)
Exemples dinstructions de retour :
return 45;
return 45; 1 return a+b;
return a,b; Impossible !
return a+b; 2 Si des instructions sont conscutives un return, elles ne seront
return a,b; Impossible ! 3 jamais excutes. Si pas dinstruction de retour, on peut appeler cette
fonction une "procdure".
Si des instructions sont conscutives un return, elles ne seront jamais excutes. Si pas dinstruction de retour, on
peut appeler cette fonction une "procdure".
Exercice 30 crire une fonction prenant un entier et un double en paramtre. Cette fonction fait la somme et renvoie
le rsultat.
Exercice 31 crire une fonction qui prend trois entiers en paramtres et affiche lcran le plus grand et le plus petit.
Exercice 32 Ecrire une fonction qui calcule n! et renvoie le rsultat.
P
Exercice 33 Ecrire une fonction qui cacule k tel que i<k i et renvoie le rsultat.
Appels de fonctions

2.3 Fonctions Programmation C
Langage Fonctions
Lappel dune fonction : Appels de fonctions

en donnant son nom
Lappel dune fonction :
en donnant des paramtres en donnant son nom
en donnant des paramtres
des constantes des constantes
dautres variables
dautres variables en stockant ventuellement la valeur de retour
en stockant ventuellement la valeur de retour int i;

i = somme(2,3);
int i; 1 mais on peut aussi faire :

int i;
i = somme(2,3); 2 somme(2,3);
mais on peut aussi faire :

int i; 1
somme(2,3); 2
Exemples
Une fonction "procdure" qui ne renvoie rien :

Langage Fonctions
void affiche(int a) { 1 void main() { 1 Exemples I

printf("a vaut %i\n", a); 2 int i = 45; 2
} 3 affiche(i); } 3
Une fonction "procdure" qui ne renvoie rien :
void affiche(int a) { void main() {
printf("a vaut %i\n", a); int i = 45;
} affiche(i); }
Une fonction qui appelle une autre fonction : Une fonction qui appelle une autre fonction :
void affiche2(int a, int b) {

void affiche2(int a, int b) {
1 if (a > b)
affiche(a);
if (a > b) 2 else
affiche(b); }
affiche(a); 3
else 4
affiche(b); } 5 J.-F. Lalande Programmation C 65/204
int plus(int a, int b) 1

{ 2 void main() { 1
a=a+b; 3 int resultat; int var = 10; 2
return a 4 resultat = calcul(var, 4, 3); } 3
} 5
int calcul(int z, int x, int y) 1

{ 2
int u; 3
u = z; 4
u = plus(x,y) ; 5
return u; 6
} 7
Dclaration de fonctions
Dclarer une fonction (exemple de [?]) :

Langage Fonctions
int min(int, int); / Dclaration de la fonction minimum / 1 Dclaration de fonctions

/ dfinie plus loin. / 2
/ Fonction principale. / 3 Dclarer une fonction (exemple de [5]) :
int main(void) 4 int min(int, int); / Dclaration de la fonction minimum /
/ dfinie plus loin. /
{ 5 / Fonction principale. /
int main(void)
int i = min(2,3); / Appel la fonction Min, dj dclare. / 6 {
int i = min(2,3); / Appel la fonction Min, dj dclare. /
return 0;
return 0; 7 }
int min(int a, int b)
} 8 {
a < b ? a : b; }
int min(int a, int b) 9
{ 10
a < b ? a : b; } 11 J.-F. Lalande Programmation C 67/204

Programmation C 2.3 Fonctions
Retour sur la porte
Porte des variables :

Langage Fonctions
Dpend de leur emplacement (main, fonction, . . . ) Retour sur la porte I

locale (main, fonction)
globale (tout le programme)
Porte des variables :
register (utilises souvent : info compilateur) Dpend de leur emplacement (main, fonction, . . . )
locale (main, fonction)
extern (dfinies dans un autre fichier source) globale (tout le programme)
register (utilises souvent : info compilateur)
static (restreint la visibilit au fichier) extern (dfinies dans un autre fichier source)
static (restreint la visibilit au fichier)
int choix = 12; 2
int main(void) { 4
int choix = 4; 5
printf("Choix numro %i \n", choix); 6
ma_fonction(); 7
return 0; 8
} 9
10
void ma_fonction() { 11
printf("Choix numro %i\n", choix); 12
} 13
Rcursivit
Il est tout fait possible dappeler depuis une fonction cette mme fonction. On
Langage Fonctions
appelle cela un appel rcursif. Rcursivit
Il est tout fait possible dappeler depuis une fonction cette mme
fonction. On appelle cela un appel rcursif.
Exemple de fonction rcursive :

Exemple de fonction rcursive : int fac(int n)
{
if (n == 0)
int fac(int n) 1 return 1;
else
{ 2 }
return nfac(n1);
if (n == 0) 3 Limite : taille de la pile dexcution

return 1; 4
else 5 J.-F. Lalande Programmation C 70/204
return nfac(n1); 6
} 7
Limite : taille de la pile dexcution
Fonctions arguments variables
La norme ANSI autorise lutilisation de fonctions arguments variables.

Langage Fonctions
Dailleurs vous utilisez courrament une fonction argument variables... Fonctions arguments variables
Les arguments variables sont reprsents par ...
Les arguments sont stocks dans une sorte de liste La norme ANSI autorise lutilisation de fonctions arguments
variables. Dailleurs vous utilisez courrament une fonction argument
La rcupration de ces variables se fait laide des fonctions : variables...
Les arguments variables sont reprsents par ...
Les arguments sont stocks dans une sorte de liste
#include <stdarg.h> 1 La rcupration de ces variables se fait laide des fonctions :
void va_start(va_list ap, nom_derniere_variable_nommee); 2 #include <stdarg.h>
type va_arg(va_list ap, type); 3 void va_start(va_list ap, nom_derniere_variable_nommee);

type va_arg(va_list ap, type);
void va_end(va_list ap);

void va_end(va_list ap);
4
Fonctions arguments variables (2)

2.3 Fonctions Programmation C
La premire tape consiste crer une variable de type va_list.

Langage Fonctions
Fonctions arguments variables (2)
va_list liste; 1
La premire tape consiste crer une variable de type va_list.
va_list liste;
La deuxime tape sappuie suir lappel va_start : lappel initialise la liste La deuxime tape sappuie suir lappel va_start : lappel initialise
la liste et la positionne afin de prparer la premire variable qui suit la
et la positionne afin de prparer la premire variable qui suit la dernire variable dernire variable nomme
Ensuite, chaque appel va_arg permet de rcuprer la valeur de la
nomme variable courante. De plus, lappel dcale le pointeur de liste sur le
prochain lment.
Ensuite, chaque appel va_arg permet de rcuprer la valeur de la variable Enfin va_end termine la liste et nettoie la mmoire avant le retour la
fonction appelante.
courante. De plus, lappel dcale le pointeur de liste sur le prochain lment.

Enfin va_end termine la liste et nettoie la mmoire avant le retour la fonction appelante. J.-F. Lalande Programmation C 72/204
Exemple de fonctions arguments variables
#include <stdarg.h> 1 Langage Fonctions
#include <stdio.h> 2 Exemple de fonctions arguments variables

int fonc_arg_var(int n, int b, ...) { 3
int i; 4 #include <stdarg.h>
#include <stdio.h>
va_list liste; 5 int fonc_arg_var(int n, int b, ...) {
int i;
va_start(liste, b); 6 va_list liste;

va_start(liste, b);
for (i=0; i<n; i++) { 7 for (i=0; i<n; i++) {

int tmp = va_arg(liste, int);
printf("%i ", tmp);
int tmp = va_arg(liste, int); 8 }}
printf("%i ", tmp); 9 int main() { // Output: 7 8 9 9

fonc_arg_var(3,100,7,8,9);
}} 10 fonc_arg_var(1,5,9);
return 0;
}
11
int main() { // Output: 7 8 9 9 12 J.-F. Lalande Programmation C 73/204
fonc_arg_var(3,100,7,8,9); 13
fonc_arg_var(1,5,9); 14
return 0; 15
} 16

Programmation C
3 Les tableaux et pointeurs
3.1 Tableaux
Tableaux
Un tableau permet de stocker plusieurs valeurs de mme type dans des cases
Les tableaux et pointeurs Tableaux
contigues de la mmoire : Tableaux

Stocker des types de base dans des cases
Dclaration avec [entier] : rserve lespace mmoire Un tableau permet de stocker plusieurs valeurs de mme type dans
des cases contigues de la mmoire :
Accs en temps constant lecture/criture Stocker des types de base dans des cases
Dclaration avec [entier] : rserve lespace mmoire
Attention aux erreurs daccs Accs en temps constant lecture/criture
Attention aux erreurs daccs
int tableau[256]; 1 int tableau[256];

int j = 4;
int j = 4; 2 tableau[j] = 34;
printf(" case %i : %i \n", j, tableau[j]);
tableau[j] = 34; 3
printf(" case %i : %i \n", j, tableau[j]); 4 J.-F. Lalande Programmation C 75/204
Initialisation des tableaux
Initialisation du tableau (int tab[7];) :

Initialisation des tableaux
Initialisation du tableau (int tab[7];) :
Ecriture de valeurs (tab[0] = 12;) :

Ecriture de valeurs (tab[0] = 12;) :
Ou initialisation directe :
int tableau[256] = {12,142,12,2,48};
int tableau[] = {12,142,12,2,48};
Ou initialisation directe :
int tableau[256] = {12,142,12,2,48}; 1

int tableau[] = {12,142,12,2,48}; 2
Arithmtique des tableaux
Accs un lment par [i] : tab[i]

Accs par arithmtique de pointeur : *(tab+i)
Arithmtique des tableaux
Accs un lment par [i] : tab[i]

Accs par arithmtique de pointeur : *(tab+i)
Notion "dadresse dun lment"

Dplacement de la bonne "mesure" dun lment un autre
Notion "dadresse dun lment"
Dplacement de la bonne "mesure" dun lment un autre J.-F. Lalande Programmation C 77/204
sizeof et les tableaux
Loprateur sizeof sapplique :

Sur un type (int, double, . . . ) sizeof et les tableaux

Sur une expression
Peut-on lutiliser sur un tableau ? Loprateur sizeof sapplique :
Sur un type (int, double, . . . )
Sur une expression
Peut-on lutiliser sur un tableau ?
J.-F. Lalande 24/56 double t[10]; Ensi de Bourges
sizeof(t) // Taille de t en octets
(sizeof)t // Idem, alternative de notation
10 sizeof(double) // 10 fois taille double
sizeof(double[10]) // Taille tableau de double
10 sizeof(t[0]) // 10 fois taille 1er elment

3.1 Tableaux Programmation C
double t[10]; 1
sizeof(t) // Taille de t en octets 2
(sizeof)t // Idem, alternative de notation 3
10 sizeof(double) // 10 fois taille double 4
sizeof(double[10]) // Taille tableau de double 5
10 sizeof(t[0]) // 10 fois taille 1er elment 6
Tableaux static
static int t[10]; 1 Les tableaux et pointeurs Tableaux
Tableaux static
Emplacement rserv ad vitam eternam

Valeur conserve mme si lon sort de la porte static int t[10];
Exemple : Emplacement rserv ad vitam eternam

Valeur conserve mme si lon sort de la porte
Exemple :
void fonction(int a_stocker, int ici) { 1 void fonction(int a_stocker, int ici) {
static int t[10]; 2 static int t[10];
t[ici] = a_stocker;
t[ici] = a_stocker; 3 }
} 4
Tableaux const
Tableau dlments constants :

Concerne les lments du tableau Tableaux const

En gnral initialis sa dclaration
Tableau dlments constants :
#include <stdio.h> 1 Concerne les lments du tableau
void ma_fonction(int t) { 2 En gnral initialis sa dclaration

#include <stdio.h>
t[1] = 3; } 3 void ma_fonction(int t) {
t[1] = 3; }
int main() { 4 int main() {
const double t[3] = {10,10,10};
const double t[3] = {10,10,10}; 5 ma_fonction(t); }
ma_fonction(t); } 6 ./prog
zsh: segmentation fault ./prog
./prog 1
zsh: segmentation fault ./prog 2
Tableaux multidimensionels
Il est possible de dclarer des tableaux plusieurs dimensions

Loprateur [x] permet dajouter une dimension Tableaux multidimensionels

Chaque dimension est contigue par rapport la premire
Il est possible de dclarer des tableaux plusieurs dimensions
int t_d[2][3]; 1 Loprateur [x] permet dajouter une dimension
Chaque dimension est contigue par rapport la premire
int t_d[2][3];
Ce qui donne, au niveau mmoire (figure issue de [?]) : Ce qui donne, au niveau mmoire (figure issue de [3]) :
Notez quil nest pas malin daccder t_d[1][0] en utilisant

t_d[0][3]...
Notez quil nest pas malin daccder t_d[1][0] en utilisant t_d[0][3]...
Tableaux dynamiques

Programmation C 3.2 Les pointeurs
La dclaration de tableaux dont la taille est inconnue est interdite ! Par exemple, Tableaux dynamiques
on ne peut faire :
La dclaration de tableaux dont la taille est inconnue est interdite ! Par
int j = 5; 1 exemple, on ne peut faire :
double tableau[j]; / Interdit en norme ANSI ! / 2 int j = 5;

double tableau[j]; / Interdit en norme ANSI ! /
Rejet des extensions du compilateur :

jf@radotte:~/ensib/cours/c/cours/prog$ gcc -o prog -ansi -pedantic
Rejet des extensions du compilateur : tableau_dyn.c
tableau_dyn.c: In function main:
tableau_dyn.c:7: warning: ISO C90 forbids variable length array
tableau
jf@radotte
:~/ensib/cours/c/cours/prog$ gcc -o prog -ansi -pedantic tableau_dyn.c J.-F. Lalande Programmation C 82/204
tableau_dyn.c: In function main:

tableau_dyn.c:7: warning: ISO C90 forbids variable length array tableau
3.2 Les pointeurs

Origine du besoin
Les pointeurs nont pas t invents par hasard...

Les tableaux et pointeurs Les pointeurs
Impossibilit de modifier une variable passe en paramtre Origine du besoin

Tableaux de taille variable parcourir
Notions de structures (struct) Les pointeurs nont pas t invents par hasard...
Impossibilit de modifier une variable passe en paramtre
Arithmtique des pointeurs est simple Tableaux de taille variable parcourir
Notions de structures (struct)
Proximit de la manipulation de la mmoire Arithmtique des pointeurs est simple
Proximit de la manipulation de la mmoire
Do Do
La notion dadresse dune case mmoire La notion dadresse dune case mmoire
La notion de pointeur (contient une adresse)
La notion de pointeur (contient une adresse)
Adresse et pointeur
Adresse dune variable :

Les tableaux et pointeurs Les pointeurs
Adresse et pointeur I
int variable; 1
scanf("%i", &variable); 2
printf("addresse de variable: %i \n", &variable); 3 Adresse dune variable :
printf("contenu de variable: %i \n", variable); 4 int variable;
scanf("%i", &variable);
printf("addresse de variable: %i \n", &variable);
printf("contenu de variable: %i \n", variable);
Pointeur p vers une variable :

Pointeur p vers une variable : int variable;
int p;
p = &variable;
int variable; 1
int p; 2
p = &variable; 3 J.-F. Lalande Programmation C 84/204
Exemple dun pointeur sur un entier :
Le pointeur p pointe vers la variable

Le pointeur p contient ladresse de la variable
do lhomognit de p = &variable;.
Oprateur * donne la valeur dun pointeur :

3.3 Consquences sur les tableaux, fonctions, chaines Programmation C
int variable; 1
int p; 2
p = &variable; 3
printf("addresse de variable: %i \n", p); 4
printf("contenu de variable: %i \n", p); 5
Ne pas confondre :
La signification du &
La signification du *
Et saider de petits dessins loccasion !
Exercice 34 Crez un pointeur p sur un float et un float f. Enregistrez 12.3 dans f et faites pointer p sur ce flottant.
Exercice 35 Crez un pointeur q sur un float. Initialisez directement la valeur pointe par q avec 45.5. Crez un
pointeur r et faites le pointer sur la mme valeur que q.
Exercice 36 Crez deux pointeurs et faites les pointer sur deux entiers. Echangez alors les valeurs points.
3.3 Consquences sur les tableaux, fonctions, chaines

Retour sur les fonctions
Utilisation dans les fonctions :

Les tableaux et pointeurs Consquences sur les tableaux, fonctions, chaines
Passage de paramtre par adresse ou par pointeur Retour sur les fonctions
Retour de fonction : adresse ou pointeur
Utilisation dans les fonctions :
int main() { 1 Passage de paramtre par adresse ou par pointeur
int p; int res; 2 Retour de fonction : adresse ou pointeur
res = ma_fonction(p); } 3 int main() {

int p; int res;
res = ma_fonction(p); }
4
void ma_fonction(int param)
void ma_fonction(int param) 5 {
param = 45;
{ 6 }
param = 45; 7
Exercice 37 Codez une fonction au_carre qui prend un pointeur sur un entier en paramtre et le passe au carr.
Exercice 38 Codez une fonction echange qui permet de prendre deux pointeurs en paramtre et qui change le
pointage vers ces deux entiers.
Exercice 39 Codez une fonction initialise ne prenant pas de paramtre et renvoyant un pointeur sur un entier.
Retour sur les tableaux
La dclaration dun tableau :

est en fait la dclaration dun pointeur vers le premier lment Retour sur les tableaux I
rserve lespace n lments conscutifs
permet de "pointer" sur le kme lment La dclaration dun tableau :
est en fait la dclaration dun pointeur vers le premier lment
Pointer sur llment 0 ou 5 : rserve lespace n lments conscutifs
permet de "pointer" sur le kme lment
int tableau[256] = {12,142,12,2,48}; 1 Pointer sur llment 0 ou 5 :

int tableau[256] = {12,142,12,2,48};
int p1 = tableau; 2 int p1 = tableau;
int p2 = &tableau[0];
int p2 = &tableau[0]; 3 int p5 = &tableau[5];
int p5 = &tableau[5]; 4
Oprations possibles sur un pointeur :

affectation dune adresse au pointeur
oprateur "*" : accs la donne
addition dun entier k : pointe sur la kme case
soustraction de deux pointeurs : nombre dlments
Exemple daddition / de soustraction :

Programmation C 3.3 Consquences sur les tableaux, fonctions, chaines
long px, px2; 1

px2 = px + i; // qui quivaut en fait a: 2
px2 = (long ) ((int) px + i sizeof (long)); 3
i = px2 px; 4
Le parcours dun tableau :

se fait en utilisant un pointeur sur les lments
utilise larithmtique des pointeurs (trs pratique)
Exemple :
int tableau[256] = {12,142,12,2,48}; 1
int p1 = tableau; 2
for (i= 0; i < 5; i++) 3
printf("tableau[%i]=%i\n", (p1+i)); 4
for (i= 0; i < 5; i++) // Est aussi possible: 5
printf("tableau[%i]=%i\n", (tableau+i)); 6
while (p1 != tableau + 5) 7
printf("tableau[%i]=%i\n", (p1++)); 8
Exercice 40 Quel est lerreur dans le while prcdent ? Comment la corriger ?

Exercice 41 Codez deux pointeurs qui pointent sur le dbut et la fin dun tableau. Puis faites parcourir ces deux
pointeurs le tableau lun de gauche droite et lautre de droite gauche.
Exercice 42 Ecrire une fonction qui prend en paramtre un tableau et renvoie un pointeur sur llment minimum.
Fonctions et sizeof
Le passage de tableau en paramtre :

int main() 1 Fonctions et sizeof I

{ 2
int tableau[3] = {1,2,3}; 3 Le passage de tableau en paramtre :
ma_fonction(tableau); 4 int main()

{
int tableau[3] = {1,2,3};
} 5 ma_fonction(tableau);
}
6 void ma_fonction(int tab[3]); // Equivalent :
void ma_fonction(int tab[3]); // Equivalent : 7 void ma_fonction(int tab[]); // Equivalent :
void ma_fonction(int tab); // La ralit
void ma_fonction(int tab[]); // Equivalent : 8

On recoit un pointeur sur un tableau
void ma_fonction(int tab); // La ralit 9 On perd la notion de taille du tableau
On recoit un pointeur sur un tableau

On perd la notion de taille du tableau
Taille dun tableau :
double t[10]; 1
sizeof(t) // Taille du tableau 2
sizeof(t) / sizeof(t[0]) // Nombre dlments 3
Par un appel de fonction, cela ne marche plus :

void ma_fonction(int t) 1
{ 2
int nb = sizeof(t) / sizeof(t[0]); 3
printf("nb=%i\n", nb); // nb vaut 1 ici 4
} 5
Preuve :
void ma_fonction(int t) { 2
printf("nb=%i\n", nb); } 4
int main() { 5
double t[10]; 6
printf("nb=%i\n", nb); 8
ma_fonction(t); } 9

3.4 Les chanes de caractres Programmation C
./prog
nb=10
nb=1
3.4 Les chanes de caractres

Les chanes de caractres
Une chaine de caractres est un tableau de char.

Les tableaux et pointeurs Les chanes de caractres
char chaine[256] = "coucou !"; 1 Les chanes de caractres I
printf("%s\n", chaine); // affiche la chaine 2

printf("%c\n", chaine[1]); // affiche le caractere o 3 Une chaine de caractres est un tableau de char.
char chaine[256] = "coucou !";
printf("%s\n", chaine); // affiche la chaine
printf("%c\n", chaine[1]); // affiche le caractere o
Particularit des chaines : Particularit des chaines :

Par convention, le dernier caractre est \0
Par convention, le dernier caractre est \0 Les caractres suivant \0 doivent tre ignors
Des \n peuvent tre utiliss
Les caractres suivant \0 doivent tre ignors char chaine[256] = "coucou ceci\0 est coupe !";
printf("%s\n", chaine); // affiche "coucou ceci"
Des \n peuvent tre utiliss
char chaine[256] = "coucou ceci\0 est coupe !";
1
printf("%s\n", chaine); // affiche "coucou ceci" 2
Rcuprer une chaine de caractre :

char chaine[256]; 1
scanf("%s", chaine); 2
Comparer deux chaines de caractres :

char chaine[256]; 1
char chaine2[256]; 2
int res; 3
res = strcmp(chaine, chaine2); 4
Autres fonctions : strcasecmp, strlen, strcat, strcpy,. . . plus dinfor-

mations : man string !
Exercice 43 Ecrire une fonction qui prend en paramtre une chaine et renvoie le nombre de caractres.
3.5 Lallocation dynamique

Allocation de la mmoire
Allocation de la mmoire :
Les tableaux et pointeurs Lallocation dynamique
allocation statique : Allocation de la mmoire

dclaration de variables global ou static
allocation dynamique : Allocation de la mmoire :
allocation statique :
variables locales dclaration de variables global ou static
allocation dynamique :
paramtres de fonctions variables locales
paramtres de fonctions
cration " la main" despace mmoire
cration " la main" despace mmoire
int fonction()
{
int fonction() 1 }
int i; int j; // Allocation dynamique
{ 2
int i; int j; // Allocation dynamique 3 J.-F. Lalande Programmation C 96/204
} 4
Allocation des tableaux

Programmation C 3.5 Lallocation dynamique
Allocation dynamique " la main" : Allocation des tableaux
void calloc(size_t nb_blocs, size_t taille_bloc) 1 Allocation dynamique " la main" :

void calloc(size_t nb_blocs, size_t taille_bloc)
allocation de nb_clocs contigs

allocation de nb_clocs contigs chaque bloc a un taille de taille_bloc
chaque bloc a un taille de taille_bloc Libration de cet espace mmoire :

void free(void ptr);
Libration de cet espace mmoire : Allocation de 10 cases contenant des entiers :
// creation dun tableau de taille 10 dentiers
void free(void ptr); 1 int tab = (int) calloc(10, sizeof(int));

// liberation de tout lespace mmoire allou
free(tab);
Allocation de 10 cases contenant des entiers :

// creation dun tableau de taille 10 dentiers 1
int tab = (int) calloc(10, sizeof(int)); 2
// liberation de tout lespace mmoire allou 3
free(tab); 4
Allocation dune variable
Allocation de variable :
void malloc(size_t size); 1 Allocation dune variable
// Allocation dun entier et dun pointeur vers lentier 1 Allocation de variable :
int x = (int) malloc(sizeof(int)); 2 void malloc(size_t size);
// liberation de lespace mmoire allou 3 // Allocation dun entier et dun pointeur vers lentier
int x = (int) malloc(sizeof(int));
free(x); 4 // liberation de lespace mmoire allou
free(x);
Allocation des chanes J.-F. Lalande Programmation C 98/204
#include<stdio.h> 1 Les tableaux et pointeurs Lallocation dynamique
#include<stdlib.h> 2 Allocation des chanes

#include<string.h> 3
int main(int argc, char argv) { 4 #include<stdio.h>
#include<stdlib.h>
char truc; char machin;

#include<string.h>
5 int main(int argc, char argv) {
char truc; char machin;
truc = "chaine constante"; 6 truc = "chaine constante";
machin = calloc(10, sizeof(char));
machin = calloc(10, sizeof(char)); 7 printf("%s\n", truc);
printf("%s\n", machin);
printf("%s\n", truc); 8 truc = x; // segmentation fault
machin = x;
printf("%s\n", machin); 9 strcpy(truc, "toto"); // segmentation fault

printf("truc=%s\n", truc);
printf("machin=%s\n", machin);
truc = x; // segmentation fault 10 free(truc); // segmentation fault
free(machin);
machin = x; 11 }
return 0;
strcpy(truc, "toto"); // segmentation fault 12 J.-F. Lalande Programmation C 99/204
printf("truc=%s\n", truc); 13
printf("machin=%s\n", machin); 14
free(truc); // segmentation fault 15
free(machin); 16
return 0; 17
} 18

Programmation C
4 Notions avances du C
4.1 Structures dencapsulationes
Struct
Dfinition dune structure :

Notions avances du C Structures dencapsulationes
struct nom_de_structure { 1 Struct I

type1 nom_champ1 ; 2
type2 nom_champ2 ; 3 Dfinition dune structure :
type3 nom_champ3 ; 4 struct nom_de_structure {

type1 nom_champ1 ;
type4 nom_champ4 ; 5 type2 nom_champ2 ;

type3 nom_champ3 ;
type4 nom_champ4 ;
... 6 ...
typeN nom_champ_N ;
typeN nom_champ_N ; 7 };
}; 8 Utilisation :
struct nom_de_structure variable;
Utilisation : J.-F. Lalande Programmation C 101/204
struct nom_de_structure variable; 1
Exemple :
struct animal { 1
char nom[50]; 2
int age; 3
float taille; }; 4
Instanciation dune structure :

struct animal bar={"Bar",12,7.5}; 1
Accs aux attributs :

bar.age = 13; 1
bar.taille = bar.taille + 5.0; 2
Struct imbriqus
Le cas particulier dun struct imbriqu :

struct boite { 1 Struct imbriqus

struct boite interieur; 2
}; 3 Le cas particulier dun struct imbriqu :
struct boite {
struct boite interieur;
};
Exemple dutilisation :
struct boite grande_poupee;
struct boite grande_poupee; 1 struct boite petite_poupee;
grande_poupee.interieur = &petite_poupee;
struct boite petite_poupee; 2 petite_poupee.interieur = NULL;
grande_poupee.interieur = &petite_poupee; 3
petite_poupee.interieur = NULL; 4
Typedef
Dfinition dun nouveau type :

typedef struct nom_de_structure nom_du_type; 1 Typedef I
Dfinition dun nouveau type :

Utilisation du nouveau type : typedef struct nom_de_structure nom_du_type;
Utilisation du nouveau type :

nom_du_type x; 1 nom_du_type x;
Exemple :
struct animal {
char nom[50];
int age;
float taille; };
J.-F. Lalande 31/56 typedef struct animal poisson;
poisson bar = {"Bar", 12, 7.5};
Ensi de Bourges
Programmation C 4.1 Structures dencapsulationes
F IGURE 1 Liste avec un lment dummy en tte
Exemple :
struct animal { 1
char nom[50]; 2
int age; 3
float taille; }; 4
typedef struct animal poisson; 5
poisson bar = {"Bar", 12, 7.5}; 6
Le struct imbriqu avec un typedef :

typedef struct BOITE { 1
struct BOITE interieur; 2
} boite; 3
boite ma_boite; 4
ma_boite.interieur = (boite )malloc(sizeof(boite)); 5
Pointeur sur struct
Si p est un pointeur sur struct :

Si x est un lment de la structure Pointeur sur struct

Alors on peut accder p :
(*p).x Si p est un pointeur sur struct :
p->x Si x est un lment de la structure
Alors on peut accder p :
Exemple : (*p).x
p->x
Exemple :
poisson bar; 1 poisson bar;
bar = (poisson ) malloc(sizeof(poisson));

bar = (poisson ) malloc(sizeof(poisson));
2 bar>taille = 5;
bar>taille = 5; 3
Structures de donnes : listes
Liste vide : lment dummy seul

Llment dummy nest pas obligatoire Structures de donnes : listes I

Sans dummy la liste vide est un pointeur NULL
Le pointeur tail nest pas obligatoire
La liste de poissons :
F IGURE: Liste avec un lment dummy en tte
#include <stdlib.h> 1
// Dfinitions 2 Liste vide : lment dummy seul
Llment dummy nest pas obligatoire
struct animal { 3 Sans dummy la liste vide est un pointeur NULL
char nom[50]; 4 Le pointeur tail nest pas obligatoire
int age; }; 5
typedef struct animal poisson; 6 J.-F. Lalande Programmation C 107/204
typedef struct CELLULE { 7

struct CELLULE suivante; 8
poisson p; 9
} cellule; 10
11
// Instanciation 12
int main() { 13
cellule dummy, premiere, deuxieme; 14
poisson bar = (poisson ) malloc(sizeof(poisson)); 15
bar>age = 5; 16

4.1 Structures dencapsulationes Programmation C
F IGURE 2 Arbre binaire de recherche dentiers
dummy = (cellule ) malloc(sizeof(cellule)); 17

premiere = (cellule ) malloc(sizeof(cellule)); 18
deuxieme = (cellule ) malloc(sizeof(cellule)); 19
dummy>p = NULL; 20
dummy>suivante = premiere; 21
premiere>p = bar; 22
premiere>suivante = deuxieme; 23
deuxieme>suivante = NULL; 24
} 25
La liste doublement chane de poissons :

cf liste de poissons avec en plus :
pointeur poisson prcdent : cellule * prec
prec est NULL pour le dbut et la fin
La liste chane circulaire de poissons :
cf liste doublement chane de poissons
prec de cellule dbut pointe sur la fin
Structures de donnes : ABR
Larbre binaire de poissons :

Structures de donnes : ABR I

// Dfinitions 2
struct animal { 3
char nom[50]; 4
int age; }; 5
typedef struct NOEUD { 7
struct NOEUD gauche; 8
struct NOEUD droite; 9 F IGURE: Arbre binaire de recherche dentiers
poisson p; 10
} noeud;
11
12
// Instanciation 13
int main() { 14
noeud premier, deuxieme, troisieme; 15
bar>age = 5; 17
premier = (noeud ) malloc(sizeof(noeud)); 18
deuxieme = (noeud ) malloc(sizeof(noeud)); 19
troisieme = (noeud ) malloc(sizeof(noeud)); 20
premier>p = bar; // A faire dans les autres noeuds 21
premier>gauche = deuxieme; 22
//premier>droite = deuxieme; // hrsie !! 23
premier>droite = troisieme; 24
} 25

Programmation C 4.1 Structures dencapsulationes
F IGURE 3 La pile dentiers
Structures de donnes : piles
La pile de poissons (version 1) :

Structures de donnes : piles I

// Dfinitions 2
struct animal { 3
char nom[50]; 4
int age; }; 5
F IGURE: La pile dentiers
typedef struct PILE { 7
int taille_max; // Taille de la pile 8
int courant; // Index de llment courant 9
poisson p; // Tableau de poissons 10 J.-F. Lalande Programmation C 114/204
} pile; 11
12
// Instanciation 13
int main() { 14
pile ma_pile = (pile )malloc(sizeof(pile)); 15
ma_pile>taille_max = 256; 16
ma_pile>p = (poisson )calloc(256, sizeof(poisson)); 17
bar>age = 5; 19
//(ma_pile>p+ma_pile>courant) = bar; // Ne marche pas 20
(ma_pile>p+ma_pile>courant++) = bar; // Copie du bar dans le tableau 21
} 22
La pile de poissons (version 2) :

// Dfinitions 2
struct animal { 3
char nom[50]; 4
int age; }; 5
typedef struct PILE { 7
int taille_max; // Taille de la pile 8
int courant; // Index de llment courant 9
poisson p; // Tableau de pointeur sur poissons 10
} pile; 11
12
// Instanciation 13
int main() { 14
pile ma_pile = (pile )malloc(sizeof(pile)); 15
ma_pile>taille_max = 256; 16
ma_pile>p = (poisson )calloc(256, sizeof(poisson )); 17
bar>age = 5; 19
(ma_pile>p+ma_pile>courant++) = bar; // Marche ! 20
} 21
Structures de donnes : files
Structures de donnes : files

4.1 Structures dencapsulationes Programmation C
F IGURE 4 File dentiers
F IGURE 5 Graphes : diffrentes reprsentations
La file de poissons : Structures de donnes : files

cf file de poisson (version 2) avec en plus :
index courant empiler (endroit pour empiler)
index courant depiler (endroit pour dpiler) La file de poissons :
cf file de poisson (version 2) avec en plus :
petite difficult : grer de faon circulaire index courant empiler (endroit pour empiler)
index courant depiler (endroit pour dpiler)
petite difficult : grer de faon circulaire
Structures de donnes : graphes
Structures de donnes : graphes
Le graphe de poissons :
Graphe sous sa premire forme : Structures de donnes : graphes

Dfinir un noeud
Dfinir un tableau de pointeurs sur noeuds Le graphe de poissons :
Graphe sous sa premire forme :
Chaque noeuds pointe sur un poisson Dfinir un noeud
Dfinir un tableau de pointeurs sur noeuds
Graphe sous sa deuxime forme : Chaque noeuds pointe sur un poisson
Graphe sous sa deuxime forme :
Tableau de poissons Tableau de poissons
Tableau de listes dadjacences
Graphe sous sa troisime forme
Tableau de listes dadjacences Tableau de poissons
Matrice dentiers
Graphe sous sa troisime forme
Tableau de poissons J.-F. Lalande Programmation C 122/204
Matrice dentiers
Union
Dfinition dune union :

Union I
J.-F. Lalande 35/56 Dfinition dune union :

Ensi de Bourges
Peut contenir diffrents types
Mais une seule valeur la fois
union nom_de_union {
type1 nom_champ1 ;
type2 nom_champ2 ;
...
typeN nom_champ_N ;
};
Utilisation :
Programmation C 4.2 Les variables
Peut contenir diffrents types
Mais une seule valeur la fois
union nom_de_union { 1
... 4
typeN nom_champ_N ; 5
}; 6
Utilisation :
union nom_de_structure variable; 1
Exemple dunion :
union number // Peut contenir 3 types 1
{ 2
short shortnumber; 3
long longnumber; 4
float floatnumber; 5
} anumber; 6
anumber.longnumer = 45; // considre anumber comme long 7
anumber.floatnumer = 45.4; // considre anumber comme float 8
numration
Type numr :
Une variable numre prend une valeur parmi N numration I

Codage rel avec des entiers
enum nom_de_numration { 1 Type numr :
Une variable numre prend une valeur parmi N
numrateur1, 2 Codage rel avec des entiers
numrateur2, 3 enum nom_de_numration {

numrateur1,
... 4 numrateur2,
...
numrateurN 5 numrateurN
};
enum nom_de_numration variable;
}; 6
enum nom_de_numration variable; 7
enum days {mon, tues, sun}; 2
3
int main() { 4
enum days d = mon; 5
printf("d=%i\n", d); 6
d= tues; 7
printf("d=%i\n", d); } 8
./prog 1
d=0 2
d=1 3
4.2 Les variables

Variables globales
Dclare dans un fichier source :

Notions avances du C Les variables
Visible dans tout le fichier Variables globales I

Modifiable (variable partage)
Dclare dans un fichier source :
Visible dans tout le fichier
Modifiable (variable partage)
Dfinie dans un autre fichier source :
Variable dclare dans un autre fichier source
Utilisable dans le fichier courant
extern int a, b;

4.2 Les variables Programmation C
Dfinie dans un autre fichier source :
Variable dclare dans un autre fichier source
Utilisable dans le fichier courant
extern int a, b; 1
Variable globale cache dans un fichier source :

Mot clef static
Visible globalement dans le fichier
Invisible en externe depuis un autre fichier
Aucune collision avec une autre variable de mme nom
Variables globales : la norme ANSI
Dclaration avec initialisation : dfinition

Notions avances du C Les variables
int n = 3; 1 Variables globales : la norme ANSI I
extern int n = 3; 2
Dclaration avec initialisation : dfinition
int n = 3;
extern int n = 3;
Dclaration avec extern sans initialisation : redclaration Dclaration avec extern sans initialisation : redclaration
int a = 3; / dfinition /
int a = 3; / dfinition / 1 ...

extern int a; / redclaration de a rfrence la dfinition /
...
... 2 extern int a; / encore une redclaration /
extern int a; / redclaration de a rfrence la dfinition / 3 extern int a; / redclaration de a: soit dans ce fichier soit aiilleurs /
...
... 4 int a = 3; / dfinition de a /
extern int a; / encore une redclaration / 5 J.-F. Lalande Programmation C 129/204
extern int a; / redclaration de a: soit dans ce fichier soit aiilleurs / 1

... 2
int a = 3; / dfinition de a / 3
static int a; / dfinition de a / 1

... 2
extern int a; / redclaration de a se rfrant la dfinition / 3
Dclaration sans extern sans initialisation :

dfinition potentielle
ne devient valide que si aucune dfinition nest trouve
si une dfinition est trouve cest une redclaration
int a; / dfinition potentielle de a / 1
... 2
... 4
/ pas dautre dfinition: a est dfinie en tant que int a = 0; / 5
extern int a; / redclaration de a: soit dans ce fichier soit ailleurs / 1

... 2
... 4
int a = 2; / dfinition de a / 5
int auto_var = 0; 10
void stat(); / prototype fn / 1 static int static_var = 0; 11
2 printf( "auto = %d, static = %d\n", auto_var, static_var); 12
main() 3 ++auto_var; 13
{ int i; 4 ++static_var; 14
for (i=0;i<5;++i) }5 15
stat(); 6 16
} 7
//Output is: 17
8 18
stat() { 9auto_var = 0, static_var= 0 19

Programmation C 4.3 Prprocessing et compilation spare
auto_var = 0, static_var = 1 auto_var = 0, static_var = 3
20 22
auto_var = 0, static_var = 2 auto_var = 0, static_var = 4
21 23
4.3 Prprocessing et compilation spare

Compilation spare
Compilation spare :
Notions avances du C Prprocessing et compilation spare
Compilation de chaque fichier source .c en .o Compilation spare

Edition des liens
Dans un fichier source, on trouve : Compilation spare :
des dclarations de variables et de fonctions externes Compilation de chaque fichier source .c en .o

Edition des liens
des dfinitions de types synonymes ou de modles de structures Dans un fichier source, on trouve :
des dclarations de variables et de fonctions externes
des dfinitions de fonctions des dfinitions de types synonymes ou de modles de structures
des dfinitions de fonctions
des directives de pr-compilation et des commentaires des directives de pr-compilation et des commentaires
Visibilit des fonctions J.-F. Lalande Programmation C 133/204
Une fonction est-elle visible ?

Si dclare plus haut dans le fichier source Visibilit des fonctions

Sinon le compilateur fait des suppositions...
Si dclare extern Une fonction est-elle visible ?
Si dclare plus haut dans le fichier source
extern ma_fonction(int truc); 1 Sinon le compilateur fait des suppositions...
Si dclare extern
extern ma_fonction(int truc);
extern : extern :
dclare dans un autre fichier
dclare dans un autre fichier dclare plus tard (plus bas)
dclare plus tard (plus bas)

Missions du prprocesseur
Traite le fichiers source avec le compilateur

Ne manipule que des chaines de caractres Missions du prprocesseur

Retire les commentaires /* */
Prend en compte les lignes en #. . .
#include Traite le fichiers source avec le compilateur
Ne manipule que des chaines de caractres
#define, #undef Retire les commentaires /* */
Prend en compte les lignes en #. . .
#if, #ifdef, #ifndef, #else, #endif #include
#define, #undef
#if, #ifdef, #ifndef, #else, #endif
Prprocesseur : les commentaires

Programme avec commentaires :

int a,b,c; 1 Prprocesseur : les commentaires
/ ajout a+b a c / 2
c += a +b ; 3 Programme avec commentaires :
/ 4 int a,b,c;
/ ajout a+b a c /
c += a +b ;
/
Aprs la phase de prprocessing : Aprs la phase de prprocessing :

int a,b,c;
c += a +b ;
int a,b,c; 1 /
c += a +b ; 2
/ 3 J.-F. Lalande Programmation C 136/204

4.3 Prprocessing et compilation spare Programmation C
Prprocesseur : directive include
Directive #include sert dfinir :

types non prdfinis, Prprocesseur : directive include I

modles et noms de structures,
types et noms de variables, Directive #include sert dfinir :
types non prdfinis,
prototypes de fonctions. modles et noms de structures,
types et noms de variables,
Utilisation : prototypes de fonctions.
Premier avantage : agrger les informations Utilisation :

Premier avantage : agrger les informations
Deuxime avantage : dclaration des prototypages Deuxime avantage : dclaration des prototypages
Diffrentes faons dinclure :

#include "/users/chris/essai/header.h" 2
#include "header.h" 3
Chemins standards ou dfinis la compilation (catalogues)

Chemin absolu, relatif au rpertoire de compilation
gcc lcatalogue 1
"" : catalogue courant, puis -l

<> : -l, puis catalogues par dfaut du compilateur
Prprocesseur : variables de pr-compilation
Dfinition de constantes :
Prprocesseur : variables de pr-compilation I

#define n 20 1
Dfinition de constantes :
Utile pour remplacer : #define n 20
Utile pour remplacer :

int tab[20];
int tab[20]; 1 for ( i = 0 ; i < 20 ; i++ )
for ( i = 0 ; i < 20 ; i++ ) 2 Par :

#define LG 20
int tab[LG];
for ( i = 0 ; i < LG ; i++ )
Par :
#define LG 20 1
int tab[LG]; 2
for ( i = 0 ; i < LG ; i++ ) 3
Utile aussi pour des expressions compliques :

#define MAXxy (x>y?x:y) 1
2
int z; 3
z = MAXxy 4
Attention cependant :
#define XMY xy 1
2
if (XMY 2 < z} 3
Prprocesseur : slection de code source

Programmation C 4.4 Fichiers
Slection de code source : Prprocesseur : slection de code source I

Dfinition dune variable
Test "dexistence" de la variable Slection de code source :
Dfinition dune variable
Test de la variable : Test "dexistence" de la variable
Test de la variable :
#ifndef variable 1 #ifndef variable

#define variable
// Code
#define variable 2 #endif
// Code 3 Effacement :
#endif 4 #undef variable
Effacement :
#undef variable 1
#define vrai 1 1
#define faux 0 2
#if vrai 3
// Code 4
#endif 5
#define DEBUG 1
#if defined DEBUG 2
code passe 3
#endif 4
#if defined(DEBUG) 5
code passe 6
#endif 7
Test plus complexe :

#define TRUC 1 1
#define CHOSE 0 2
#if TRUC && !CHOSE 3
... 4
#endif 5
Option la compilation gcc -Dvariable=valeur :

gcc -DCHOSE=1 -o truc truc.c
4.4 Fichiers
Introduction aux I/O
Les I/O dans les langages de programmation :

Notions avances du C Fichiers
2 modes possibles : Introduction aux I/O I

Forme brute dite binaire
comme la mmoire Les I/O dans les langages de programmation :
2 modes possibles :
dpendant du systme Forme brute dite binaire
comme la mmoire
dpendant du systme
Forme formate dite texte Forme formate dite texte
dpendant du jeu de caractres
dpendant du jeu de caractres 2 accs possibles :
Accs squentiel (dans lordre du fichier)
2 accs possibles : Accs direct
Accs squentiel (dans lordre du fichier) Accs par enregistrements
Accs direct J.-F. Lalande Programmation C 144/204
Accs par enregistrements

En C, les choses sont diffrentes :
Enregistrements : cela nexiste pas
Fichier vu comme collection doctets
Distinction fichier binaire/format :
faite parfois louverture

4.4 Fichiers Programmation C
dpend des implmentations
Types doprations :
binaire : fread, fwrite
format : fscanf, fprintf, fgets, fputs
mixte : fgetc, getc, fputc, puc
Accs squentiel/direct :
Pas de fonctions spcifiques
Manipulation du pointeur de fichier (octet)
Ouverture/Fermeture
Ouverture dun fichier :

FILE fopen(const char , const char ) ; 1 Ouverture/Fermeture
nom du fichier Ouverture dun fichier :

FILE fopen(const char , const char ) ;
type douverture nom du fichier
retour : pointeur sur un objet de type FILE type douverture
retour : pointeur sur un objet de type FILE
retour : pointeur NULL (erreur) retour : pointeur NULL (erreur)
Fermeture :
Fermeture : int fclose(FILE ) ;
int fclose(FILE ) ; 1
Lecture/Ecriture de caractres
Lecture/Ecriture de caractres :
int fgetc(FILE ); 1 Lecture/Ecriture de caractres

int fputc(int , FILE ) ; 2
Lecture/Ecriture de caractres :
int fgetc(FILE );
fgetc : la valeur du caractre lu dans un entier ; int fputc(int , FILE ) ;
EOF en cas derreur ou de fin de fichier fgetc : la valeur du caractre lu dans un entier ;
EOF en cas derreur ou de fin de fichier
FILE MyFic; 1 FILE MyFic;

int TheCar;
int TheCar; 2 MyFic = fopen (argv[1], r);
TheCar = fgetc (MyFic)
MyFic = fopen (argv[1], r); 3 fputc (TheCar, stdout)
TheCar = fgetc (MyFic) 4

fputc (TheCar, stdout) 5 J.-F. Lalande Programmation C 147/204
Ecriture
crire dans un fichier [?] :

#include <stdio.h> 1 Ecriture

2
int main(void) { 3 crire dans un fichier [1] :
FILE fic; 4 #include <stdio.h>
int i = 100; char c = C; double d = 1.234; 5 int main(void) {

FILE fic;
int i = 100; char c = C; double d = 1.234;
6
/ Ouverture du fichier /
/ Ouverture du fichier / 7 fic = fopen("fichier.dat", "w+");
/ Ecriture des donnes dans le fichier /
fic = fopen("fichier.dat", "w+"); 8 fprintf(fic, "%d %c %lf", i, c, d);
/ Fermeture du fichier /
/ Ecriture des donnes dans le fichier / 9 fclose(fic);
fprintf(fic, "%d %c %lf", i, c, d); 10

/ Fermeture du fichier / 11 J.-F. Lalande Programmation C 148/204
fclose(fic); 12
Lecture/Ecriture de string

Programmation C 4.4 Fichiers
Lecture de string : Lecture/Ecriture de string
char fgets(char , int , FILE ); 1

Lecture de string :
char fgets(char , int , FILE );
adresse de la zone de stockage des caractres en mmoire adresse de la zone de stockage des caractres en mmoire
nombre maximum de caractres (taille de la zone de stockage)
nombre maximum de caractres (taille de la zone de stockage) rfrence de type FILE du fichier ouvert
rfrence de type FILE du fichier ouvert renvoie : adresse reue en entre sauf en cas derreur
Attention linitialisation de la zone de stockage !
renvoie : adresse reue en entre sauf en cas derreur
Attention linitialisation de la zone de stockage ! J.-F. Lalande Programmation C 149/204
De manire similaire :
int fputs(const char , FILE ); 1
Retour : 0 ou EOF en cas derreur. De manire similaire :

int fputs(const char , FILE );
Pseudos fichiers : Retour : 0 ou EOF en cas derreur.
Pseudos fichiers :
stdin : entre standard stdin : entre standard
stdout : sortie standard stdout : sortie standard
Fin de fichier / Erreurs J.-F. Lalande Programmation C 150/204
Fin de fichier et indicateur derreur :

Fin de fichier / Erreurs

int feof(FILE stream); 1
int ferror(FILE stream); 2
Fin de fichier et indicateur derreur :
int feof(FILE stream);
int ferror(FILE stream);
indicateur disponible tout instant indicateur disponible tout instant
indiponible di fopen choue indiponible di fopen choue

fichier inexistant
fichier inexistant droits insuffisants (fichier, rpertoire)
disque satur, erreur matrielle
droits insuffisants (fichier, rpertoire) Certains implmentation de primitives ne positionnent pas lindicateur :
utiliser les valeurs de retours des fonctions.
disque satur, erreur matrielle
Certains implmentation de primitives ne positionnent pas lindicateur : utiliser les valeurs de retours des fonctions.
Accs par enregistrement
Accs par enregistrement :

Ouverture du fichier en mode binaire Accs par enregistrement

Permet dcrire/lire des structures :
Accs par enregistrement :
Ouverture du fichier en mode binaire
size_t fread(void Zone, size_t Taille, size_t Nbr, FILE fp) ; 1 Permet dcrire/lire des structures :
size_t fwrite(void Zone, size_t Taille, size_t Nbr, FILE fp) ; 2 size_t fread(void Zone, size_t Taille, size_t Nbr, FILE fp) ;
size_t fwrite(void Zone, size_t Taille, size_t Nbr, FILE fp) ;
Zone : pointeur vers la zone de mmoire

Zone : pointeur vers la zone de mmoire Taille : taille dun enregistrement (octets)
Nbr : nombre denregistrements
Taille : taille dun enregistrement (octets) fp : Pointeur vers le fichier
Retourne le nombre de structures changes
Nbr : nombre denregistrements
fp : Pointeur vers le fichier

Retourne le nombre de structures changes
Accs par enregistrement : exemple

4.4 Fichiers Programmation C
#include <stdio.h> 1 Accs par enregistrement : exemple I
#include <stddef.h> 2
struct automobile { 3 #include <stdio.h>
#include <stddef.h>
int age; 4 struct automobile {

int age;
char couleur[20], numero[10], type[10], marque[10];
char couleur[20], numero[10], type[10], marque[10]; 5 } ParcAuto[20];
} ParcAuto[20]; 6 int main (int argc, char argv[]) {

FILE TheFic; int i; size_t fait;
TheFic = fopen ("FicParcAuto", "rb+");
7 if (TheFic == NULL)
int main (int argc, char argv[]) { 8 {

printf ("Impossible d ouvrir le fichier FicParcAuto\n");
FILE TheFic; int i; size_t fait; 9 }

return 1;
for (i = 0; i < 20; i++)

TheFic = fopen ("FicParcAuto", "rb+"); 10
if (TheFic == NULL) 11 J.-F. Lalande Programmation C 153/204
{ 12
printf ("Impossible d ouvrir le fichier FicParcAuto\n"); 13
return 1; 14
} 15
for (i = 0; i < 20; i++) 16
{ 17
fait = fread (&ParcAuto[i], sizeof (struct automobile), 1, TheFic); 18
if (fait != 1) 19
{ 20
printf ("Erreur lecture fichier parcauto \n"); 21
return 2; 22
} 23
} 24
fclose (TheFic); 25
return 0; } 26
I/O Formattes
A la manire de printf/scanf :
I/O Formattes
int sprintf(char string, const char format, ...) ; 1
int sscanf(char string, const char format, ...) ; 2
int fprintf(FILE ,const char , ...) ; 3
int fscanf(FILE ,const char , ...) ; 4 A la manire de printf/scanf :
int sprintf(char string, const char format, ...) ;
int sscanf(char string, const char format, ...) ;
int fprintf(FILE ,const char , ...) ;
int fscanf(FILE ,const char , ...) ;
Retour : nombre de conversions russies.
Retour : nombre de conversions russies.
I/O Formattes : exemple

int fic; IntString is[4], lu; int i; 1 Notions avances du C Fichiers
2 I/O Formattes : exemple

if (fic = open("donnees.txt", O_CREAT | O_WRONLY, S_IRWXU)) { 3
for(i=0;i<4;i++) 4
int fic; IntString is[4], lu; int i;
{ 5
if (fic = open("donnees.txt", O_CREAT | O_WRONLY, S_IRWXU)) {
scanf("%d %s", &lu.x, lu.s); 6 for(i=0;i<4;i++)
{
write(fic, &lu, sizeof(IntString)); 7 scanf("%d %s", &lu.x, lu.s);
write(fic, &lu, sizeof(IntString));
printf("%d, Donnees ecrites : %d et %s\n", 8 printf("%d, Donnees ecrites : %d et %s\n",

i, lu.x, lu.s);
i, lu.x, lu.s); 9 } } else fprintf(stderr, "Erreur douverture...\n");
close(fic);
} } else fprintf(stderr, "Erreur douverture...\n"); 10
11
close(fic); 12 J.-F. Lalande Programmation C 156/204
Dplacement dans le fichier
Lecture/Ecriture : dplacement automatique

Dplacement par rapport une position courante Dplacement dans le fichier I
Lecture/Ecriture : dplacement automatique

Dplacement par rapport une position courante
int fseek(FILE , long, int) ;

long ftell(FILE ) ;
param 3 : SEEK_SET, SEEK_CUR, SEEK_END

Position courante :
long ftell(FILE ) ;
Conserver la position courante :

int fgetpos(FILE , fpos_t ) ;
Programmation C 4.5 Pointeurs de fonctions
int fseek(FILE , long, int) ; 1

long ftell(FILE ) ; 2
param 3 : SEEK_SET, SEEK_CUR, SEEK_END

Position courante :
long ftell(FILE ) ; 1
Conserver la position courante :

int fgetpos(FILE , fpos_t ) ; 1
Modifie la position courante :

int fsetpos(FILE , const fpos_t ) ; 1
Comme pour les K7 :

void rewind(FILE ) ; 1
Contrle du tampon
Modifier la zone mmoire tampon :

Contrle du tampon I
void setbuf(FILE flux, char tampon); 1
Exemple : Modifier la zone mmoire tampon :

void setbuf(FILE flux, char tampon);
char buf[BUFSIZ]; 1 Exemple :
setbuf(stdin, buf); 2 char buf[BUFSIZ];

setbuf(stdin, buf);
printf("Hello, world!\n"); 3 printf("Hello, world!\n");
Modifier la zone mmoire tampon, avec un mode :

_IONBF pas de tampon

_IOLBF tampon de ligne
_IOFBF tampon complet
int setvbuf (FILE stream, char buf, int mode , size_t size); 1
Vider le tampon :
int fflush(FILE ); 1
man setbuf Les trois types de tampons disponibles sont les suivants : pas de tampons, tampons de blocs, et tampons
de lignes. Quand un flux de sortie na pas de tampon, les donnes apparaissent dans le fichier destination, ou sur le
terminal, ds quelles sont crites. Avec les tampons par blocs, une certaine quantit de donnes est conserve avant
dtre crite en tant que bloc. Avec les tampons de lignes, les caractres sont conservs jusqu ce quun saut de ligne
soit transmis, ou que lon rclame une lecture sur un flux attach au terminal (typiquement stdin). La fonction fflush(3)
peut tre utilise pour forcer lcriture nimporte quel moment (voir fclose(3)). Normalement, tous les fichiers utilisent
des tampons de blocs. Quand une premire opration dentre-sortie se droule sur un fichier, malloc(3) est appele, et
un tampon est cr. Si le flux se rapporte un terminal (comme stdout habituellement) il sagit dun tampon de ligne.
Le flux standard de sortie derreur stderr na jamais de tampon par dfaut.
4.5 Pointeurs de fonctions

Pointeurs de fonctions

4.5 Pointeurs de fonctions Programmation C
Notions avances du C Pointeurs de fonctions
Objectif des pointeurs de fonctions : Pointeurs de fonctions

Manipuler des fonctions comme les variables
Passer en paramtre des fonctions Objectif des pointeurs de fonctions :
Manipuler des fonctions comme les variables
But : gnricit et modularit du code Passer en paramtre des fonctions
But : gnricit et modularit du code
Dclaration : Dclaration :
type (identificateur)(parametres);
type (identificateur)(parametres); 1
type est le type retour par la fonction
parametres sont les paramtres de la fonction
identificateur est le nom du pointeur de fonction
type est le type retour par la fonction
parametres sont les paramtres de la fonction J.-F. Lalande Programmation C 161/204
identificateur est le nom du pointeur de fonction
Pointeurs de fonctions : exemple
Exemple : pf pointeur de fonction (param : 2 int, retour : int)

int (pf)(int, int); / Dclare un pointeur de fonction. / 1 Pointeurs de fonctions : exemple
pf2 pointeur de fonction (param : 1 float, 1 int, retour : void) Exemple : pf pointeur de fonction (param : 2 int, retour : int)
int (pf)(int, int); / Dclare un pointeur de fonction. /
void (pf2)(float, int); / Dclare un pointeur de fonction. / 1 pf2 pointeur de fonction (param : 1 float, 1 int, retour : void)
void (pf2)(float, int); / Dclare un pointeur de fonction. /
En utilisant un typedef :
En utilisant un typedef : typedef int (PtrFonct)(int, int);
PtrFonct pf;
typedef int (PtrFonct)(int, int); 1

PtrFonct pf; 2
Utilisation

int f(int i, int j) / Dfinit une fonction. / { 1 Utilisation

return i+j; } 2
3
int f(int i, int j) / Dfinit une fonction. / {
int (pf)(int, int); / Dclare un pointeur de fonction. / 4 return i+j; }
5 int (pf)(int, int); / Dclare un pointeur de fonction. /
int main(void) { 6 int main(void) {

int l, m; / Dclare deux entiers. /
int l, m; / Dclare deux entiers. / 7 pf = &f;

printf("\nLeur somme est de : %u\n", (pf)(5,6));
}
pf = &f; 8
printf("\nLeur somme est de : %u\n", (pf)(5,6)); 9 pf sutilise comme un pointeur classique
pf pointe vers lespace mmoire de la fonction
} 10
pf sutilise comme un pointeur classique

pf pointe vers lespace mmoire de la fonction
Pointeur de fonction en paramtre
Intrt des pointeurs de fonctions :

Utiliser diffrentes fonctions la fois Pointeur de fonction en paramtre

Le pointeur pointe sur celle utiliser
Gnricit du code ! Intrt des pointeurs de fonctions :
Utiliser diffrentes fonctions la fois
Appel de fonctions avec pointeur de fonctions : Le pointeur pointe sur celle utiliser
Gnricit du code !
void classer(int (pf)(int, int)) 1 Appel de fonctions avec pointeur de fonctions :

void classer(int (pf)(int, int))
Le paramtre est une fonction

Le paramtre est une fonction La fonction classer recoit une fonction en paramtre
La fonction donne est modulable
La fonction classer recoit une fonction en paramtre
La fonction donne est modulable J.-F. Lalande Programmation C 164/204

Programmation C 4.5 Pointeurs de fonctions
Exemple dutilisation concrte
#include <stdio.h> 1 Notions avances du C Pointeurs de fonctions
#include <math.h> 2 Exemple dutilisation concrte I

#define N 5 3
4 #include <stdio.h>
#include <math.h>
int compare1(int i, int j) / Comparaison standard / { 5 #define N 5
return i>j; } 6 int compare1(int i, int j) / Comparaison standard / {

return i>j; }
int compare2(int i, int j) / Comparaison de 2i et j / { 7 int compare2(int i, int j) / Comparaison de 2i et j / {
return 2i < j; }
return 2i < j; } 8 void classer(int numtest, int reference, int tab[N], int (pf)(int, int)) {
int i;
9 for (i=0; i<N; i++) {
if ((pf)(tab[i], reference)) {
void classer(int numtest, int reference, int tab[N], int (pf)(int, int)) { 10 printf("Test %i: condition ok pour ref=%i tab[%i]=%i\n",numtest,reference,i,tab[i])
;
int i; 11 }}}
for (i=0; i<N; i++) { 12 J.-F. Lalande Programmation C 165/204
if ((pf)(tab[i], reference)) { 13
printf("Test %i: condition ok pour ref=%i tab[%i]=%i\n",numtest,reference,i,tab[i]); 14
}}} 15
16
int main(void) { 17
int i; int tab[N]; 18
int (pf)(int, int); / Dclare un pointeur de fonction. / 19
srand(time(NULL)); 20
for (i=0; i<N; i++) 21
tab[i] = rand() % 800; 22
pf = &compare1; 23
classer(1,500,tab,pf); 24
pf = &compare2; 25
classer(2,500,tab,pf); } 26

Programmation C
5 Divers
5.1 gcc
Options de gcc
ptions intressantes de gcc (Nicolas Jouandeau [?])

-o file pour renommer le fichier de sortie file. Sans cette option, le fichier
Divers gcc
Options de gcc I
de sortie se nomme a.out,
-c -o file1.o pour crer un fichier-objet, ptions intressantes de gcc (Nicolas Jouandeau [6])
-o file pour renommer le fichier de sortie file. Sans cette
file1.c -o a.out file2.o file3.o pour crer un fichier ex- option, le fichier de sortie se nomme a.out,
-c -o file1.o pour crer un fichier-objet,
file1.c -o a.out file2.o file3.o pour crer un fichier
cutable rsultant du programme file1.c utilisant des fonctions dfinies dans excutable rsultant du programme file1.c utilisant des fonctions
dfinies dans les fichiers-objet file2.o et file3.o rsultats respectifs
les fichiers-objet file2.o et file3.o rsultats respectifs de la compilation sans de la compilation sans dition de liens de deux programmes C,
-O rduit la taille du code et le temps dxecution du programme,
dition de liens de deux programmes C, -O1 augmente le code en droulant les fonctions,
-O rduit la taille du code et le temps dxecution du programme, -O2 optimise plus que O1,
-Os diminue au maximum la taille du programme,
-O1 augmente le code en droulant les fonctions, J.-F. Lalande Programmation C 168/204
-O2 optimise plus que O1,

-Os diminue au maximum la taille du programme,
-I rpertoire ajoute le rpertoire rep dans la tte de liste des rpertoires con-
tenant hypothtiquement les fichiers dentte inclus,
-l rpertoire ajoute un librairie dans la phase ddition de liens,
-L rpertoire ajoute le rpertoire rep dans la tte de liste des rpertoires con-
tenant hypothtiquement les librairies utilises,
-Dnom ralise lquivalent dun #define nom,
-Dnom=valeur ralise lquivalent dun #define nom valeur,
-include file ralise lquivalent dun #include file,
-g produit des informations de dboguage (il annule loption -O),
-Wall combine toute les options -W,
-Werror transforme tous les warnings en erreurs,
-pedantic assure la norme des warnings au strict C et C++ ISO,
-ansi impose au code dtre conforme la norme ANSI (du langage corre-
spondant).
Bibliothque partage
Cration de la bibliothque :
Divers gcc
gcc c moperations.c 1 Bibliothque partage
gcc c mnonoperations.c 2
ld G o mabib.so moperations.o mnonoperations.o 3
Cration de la bibliothque :
gcc c moperations.c
gcc c mnonoperations.c
Utilisation de la bibliothque : ld G o mabib.so moperations.o mnonoperations.o
Utilisation de la bibliothque :
gcc main.c lmabib 1 gcc main.c lmabib
Pensez aux .h de votre bibliothque !
Pensez aux .h de votre bibliothque !

5.2 Ncurses
Ncurses
Quest ce que ncurses ?

Divers Ncurses
Manipulation de lcran pour le jeu rogue Ncurses

Manipulation de
curseurs
couleurs Quest ce que ncurses ?
Manipulation de lcran pour le jeu rogue
Manipulation de
curseurs
couleurs
menus
Article de rfrence : [8]

Programmation C 5.2 Ncurses
menus
Article de rfrence : [?]
Exemple Ncurses
n premier exemple :
Divers Ncurses
Exemple Ncurses I
#include <stdlib.h> 2 n premier exemple :
#include <curses.h> 3 #include <stdio.h>
#include <stdlib.h>
#include <signal.h> 4 #include <curses.h>
#include <signal.h>
5 static void finish(int sig);
static void finish(int sig); 6 int main(int argc, char argv[])
{
7 int num = 0;
int main(int argc, char argv[]) 8 / initialize your noncurses data structures here /
(void) signal(SIGINT, finish); / arrange interrupts to terminate /
{ 9
(void) initscr(); / initialize the curses library /
int num = 0; 10
11
/ initialize your noncurses data structures here / 12
(void) signal(SIGINT, finish); / arrange interrupts to terminate / 13
14
(void) initscr(); / initialize the curses library / 15
keypad(stdscr, TRUE); / enable keyboard mapping / 16
(void) nonl(); / tell curses not to do NL>CR/NL on output / 17
(void) cbreak(); / take input chars one at a time, no wait for \n / 18
(void) echo(); / echo input in color / 19
20
if (has_colors()) 21
{ 22
start_color(); 23
24
/ 25
Simple color assignment, often all we need. Color pair 0 cannot 26
be redefined. This example uses the same value for the color 27
pair as for the foreground color, though of course that is not 28
necessary: 29
/ 30
init_pair(1, COLOR_RED, COLOR_BLACK); 31
init_pair(2, COLOR_GREEN, COLOR_BLACK); 32
init_pair(3, COLOR_YELLOW, COLOR_BLACK); 33
init_pair(4, COLOR_BLUE, COLOR_BLACK); 34
init_pair(5, COLOR_CYAN, COLOR_BLACK); 35
init_pair(6, COLOR_MAGENTA, COLOR_BLACK); 36
init_pair(7, COLOR_WHITE, COLOR_BLACK); 37
} 38
39
for (;;) 40
{ 41
int c = getch(); / refresh, accept single keystroke of input / 42
attrset(COLOR_PAIR(num % 8)); 43
num++; 44
/ process the command keystroke / 45
} 46
47
finish(0); / were done / 48
} 49
50
static void finish(int sig) 51
{ 52
endwin(); 53
/ do your noncurses wrapup here / 54
exit(0); 55
} 56
Compilation et fonctions

5.2 Ncurses Programmation C
Divers Ncurses
Pour compiler un programme utilisant ncurses : Compilation et fonctions
gcc lncurses o prog mon_programme.c 1

Pour compiler un programme utilisant ncurses :
gcc lncurses o prog mon_programme.c
initscr() : initialisation du terminal et de ncurses initscr() : initialisation du terminal et de ncurses

endwin() : restaurer ltat du TTY, remettre le curseur au bon
endwin() : restaurer ltat du TTY, remettre le curseur au bon endroit endroit
refresh() : effacer lcran
refresh() : effacer lcran move(int, int) : se dplacer en (y,x)
addch(char) : afficher un caractre aux coordonnes (y, x)
move(int, int) : se dplacer en (y,x) trace(int level) : gnre une trace des actions ncurses
dans un fichier
addch(char) : afficher un caractre aux coordonnes (y, x)
trace(int level) : gnre une trace des actions ncurses dans un fichier J.-F. Lalande Programmation C 176/204
Exemples
Exemple :
Divers Ncurses
#include <stdio.h> 1 Exemples
#include <stdlib.h> 2 Exemple :

#include <curses.h> 3 #include <stdio.h>
#include <stdlib.h>
#include <signal.h> 4 #include <curses.h>
#include <signal.h>
static void finish(int sig); 5 static void finish(int sig);
int main(int argc, char argv[]) {

6 signal(SIGINT, finish); / arrange interrupts to terminate /
initscr(); / initialize the curses library /
int main(int argc, char argv[]) { 7 move(5,4);
addch(a);
signal(SIGINT, finish); / arrange interrupts to terminate / 8 move(5,7);
addch(b);
initscr(); / initialize the curses library / 9 int c = getch(); // To make a pause...
finish(0);
move(5,4); 10 }
addch(a); 11 static void finish(int sig) {

endwin();
exit(0);
move(5,7); 12 }
addch(b); 13 Sortir/Restaurer du mode ncurses :

addstr("Shelling out...");
int c = getch(); // To make a pause... 14 def_prog_mode(); / save current tty modes /
endwin(); / restore original tty modes /
finish(0); 15 system("sh"); / run shell /
addstr("returned.\n"); / prepare return message /
refresh(); / restore save modes, repaint screen /
} 16
17
static void finish(int sig) { 18
endwin(); 19
exit(0); 20
} 21
Sortir/Restaurer du mode ncurses :

addstr("Shelling out..."); 1
def_prog_mode(); / save current tty modes / 2
endwin(); / restore original tty modes / 3
system("sh"); / run shell / 4
addstr("returned.\n"); / prepare return message / 5
refresh(); / restore save modes, repaint screen / 6
Ncurses : menus
Cration dun menu :

Divers Ncurses
1. Initiliser ncurses menu Ncurses : menus I
2. Crer les items du menu avec new_item Cration dun menu :

1 Initiliser ncurses menu
3. Crer le menu avec new_menu 2 Crer les items du menu avec new_item
3 Crer le menu avec new_menu
4. Poster le menu avec post_menu 4
5
Poster le menu avec post_menu
Rafraichir lcran
6 Traiter les demandes de lutilisateur dans une boucle
5. Rafraichir lcran 7 Dposter le menu
8 Librer le menu avec free_menu
Librer les items avec free_item
6. Traiter les demandes de lutilisateur dans une boucle 9
10 Terminer ncurses
7. Dposter le menu J.-F. Lalande Programmation C 178/204
8. Librer le menu avec free_menu

Programmation C 5.2 Ncurses
9. Librer les items avec free_item
10. Terminer ncurses
ITEM new_item(const char name, const char description); 1

int free_item(ITEM item); 2
MENU new_menu(ITEM items); 3
int free_menu(MENU menu); 4
int post_menu(MENU menu); 5
int unpost_menu(MENU menu); 6
Agir sur le menu :

Dplacer la selection : set_current_item
Rcuprer la selection : get_current_item
Vers le bas/haut : menu_driver
int set_current_item(MENU menu, const ITEM item); 1
ITEM current_item(const MENU menu); 2
int menu_driver(MENU menu, int c); 3
Exemple :
#include <curses.h> 3
#include <menu.h> 4
#include <signal.h> 5
static void finish(int sig); 6
7
int main(int argc, char argv[]) { 8
int c; 9
signal(SIGINT, finish); 10
initscr(); 11
noecho(); 12
ITEM myitem[4]; 13
myitem[0] = new_item("Menu", "Description 1"); 14
myitem[1] = new_item("Menu2", "Description 2"); 15
myitem[2] = new_item("Menu3", "Description 3"); 16
myitem[3] = NULL; 17
MENU menu = new_menu(myitem); 18
post_menu(menu); 19
refresh(); 20
c = getch(); // Pause 21
set_current_item(menu, myitem[1]); // Dplacer la slection 22
refresh(); 23
c = getch(); // Pause 24
move(5,5); 25
refresh(); 26
printf("menu: %s", current_item(menu)>description); 27
while((c = getch()) != x) { 28
switch(c) { 29
case s: 30
menu_driver(menu, REQ_DOWN_ITEM); 31
break; 32
case z: 33
menu_driver(menu, REQ_UP_ITEM); 34
break; 35
case 10: / Enter / 36
move(20, 0); 37
clrtoeol(); 38
mvprintw(20, 0, "Item selected is : %s", 39
item_name(current_item(menu))); 40
pos_menu_cursor(menu); 41
break; 42
} 43
refresh(); 44
} 45
unpost_menu(menu); 46
free_menu(menu); 47
int i; 48
for(i = 0; i < 4; i++) 49

5.3 Oprations binaires Programmation C
free_item(myitem[i]); 50
finish(0); 51
} 52
53
static void finish(int sig) { 54
endwin(); 55
exit(0); 56
} 57
Pour compiler les menus :

#include <menu.h> 1
gcc lncurses lmenu o prog mon_programme.c 2
5.3 Oprations binaires

Oprateurs binaires
Oprations bit bit :

& : et bit bit
Divers Oprations binaires
Oprateurs binaires
| : ou bit bit
^ : ou exclusif bit bit Oprations bit bit :
~ : complment 1 bit bit & : et bit bit
| : ou bit bit
Opration : op1 oprande op2 ^ : ou exclusif bit bit
~ : complment 1 bit bit
op1 et op2 de type int ou char Opration : op1 oprande op2
op1 et op2 de type int ou char
type de retour : int uniquement type de retour : int uniquement
Oprateurs de dcalage J.-F. Lalande Programmation C 184/204
Oprations de dcalage :
>> : dcalage droite
Oprateurs de dcalage
<< : dcalage gauche
Dcalage gauche :
Oprations de dcalage :
expr1 << expr2 >> : dcalage droite
<< : dcalage gauche
expr1 est dcale gauche de expr2 bits Dcalage gauche :
expr1 << expr2
Des zros sont ajouts si ncessaire expr1 est dcale gauche de expr2 bits
Des zros sont ajouts si ncessaire
type de retour : du type de loprande de gauche type de retour : du type de loprande de gauche
Exemples doprations binaires J.-F. Lalande Programmation C 185/204
Affichage binaire, tir de [?].

Exemples doprations binaires I

Listing 3 Affichage binaire
Affichage binaire, tir de [4].
/ file name : bin_print.c 1
Listing 3 Affichage binaire
authors : JeanAlain Le Borgne 2 / file name : bin_print.c
copyright : Universit Paris 8 3 authors : JeanAlain Le Borgne

copyright : Universit Paris 8
/
/ 4 #include <stdio.h>
#include <stdlib.h>
#include <stdio.h> 5 #include <limits.h>
#include <stdlib.h> 6 void bin_print(long n, int taille) {

unsigned long mask= 1 << ((taille CHAR_BIT) 1);
#include <limits.h> 7 printf("%ld: ", n);
while (mask > 0) {
8
void bin_print(long n, int taille) { 9 J.-F. Lalande Programmation C 186/204
unsigned long mask= 1 << ((taille CHAR_BIT) 1); 10

11
printf("%ld: ", n); 12
while (mask > 0) { 13
putchar(n & mask ? 1 : 0); 14
mask>>= 1; 15

Programmation C 5.3 Oprations binaires
} 16
putchar(\n); 17
} 18
19
void bin_print_char(char n) { 20
bin_print(n, sizeof(n)); 21
} 22
23
void bin_print_int(int n) { 24
bin_print(n, sizeof(n)); 25
} 26
Listing 4 Affichage -1 255 char

authors : JeanAlain Le Borgne 2
copyright : Universit Paris 8 3
4
modifications: 5
separated in two files 6
/ 7
#include <limits.h> 10
11
extern void bin_print(long n, int taille); 12
extern void bin_print_char(char n); 13
extern void bin_print_int(int n); 14
15
int main() { 16
bin_print_int(1); 17
bin_print_int(255); 18
19
bin_print_char(1); 20
bin_print_char(255); 21
22
return EXIT_SUCCESS; 23
} 24
Listing 5 Excution Affichage -1 255 char

1: 11111111111111111111111111111111 1
255: 00000000000000000000000011111111 2
1: 11111111 3
1: 11111111 4
Listing 6 Non, ou, et

authors : J.F. Lalande 2
copyright : Ensi de Bourges 3
4
modifications: 5
separated in two files 6
/ 7
#include <limits.h> 10
11
extern void bin_print(long n, int taille); 12
extern void bin_print_char(char n); 13
extern void bin_print_int(int n); 14
15
int main() { 16
int c = 17; 17
int d = 204; 18
printf("c:"); 19
bin_print_int(c); 20
printf("d:"); 21

5.4 Cest tout cass, ca marche pas Programmation C
bin_print_int(d); 22
printf("~c:"); 23
bin_print_int(~c); 24
printf("c|d:"); 25
bin_print_int(c | d); 26
printf("c&d:"); 27
bin_print_int(c & d); 28
printf("c << 2:"); 29
bin_print_int(c << 2); 30
printf("d >> 2:"); 31
bin_print_int(d >> 2); 32
33
return EXIT_SUCCESS; 34
} 35
Listing 7 Excution Non, ou, et

c:17: 00000000000000000000000000010001
d:204: 00000000000000000000000011001100
~c:-18: 11111111111111111111111111101110
c|d:221: 00000000000000000000000011011101
c&d:0: 00000000000000000000000000000000
c << 2:68: 00000000000000000000000001000100
d >> 2:51: 00000000000000000000000000110011
Le masquage
Forcer 1 les 9 bits de poids faible :

n = n | 0x1FFu ; / u : masque non s i g n / Le masquage

n | = 0x1FFu ; / c r i t u r e ramasse /
Forcer 0 les 9 bits de poids faible : n = n | 0x1FFu ; / u : masque non s i g n /

n | = 0x1FFu ; / c r i t u r e ramasse /

n = n & ~0x1FFu ; / u : masque non s i g n / n = n & ~0x1FFu ; / u : masque non s i g n /
Forcer le bit de rang i :

Forcer le bit de rang i : n = n | ( 1 u << i ) ;
Connatre le bit de rang i :

n = n | ( 1 u << i ) ; p = n & ( 1 u << i ) ;
Connatre le bit de rang i : J.-F. Lalande Programmation C 193/204
p = n & ( 1 u << i ) ;
5.4 Cest tout cass, ca marche pas

Affectation
Suggest parentheses around assignment used as truth value

Divers Cest tout cass, ca marche pas
Utilisez des parenthses autour daffectations utilises comme valeurs logiques Affectation
if (a=b) { 1
... 2 Suggest parentheses around assignment used as truth value
Utilisez des parenthses autour daffectations utilises comme valeurs
logiques
if (a=b) {
...
if (a==b) { 1
... 2 if (a==b) {
...
if ((a=b)) {
if ((a=b)) { 3 ...
if ((a=b)!=0) {
... 4 ...
if ((a=b)!=0) { 5
... 6 J.-F. Lalande Programmation C 194/204
Format du printf

Programmation C 5.4 Cest tout cass, ca marche pas
Unknown conversion type character c in format Format du printf

Too few/many arguments for format
Type de format faux (%c,%i,...), ou nombre darguments faux.
Unknown conversion type character c in format
printf("valeur: %d", var1, var2); 1 Too few/many arguments for format

Type de format faux (%c,%i,...), ou nombre darguments faux.
printf("valeur: %d", var1, var2);
Et le fameux :
Et le fameux : s c a n f ("%30 s " , s t ) ; / Et l e & ? /
s c a n f ("%30 s " , s t ) ; / Et l e & ? /
Return
Control reaches end of non void function

Aucune instruction "return" trouve avant la fin de la fonction. Return
int fonction(int a) { 1 Control reaches end of non void function

Aucune instruction "return" trouve avant la fin de la fonction.
if (a>0) { 2 int fonction(int a) {
if (a>0) {
return 1; 3 return 1;
}
} 4 }
} 5 Solutions :
void func(int a) { int func(int a) {

if (a>0) if (a>0) {
Solutions : printf("a positif"); return 1; }
return 0;
} }
void func(int a) { 1int func(int a) { 1

if (a>0) 2 if (a>0) { 2
printf("a positif"); 3 return 1; } 3
4 return 0; 4
} 5} 5
Dclarations
Implicit declaration of function func

La fonction utilise na pas t dclare. Par dfaut, ce sera : Dclarations
int func(); 1 Implicit declaration of function func

La fonction utilise na pas t dclare. Par dfaut, ce sera :
int func();
too few/many arguments to function func too few/many arguments to function func
Pas le bon nombre darguments...
Pas le bon nombre darguments... int a,b;
int func(int a, double b);
func(a);
int a,b; 1 Passing arg n of func from incompatible pointer type
int func(int a, double b); 2 Ca progresse : le bon nombre mais le type nest pas bon !
func(a); 3 func(a,a);
Passing arg n of func from incompatible pointer type

Ca progresse : le bon nombre mais le type nest pas bon !
func(a,a); 1
Pointeurs et entiers
Passing arg n of func makes pointer from integer without a cast

int length = 48; 1 Pointeurs et entiers

int truc; 2
truc = strlen(length); 3
Passing arg n of func makes pointer from integer without a cast
int length = 48;
int truc;
truc = strlen(length);

5.4 Cest tout cass, ca marche pas Programmation C
Break dans un switch
Erreur classique (difficile voir) : loubli du break.

int x = 2; 1 Break dans un switch
switch(x) { 2
case 2: 3
printf("Two\n"); 4 Erreur classique (difficile voir) : loubli du break.
int x = 2;
case 3: 5 switch(x) {
case 2:
printf("Three\n"); 6 printf("Two\n");
case 3:
} 7 }
printf("Three\n");
Feof et fgets
Ca ne marche pas (double affichage de la dernire ligne, feof renvoie true lorsque
fgets choue) : Feof et fgets I
Ca ne marche pas (double affichage de la dernire ligne, feof renvoie
int main() { 2 true lorsque fgets choue) :
FILE fp = fopen("test.txt", "r"); 3 #include <stdio.h>
int main() {
char line[100]; 4 FILE fp = fopen("test.txt", "r");
char line[100];
5 while( ! feof(fp) ) {
while( ! feof(fp) ) { 6 fgets(line, sizeof(line), fp);

fputs(line, stdout);
}
fgets(line, sizeof(line), fp); 7 fclose(fp);
return 0; }
fputs(line, stdout); 8
fclose(fp); 10
return 0; } 11
Cest mieux (mme si cest moche) :

int main() { 2
FILE fp = fopen("test.txt", "r"); 3
char line[100]; 4
while( 1 ) { 5
fgets(line, sizeof(line), fp); 6
if ( feof(fp) ) / check for EOF right after fgets() / 7
break; 8
fputs(line, stdout); } 9
fclose(fp); 10
return 0; } 11
Carrment plus mieux (fgets renvoie NULL le dernier coup) :

int main() 2
{ 3
FILE fp = fopen("test.txt", "r"); 4
char line[100]; 5
6
while( fgets(line, sizeof(line), fp) != NULL ) 7
fputs(line, stdout); 8
fclose(fp); 9
return 0; 10
} 11
Je boucle linfini (balze)
int main(int argc, char argv){ 1 Divers Cest tout cass, ca marche pas
int i, tab[9]; 2 Je boucle linfini (balze) I
int main(int argc, char argv){

J.-F. Lalande 55/56 int i, tab[9];
int p;
Ensi de Bourges
p=&tab[1];
// Remplire le tableau de 4
for(i=0;i<9;i++){
(p+i)=4;
printf("%i ", i);
}}
0 1 2 3 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4
5 6 7 4 5 6 7 4 ...
Programmation C 5.4 Cest tout cass, ca marche pas
int p; 3
p=&tab[1]; 4
// Remplire le tableau de 4 5
for(i=0;i<9;i++){ 6
(p+i)=4; 7
printf("%i ", i); 8
}} 9
0 1 2 3 4 5 6 7
4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 5 6 7 4 ...

2015 10 11 Cours-C

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

2015 10 11 Cours-C

Cargado por

Copyright:

Formatos disponibles

Programmation C

Table des matires

3 Les tableaux et pointeurs 24

J.-F. Lalande 2/56 Ensi de Bourges

Quelques faits marquants :

cr en 1972 par Dennis Richie et Ken Thompson Faits marquants

1990 : norme ISO/IEC 9899 1973 Alan Snyder crit un compilateur C

Les anctres, extrait de [?]

C a trois anctres : les langages CPL, BCPL et B.

Historique, extrait de [?]

1978 - K&R C : La plus ancienne version de C encore en usage a t for-

oriente objet inspir de Smalltalk.

J.-F. Lalande 3/56 Ensi de Bourges

Un programme est produit partir dun fichier source dont un compilateur se

sert pour produire un fichier excutable : Premier programme

Listing 1 Exemple de premier programme : Hello world !

int main(int argc, char argv)

Ce quil faut remarquer propos de ce premier programme :

Instructions dlimites par un ; Premiers principes

Retour du programme : return Parenthses et accolade (notion de paramtre et de bloc)

Lalphabet du C est bas sur la langue anglaise laquelle on ajoute un cer-

A B C D E F G H I J K L M N O P Q R S T U VWX Y Z 2 ! " # % & ( ) + ,

space , h o r i z o n t a l and v e r t i c a l tab 6

gcc options fichier1.c fichier2.c ...

Compilation en deux phases : Compilation

gcc -o prog fichier.o gcc -c fichier.c

ou en une seule fois :

J.-F. Lalande 4/56 Ensi de Bourges

Attention, les espaces importent !

Attention, les espaces importent !

Excution du fichier prog :

Les diffrentes phases de compilation sont :

Le traitement par le prprocesseur : le fichier source est analys par un Compilation

Ldition de liens : assemblage des diffrents fichiers objets

1.3 Types et variables

char d, ma_variable; 3 int a;

Dclaration : J.-F. Lalande Programmation C 16/204

J.-F. Lalande 5/56 Ensi de Bourges

Introduction Types et variables

Rgle sur les identifiants (labels) des variables : Identifiants de variables

La gestion des espaces blancs et le format libre

Chaque instruction du langage est dlimit par le point virgule. Le

est libre de ltaler sur plusieurs lignes. int x

int x 1 J.-F. Lalande Programmation C 18/204

Linstruction printf permet denvoyer des caractres sur la sortie standard.

printf("Affichage de texte\n"); 2 printf("Affichage de %i\n", x);

Son prototype gnral dutilisation est donc :

J.-F. Lalande Programmation C 19/204

Son prototype gnral dutilisation est donc :

Code de formats autoriss dans la chane :

%i : integer, %d : double Printf (2)

J.-F. Lalande Programmation C 20/204

Le type flottant (rels) :

Notation mantisse/exposant : 0.453 E 15 Les flottants

Les flottants (2)

Consquence de cette approximation :

#include <stdio.h> 1 Les flottants (2)

x avec 1 decimale: 1.0e-01

J.-F. Lalande 7/56 Ensi de Bourges

Introduction Types et variables

Non respect des rgles de lalgbre : Comparaisons difficiles !

On prfrera (avec eps tq eps + 1 == eps) :

On prfrera (avec eps tq eps + 1 == eps) : float eps = 0.000001;