L2 -UE Programmation 3 Langage C 2009 2010helios.mi.parisdescartes.fr/~cloppet/prog3/PolyCoursProg... · 2012-12-17 · UE programmation 3 –F. Cloppet 12 Programmer en Langage C

L2 - UE Programmation 3Langage C2009 2010

Equipe pédagogique:Florence Cloppet

Neilze DortaDavid Janiszek

[email protected]@mi.parisdescartes.fr

UE programmation 3 – F. Cloppet 2

Sommaire

1. Informations administratives2. Introduction3. Programmer en Langage C4. Notions de Langage C

1. Variables , Constantes2. Opérateurs3. Fonctions4. Pointeurs5. Tableaux6. Tableaux de caractères – chaîne de caractères7. Synthèse Tableaux - Pointeurs / Tableau de Pointeurs8. Structures – Unions – Énumérations9. Fichiers10. Pré-processeur11. Compilation séparée12. Intégration d’un programme C dans l’environnement hôte


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

CPU

Moniteur

Mémoire centrale

RAM

ROM

ImprimanteClavier

Disque Dur

Disquette

CDROM


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)

Enoncé du

problèmeProblème Spécification

du système Saisie des

exigences exigences

fonctionnelles

Modèles abstraits

du système

conception

initiale

conception

finale

Modèle final

(code source)Solution

livraison

Aspects de conception liés aux problèmes

impliquant le monde réel

Aspects de conception liés

à la conception elle-même

améliorations

successives

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)

fic1.c fic1.h fic2.c fic2.h

cc -c fic1.c cc -c fic2.c

fic1.o fic2.o

cc fic1.o fic2.o -o toto

toto

Exemple des phases de compilation et d'édition

de liens avec le compilateur cc sous UNIX.

� Compilation (3 étapes)� phase de pré-processing des

fichiers *.c

� compilation des fichiers *.c

� édition des liens


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 0Calculer puis afficher le carré de 1

..........Calculer puis afficher le carré de 8Calculer puis afficher le carré de 9



Programme :

#include <stdio.h>

void main()

{

printf("Le carré de 0 est %d\n", 0*0);


…… etc………



}

Le carré de 0 est 0 Le carré de 1 est 1 Le carré de 2 est 4 Le carré de 3 est 9 Le carré de 4 est 16 Le carré de 5 est 25 Le carré de 6 est 36 Le carré de 7 est 49 Le carré de 8 est 64 Le carré de 9 est 81



#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-1j = carre(i); appel de la fonct. carre et affect. du résultat à jprintf("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

#include <fichier d'entête>

#define constante valeur

typedef struct duo {

int a, b;

}tduo;

extern int VarGlobaleExt;

typefct1 fonction1(int, char);

typefct2 fonction2(int, int);

int VarGlobaleInt;

typefct1 fonction1(int a, char b)

{

return(variable1);

}

typefct2 fonction2(int a, b)

{

return(variable2);

}

void main()

{

int a, b;

a = fonction1(2,'a');

b = fonction2(2,3);

}

Directives de compilation

du préprocesseur

Définitions des types

Définitions des fonctions

et variables externes

Définitions des variables globales

au fichier


Définition de la fonction main et

appel d'autres fonctions.

monfichier.c


Paramétrage des fonctions internes


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 + 1c = 'b' => c = 98

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


Notions Langage C / Variables (2)

� 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 ;

� variable globale: automatiquement initialisée à 0 lors de sa définition

� variable locale: si pas d’initialisation, sa valeur n’est pas définie

&A

……..

OXf1 OXf2 OXf3

10



� 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>

int somme(int a){

int s=0 ; s=s+a ;

return(s) ;

}

void main(void){

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

0 5 5

1 4 4

2 10 10

3 3 3

int somme(int a){

static int s ;

s=s+a ;

return(s) ;

}

Exemple d’exécution

i valeur rentrée valeur affichée

0 5 5

1 4 9

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 affectationvar += 10; var *=10;



� Opérateurs binaires de comparaison> <>= =<= =!=!

� Opérateurs logiques : && (ET logique), || (OU logique)

V V F F V F V F V F F F V V V F

A B A && B A || B



� 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)



( ), [], ->, . ~, ++, --, (signe +/-), *(adresse), &, sizeof(var)

*, /, % + , -<<, >>< <=, > >= = =, != & ^ | &&|| ? : tous les combinés

+ prioritaire

- prioritaire


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 conditionnelleSi (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 : switchau 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)

� main() est une fonction particulière

TRAITEMENTPARAMETRES

VALEUR DE

RETOUR

FONCTION


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 ;

{

……

}


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)

appel de fonction

fonction appelante fonction appelée

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 TypeDeRetourTypeDeRetour 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� Variable Locale / Globale (suite)

� Illustration par l’exemple

int X; /* déf. variable globale */

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



X=5; Y=8;

printf("%d\n", Min(X+1 , Y ) ) ;

fonction appelantefonctionappelée

main()intMin(int a, int b)

{

return((a<b)?a:b);

}

6 8

6

a 6b 8

copie dans un emplacement

local à la fonction

X 5Y 8

5+1

Passage par valeur



� 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;



int X=0;

Transfo(&X);

printf("%d\n",X);

fonction appelantefonctionappelée

main()void Transfo (int *a)

{ int i;

f or(i=0; i<10;i++)(*a)++;

}

oxff15

X1O

oxff15

0

a

Passage par adresse



� 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! = 1n! = n * (n - 1) * (n - 2) * .......* 2 * 1

ou n! = n * (n-1)!


