Structures de données et algorithmes

(1)

Chapitre 1 Techniques de programmation

2

^ième

partie :

Programmation en langage C

GPA665 - Automne 2002 © Mohamed Cheriet, ing., Ph. D.

2 1.4 La programmation en langage C Historique du langage C

l 1960 – Création d’Algol60 (très abstrait mais donne naissance à des langages comme Pascal, PL/I et le CPL)

l 1967 – Martin Richards crée le BCPL (Basic Combined Programming Language)

l 1970 – Ken Thompson développe en assembleur la première version de Unix et son propre langage de programmation qui permettra d’assurer l’évolution de Unix – le langage B (qui est largement inspiré du BCPL)

l 1972 – Dennis Ritchie et Ken Thompson modifient le

langage B et donne naissance au langage C

(2)

3 système on s’efforce de le rapprocher du langage machine

On appelle parfois le langage C le langage assembleur évolué l C’est un langage typé faible

Exemple : permet l’affectation d’un caractère ou même un pointeur à un entier

4 1.4 La programmation en langage C Description générale du C

l

Chaque programme C doit posséder une fonction nommée main, désignant le début d’exécution du programme.

l

Un programme C type peut être conçu de plusieurs fonctions pouvant être contenues dans un ou plusieurs fichiers.

l

On peut également définir des fonctions qui retournent les valeurs qui peuvent être appelées récursivement. Une fonction qui ne retourne pas une valeur peut être déclarée void.

l

Souvent des déclarations et des fonctions contenues dans un fichier source sont référencées dans un autre fichier source.

l

Pour que le compilateur soit au courant des références externes, des fichiers “ include ” sont fréquemment utilisés.

l

Chaque fichier source est compilé séparément, ils seront ensuite liés ensemble pour former un programme exécutable.

l

Le C possède des instructions standards de contrôle if ou switch pour

les branchements et for, while et do pour les itérations

(3)

5 l Un programme très simple

main() {

printf("Ça marche.\n");

}

6 1.4 La programmation en langage C 1.4.1 Quelques exemples de programmes

l Une conversion octale

#include <stdio.h>

int main () { int n = 1;

char c;

while ((c = getchar()) != EOF) {

printf("%o", c);

if (n++ > 10) {

n = 1;

printf("\n");

} else

printf(" ");

}

if (n != 1) /* fin de ligne incomplète */

printf("\n");

return(0);

} /* Fin du main */

abcdefghijklmnopqrst

141 142 143 144 145 146 147 150 151 152 153 154 155 156 157 160 161 162 163 164 12

(4)

7

#define XMAX 9

#define YMAX 9 double Moyenne();

int main() {

int x, y;

double somme = 0.0;

for (x = 0; x < XMAX; x++) {

printf("%d: ", x);

for (y = 0; y < YMAX; y++) {

double s = Moyenne(x,y);

somme += s;

printf("%.2f", s);

} printf("\n");

}

printf("moyenne= %f\n", somme / (YMAX * XMAX - 1));

} /* Fin du main */

int x, y;

double somme = 0.0;

for (x = 0; x < XMAX; x++) for (y = 0; y < YMAX; y++) {

double d = (x - x0)*(x - x0)+(y - y0)*(y - y0);

somme += sqrt(d);

}

somme /= (XMAX * YMAX - 1);

return(somme);

} /* Fin de Moyenne */

0: 6.32 5.75 5.34 5.09 5.01 5.09 5.34 5.75 6.32 1: 5.75 5.15 4.71 4.44 4.35 4.44 4.71 5.15 5.75 2: 5.34 4.71 4.24 3.96 3.86 3.96 4.24 4.71 5.34 3: 5.09 4.44 3.96 3.66 3.57 3.66 3.96 4.44 5.09 4: 5.01 4.35 3.86 3.57 3.47 3.57 3.86 4.35 5.01 5: 5.09 4.44 3.96 3.66 3.57 3.66 3.96 4.44 5.09 6: 5.34 4.71 4.24 3.96 3.86 3.96 4.24 4.71 5.34 7: 5.75 5.15 4.71 4.44 4.35 4.44 4.71 5.15 5.75 8: 6.32 5.75 5.34 5.09 5.01 5.09 5.34 5.75 6.32 moyenne = 4.779420

