Base C

L2 - UE Programmation 3
Langage C
2009 2010
Equipe pédagogique:
Florence Cloppet
Neilze Dorta
David Janiszek
prenom.nom@math-info.univ-paris5.fr
prenom.nom@mi.parisdescartes.fr
Sommaire
1. Informations administratives
2. Introduction
3. Programmer en Langage C
4. Notions de Langage C
1. Variables , Constantes
2. Opérateurs
3. Fonctions
4. Pointeurs
5. Tableaux
6. Tableaux de caractères – chaîne de caractères
7. Synthèse Tableaux - Pointeurs / Tableau de Pointeurs
8. Structures – Unions – Énumérations
9. Fichiers
10. Pré-processeur
11. Compilation séparée
12. Intégration d’un programme C dans l’environnement hôte
UE programmation 3 – F. Cloppet 2
Informations Administratives (1)
Emploi du Temps
Cours lundi 13h00-14h30 amphi Giroud
L2 : 1TD et 1TP / semaine
groupe 5
lundi 8h30-10h et 10h15-12h15 : D. Janizsek
groupe 8
mardi 10h15-11h45 et 12h45-14h45 : F. Cloppet
groupe 4
jeudi 12h30-14h00 et 14h15-16h15 : N. Dorta
groupe 6
jeudi 14h30-16h00 et 16h30-18h30 : D. Janizsek
Informations Administratives (2)
Contrôle des Connaissances
1 Contrôle Continu sur machine à la mi-novembre (CC)
1 examen final (sur papier)
Note finale = max ((CC+Examen) /2, Examen)
Bibliographie
La Bible ….
Le langage C Norme ANSI , Brian W. Kernighan et
Dennis M. Ritchie, Dunod 2ème Edition (2004)
Un peu plus pédagogique

Programmer en langage, Claude Delannoy, Eyrolles
(2002)
Remarque
Poly disponible sur

http://www.math-info.univ-paris5.fr/~cloppet/prog3/PolyProg3_2009.pdf
Attention ceci n’est qu’un résumé à trous …

des transparents de cours
Ce poly n’est là que pour vous aider à la prise de notes et ne

vous dispense en aucun cas d’assister au cours !!!!
Introduction / Notions de base (1)
Un ordinateur permet :
la saisie d’informations ,
le traitement des informations saisies ,
le stockage des informations et des résultats des traitements ,
la visualisation des résultats.
Un système informatique RAM

Disquette
ROM CDROM
Mémoire centrale CPU
Disque Dur
Clavier Moniteur Imprimante
Introduction / Notions de base (2)
l’utilisateur et les programmes

système d’exploitation
les programmes applicatifs
programmes développés
Relations programmes - Machines

système binaire =>langage machine
langage d’assemblage ou assembleur
langages de haut niveau
Introduction / Activité de programmation (1)
Étudier le problème à résoudre
solution programmable ?
Développer un programme optimal

programme fait ce qu’il est censé faire
programme prend en compte les situations anormales
programme facile à modifier et à étendre
Limiter les coûts de production
Appel aux techniques du génie logiciel

le développement d’un logiciel doit être divisé en plusieurs parties pour
être contrôlable
modèles de développement de logiciels
Introduction / Activité de programmation (2)
Aspects de conception liés aux problèmes Aspects de conception liés
impliquant le monde réel à la conception elle-même
Problème Enoncé du Spécification

Saisie des problème exigences du système
exigences fonctionnelles
conception
initiale
Modèles abstraits
du système
améliorations
successives
conception
finale
livraison
Modèle final
Solution
(code source)
Vue générale des activités de développement d’un système

Introduction / Langage C
Conçu par B.W. Kernighan et D.M. Ritchie (années 1970)
pour développer le système d’exploitation Unix sur les stations de
travail
Langage structuré de haut niveau (fonctions, structures de contrôle

etc.)
Langage de bas niveau (opérateurs permettant de travailler au
niveau du codage machine)
Il s’étend des stations de travail aux micro-ordinateurs
Norme C ANSI (American Standards National Institute)

donner une définition non ambiguë et indépendante de la machine
C++ est une extension de C
Programmer en Langage C (1)
Réflexion (PHASE PRIMORDIALE)
Saisie des instructions du code dans un fichier texte

fichier source qui doit avoir comme extension .c
Une application peut être conçue comme une collection de modules,

chaque module pouvant être :
une collection de sous-programmes,
une collection de données partagées.
De tels modules peuvent constituer des unités de programmes en C

chacune mémorisée dans un fichier.
Une unité de programme constitue une unité de compilation ou

projet.
Programmer en Langage C (2)
Compilation (3 étapes)
phase de pré-processing des
fichiers *.c
fic1.c fic1.h fic2.c fic2.h
cc -c fic1.c cc -c fic2.c
compilation des fichiers *.c
fic1.o fic2.o
cc fic1.o fic2.o -o toto
édition des liens

toto
Exemple des phases de compilation et d'édition

de liens avec le compilateur cc sous UNIX.
Programmer en Langage C / Illustration par
l’exemple
#include <stdio.h> on demande d'inclure la librairie stdio.h.
void main() la fonction main sans argument

{ début du bloc de la fonction main
/* Ecriture de Bonjour */ un commentaire
printf("Bonjour !\n"); une instruction composée de la fonction printf
} fin du bloc de la fonction main
Après compilation de bonjour.c, le lancement du programme affiche à

l'écran :
Bonjour !
Programmer en Langage C / Programme ? (1)
programme = traduction en instructions
Exemple : problème : Affichage des carrés des nombres

de 0 à 9
Algorithme :
Calculer puis afficher le carré de 0
..........
Programme :
Le carré de 0 est 0
#include <stdio.h> Le carré de 1 est 1
void main() Le carré de 2 est 4
{ Le carré de 3 est 9
printf("Le carré de 0 est %d\n", 0*0); Le carré de 4 est 16
printf("Le carré de 1 est %d\n", 1*1); Le carré de 6 est 36
…… etc………
printf("Le carré de 8 est %d\n", 8*8);
printf("Le carré de 9 est %d\n", 9*9);
}
#include <stdio.h> On demande d'inclure la librairie stdio.h.
#define NBFOIS 10 définition de la constante symbolique NBFOIS = 10
int carre (int a) définition de la fonction carre

{ début du bloc de la fonction carre
return (a * a); on retourne la valeur entière a*a
} fin du bloc de la fonction carre
void main() définition de la fonction main

{ début du bloc de la fonction main
int i, j; déclaration des variables entières i et j
for(i = 0; i < NBFOIS; i++){ boucle for de 0 à NBFOIS-1

j = carre(i); appel de la fonct. carre et affect. du résultat à j
printf("Le carré de %d est %d\n",i,j);
} fin du bloc for
} fin du bloc de la fonction main
Programmer en Langage C /Structure d’un programme C
monfichier.c
#include <fichier d'entête> Directives de compilation
#define constante valeur du préprocesseur
typedef struct duo { Définitions des types
int a, b;
}tduo;
Définitions des fonctions
extern int VarGlobaleExt; et variables externes
typefct1 fonction1(int, char);
typefct2 fonction2(int, int); Paramétrage des fonctions internes
int VarGlobaleInt; Définitions des variables globales

