1 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

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

l Puisqu’il est destiné à la programmation de 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

(2)

4

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

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

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

(3)

7

l Les distances moyennes

#include <math.h>

#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 x0, y0;

{ 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

– signeda pour effet de centrer les données autour de 0 (pour charet int) – unsigneda pour effet de rendre la borne inférieure des valeurs possibles

égale à 0 (pour charet 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 intet float)

9 1.4 La programmation en langage C 1.4.2 Le langage C

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

(4)

10

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

11 1.4 La programmation en langage C 1.4.2 Le langage C

l

Le type int (32 bits), long int ou long

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

(5)

13

l

Le type long float ou double

1.7 × 10^-308= |X| = 1.7 × 10³⁰⁸

52 bits de données pour la mantisse 11 bits de données pour l'exposant

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⁴⁹³²

60 bits de données pour la mantisse 19 bits de données pour l'exposant

1 bit de signe

80 bits - 10 octets

15 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

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)

lOn peut utiliser le caractère “ _ ”

lLe C distingue les majuscules et les minuscules

lLes types externes ⇒identificateurs limités à 6, 7, 8 caractères lAttention aux mots réservés

(6)

16

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

17 1.4 La programmation en langage C 1.4.2 Le langage C

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

lEntières: 537

lOctales: 0214 (commençant par un zéro) 2148= 14010

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

(minuscule ou majuscule)) 32f₁₆= 815₁₀

lLes nombres réels: 0.0 ou 3.141592654 ou 7.587E12 ou 9.7e-4 lCaractères: ‘A' (entre apostrophes)

le caractère ‘A' est équivalent au code ascii 65 lChaî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

lCaractères spéciaux: ex: \n, \t, \b, \r, \f, \0

(7)

19

l

Les règles d’écriture

– 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

lLes opérateurs arithmétiques:+ - * / % (modulo) lLes opérateurs rationnels:> >= <= <

retournent la valeur 0 si faux ou 1 si vrai lLes opérateurs d’égalité et d’inégalité :== !=

retournent la valeur 0 si faux ou 1 si vrai lLes opérateurs de décalage de bits :>> <<

>> décale à droite (÷2) et << décale à gauche (×2) lLes opérateurs bit à bit :& | ^

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

lLes opérateurs logiques :&& ||

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

21 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les opérateurs

lLes opérateurs d’affectation:

Simple affectation: = Affectation avec opération:

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

exemple : x += y est équivalent à x = x + y lL’opérateur conditionnel:exp1 ? exp2 : exp3

retournent exp2 si exp1 est vrai sinon retourne exp3 lLes 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)

(8)

22

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

23 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 conditionnelle :

if (exp1)inst1 elseinst2

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

sans break avec break avec break

avec break

(9)

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 instwhile (exp);

exp inst

faux vrai

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

for (inst1; exp1; inst2) inst3

(10)

28

l

Les règles d’écriture

– Les instructions de contrôle

lLes 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

29 1.4 La programmation en langage C 1.4.2 Le langage C

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;

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

lL’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

lUn tableau est un ensemble de variables de même type lUn 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).

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

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

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

(11)

31

l

Les règles d’écriture

–

Les tableaux

lOn peut déclarer des tableaux à N dimensions de la façon suivante : int A[dim1][dim2][dim3][dim4];

lOn 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};

lIl 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

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

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

33 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les tableaux

lLes 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).

lLes 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 */

(12)

34

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.

35 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture – Les fonctions

lClasse 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

lDé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

lDé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

(13)

37

l

Les règles d’écriture – Les fonctions

lAppel d’une fonction –Avec argument

lSyntaxe:

A = nom_fonction (arg1, arg2, …);

nom_fonction (arg1, arg2, …);

–Sans argument

lSyntaxe:

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

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

}

39 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

– 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

(14)

40

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

}

41 1.4 La programmation en langage C 1.4.2 Le langage C

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 */

}

(15)

43

l

Les règles d’écriture

–

Les structures

lUne 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 structtag{...}type;

44 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les structures

lSé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)

45 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les structures

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

struct _SNoeud *Gauche;

struct _SNoeud *Droite;

int Val;

} SNoeud;

(16)

46

l

Les règles d’écriture

–

Les unions

lPermet de stocker Ntypes de données dans un même espace mémoire.

union Nombre { int A;

float B;

double C;

};

47 1.4 La programmation en langage C 1.4.2 Le langage C

l

Les règles d’écriture

–

Les énumérateurs

lUne é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

lL’opérateur sizeofet les fonctions mallocet freepermettent 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);

(17)

49

l

Les règles d’écriture

– Allocation dynamique de la mémoire

lAutres 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

51 1.4 La programmation en langage C 1.4.2 Le langage C

l Le préprocesseur

– 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

(18)

52 l Le préprocesseur

– Les définitions

#defineidentificateur<description>

#undefidentificateur

–

Les macros

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

#define square(a) a*a

53 1.4 La programmation en langage C 1.4.2 Le langage C

l Le préprocesseur

–

Les macros (pourquoi les éviter)

lint A, *B;

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

lint i = 1, j = 2;

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

lint 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

(19)

55 l La structure du langage

–

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

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

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

lL’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.

57 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

–

Variables locales et globales

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

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

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

(20)

58

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

}

59 1.4 La programmation en langage C 1.4.2 Le langage C

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 externou 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 : autoint x;

Ou bien : int x;

(21)

61 l La structure du langage

–

Classe de mémorisation pour les variables locales

2. Les variables locales de type staticont 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 : staticint 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 :

registerint Sum, r1, r2;

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

Sum = r1 + r2;

63 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

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

(22)

64 l La structure du langage

–

Classe de mémorisation pour les variables globales

1. Les variables globales ont la classe externlorsqu’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

externint e;

65 1.4 La programmation en langage C 1.4.2 Le langage C

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>

(23)

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). RetournentEOFen 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 %)

69 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

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

(24)

70 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

71 1.4 La programmation en langage C 1.4.2 Le langage C

l La structure du langage

–

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