8 1.4 La programmation en langage C 1.4.2 Le langage C

l Les types de base

5 types de base : char, int, float, double et void

l Modificateurs de type

2 pour l’utilisation des signes +/- : signed et unsigned

– signed

a pour effet de centrer les données autour de 0 (pour char et int)

– unsigned

a pour effet de rendre la borne inférieure des valeurs possibles égale à 0 (pour char et int)

2 pour la taille en mémoire : short et long

- short a pour effet de réduire l’intervalle des données (pour int)

- long a pour effet d’augmenter l’intervalle des données (pour int

et float)

(5)

9 l Le type char

1 bit de signe

7 bits de données 8 bits de données

8 bits - 1 octets 8 bits - 1 octets

signed -128 = X = 127

unsigned 0 = X = 255

10 1.4 La programmation en langage C 1.4.2 Le langage C

l Le type int (16 bits) ou short int

signed -32 768 = X = 32 767

unsigned 0 = X = 65 535

16 bits - 2 octets 15 bits de données

16 bits - 2 octets 16 bits de données 1 bit de signe

(6)

11 signed

- 2 147 483 648 = X = 2 147 483 647

unsigned 0 = X = 4 294 967 295

31 bits de données 1 bit de signe

32 bits - 4 octets

32 bits de données

32 bits - 4 octets

12 1.4 La programmation en langage C 1.4.2 Le langage C

l Le type float

3.4 × 10

^-38

= |X| = 3.4 × 10

³⁸

32 bits - 4 octets

23 bits de données pour la mantisse 8 bits de données pour l'exposant

1 bit de signe

(7)

13 l Le type long float ou double

1.7 × 10

^-308

= |X| = 1.7 × 10

³⁰⁸

1 bit de signe

64 bits - 8 octets

14 1.4 La programmation en langage C 1.4.2 Le langage C

l Le type long double

Ce n’est pas un type du C, il est seulement disponible sur certains compilateurs C++ (comme Visual C++ ou C++Builder)

3.4 × 10

^-4932

= |X| = 3.4 × 10

⁴⁹³²

1 bit de signe

80 bits - 10 octets

(8)

15

–

Les identificateurs

Sert pour nommer les variables, les étiquettes et les fonctions. Ils sont constitués d’une suite de lettres et de chiffres (commençant par une lettre)

l

On peut utiliser le caractère “ _ ”

l

Le C distingue les majuscules et les minuscules

l

Les types externes ⇒

identificateurs limités à 6, 7, 8 caractères

l

Attention aux mots réservés

16 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Les mots réservés du C

while volatile

void unsigned

union typedef

switch struct

static sizeof

signed short

return register

long int

if goto

for float

extern enum

else double

do default

continue const

char case

break

auto

(9)

17 l Les règles d’écriture

–

Les commentaires et les espaces

l

Utiliser : /* */

l

Attention aux imbrications de commentaires

l

Attention aux commentaires débutant par : //

18 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les constantes

l

Entières : 537

l

Octales : 0214 (commençant par un zéro) 214

₈

= 140

₁₀

l

Hexadécimales : 0x32f ou 0X3B (commençant par zéro et "X"

(minuscule ou majuscule)) 32f

₁₆

= 815

₁₀

l

Les nombres réels : 0.0 ou 3.141592654 ou 7.587E12 ou 9.7e-4

l

Caractères : ‘A' (entre apostrophes)

le caractère ‘A' est équivalent au code ascii 65

l

Chaînes de caractères : "GPA665" (entre guillemets) la chaîne de caractères "GPA665" correspond au tableau de caractères suivant : 71-80-65-54-54-53-0

l

Caractères spéciaux : ex:

\n, \t, \b, \r, \f, \0

(10)

19 – Les expressions

l