au fichier
typefct1 fonction1(int a, char b)
{

return(variable1);
}
typefct2 fonction2(int a, b)
{
return(variable2);
}
void main()
{
int a, b;
Définition de la fonction main et
a = fonction1(2,'a'); appel d'autres fonctions.
b = fonction2(2,3);
}
Notions Langage C
Identificateurs
lettres ou lettres et chiffres ( taille < 31)
pas de caractères d’espacement
C fait la différence entre majuscule et Minuscule (toto est différent de
Toto)
donner des noms qui indiquent le rôle de la variable ou de la fonction
Mots clés et opérateurs réservés
Variables
stocker des valeurs numériques qui peuvent changer
type
définition / déclaration
Initialisation
Constantes (#define / const)
Notions Langage C / Variables (1)
Type d’une variable = défini suivant le type de valeurs qu’elle peut
prendre
Types diffèrent par la place mémoire occupée
char => caractère (1 octet) = 2 8 = 256 valeurs

En C un caractère est un entier car il s'identifie à son code ASCII (le plus
souvent).
On peut donc appliquer toutes les opérations entières sur les caractères
(addition, soustraction, etc.).
char c;
c = 'a' => c = 97
c=c+1
c = 'b' => c = 98
int => entiers (2 octets) = 2 16 = 65 536 valeurs
float => réels (4 octets)
double => grands réels (8 octets)
En C, il n’existe pas de type booléen

Par convention : 0 faux
tout entier différent de 0 vrai
Combinaison avec les mots short, long, unsigned,

signed
long int => 4 ou 8 octets
signed char => [-128, 127]
unsigned char => [0, 255]
Syntaxe de déclaration d’une variable
NomDuType1 NomDeVariable1, NomDeVariable2 ;

NomDuType2 NomDeVariable ;
Exemple:
int A; => A est une variable de type entier
=> A représente le contenu d’un emplacement mémoire
=> l ’emplacement mémoire ( = adresse mémoire) qui
comporte la valeur de la variable A est obtenu par &A
&A
……..
OXf1 OXf2 OXf3
Où et quand déclarer les variables ?
En dehors du corps des fonctions
Dans le corps d’une fonction
En début d’un bloc
Dans tous les cas, AVANT de les utiliser
Visibilité des Variables
variables déclarées en dehors de toute fonction = variables globales
=> visibles dans toutes les fonctions du fichier où elles sont
déclarées
variables déclarées dans un bloc = variables locales ou variables
automatiques
=> visibles uniquement dans le bloc où elles sont déclarées et
dans les sous-blocs de celui-ci
Une variable locale qui a le même nom qu’une variable globale
masque la variable globale dans la zone de visibilité de la
variable locale
Durée de vie des variables
locales : variable est allouée à chaque entrée dans le bloc et elle est
détruite à la sortie du bloc (=> perte de sa valeur)
globales: variable est allouée en début de programme et est détruite à la

fin du programme
Initialisation
initialiser une variable = lui affecter une valeur initiale
=> peut se faire en même temps que sa déclaration
=> Ex: int A=10 ; &A

10 ……..
OXf1 OXf2 OXf3
variable globale: automatiquement initialisée à 0 lors de sa définition
variable locale: si pas d’initialisation, sa valeur n’est pas définie
Classes particulières de variables
extern : utilisé pour des variables globales déclarées dans d’autres

fichiers
ex: extern int A ;
register : variables de type registre sont stockées dans un registre
static :
variable globale : variable sera invisible dans les autres fichiers
variable locale à une fonction: la variable n’est pas détruite à la fin de l ’appel
de la fonction
#include <stdio.h> Exemple d’exécution

int somme(int a){
i valeur rentrée valeur affichée
int s=0 ;
0 5 5
s=s+a ;
return(s) ;
1 4 4
} 2 10 10
void main(void){ 3 3 3
int i, x ;
for(i=0 ; i<4 ; i++){

printf("Rentrez la valeur de x\n ") ;
scanf("%d ", &x) ;
printf("La somme des nb rentrés est : %d\n ", somme(x)) ;
}
} Exemple d’exécution
i valeur rentrée valeur affichée
int somme(int a){ 0 5 5
static int s ;
1 4 9
s=s+a ;
return(s) ; 2 10 19
} 3 3 22
Notions Langage C / Les constantes (1)
Définies en utilisant les macro définitions
Ex: #define TOTO 5
=> le pré-processeur remplace dans la suite du programme toute

référence à cette macro (TOTO) par sa définition
=> si on veut changer la valeur de TOTO il suffit de mettre à jour

la définition de la macro
Notions Langage C/ Opérateurs (1)
Opérateurs à 1, 2 ou 3 opérandes : unaires, binaires,
ternaires
Opérateurs arithmétiques et d ’affectation binaires

+
-
*
/
= (affectation)
% (reste de la division entière) : 10 % 8 = 2
* et / sont prioritaires
Notions Langage C / Opérateurs (2)
Si les opérandes ne sont pas de même type

=> le compilateur agrandit en général l’opérande le plus
étroit
Ex: l ’affectation d ’un type étroit à un type plus large n’entraîne

pas de problème alors que l’inverse peut entraîner une perte
d’information
Opérateur d’incrémentation unaire
var++;
++var;
mais (1) v1 = var++;

différent de (2) v1 = ++var;
var -- => décrémente de 1 la valeur de var
Opérateurs unaires combinés: associent une opération (+, -, *,/,%)

avec une affectation
var += 10; var *=10;
Opérateurs binaires de comparaison

> <
>= =<
==
!=
!
Opérateurs logiques : A
V V F F
&& (ET logique), B V F V F
|| (OU logique)
A && B V F F F
A || B
V V V F
Opérateurs binaires de traitement des bits : s’appliquent sur des entiers
et des caractères
& (ET): réalise un ET logique sur chacun des bits des 2 opérandes
27 26 25 24 23 22 21 20
ex : 6 0 0 0 0 0 1 1 0
&
10 0 0 0 0 1 0 1 0
2 0 0 0 0 0 0 1 0
| (OU inclusif): réalise un OU logique sur chacun des bits des 2
opérandes
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1
|
121 0 1 1 1 1 0 0 1
121 0 1 1 1 1 0 0 1
^ (OU exclusif): met à 0 tous les bits qui sont identiques dans op1 et
op2, et à 1 ceux qui diffèrent
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1
^
121 0 1 1 1 1 0 0 1
120 0 1 1 1 1 0 0 0
<< : opérateur de décalage à gauche