Fonctions / Récursion (2)

fact_1

fact_2

fact_3

n1 = 3

n2 = 2

fact_3 = n3 * fact_4

fact_1 = n1 * fact_2

fact_2 = n2 * fact_3empilement

NB : fact_1 = 1er appel de la fonction factorielle

dépilement

1

1

2

6

fact_4

n3 = 1

n4 = 0fact_4 = 1

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)

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p Oxff15

234

p est un pointeur d'entiers

� Organisation de la mémoire

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

ex : int A=234 ;&A;

� * : opérateur d'indirection ou de

déréférence

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p Oxff15

234


A


Les pointeurs / Initialisation

� Il existe 2 manières d'initialiser un pointeur

� Affectation d'une adresse déjàexistante

�Allocation dynamique

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p Oxff15

234


A


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)) ;



Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p1 Oxff15

p1 est un pointeur d'entiersOxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p2 Oxff17

p2 est un pointeur d'entiers

Oxff16

Oxff17

Oxff21

mallocmalloc



Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p3 Oxff16


Oxff16

Oxff17

Oxff20

0

0

0

0

0

Oxff11

Oxff12

Oxff15

.

.


Oxff16

Oxff17

Oxff20

0

0

0

0

0

.

.

.

.

Oxff25

Oxff24

p3 Oxff16

.

.

calloc realloc



� 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 reallocdoivent être libérés à la fin de leur utilisation par la fonction free

free(pointeur);


Les pointeurs / Opérations (1)

� Affectation de pointeurs

int *p, *p1, x=4 ; /* (I1) */

p = NULL ; /* (I2) */p1 = p; /* (I3) */p = &x; /* (I4) */

� Que vaut *p ?� Sur quoi pointe p1 ?

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p

NULL

4

p et p1 sont des pointeurs d'entiers

NULL

p1

x

(I2)

(I1)

(I3)

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p

NULL

4

p1

x

(I4) Oxff15


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++ ;

oup+=4 ;


Les pointeurs / Opérations d’incrémentation (1)

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

.

p

p pointeur d'entiers

x

Oxff12

Oxff13

Oxff14

Oxff15

p

4x

Oxff17Oxff15

4

p++

Oxff16

Oxff17

Oxff18

8y 8y

si un entier est codé sur 16bits


Les pointeurs / Opérations d’incrémentation (2)

Oxff12

Oxff13

Oxff14

Oxff15

.

.

.

p

4

p pointeur d'entiers

x

Oxff12

Oxff13

Oxff14

Oxff15.

.

.

p

5x

Oxff14Oxff14

(*p)++

++ 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éclarationint 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éclarationchar 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"

B O N J O U R \0

Chaine


Les tableaux de caractères / Initialisation

� Au moment de la déclarationchar ch[] = " BONJOUR "; char ch[] = {’B’,’O’,’N’,’J’,’O’,’U’,’R’,’\0’} ;

� Par des valeurs fournies par l'utilisateurchar 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 ;B= &A ;

(2) ptab = tab ;

(3) ptab = &tab[5] ;

ptab++ ;

(4) strcpy(chaine, "Bonjour !") ;

ch1 = chaine ;

ch2 = &chaine[2] ;

ch2++ ;

� Peut on écrire chaine = ch2 ?



� 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

� Avantage par rapport à un tableau 2D

l n du

m r da

m r ce

s m ea

i

r

d

tab i

e d i

i


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 structproduit

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


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 structureunion 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 :


� 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 Énumérations (2)


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 fcloseint fclose( FILE *fic) => ferme le fichier pointé par fic

� Ex. de séquence ouverture / fermeture de fichierFILE *Fic = NULL ;

charchar NomFichierNomFichier[200] [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 tabFILE*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 fichierint 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))




� 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.




� 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 expressionensemble-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



� Compilation conditionnelle� 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);

}



� Compilation conditionnelle� 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 :

.c .o

Compilation Édition de liens

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

.c

.o

Compilation Édition de liens

fichier.c

fichier.o

prog.exe

source code objet programme exécutable

.h

fichier.h

.c

main.c

.omain.o



� 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 x=25;

extern int Val;

extern int Fonct();

main(){

....

}

int Val=100;

int Fonct(int P){

extern int v;

int j;

........

}

int Toto(float z){

.......

}

extern int Fonct(int);


int y=6, res;

res=Fonct(y);


� 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 autremodule doit "inclure" le fichier d'en-tête de celui-ci (pour avoir les déclarations).



� Fichier d'en-tête (suite)� Exemple

#include <stdio.h>

extern void empiler(double);

void main(void){

double x ;

.......

empiler (50) ;

....

}

main.c

#include <stdio.h>

#include "pile.h"

void empiler(double y){

.......

}

double depiler (void){

....

}

pile.c

void empiler (double);

double depiler(void) ;

pile.h



� 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é inclus1 s'il a déjà été inclus



main.c pile.c pile.h



� Fichier d'en-tête (suite)� Exemple

main.c pile.c pile.h

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 "pile.h"

void main(void){

double x ;

.......

empiler (50) ;

x = depiler();

....

}

main.c

#include <stdio.h>

#define PILE

#include "pile.h"

void empiler(double y){

.......

}

double depiler (void){

....

}

pile.c pile.h

void empiler (double);

double depiler(void);

extern void empiler (double);

extern 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

Documents

L2 -UE Programmation 3 Langage C 2009 2010helios.mi.parisdescartes.fr/~cloppet/prog3/PolyCoursProg... · 2012-12-17 · UE programmation 3 –F. Cloppet 12 Programmer en Langage C