Une expression est une combinaison d’éléments tels que des constantes, des identificateurs, des éléments de tableaux, des références à des structures ou unions, des appels de fonctions par des opérateurs binaires ou unaires

– Les instructions

l

Une instruction est l’appel d’un opérateur ou d’une fonction. Il est possible de regrouper plusieurs instructions par la définition d’un bloc. Un bloc est défini par des accolades { }.

20 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les opérateurs

l

Les opérateurs arithmétiques: **+ - * / %**

(modulo) l

Les opérateurs rationnels: > >= <= <

retournent la valeur 0 si faux ou 1 si vrai

l

Les opérateurs d’égalité et d’inégalité : == !=

retournent la valeur 0 si faux ou 1 si vrai l

Les opérateurs de décalage de bits : >> <<

>> décale à droite (÷2) et << décale à gauche (×2) l

Les opérateurs bit à bit : & | ^

le &est le ET logique, le |est le OU logiqueet le ^est le X-OU logique exclusif

l

Les opérateurs logiques : && ||

le &&est le ET logiqueet le ||est le OU logique

(11)

21

l

Les règles d’écriture

–

Les opérateurs

l

Les opérateurs d’affectation:

Simple affectation: = Affectation avec opération:

**+= -= *= /= %= >>= <<= &= |= ^=**

exemple : x += y est équivalent à x = x + y l

L’opérateur conditionnel: exp1 ? exp2 : exp3

retournent exp2 si exp1 est vrai sinon retourne exp3 l

Les opérateurs unaires :

*v (le contenue de v) ++v (pré-incrémentation de v)

&v (l’adresse de v) --v (pré-décrémentation de v) -v (le négatif de v) v++ (post-incrémentation de v)

!v (non v) v-- (post-décrémentation de v)

~v (le complément bit à bit de v)

(type)v (change le type de v – casting)

Sizeof(v) ou sizeof(v) (retourne le nombre d’octets du type ou de la variable v)

22 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Ordre

d’évaluation et priorité des

opérateurs

De gauche à droite ,

De droite à gauche

= += -= *= /= %= >>= <<= &= |= ^=

? :

De gauche à droite

||

&&

|

^

&

== !=

< <= > >=

>> <<

De gauche à droite + -

* / %

! ~ ++ -- + - * & (type) sizeof

De gauche à droite ( ) [ ] ->

Évaluation Opérateurs

(12)

23 – Les instructions de contrôle

l

L’instruction conditionnelle :

if (exp1) inst1 else inst2

Attention aux instructions if imbriquées

exp1

inst2 inst1

faux vrai

24 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Les instructions de contrôle

l

L’instruction switch :

switch (exp1) {

[case const1 : inst1; [break;]]

. . .

[default : instd; ] };

Chacune des branches suivantes est exécutée sauf si break

exp1

inst1

inst2

inst3

instd 1

2 3

autre

sans break

avec break avec break

avec break

(13)

25 l Les règles d’écriture

– Les instructions de contrôle

l

Les instructions d’itération :

while (exp) inst exp

inst

faux

vrai

26 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Les instructions de contrôle

l

Les instructions d’itération :

do inst while (exp);

exp inst

faux vrai

(14)

27 – Les instructions de contrôle

l

Les instructions d’itération :

for (inst1; exp1; inst2) inst3

28 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Les instructions de contrôle

l

Les commandes d’arrêt d’une itération ou d’une instruction sont :

– break;

– continue;

– goto;

Expression 1

Exp 2

Expression 3

Instruction faux vrai

continue break

goto

(15)

29 l Les règles d’écriture

–

Les pointeurs

Un pointeur est une variable dont le contenu a pour valeur l’adresse d’une autre variable. Tous les pointeurs ont 32 bits.

Pour déclarer un pointeur on utilise l’astérisque de la façon suivante :

int *pA;

l

L’opérateur & permet d’obtenir l’adresse d’une variable.

l

L’opérateur * permet la déclaration d’un pointeur ou l’obtention du contenu de la case mémoire identifiée par un pointeur

int *pA = NULL;

int B, C;

pA = &B;