op1<<op2 => décalage vers la gauche de op2 bits de op1, les bits
de droite sont remplacés par des 0
27 26 25 24 23 22 21 20
ex : 1 0 0 0 0 0 0 0 1
1<<2 0 0 0 0 0 1 0 0 ( = 1 *4)
>> décalage à droite : op1 >> op2 => décalage vers la droite de op2
bits de op1
27 26 25 24 23 22 21 20
ex : 8 0 0 0 0 1 0 0 0
8>>2 0 0 0 0 0 0 1 0 ( = 8 /4)
~ : donne le complément à un d’une opérande de type entier (inversion
de tous les bits).
27 26 25 24 23 22 21 20
ex : 28 0 0 0 1 1 1 0 0
~28 1 1 1 0 0 0 1 1 (= 227)
( ), [], ->, .
+ prioritaire
~, ++, --, (signe +/-), *(adresse), &, sizeof(var)
*, /, %
+, -
<<, >>
< <=, > >=
= =, !=
&
^
|
&&
||
?:
- prioritaire tous les combinés
Notions Langage C / Structures de Contrôle (1)
3 types de structure de contrôle

a - pour exprimer des prises de décision ;
b - pour exprimer des prises de décision à choix multiples ;
c - pour répéter une suite d’instructions.
Expression d’une prise de décision :
if-else = expression conditionnelle

Si (condition est vraie) Alors
faire Action1;
Sinon
faire Action2;
les if - else peuvent s’enchaîner
if(valeur == 0)
Calculer1(0) ;
else if (valeur == 1){
Calculer2(1) ;
Calculer3(1) ;
}else if (valeur == 3)
printf("La valeur est 3\n ") ;
else
printf("Valeur trop grande\n ") ;
Opérateur ternaire ?
Var = test ? Valeur_Var si test vrai : Valeur_Var si test faux ;
prises de décision à choix multiples : switch
au cas où la valeur est égale à 2 ou à 4 afficher " + ",
au cas où la valeur est égale à -2 ou à -4 afficher " - " ,
au cas où la valeur est égale à 0 afficher "valeur nulle ",
sinon afficher "mauvaise valeur "
=> switch( valeur ){

case 2 : case 4 : printf("Valeur positive\n ") ;
break ;
case -2 : case -4 : printf("Valeur négative\n ") ;
break ;
case 0 : printf("Valeur nulle\n ") ;
break ;
default : printf("Mauvaise valeur\n ") ;
}
Répéter une suite d’instructions
while
while(condition_vraie){
instructions ;
}
for
for(initialisation ; condition ; instructions d’incrémentation){
instructions ;
}
do-while
do{
instructions
}while(condition_vraie) ;
Mots clés : break, continue

break => permet de sortir immédiatement d’une boucle ou d’un switch
continue => permet de passer immédiatement à une autre évaluation

de la boucle
Langage C / Les Fonctions
la même instruction ou même suite d’instructions est
utilisée plusieurs fois dans un programme
#include <stdio.h>
void main(){
int x, y, z, w, minimum;
printf("Rentrez 2 valeurs entières\n");

scanf("%d %d", &x, &y);
minimum = (x<y) ? x : y;
printf (" Le minimum de %d et %d est : %d\n",x,y, minimum);
printf("Rentrez 2 valeurs entières\n");
scanf("%d %d", &z, &w);
minimum = ((z<w) ? z : w);
printf (" Le minimum de %d et %d est : %d\n",z,w, minimum);
}
Écriture d’un fonction

Fonctions / Généralités (1)
fonction permet de partitionner les gros traitements en

tâches plus petites
fonction permet de construire les programmes à partir de

briques déjà existantes
le découpage en fonction permet de gérer explicitement

la communication entre ces modules
Fonctions / Généralités (2)
FONCTION
VALEUR
DE
PARAMETRES TRAITEMENT RETOUR
main() est une fonction particulière
Fonctions / Déclaration (1)
Déclaration d’une fonction en norme ANSI
TypeDeRetour NomDeFonction (Type1 Paramètre1, Type2 Paramètre2)

{
Déclarations des variables locales à la fonction
Liste des instructions
return ( Valeur de retour si elle existe ) ;
}
Déclaration d’une fonction (sans la norme ANSI)

TypeDeRetour NomDeFonction (Paramètre1, Paramètre2)
Type1 Paramètre1 ;
Type2 Paramètre2 ;
{
…… UE programmation 3 – F. Cloppet 45
}
Fonctions / Déclaration (2)
Il est interdit de déclarer une fonction à l’intérieur d’une fonction
Valeur de retour
doit être de type scalaire (entier, réel, caractère, etc.) pointeur ou

structure mais ne peut pas être un tableau
si pas de mot clé return
mot clé return à l’intérieur d’une fonction
si return est suivi d’une valeur

si pas de TypeDeRetour
si fonction ne renvoie pas de valeur
Fonctions / Appel (1)
fonction appelante fonction appelée
appel de fonction
schéma d’un appel de fonction

Fonctions / Appel (2)
Syntaxe d’un appel de fonction avec un TypeDeRetour = void
NomDeFonction ( Liste des paramètres ) ;
Syntaxe d’un appel de fonction avec un TypeDeRetour

TypeDeRetour Variable;
Variable = NomDeFonction ( Liste des paramètres ) ;
Une fonction doit être définie avant d’être appelée ou alors elle doit
être prototypée en début de fichier
Fonctions / Appel (3) – Illustration par l’exemple
#include <stdio.h>
void Somme ( int A, int B){ /* déclaration de la fonction Somme */
int C ;
C=A+B;
printf(" Le résultat de %d + %d est %d.\n ", A, B, C) ;
return ;
}
int main( ){
int AA, BB ;
printf(" Rentrer deux nombres : " ) ;
scanf(" %d %d ", &AA, &BB) ;
Somme(AA, BB) ; /* Appel de la Fonction Somme */
return(1);
}
Fonctions / Paramètres formels et effectifs (1)
paramètre formel => apparaît dans la définition de la fonction
paramètre effectif => objet substitué au paramètre formel lors de

l’exécution de la fonction
la correspondance entre paramètres formels et effectifs est établie

selon l’ordre d’apparition dans l’en-tête de la fonction
/* déclaration de la fonction Min */
int Min (int a, int b){
return(a<b ? a : b);
}
/* appel de la fonction Min */

x=5; y=8;
printf("%d\n",Min(x, y));
/* de même */
u=8; v=9;
printf("%d\n",Min(u, v));
RAPPELS
Variable Locale / Globale
la portée d'une variable dépend de l'endroit où elle déclarée
début de fichier => variable globale
Début d'un bloc d'instruction => variable locale
Variable Globale
allocation de cette variable par le compilateur dans un segment
permanent de données
domaine de visibilité => de la déclaration à la fin du programme
RAPPELS
Variable Locale / Globale (suite)
Variable Locale
variable déclarée au début d'un bloc d'instructions
accessible seulement dans le bloc où elle est déclarée
créée lors du début de l'exécution du bloc d'instructions
détruite à la sortie du bloc d'instructions
paramètre formel = variable locale à la fonction
attribut static => définition de variables rémanentes

variable conserve sa valeur entre 2 appels de la fonction
mais visible seulement dans la fonction où elle est définie
RAPPELS .....
int X; /* déf. variable globale */
Variable Locale / Globale (suite)
Illustration par l’exemple void toto1(){

X+=10;
}
void toto2(){
int X = 5;
X*= 10;
}
void main(){
X = 20;
toto1();
printf ("%d\n", X);
toto2();
printf ("%d\n", X);
}
Fonctions / Passage de paramètres (1)
2 modes de transmission
par valeur
par adresse ou référence
Passage par valeur