B = 3;

C = *pA;

pA = C;

*pA = 4;

Nom Type

Valeur Adresse

Exemple de représentation mémoire pratique

30 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Les tableaux

l

Un tableau est un ensemble de variables de même type

l

Un tableau est constitué de deux parties : l’espace contiguë des données et une variable (pointeur constant) de référence qui possède l’adresse du tableau de données (d’où l’étroite relation entre les tableaux et les pointeurs).

l

Pour déclarer un tableau on dimensionne la variable par des [ ]

int A[6]; /* déclare un tableau d’entier constitué de 6 éléments */

l On accède aux éléments par A[indexe]où l’indexe est de 0 à N - 1

A

(16)

31

–

Les tableaux

l

On peut déclarer des tableaux à N dimensions de la façon suivante :

int A[dim1][dim2][dim3][dim4];

l

On peut initialiser un tableau par :

int A[2][3] = {{1,2,3},

{4,5,6}, };

int B[4] = {1, 2, 3, 4};

int C[] = {1, 2, 3, 4};

l

Il est possible d’utiliser un tableau comme paramètre de fonction. Les tableaux sont toujours passés aux fonctions par adresse.

32 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Les tableaux

l

Exemple 1

int A[] = {1, 2, 3, 4, 5, 6};

int *pA = A;

int B, C;

B = *(pA++); C = *(A++);

B = *(pA + 2); C = *(A + 2);

l

Exemple 2

int Longueur(tampon, taille)

char tampon[];/* aucune allocation mémoire */

int taille; /* c’est une adresse (pointeur vers le 1^erélément) */

{

int i = 0;

while (i < taille && (tampon[i] != ’ ’) i++;

return(i);

} /* Fin de Longueur */

L ’appel: Longueur(tab, sizeof(tab));

(17)

33 l Les règles d’écriture

–

Les tableaux

l

Les chaînes de caractères sont définies comme étant des tableaux de char et dont le dernier élément de la phrase est un code nul (\0).

l

Les fonctions standards que vous utilisez respectent ce standard.

char T[] = "Allo";

void Copie(chaine1, chaine2) char chaine1[], chaine2[];

{ int i;

for (i = 0; (chaine2[i] = chaine1[i]) != ’\0’; i++);

} /* Fin de Copie */

34 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture – Les fonctions

Syntaxe moderne :

/* En-tête de la fonction */

[classe de mémorisation] [type] nom ([d1 n1, d2 n2, …, dn nn]) /* Corps de la fonction */

{

[Définition des variables locales]

[Définition de variables externes]

[Définition de fonctions supplémentaires]

[instructions]

}

Si une fonction est utilisée dans un programme avant d’être définie, on devra alors déclarer avant son appel le nom de cette fonction ainsi que le type de son résultat.

(18)

35 – Les fonctions

l Classe de mémoire des fonctions

• extern(par défaut)

La fonction est une entité globale et peut être utilisée partout où elle est référenciée.

• static

L’utilisation de la fonction est limitée dans le module où elle a été définie.

• Valeur de retour

• Type élémentaire

char, short, int, long, float, double, long double ou un pointeur quelconque

• On utilise le mot clé voidpour les fonctions qui ne retournent pas de valeur.

• Si le type est omis la fonction renvoie par défautun type entier (int).

• L’instruction return termine la fonction return; /* ne retourne rien – void */

return V; /* retourne la valeur de V */

36 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Les fonctions

l Déclaration des fonctions

L’endroit où est déclarée une fonction a son importance

– Déclaration locale : déclarer la fonction au sein de la fonction qui doit l’utiliser

– Déclaration globale : on déclare les fonctions au début du fichier source avant le main, ainsi, la fonction peut être appelée par toutes les fonctions du module

l Déclaration de fonctions dans les programmes comportant plusieurs modules

Il faut déclarer une fonction dans un module lorsque sa définition se trouve dans un autre module du programme

c’est une fonction externe - exemple : cube8.c et func23.c

(19)

37 l Les règles d’écriture

– Les fonctions

l

Appel d’une fonction

– Avec argument

l

Syntaxe:

A = nom_fonction (arg1, arg2, …);

nom_fonction (arg1, arg2, …);

– Sans argument

l

Syntaxe:

A = nom_fonction ();

nom_fonction ();

38 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

– Les fonctions

l

Exemple de fonctions

/******* Cube8.c ******/

#include <stdio.h>

externdouble second(double x);

main(){

double first(void);/*déclaration*/

printf(“\n Volume =%f”,first());

}

double first(void){

double e;

externvoid third(void);/*déclaration*/

third();

printf(“Longueur de l’arrête:”);

scanf(“%lf”,&e);

return(second(e));

}

/***** func23.c *****/

# include<stdio.h>

double second(double x) {

return(x*x*x);

}

void third(void) {

printf(“\033[2j”);

}

(20)

39 – Passages des paramètres

Il existe 2 méthodes pour passer des paramètres à une fonction

–

Passage par valeur (call by value)

–

Passage par référence ou par adresse (call by reference)

l

Passage par valeur :

La fonction appelée reçoit une copie de la valeur de l’objet passé comme paramètre effectif. Cette copie est affectée au paramètre formel correspondant.

La fonction travaille donc sur un duplicata (et non sur l’original) de la valeur transmise

40 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

– Passages des paramètres

Exemple de passage par valeur

/*** show prouve qu'en cas de passage de paramètres par valeur, ***/

/*** ce sont les copies et non les originaux qui sont transmis. ***/

#include <stdio.h>

main(){

void show(int x, int y); /* déclaration de show */

int a = 3, b = 5; /* variables locales … main */

printf("Valeurs des variables dans 'main' : %d\t%d\n", a, b);

show(a, b); /* appelle show : passage par valeur */

printf("Valeurs des variables dans 'main' : %d\t%d", a, b);

}

void show(int x, int y) { /* définition de show */

x++;

y++;

printf("Valeurs des variables dans 'show' : %d\t%d\n", x, y);

(21)

41 l Les règles d’écriture

– Passages des paramètres

l

Passage par adresse :

Lorsqu’on veut qu’une fonction puisse modifier la valeur d’une donnée passée comme paramètre, il faut transmettre à la fonction l’adresse de la donnée

42 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

– Passages des paramètres

Exemple de passage par adresse

#include <stdio.h>

void swap(int *x, int *y); /* déclaration de swap */

main(){

int x = 0, y = 12345; /* variables locales … main */

printf("Valeurs des variables dans 'main' : %d\t%d\n", x, y);

swap(&x, &y); /* appelle show : passage par référence */

printf("Valeurs des variables dans 'main' : %d\t%d", x, y);

}

void swap(int *x, int *y) /* permute les valeurs d’origine de deux valeurs*/

{

int buffer = *x;

*x = *y; /* permutation */

*y = buffer; /* pointeurs déréférencés */

}

(22)

43

–

Les structures

l

Une structure regroupe des informations concernant un même sujet.

Déclaration

struct { struct individu {

char Nom[30]; char Nom[30];

int Age; int Age;

float Poids; float Poids;

} personne; };

Définit la variable personne Définit le type de donné individuqui qui est une structure telle est une structure telle que définit que définit

typedef struct {...} type;

typedef struct tag {...} type;

44 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Les structures

l

Sélecteur de champ

struct individu Pierre;

individu *pPierre;

pPierre = &Pierre;

Pour une variable structurée : Pierre.Age = 2;

Pour un pointeur de type structuré : pPierre->Age = 2;

(équivalent à (*Pierre).Age)

(23)

45 l Les règles d’écriture

–

Les structures

l

Elle peut contenir des références à elle même typedef struct _SNoeud {

struct _SNoeud *Gauche;

struct _SNoeud *Droite;

int Val;

} SNoeud;

46 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Les unions

l

Permet de stocker N types de données dans un même espace mémoire.

union Nombre { int A;

float B;

double C;

};

(24)

47

–

Les énumérateurs

l

Une énumération consiste à associer un ensemble de constante numérique à un ensemble d’identificateurs.

Exemple

enum JourDeLaSemaine

{dimanche, lundi, mardi, mercredi, jeudi, vendredi, samedi};

enum JourDeLaSemaine Jour;

JourDeLaSemaine* pJour;

48 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Allocation dynamique de la mémoire

l

L’opérateur sizeof et les fonctions malloc et free permettent une gestion dynamique de la mémoire.

– sizeofretourne le nombre d’octet d’un type ou d’une variable (retourne un entier)

– mallocretourne un pointeur voidsur une nouvelle allocation contiguë dont la taille est définie en nombre d’octets (il est important de changer le type et de vérifier si l’allocation dynamique a bien réussi)

– freelibère la mémoire associé à un pointeur

l Exemple:

struct noeud *ptr;

ptr = (noeud*) malloc(sizeof(struct noeud));

free(ptr);

(25)

49

l

Les règles d’écriture

–

Allocation dynamique de la mémoire

l

Autres exemples basés sur les arbres

nptr Créer(v) int v;

{

nptr n = (nptr) malloc(sizeof(struct noeud));

n→ga = n→dr = NULL;

n→val = v;

return(n);

} /* Fin de Créer */

Une autre fonction est nécessaire pour imprimer un arbre

void Imprimer(n) nptr n;

{

if(n != NULL) {

Imprimer(n→ga);

printf("%d\n", n→val);

Imprimer(n→dr);

}

} /* Fin d’Imprimer */

50 1.4 La programmation en langage C 1.4.2 Le langage C

l Les règles d’écriture

–

Le compilateur et l’éditeur de liens

Programme source

Compilateur

Fichier objet

Éditeur de liens

Programme exécutable

Le compilateur transforme les fichiers sources en fichiers objets

L'éditeur de liens transforme les fichiers objets pour générer un exécutable

(26)

51 – L’insertion de fichiers

#include "filename" /* recherche locale + catalogue système */

#include <filename> /* recherche catalogue système */

– La compilation conditionnelle

#if …

première partie

#else …

deuxième partie

#endif

#ifdef

#ifndef

52 1.4 La programmation en langage C 1.4.2 Le langage C

l Le préprocesseur

– Les définitions

#define identificateur <description>

#undef identificateur

– Les macros

#define max (a, b) ((a) > (b) ? (a) : (b))

#define square(a) a*a

(27)

53 l Le préprocesseur

– Les macros (pourquoi les éviter)

l int A, *B;

A = max(‘a’, B); /* aucune vérification de type – compile */

l int i = 1, j = 2;

int A = max(++i, ++j); /* on s’attend à 3 alors qu’on obtient 4 */

l int Y = 3, Z = 0;

Z = square(Y + 1); /* on s’attend à 16 alors qu’on a 7 */

C’est pourquoi on utilise le parenthésage qui lève l’embiguïté

54 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Bloc

l

Le bloc est constitué de déclarations et d’instructions

l

Si le bloc n’a pas de déclaration alors il est constitué d’instructions composées

l

Un bloc peut contenir un bloc – Classes de variables

auto, static, extern, register et typedef exemple : static int A[10]

typedef n’engendre pas d’allocation mémoire

(28)

55 – Initialisation des variables

l

Les variables statiques et externes sont initialisées à 0.

l

Les expressions les initialisant sont des constantes ou des adresses déclarées.

l

Les tableaux automatiques, les structures et les unions ne peuvent pas être initialisés.

l

Exemple d’initialisation

int Tab[] = {1, 2, 3, 4}; /* tableau de dimension 4 */

char Message[] = "Vous avez du courrier /n"; /*chaîne de 24 caractères*/

char Matrice2x2[4][3] = { {1, 2, 3}, {3, 4, 5}, {5, 6, 7}, {7, 8, 9}};

56 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

–

Les variables

l La manière dont un programme C gère les variables ne dépend pas seulement du type de celles-ci, mais aussi de l’endroit du programme dans lequel elles sont définies et de la classe de mémorisation qui leur a été attribuée.

l La classe de mémorisation (storage class)d’une variable détermine l’endroit où sera rangée la variable, endroit situé dans la zone mémoire occupée par le programme C.

l L’emplacement de définition ainsi que la classe de mémorisation d’une variable conditionne les points suivants :

- Le domaine de validitéd’une variable (on parle de visibilité -scope)

- Durée de viede la variable : fraction de la durée totale du programme pendant laquelle la variable existe vraiment.

(29)

57 l La structure du langage

–

Variables locales et globales

l C’est l’emplacement dans le programme qui définit si une variable est locale ou globale.

l Une variable globale est définie hors de toute fonction. Elle est connue (donc valide et utilisable) dans tout le fichier (donc dans chaque bloc ou chaque fonction) où elle est définie; cela à partir de l’endroit de sa définition. Selon sa classe de mémorisation, sa portée peut même s’étendre à d’autres fichiers si le programme est composé de plusieurs fichiers.

l Une variable locale au contraire, est définie à l’intérieur d’un bloc ou d’une fonction.

58 1.4 La programmation en langage C 1.4.2 Le langage C

/* SCOPE1 montre l’utilisation des variables locales */

#include <stdio.h>

int global = 1000;/* Variable globale: portée = tout le fichier */

main(){ /* début bloc externe de main */

int local1 = 2000; /* Variable locale : portée = main */

printf("Bloc externe main : La valeur de global est %d\n", global);

printf("Bloc externe main : La valeur de local1 est %d\n", local1);

{ /* début bloc interne de main */

int local2 = 3000; /* Variable locale : portée = bloc */

printf("Bloc interne main : La valeur de global est %d\n", global);

printf("Bloc interne main : La valeur de local1 est %d\n", local1);

printf("Bloc interne main : La valeur de local2 est %d\n", local2);

} /* fin bloc interne main */

fonc(); /* appel de la fonction fonc */

} /* fin bloc externe main */

fonc(){/* le programme contient une autre fonction que main : fonc */

int local3 = 4000; /* Variable locale : portée = fonc */

printf("\n\n fonc : La valeur de global est %d", global);

printf("\n fonc : La valeur de local3 est %d", local3);

}

(30)

59 l La structure du langage

– Classe de mémorisation

l

Toute variable en C possède une (et une seule) classe de mémorisation parmi les suivantes :

– extern

– static

– auto

– register

Les variables globales ne peuvent être que des classes extern ou static

60 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Classe de mémorisation pour les variables locales

1.

La classe auto (automatic) (qui est la classe de mémorisation par défaut) est attribuée à une variable lorsque celle-ci est définie à l’intérieure d’une fonction ou bloc.

Syntaxe : [auto] <type> <variable>

Exemple : auto

int x;

Ou bien : int x;

(31)

61 l La structure du langage

–

Classe de mémorisation pour les variables locales

2. Les variables locales de type static ont la même validité que les variables de la classe auto (ne sont connues que dans les blocs où elles ont été définies). Cependant, sa durée de vie n’est pas limitée à l’intervalle de temps durant lequel le bloc concerné est traité dans le programme.

– Les variables staticexistent pendant toute la durée du programme.

– Elles ne sont crées qu’une seule fois en mémoire. Les variables statiques conservent leurs valeurs.

– Exemple : static int a;

62 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Classe de mémorisation pour les variables locales

3. Une variable de classe register obéit aux mêmes règles de portée et de durée de vie, qu’une variable de classe auto. La différence est qu’elle n’est pas rangée dans la mémoire de travaille, mais plutôt dans les registres du CPU.

- Avantage : Accès beaucoup plus rapide au CPU.

Exemple :

register int Sum, r1, r2;

for (r1=1; r1<=2000; r1++) for (r2=1; r2<=2000; r2++)

Sum = r1 + r2;

(32)

63 l La structure du langage

– Classe de mémorisation pour les variables locales

4. Le mot clé extern utilisé dans un bloc ou une fonction, indique au compilateur qu’il s’agit d’une variable définie à un autre endroit du programme.

•

N’entraîne pas d’allocation mémoire

•

On parle d’importation de variable globale

64 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Classe de mémorisation pour les variables globales

1.

Les variables globales ont la classe extern lorsqu’elles sont définies sans aucune indication de classe de mémorisation.

-

Le programme comprend un seul fichier source, mais la variable doit être utilisée avant sa définition.

-

le programme se compose de plusieurs fichiers source et la variable doit être utilisée dans un autre fichier que celui dans lequel elle est définie

extern int e;

(33)

65 l La structure du langage

– Classe de mémorisation (résumé)

Durée du programme Fichier source avec définition

static

Durée du programme Fichier source avec déclaration et

après chaque déclaration dans tous les modules du programme extern

Variables globales

Durée du programme Bloc

static

Durée du bloc Bloc

register

Durée du bloc Bloc

auto Variables

locales

Durée de vie Portée

Classe mémoire

66 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Les bibliothèques standards du langage C

l

Une bibliothèque est un fichier archive composé de fichiers exécutables (fichier.a). C’est à l’aide de la commande #include qu’une bibliothèque est ajoutée au programme.

Exemple:

#include <stdio.h>

#include <math.h>

(34)

67 l La structure du langage

– Les bibliothèques standards du langage C

l

La bibliothèque standard d’entrée/sortie (stdio.h)

–

Les redirections stdio, stdin, stdout, stderr

–

Les fonctions

getc, putc, gets, fgets, scanf, fscanf, fread, puts, fputs, printf, fprintf, fwrite

68 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

–

Les bibliothèques standards du langage C

l Les fonctions printfet scanf

int printf(const char *format[, argument, ...]);

int scanf(const char *format[, address, ...]);

l Ces fonctions retournent le nombre d’octets affichés (pour printf) et le nombre de champs lus (pour scanf). Retournent EOFen cas d’erreur.

l Le format est une chaîne de caractères pouvant posséder des identificateurs de variables (avec le %).

%[n]c, %[n][l]d, %[n][.n][l]f,

(où n indique la largeur de colonne, l indique le type long et le point indique la précision)

%o (octal), %x (hexadécimal),%c (caractère),

%s (chaîne de caractères) et %% (pour le caractère %)

(35)

69 l La structure du langage

– Les bibliothèques standards du langage C

l

C’est la liste des variables qui est utilisée par printf et la liste des adresses de variables qui est utilisée par scanf.

l

Les caractères spéciaux

\a Bell \b Backspace \f Formfeed

\n Newline (linefeed) \r Carriage return \t Tab (horizontal)

\v Vertical tab \\ Backslash

70 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Les bibliothèques standards du langage C

l

Exemple des fonctions printf et scanf

int i, float n, char nom[50];

char Texte[] = "un entier, un nombre réel et du texte";

printf("Veuillez saisir %s", Texte);

scanf (" %d %f %s ", &i, &n, nom);

À l’exécution : 25 54.32E-1 thompson

(36)

71 – Quelques conseils

l

Utiliser typedef.

l

Utiliser #défine pour les constantes (en majuscules).

l

Éviter les macros à la place de fonction.

l

Toujours déclarer le type du résultat d’une fonction et utiliser return.

l

Toujours donner un résultat au main: état de sortie.

l

Vérifier le résultat d’une fonction système pour erreurs.

l

Utiliser les fichiers entête: <math.h>, <stdio.h>.

l

Éviter les expressions conditionnelles dont les branchements ne sont pas numériques.

72 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

– Quelques conseils

l

Utiliser un style logique et mettre des {} pour les instructions de contrôle.

l

Un commentaire à la fin de la définition d’une fonction s’avère intéressant.

l

Utiliser l’opérateur de conversion de type, dans le cas d’allocations, dans le type adéquat.

l

Bien séparer du programme principale des déclarations pour réaliser des déclarations uniques et utiliser #include.

l

Regrouper dans un fichier toutes les fonctions de même domaine.

l

Utiliser la classe static pour les fonctions de même fichiers.

l