création d'une copie de l'objet paramètre effectif qui reçoit le nom
du paramètre formel
Passage par valeur
main()
fonction appelante int Min(int a, int b)
fonctionappelée
X 5 copie dans un emplacement
Y 8 local à la fonction a 6
6 8 b 8
X = 5; Y = 8; 5+1 {
printf("%d\n", Min(X+1 , Y ) ) ; return ((a<b)?a:b);
6 }
Passage par adresse
l'adresse de la variable est passée en paramètre et non la valeur
la fonction effectue son traitement directement sur le paramètre effectif
2 façons d'obtenir l'adresse d'une variable selon sa déclaration

int A; => variable A de type entier
=> &A est l'adresse de la variable A
int *B; => B est un pointeur sur un entier <=> B représente l'adresse
mémoire de la variable
=> la valeur contenue à cet emplacement mémoire est

obtenue par *B;
Passage par adresse
main()
fonction appelante void Transfo (int *a)
fonctionappelée
oxff15 a
oxff15
{ int i;
int X=0; X 01O f or(i=0; i<10;i++)
(*a)++;
Transfo(&X); }
printf("%d\n",X);
Valeur ou adresse ?
Valeur
les paramètres effectifs ne doivent pas être modifiés
1 seule valeur à modifier, la valeur modifiée est renvoyée comme

valeur de retour de la fonction
Adresse
paramètres effectifs doivent être modifiés
plusieurs valeurs doivent être renvoyées par la fonction
pour passer un tableau en paramètres
Fonctions / Récursion (1)
En C, les fonctions peuvent être
utilisées de façon récursive
possible car la gestion des appels

de fonction est assurée dans une
pile
Ex:
Fonction Factorielle
0! = 1
n! = n * (n - 1) * (n - 2) * .......* 2 * 1
ou n! = n * (n-1)!
Fonctions / Récursion (2)
dépilement
fact_4 fact_4 = 1 1
n4 = 0
fact_3 = n3 * fact_4 1
fact_3 n3 = 1
empilement fact_2 = n2 * fact_3 2

fact_2 n2 = 2
fact_1 = n1 * fact_2 6
fact_1 n1 = 3
NB : fact_1 = 1er appel de la fonction factorielle
Exemple d'exécution de la fonction Factorielle avec au départ n=3
Langage C / Les Pointeurs
pointeur = variable qui contient l'adresse mémoire où est
stocké l'objet pointé (variable ou fonction)
p est un pointeur d'entiers
Oxff12
Organisation de la mémoire
Oxff13
p Oxff15
Oxff14
234 Oxff15
.
.
.
.
pointeur = groupe de cases (2 ou 4) qui
contient l'adresse de l'objet sur lequel il
pointe
Les pointeurs / Déclaration
La déclaration d'une variable de type pointeur fait

toujours intervenir le type des objets pointés
Exemple de déclaration
int *p ;
char *pc ;
Les pointeurs / Opérateurs unaires * et &
& : fournit l'adresse de l'objet

opérande p est un pointeur d'entiers
ex : int A=234 ; Oxff12
&A; Oxff13
p Oxff15
Oxff14
A 234 Oxff15
.
.
* : opérateur d'indirection ou de .
déréférence .
Les pointeurs / Initialisation
p est un pointeur d'entiers
Il existe 2 manières d'initialiser
Oxff12
un pointeur
Oxff13
p Oxff15
Affectation d'une adresse déjà Oxff14
existante A 234 Oxff15
.
.
.
.
Allocation dynamique
Les pointeurs / Allocation dynamique (1)
Soient int *p1, *p2, *p3 ;
Plusieurs manières d'allouer dynamiquement la mémoire

p1 = (int *) malloc(sizeof(int)) ;
p2 = (int*) malloc(5 * sizeof(int)) ;
p3 = (int *) calloc(5, sizeof(int)) ;
(int *) realloc(p3, 10*sizeof(int)) ;
malloc malloc
p1 est un pointeur d'entiers p2 est un pointeur d'entiers
Oxff12
Oxff12
Oxff13
Oxff13
p1 Oxff15 Oxff14
p2 Oxff17
Oxff14
Oxff15
Oxff15 Oxff16
.
Oxff17
.
. .
. .
.
.
UE programmation 3 – F. Cloppet Oxff21 67
calloc realloc
p3 est un pointeur d'entiers p3 est un pointeur d'entiers
Oxff11
p3 Oxff12
Oxff16
Oxff16 Oxff12
p3
Oxff13
.
Oxff14 .
Oxff15
Oxff15 0 Oxff16
0 Oxff17
0 Oxff16 .
0 .
0 Oxff17 0
.
. .
0 . 0 Oxff20
.
. .
0 . Oxff24
0 Oxff20 Oxff25
Fonctions malloc, calloc, realloc sont définies dans stdlib.h
Leur type de retour est pointeur sur void => cast obligatoire
S'il n'y a pas assez d'espace mémoire => l'allocation ne peut pas se
faire => la valeur renvoyée est NULL
NULL = valeur de pointeur constante prédéfinie

p = NULL => fait explicitement pointé p sur l'adresse 0
0 est la seule valeur entière que l'on peut comparer à des pointeurs
Les espaces mémoires alloués par un malloc, un calloc ou un realloc

doivent être libérés à la fin de leur utilisation par la fonction free
free(pointeur);
Les pointeurs / Opérations (1)
Affectation de pointeurs
p et p1 sont des pointeurs d'entiers

Oxff12 Oxff12
int *p, *p1, x=4 ; /* (I1) */ (I2) p NULL Oxff13 (I4) p Oxff15 Oxff13
Oxff14 Oxff14
p = NULL ; /* (I2) */ Oxff15 Oxff15
(I1) x 4 x 4
p1 = p; /* (I3) */ . .
(I3) p1 NULL p1 NULL
p = &x; /* (I4) */ . .
. .
. .
Que vaut *p ?
Sur quoi pointe p1 ?
Les pointeurs / Opérations (2)
Comparaison de pointeurs
comparaison avec valeur NULL
test d'égalité entre 2 pointeurs
les autres relations d'ordre n'ont de sens que si on a une idée de

l'implantation des objets en mémoire
Opérations d'addition et de soustraction
Ex : int *p, x=4 ;

p=&x ;
p++ ;
ou
p+=4 ;
Les pointeurs / Opérations d’incrémentation (1)
p pointeur d'entiers p++
Oxff12 Oxff12
p Oxff13 p Oxff17 Oxff13

Oxff15
Oxff14 Oxff14
x 4 Oxff15 x 4 Oxff15
.
Oxff16
.
y 8 . y 8 Oxff17
.
Oxff18
si un entier est codé sur 16bits
Les pointeurs / Opérations d’incrémentation (2)
p pointeur d'entiers (*p)++
p Oxff14 Oxff12 p Oxff14 Oxff12

Oxff13 Oxff13
x 4 Oxff14 x 5 Oxff14
Oxff15 Oxff15
. .
. .
. .
++ est prioritaire sur * =>
Langage C / Les Tableaux (1)
Tableau = Liste de valeurs de même type qui sont consécutives en
mémoire
Syntaxe de déclaration d'un tableau monodimensionnel
NomDeType NomTableau [Nombre_Eléments] ;
La déclaration d'un tableau réserve la place mémoire pour tous les éléments
du tableau
Chaque élément d'un tableau est considéré comme une variable
Tab[0] Tab[1] Tab[2] Tab[3] Tab[4] Tab[5] Tab[6]
Langage C / Les Tableaux (2)
int Tab [ 10 ] ; (10 cases de taille sizeof(int))
Tab est l’adresse du début du tableau.
Tab [ i ] est la valeur de l'élément i du tableau.
& Tab [ 0 ] est équivalent à Tab.
& Tab [ i ] est l’adresse de l’élément i du tableau
Les Tableaux Monodimensionnels / Initialisation
Les tableaux définis comme variables globales ont leurs

cases initialisées à 0
2 types d'initialisation possibles
Initialisation du tableau en bloc avec un ensemble de valeurs au
moment de la déclaration
Initialisation par des valeurs fournies par l'utilisateur
Les Tableaux Bidimensionnels / Déclaration –
Initialisation (1)
Syntaxe de déclaration d'un tableau bidimensionnel
NomDeType NomTableau[Nombre_Elts_lignes] [Nombre_Elts_colonnes] ;
Ex : int Tab[5][2];
Intialisation avec un ensemble de valeurs lors de la déclaration

int Tab[4][3] = {{1,3,5}, {2,4,6}, {3,5,7}} ;
ou 1 3 5
2 4 6
3 5 7
? ? ?
Les Tableaux Bidimensionnels / Déclaration –
Initialisation (2)
Initialisation par des valeurs fournies par

l'utilisateur
int Tab[4] [3], i, j, valeur ;
for(i = 0 ; i < 4 ; i++)

for(j=0 ; j < 3 ; j++){
printf("Entrer la valeur n° %d, %d : ", i,j) ;
scanf("%d",&valeur) ;
Tab[i] [j] = valeur ;
}
Tableaux / Passage d’un tableau ou d’un élément
en paramètres
int Tab[10], NbTab=10 ;
void maFonction1(int A) ;
void maFonction2(int A[ ], int Nb) ;
void maFonction3(int *A) ;
Les appels de fonction seront de la forme :
maFonction1(Tab[5]) ;
maFonction2(Tab, NbTab) ;
maFonction3(&Tab[5]) ;
Tableaux / Passage d’un tableau 2D en paramètres
le nombre d'éléments de la 2ème composante est

obligatoire
int Tab2[10][20], Nb_lig=10, Nb_col=20 ;
void Fonction2(int Tab2[ ] [20], int nb_ligne, int nb_colon) ;
Appel de la fonction
Fonction2( Tab2, Nb_lig, Nb_col) ;
Pour tester l'égalité de 2 tableaux, il faut faire une

comparaison élément par élément
Langage C / Les Tableaux de caractères (1)
'a' est un caractère => type char
"Bonjour à vous tous" est une chaîne de caractères => tableau de
caractères
Syntaxe de déclaration
char NomChaine[Nb_Elts] ;
Ex : char Chaine[10] ; /* déclaration d'un tableau de 10 caractères de nom Chaine */
En C, une chaîne de caractères se termine toujours par '\0'

Si la chaîne de caractères Chaine est égale à "Bonjour"
Chaine
B O N J O U R \0
Les tableaux de caractères / Initialisation
Au moment de la déclaration
char ch[] = " BONJOUR ";
char ch[] = {’B’,’O’,’N’,’J’,’O’,’U’,’R’,’\0’} ;
Par des valeurs fournies par l'utilisateur

char ch[10] ;
for(i = 0 ; i < 9 ; i++) /* lecture caractère par caractère */

ch[i] = getch() ;
ch[i] = ‘\0’ ;
ou
scanf("%s ",ch) ; /* lecture en bloc de la chaîne de caractères */
On ne peut pas écrire

char ch[10];
ch = "Bonjour" car ch est une adresse non réassignable
Les tableaux de caractères / Fonctions prédéfinies (1)
Fonctions d'entrée / sortie :

char ch[100], ch1[100], ch2[100] ;
int toto, x=4 ;
scanf ("%s ", ch) ;
sscanf (ch1, "%s ", ch2) ;
sprintf(ch, "le nombre est %d\n ", x) ;
gets(ch) ;
puts(ch) ;
Fonctions de traitement des chaînes de caractères :

définies dans la librairie string.h
strcpy :
strcpy(ch1, ch2) ;
char ch[10] ;
strcpy(ch, "BONJOUR ! ") ;
strcat, strcmp, strchr, strlen
char ch[100], ch1[100], ch2[100] , c, *c1;

int toto;
strcat :
strcat(ch1, ch2) ;
strcpy(ch1, "Bonjour") ;
strcat(ch1, " à vous") ;
printf("%s", ch1) ; => Bonjour à vous
strcmp :
toto = strcmp(ch1, ch2) ;
strcpy(ch1, "Bonjour") ; strcpy(ch2, "Bonsoir") ;

toto=strcmp(ch1,ch2) ;
printf("%d\n", toto) ;
strchr :
strchr(ch, c) ;
c1 = strchr(ch1, 'o') ;
printf("%s\n", c1) ;
strlen :
toto = strlen(ch) ;
toto = strlen(ch1) ;
printf(" longueur : %d\n", toto) ; => 7
Langage C / Synthèse Tableaux -Tableaux de
caractères - pointeurs (1)
En C, les pointeurs et les tableaux sont très fortement liés.
int tab[10] ;
int *ptab ;
ptab = &tab[0] ;
ptab++ ;
ptab + i ;
*(ptab + i);
ptab[i];
Soient
int A;
int tab[10] ;
int *B, *ptab ;
char car ;
char chaine[10] ;
char *ch1, *ch2 ;
Que représentent A, tab, tab[0], B, ptab, car, chaine,

chaine[0], ch1, ch2 ?
A est une variable …
tab est l’adresse de …
B (et ptab) sont des …
car est une variable …
chaine est …
chaine[0] …
ch1 et ch2 sont des …
Que représentent les suites d'instructions suivantes (avec

les déclarations de variables précédentes)?
(1) A =256 ; (4) strcpy(chaine, "Bonjour !") ;

B= &A ; ch1 = chaine ;
ch2 = &chaine[2] ;
(2) ptab = tab ; ch2++ ;
Peut on écrire chaine = ch2 ?
(3) ptab = &tab[5] ;
ptab++ ;
A = 256 ;
B = &A ;
ptab = tab ;
ptab = &tab[5] ;
ptab ++ ;
strcpy(chaine, "BONJOUR ! ") ;
ch1 = chaine ;
ch2 = &chaine[2] ;
ch2 ++ ;
chaine = ch2 ;
Ces séquences d'instructions sont elles correctes ?
(1) (2)
int A = 20, *B ;
B = &A ;
*B = 200 ;
(3) (4)
char ch[20] ;
ch= "Bonjour";
(3) char ch[20] ;
ch= "Bonjour" ;
(4) char *ch1;

ch1="Bonjour" ;
Langage C / Synthèse Pointeurs / Tableaux de
pointeurs (1)
Les pointeurs sont des variables

Il est possible de les stocker dans des tableaux
Ex : char *tab[4] = {"Lundi", "Mardi","Mercredi","Samedi"} ;
Les 4 éléments du tableau sont des pointeurs de caractères
tab l u n d i
m a r d i
m e r c r e d i
s a m e d i
Avantage par rapport à un tableau 2D
Langage C / Les structures (1)
Une structure rassemble plusieurs entités qui peuvent

avoir des types différents
Structure permet de traiter un groupe de variables liées

entre elles comme un tout et non comme des entités
séparées.
Notion différentes de la notion de tableau qui permet de

regrouper des objets de même type
Les structures / Déclaration (1)
Syntaxe
struct NomStructure{/* NomStructure = étiquette de la structure */

type1 champ1 ;
type2 champ2 ;
.....
} ;
mot clé struct indique une déclaration de structure constituée d'une

liste de déclaration entre accolades
Exemple
Déclaration d'une structure permet de définir un modèle objet mais
n'engendre aucune réservation mémoire
Le modèle défini peut être utilisé dans une déclaration de variable
Ex : Déclaration d'une variable nommée UnProduit de type struct

produit
struct produit UnProduit ;
Ex : Déclaration d'un pointeur de struct produit

struct produit *PtrProduit;

Définition du type structure défini comme un type utilisateur
utilisation de l'opérateur typedef
syntaxe :
typedef spécification_de_type nouveau_nom_de_type ;
Ex :
typedef struct produit { /* Nom de la structure */
int reference, categorie ;
char *nom, *provenance ;
} produit, *Pproduit ; /* Noms des nouveaux types */
Déclaration d'un produit et d'un pointeur sur un produit
produit UnProduit ;
Pproduit PtrProduit;
Les structures / Initialisation
Au moment de la déclaration
Variable du type de la structure peut être initialisée par une liste
de valeurs constantes correspondant à chacun des membres
Ex:
produit UnProduit = {15, 3, "toto", "Inde"} ;
Avec des valeurs rentrées par l'utilisateur

appel à une fonction (définie dans le programme) qui remplira
les champs de la structure et retournera la structure initialisée.

Les structures / Accès à un champ d’une structure (1)
Si la variable est du type de la structure

opérateur •
Ex : Accès aux valeurs stockées dans les champs d'une variable de type
produit
produit UnProduit = {15, 3, "toto", "Inde"} ;
char *NomDuProduit ;
int NumDuProduit;
Ex : remplissage des champs d'une variable de type produit ;

Les structures / Accès à un champ d’une structure (2)
Si la variable est du type pointeur sur la structure

opérateur : ->
Ex : Accès aux valeurs stockées dans les champs d'une variable de type
pointeur sur produit
Pproduit PtrProduit ;
char *NomDuProduit ;
int NumDuProduit;

Les structures / Tableaux de structures
Si l'on veut compter le nombre d'occurrences de chaque mot d'une liste de

mots clés : => 2 solutions
gérer 2 tableaux en parallèle :
char *liste_motcle[NB] ; /* NB supposé défini par 1 #define */
int compteur[NB] ;
utiliser un tableau de structure :

typedef struct cle{
char *mot ;
int compt ;
}cle ;
cle liste_cle[NB] ; /* NB supposé défini par 1 #define */
l'accès au 3ème mot clé :

l'accès à son nombre d'occurrences :
Les structures / Composition de structures
Une structure permet de définir un type qui peut être
utilisé
dans une déclaration de variable
comme type d'un des champs d'une autre structure =>
composition
Ex :

Les structures / Struct. Récursives ou autoréférentielles
structure récursive quand un des champs est du type de la structure

qu'on est en train de définir
Il est INTERDIT de définir une structure contenant une instance d'elle-
même MAIS il n'est pas interdit qu'un champ soit du type pointeur sur la
structure.
Ex :
typedef struct Individu{ typedef struct Individu{
char nom[40] ; char nom[40] ;
int age ; int age ;
struct Individu *pere, struct Individu pere,
*mere ; mere ;
}Individu ; }Individu ;
écriture correcte écriture incorrecte
Avant de remplir les champs de pere et mere

=> allouer de l'espace UE programmation 3 – F. Cloppet 107
Langage C / Les Unions (1)
Un objet de type union pourra contenir à des instants différents
des objets de type et de taille différente.
L'espace mémoire réservé correspond à l'espace mémoire nécessaire

pour stocker le plus grand des types
Définition d'une union est analogue à la définition d'une structure

union Cat{ /* la catégorie peut être soit de type int soit de type char * */
int Icat ;
char *Ccat ;
};
Un objet de type structure est composé de
Un objet de type union est composé d'un

Langage C / Les Unions (2)
L'accès aux membres d'une union se fait comme pour les structures
On peut placer des unions à l'intérieur de structures
typedef struct produit {
int reference, TypeCat ; /* TypeCat = 0 : int, TypeCat = 1 : char */
union cat{ /* Nom de l’union */
int Icat ;
char *Ccat ;
} Cat ; /* Champs Cat de type Union cat */
char *nom, *provenance ;
} produit, *ptproduit ;
produit P ; …. /* On suppose les champs de P remplis */

Langage C / Les Énumérations (1)
n'existent pas dans le standard défini par Kernighan et Ritchie
mais admises par de + en + de compilateurs
une déclaration d'énumération permet de définir un modèle d'entiers

dont les valeurs sont notées par des constantes symboliques
syntaxe :
enum NomIdentificateur { liste de valeurs symboliques } ;
Ex :

Langage C / Les Énumérations (2)
Intérêt : facilite la compréhension et la maintenance du

programme
Ex :
typedef enum Couleur{VERT,ORANGE,ROUGE} CouleurFeu;
CouleurFeu Feu;
Feu = ORANGE ;
printf("Couleur du feu : %d\n", Feu) ; => Couleur du feu : 1
switch(Feu){
case VERT: printf("passez\n");
break;
case ORANGE: printf("ralentissez\n");
break;
case ROUGE: printf("arrêtez vous\n");
break;
}
Langage C / Les Fichiers (1)
Les fichiers permettent de conserver de façon permanente des
informations dans la mémoire de masse d’un ordinateur.
Ce sont des objets qui sont manipulés de manière linéaire, du début
jusqu’à la fin.
La méthode classique d’utilisation des fichiers est :
• Ouverture d’un fichier.
• Opération sur le fichier (lire, écrire, ajouter).
• Fermeture du fichier.
FILE est le type d'un fichier => librairie <stdio.h>
ex de déclaration : FILE *fich;

Les Fichiers / Ouverture
fonction fopen
FILE *fopen(char *chemin, char *mode d'accès)
renvoie NULL si erreur lors de la tentative d'ouverture
modes (fichiers de type texte)
"r"
"w"
"a"
pour les fichiers de type binaire ….
ex : FILE *fich ;
fich = fopen("toto.txt", "r") ;
ou fich=fopen("d :\\tmp\\toto.txt", "r");
Les Fichiers / Fermeture
fonction fclose
int fclose( FILE *fic) => ferme le fichier pointé par fic
Ex. de séquence ouverture / fermeture de fichier

FILE *Fic = NULL ;
char NomFichier[200] ;
.......
Fic = fopen(NomFichier, "w ") ;
if(Fic == NULL){
printf("Erreur à l’ouverture du fichier %s ", NomFichier) ;
return ;
}
…… traitement ……
fclose(Fic) ;

Les Fichiers / Opérations (1)
Entrées / Sorties de caractères
char fgetc(FILE *fic)
char fputc(char c, FILE *fic)
Ex : Affichage de tous les caractères d'un fichier sur la sortie

standard
char c;
FILE *Fic ;
.......
while((c = fgetc(Fic)) != EOF)
printf("%c",c) ;

Entrées / Sorties avec formatage (sur fichiers en mode texte)
fscanf
ex : Lecture de deux entiers séparés par un espace, puis passage à la ligne.
fprintf
ex : Écriture de deux entiers séparés par un espace, puis passage à la ligne.

Entrées / Sorties de blocs (sur fichiers ouverts en mode
binaire)
fread
size_t fread(type *ptr, size_t tailleObj, size_t NbObjet, FILE *Fic)
fwrite
size_t fwrite(type *ptr, size_t tailleObj, size_t NbObjet, FILE *Fic)

Lecture de 40 caractères du fichier pointé par Fic dans le tableau tab

FILE *Fic ;
char tab[40] ;
........
fread(tab, sizeof(char), 40, Fic) ;
Ecriture de 40 caractères du tableau tab, dans le fichier pointé par

Fic
FILE *Fic ;
char tab[40] ;
........
fwrite(tab, sizeof(char), 40, Fic) ;

fseek => positionnement du marqueur de fichier

int fseek (FILE *flux, long offset , int mode)
fseek fait pointer le pointeur de fichier associé au flux
flux offset octets plus loin.
mode peut prendre les valeurs 0, 1, 2 selon que le
déplacement doit être :
0 : par rapport au début du fichier
1 : par rapport à la position courante
2 : par rapport à la fin du fichier.

ftell => retourne la position du marqueur de fichier

ces 2 fonctions sont surtout utiles pour gérer des fichiers
avec des structures (du type fiches)
rewind => met le marqueur en début de fichier
remove => destruction d'une fichier
rename => change le nom d'un fichier

Langage C / Le pré-processeur (1)
Le préprocesseur est un programme standard qui

effectue des modifications sur un texte source.
Il modifie le source d'après les directives données par le

programmeur, et introduites par le caractère #.
La directive du préprocesseur commence par un # et se

termine par la fin de ligne.

Le préprocesseur peut rendre plusieurs services :
l'inclusion de fichier
la substitution de symboles
le traitement de macro-instructions
la compilation conditionnelle

L'inclusion de fichier source

La commande #include du préprocesseur permet d'inclure des
fichiers source.
Lorsque le préprocesseur rencontre la commande #include, il
remplace cette ligne par le contenu du fichier.
Syntaxe

Substitution de symboles
#define nom reste-de-la-ligne
le préprocesseur remplace toute nouvelle occurrence de nom par

reste-de-la-ligne dans toute la suite du source.
Exemple :

Macro-instructions
Une définition de macro-instruction permet une substitution de
texte paramétrée par des arguments.
Syntaxe :
#define nom(liste_parametres_formels) reste_de_la_ligne
La liste de paramètres formels est une liste d'identificateurs

séparés par des virgules.
Il n'y a pas d'espace entre le nom et (
Toute occurrence ultérieure de nom sera un appel de la macro et

devra avoir la forme :
nom(liste_parametres_effectifs)

Macro-instructions
Lors de l'appel, le préprocesseur remplace
l'ensemble nom de la macro et liste des paramètres effectifs

"parenthésés "
par
la chaîne reste_de_la_ligne dans laquelle toutes les occurrences des
paramètres formels sont remplacées par les paramètres effectifs.

Macro-instructions
Exemple :
borne_inferieure = min(i,j); Remplacé par borne inferieure = ((i)<(j) ? (i):(j))

borne_superieure = max(i,j); Remplacé par borne superieure = ((i)>(j) ? (i):(j))

Macro-instructions
Si on ne met pas de parenthèses sur les paramètres formels, il
peut y avoir des erreurs.
On recommande donc de toujours utiliser deux règles dans la

définition d'une macro-instruction :
parenthéser les occurrences des paramètres formels;
parenthéser le corps complet de la macro.

Macro-instructions
Attention aux effets de bord inattendus sur les paramètres

effectifs.
Exemple :
#define carre(a) ((a)*(a))
L'utilisation de carre(x++) sera transformé en ….

Compilation conditionnelle
Les mécanismes de compilation conditionnelle ont pour but de

compiler ou d'ignorer des ensembles de lignes, le choix étant
basé sur un test exécuté à la compilation.

Compilation conditionnelle : #if

Syntaxe :
#if expression
ensemble-de-lignes
#endif
ensemble-de-lignes est une suite de lignes quelconques.
L'évaluation de expression a lieu au moment de la compilation.
Si expression est vraie ensemble-de-lignes est compilé.

Compilation conditionnelle : #if #else #elif

Exemple
#include <stdio.h>
#define AFFICHE 0
int main(){
int x = 10;
x = x +10;
#if AFFICHE
printf("x: %d\n", x);
#endif
printf("fin du programme\n");
return(1);
}

Exemple
#include <stdio.h>
#define AFFICHE 1
int main(){
int x = 10;
x = x +10;
#if AFFICHE
printf("x: %d\n", x);
#endif
printf("fin du programme\n");
return(1);
}

#ifdef
Ces commandes permettent de tester si un symbole a été défini
par la commande #define
Exemple :

#ifndef
#ifndef (NOM) ou #if !defined (NOM)

instructions instructions
#endif #endif
Exemple

L'opérateur defined est un opérateur spécial : il ne peut

être utilisé que dans le contexte d'une commande #if ou
#elif.
Il permet d'écrire des tests portant sur la définition de
plusieurs symboles alors que #ifdef ne peut en tester
qu'une.
Syntaxe :
defined nom ou defined(nom)
Exemple :
#if defined(SYMBOLE1) || defined(SYMBOLE2)

Langage C / Compilation séparée (1)
Compilation simple (Rappel)
Phase de compilation :
Phase d'édition de liens :
Compilation Édition de liens
.c .o
fichier.c fichier.o prog.exe
source code objet programme exécutable

Compilation séparée
Lorsqu'un programme devient grand, il devient intéressant

de diviser le code source en plusieurs fichiers .c,
De plus, vous pouvez regrouper un ensemble de fonctions et

l'isoler dans un fichier source ce qui permet de pouvoir les
réutiliser dans d'autres projets.

Compilation séparée
Compilation Édition de liens
.h
fichier.h .o
fichier.o
.c
fichier.c
prog.exe
.c .o
main.c main.o
source code objet programme exécutable

Un fichier objet (.o) est un fichier contenant :
le code compilé du source correspondant
une table des variables et des fonctions exportées définies dans

le source
une table des variables et des fonctions qui sont utilisées mais
non définies

Langage C / Communication entre modules (1)
1 Application peut être conçue comme une collection de modules
module = unité de programme mémorisée dans un fichier, qui

constitue une unité de compilation
les unités sont compilées séparément
tâche de l'éditeur de liens = …

1 protocole est nécessaire pour la communication entre les divers
modules

Règles de Communication(1)
1 variable ou 1 fonction est partagée entre 2 modules quand
elle est utilisée dans ces 2 modules
Seules les variables globales à un module peuvent être partagées
Toute fonction peut-être partagée
1 variable ou fonction partagée doit faire l'objet d'une

déclaration d'importation dans le module où elle est utilisée mais
non définie
mot clé extern

Règles de Communication(2)
Déclaration d'importation d'une variable
extern int X ;
Déclaration d'importation d'une fonction
extern void toto() ; ou extern void toto(int) ;

Module 1 Module 2
int v=23; int Val=100;

int x=25;
extern int Val; int Fonct(int P){
extern intFonct(int);
extern int Fonct(); extern int v;
int j;
main(){
int y=6, res; ........
.... }
res=Fonct(y);
} int Toto(float z){

.......
}
Protection de données
Cas où on ne désire pas que les symboles définis dans un module soient
accessibles depuis l'extérieur d'un module
Conflit entre variables souvent quand plusieurs personnes interviennent

sur un projet et ne se concertent pas pour les noms
Pour rendre un identificateur non exportable => attribut static
Ex :

Fichier d'en-tête
En C un module doit être implanté à l'aide de deux fichiers :
les définitions dans un fichiers source (.c)
les déclarations des variables et fonctions exportables (utilisables

dans d'autres modules) dans un fichier d'en-tête (.h)
Un module utilisant les fonctions et/ou les variables d'un autre

module doit "inclure" le fichier d'en-tête de celui-ci (pour avoir
les déclarations).

Fichier d'en-tête (suite)

Exemple
main.c pile.c pile.h

#include <stdio.h> #include <stdio.h> void empiler (double);
extern void empiler(double); #include "pile.h" double depiler(void) ;
void main(void){ void empiler(double y){

double x ; .......
....... }
empiler (50) ;
.... double depiler (void){
} ....
}

Inclusion Conditionnelle
pour éviter d'inclure plusieurs fois le contenu d'un fichier entete.h
Placer le contenu du fichier à l'intérieur d'une instruction conditionnelle
Ex :
#ifndef ENTETE
#define ENTETE
/* on met ici le contenu de entete.h */
#endif
expression ENTETE vaut 0 si le fichier n'a pas été inclus

1 s'il a déjà été inclus


Fichier d'en-tête (suite)
Exemple
Problème: empiler et depiler doivent être vues comme étant

définies dans un autre fichier source
=>prototypes précédés de extern

#include <stdio.h> #include <stdio.h>
#include "pile.h"
#define PILE
void main(void){
double x ; #include "pile.h"
.......
empiler (50) ; void empiler(double y){
x = depiler(); .......
.... }
}
double depiler (void){
....
}
extern void empiler (double); void empiler (double);
extern double depiler(void); double depiler(void);
Langage C / Arguments de la ligne de commandes (1)
Langage C offre des mécanismes qui permettent d'intégrer

parfaitement un programme C dans l'environnement hôte
ex: environnement orienté ligne de commande (Unix, Linux)
Programme C peut recevoir de la part de l'interpréteur de
commandes qui a lancé son exécution, une liste d'arguments
Liste = ligne de commande qui a servi à lancer l'exécution du
programme
Liste composée
Du nom du fichier binaire contenant le code exécutable du programme
des paramètres de la commande

Fonction main reçoit tous ces éléments de la part de
l’interpréteur de commandes
2 paramètres
argc (argument count)
argv (argument vector)

Si on veut analyser la ligne de commande, l’entête de la fonction

main est alors

Base C

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Base C

Transféré par

Droits d'auteur :

Formats disponibles

L2 - UE Programmation 3

L2 : 1TD et 1TP / semaine

Contrôle des Connaissances

1 Contrôle Continu sur machine à la mi-novembre (CC)

1 examen final (sur papier)

Note finale = max ((CC+Examen) /2, Examen)

Un peu plus pédagogique

Poly disponible sur

Attention ceci n’est qu’un résumé à trous …

Ce poly n’est là que pour vous aider à la prise de notes et ne

Un système informatique RAM

Mémoire centrale CPU

Clavier Moniteur Imprimante

l’utilisateur et les programmes

Relations programmes - Machines

langage d’assemblage ou assembleur

langages de haut niveau

Développer un programme optimal

Limiter les coûts de production

Appel aux techniques du génie logiciel

modèles de développement de logiciels

Problème Enoncé du Spécification

Vue générale des activités de développement d’un système

Langage structuré de haut niveau (fonctions, structures de contrôle

Il s’étend des stations de travail aux micro-ordinateurs

Norme C ANSI (American Standards National Institute)

Saisie des instructions du code dans un fichier texte

Une application peut être conçue comme une collection de modules,

De tels modules peuvent constituer des unités de programmes en C

Une unité de programme constitue une unité de compilation ou

compilation des fichiers *.c

édition des liens

Exemple des phases de compilation et d'édition

#include <stdio.h> on demande d'inclure la librairie stdio.h.

void main() la fonction main sans argument

Après compilation de bonjour.c, le lancement du programme affiche à

programme = traduction en instructions

Exemple : problème : Affichage des carrés des nombres

int carre (int a) définition de la fonction carre

void main() définition de la fonction main

for(i = 0; i < NBFOIS; i++){ boucle for de 0 à NBFOIS-1

int VarGlobaleInt; Définitions des variables globales

Définitions des fonctions

Constantes (#define / const)

Types diffèrent par la place mémoire occupée

char => caractère (1 octet) = 2 8 = 256 valeurs

int => entiers (2 octets) = 2 16 = 65 536 valeurs

double => grands réels (8 octets)

En C, il n’existe pas de type booléen

Combinaison avec les mots short, long, unsigned,

Syntaxe de déclaration d’une variable

NomDuType1 NomDeVariable1, NomDeVariable2 ;

globales: variable est allouée en début de programme et est détruite à la

=> Ex: int A=10 ; &A

extern : utilisé pour des variables globales déclarées dans d’autres

register : variables de type registre sont stockées dans un registre

#include <stdio.h> Exemple d’exécution

for(i=0 ; i<4 ; i++){

Définies en utilisant les macro définitions

Ex: #define TOTO 5

=> le pré-processeur remplace dans la suite du programme toute

=> si on veut changer la valeur de TOTO il suffit de mettre à jour

Opérateurs arithmétiques et d ’affectation binaires

& : fournit l'adresse de l'objet

p2 = (int) malloc(5 sizeof(int)) ;

(int ) realloc(p3, 10sizeof(int)) ;