01/02/2021

Les Structures
PROGRAMMATION Pr. Hasna ABIOUI
EN LANGAGE C E-mail: h.abioui@uiz.ac.ma
Année Universitaire 2020/2021
STRUCTURES / POINTEURS
1 2

RAPPEL LES STRUCTURES

TYPES MANIPULÉS PAR LANGAGE C PROGRAMMATION C
• Types de variables manipulées en C :
Types prédéfinis Signification Taille (octet) Plage des valeurs
char caractère 1 -128 à 127
unsigned char Caractère non signé 1 0 à 255
short int Entier court 2 -32 768 à 32 767 Le langage C autorise la déclaration de types particuliers
unsigned short int Entier cout non signe 2 0 à 65 535
int Entier 4 - 2 147 483 648 à 2 147 483 647 Les Structures
unsigned int Entier non signé 4 0 à 4 294 967 295
long int Entier long 4 - 2 147 483 648 à 2 147 483 647
unsigned long in Entier long non signé 4 0 à 4 294 967 295
float Réel simple précision 4 3,4 * 10 -38 à 3,4 * 10 38
double Réel double précision 8 1,7 * 10 -308 à 1,7 * 10 308
long double Flottant double long 10 3,4 * 10 -4932 à 3,4 * 10 4932

3 4

1
 01/02/2021

LES STRUCTURES LES STRUCTURES

PROGRAMMATION C PROGRAMMATION C

Défini&on : Structure : Caractéristiques :

§ Une structure est un agrégat de données de types plus simples § Une structure est une collection d’une ou plusieurs variables

§ Les structures perme8ent de construire des types complexes à par:r des types de § Les variables d'une structure sont groupées sous un seul nom
base ou d’autres types complexes § Les structures permettent d'organiser les données compliquées
§ Une structure est cons:tuée de plusieurs éléments de même type ou non § Les variables liées sont groupés en une seule entité au lieu des entités séparées

5 6

LES STRUCTURES : EXEMPLE LES STRUCTURES : EXEMPLE

PROGRAMMATION C PROGRAMMATION C

Exemple 1 : Exemple 2 :
Un étudiant peut être décrit par : • Un point est une paire de deux coordonnées x et y
§ Nom
• Un rectangle est une paire de deux points
§ Prénom
§ Date de naissance • Etc.
§ Code Apogée
§ Tuteur
§ ….

L’étudiant peut donc être décrit par une structure

7 8

2
 01/02/2021

DÉFINITION D’UNE STRUCTURE DÉFINITION D’UNE STRUCTURE

PROGRAMMATION C PROGRAMMATION C
• Le langage C permet au programmeur de construire ses propres types de données • La syntaxe de défini:on d'un type nommé nom_structure est:

• Avant l’u:lisa:on d’une structure, on doit tout d’abord la définir struct nom_structure {

type1 champ1;
• Pour définir une structure, le programmeur doit préciser: type2 champ2;
type3 champ3;
§ Le nom du nouveau type ...

§ La composi:on du type };
§ c'est à dire le nom et la nature des données qu'il con:ent
• Ce8e structure définit le type struct nom_structure composé des variables champ1,
champ2, champ3, ...

9 10

DÉFINITION D’UNE STRUCTURE DÉFINITION D’UNE STRUCTURE

PROGRAMMATION C PROGRAMMATION C
• Remarques : • Exemple :

• On appelle les données membres d’une structure des champs • Un point d'un plan 2-D est caractérisé par ses coordonnées x et y
• Les types des champs doivent être donnés dans la définition de la structure • Supposant que les coordonnées sont des entiers, la structure décrivant un

• Les champs peuvent être de n’importe quel autre type ou même une autre point est déclarée en C par:
struct point {
structure
int x;
• La structure ainsi définie peut alors être utilisée pour définir une variable dont int y;
le type est cette structure
};
• Le mot-clé struct introduit la déclaration de la structure, qui est une liste
de déclarations placées entre { et }

11 12

3
 01/02/2021

DÉFINITION D’UNE STRUCTURE DÉFINITION D’UNE STRUCTURE

PROGRAMMATION C PROGRAMMATION C
• Exemple : • Exemples de nouveaux types :

• Le mot-clé struct peut être suivi d'un nom qu'on souhaite a8ribuer à la
structure. Dans ce cas, point struct complex { struct date {

• Ce nom sera u:lisé par la suite pour se référer à la structure (déclara:on des int real; int jour;
int imaginary; int mois;
variables de ce type)
struct point { int annee;
• La déclara:on d'une structure définit un nouveau type };
int x; };
• struct point cons:tue le nouveau type
int y;

};

13 14

DÉCLARATION DES VARIABLES D’UNE STRUCTURE DÉCLARATION DES VARIABLES D’UNE STRUCTURE
PROGRAMMATION C PROGRAMMATION C
• Définition de la structure struct point (le nouveau type) : • Différentes façons de déclarer les variables d’une structure

struct point { • p1, p2, p3, p4, p5 des variables globales,

struct point {
int x; int x; ini:alisées automa:quement à 0.
int y; int y;
}; } p1, p2, p3 ; • p1, p2, p3 des variables déclarées avec la

struct point p4,p5; défini:ons de la structure.

• Déclaration d’une variable de type struct point :
• p4, p5, p6 déclarées en u:lisant le nom du
struct point p; /* une variable simple de la structure */ main() {
struct point p6; nouveau type.
struct point q, r;
printf("%d %d\n",p1.x, p1.y);
struct point tab [100]; /* un tableau de 100 éléments de la structure */ printf("%d %d\n",p4.x, p4.y); • p6 est une variable locale ini:alisée aléatoirement.
printf("%d %d\n",p6.x, p6.y);
}

15 16

4
 01/02/2021

DÉCLARATION DES VARIABLES D’UNE STRUCTURE DÉCLARATION DES VARIABLES D’UNE STRUCTURE
PROGRAMMATION C PROGRAMMATION C
• Différentes façons de déclarer les variables d’une structure • Différentes façons de déclarer les variables d’une structure
• Le nom du nouveau type non spécifié
struct point { struct {
int x; int x; • Chaque fois qu'on souhaite déclarer une nouvelle
int y; int y;
} p1, p2, p3 ; } q1, q2 ; variable on a besoin de réécrire le code de la

struct point p4,p5; structure

main() {
main() { struct {
• q1, q2 des variables globales, initialisées
struct point p6; int x; automatiquement à 0
int y;
printf("%d %d\n",p1.x, p1.y); } q3, q4, q5 ; • q3, q4 et q5 sont des variables locales initialisées
printf("%d %d\n",p4.x, p4.y);
printf("%d %d\n",p6.x, p6.y); printf("%d %d\n", q1.x, q1.y); aléatoirement
} printf("%d %d\n", q4.x, q4.y);
}

17 18

DÉCLARATION DES VARIABLES D’UNE STRUCTURE UTILISATION DES STRUCTURES

PROGRAMMATION C PROGRAMMATION C
• Différentes façons de déclarer les variables d’une structure /* Définition de la structure */
struct point {
int x;
struct {
int y;
int x;
};
int y;
} q1, q2 ; /* Programme principal */

int main() {
main() {
struct { struct point p;
int x; struct point q, r;
int y;
} q3, q4, q5 ;
struct point tab [100];
printf("%d %d\n", q1.x, q1.y); return 0;
printf("%d %d\n", q4.x, q4.y); }
}

19 20

5
 01/02/2021

INITIALISATION ET ACCÈS AUX CHAMPS INITIALISATION ET ACCÈS AUX CHAMPS

PROGRAMMATION C PROGRAMMATION C
• Les champs peuvent être initialisés au moment de la déclaration de la variable de type • L’ accès aux champs d’une variable se fait par un point, suivi du nom du champ de la
structure
structure à accéder :
• Exemple :
struct point p1 = {20,30}; • Syntaxe : nom_variable.champs
struct point p2 = {2,3}, p3 = {-7,50};
• Remarques : • Le point (.) permet de connecter le champ (variable membre) à la structure dont il fait
• Les valeurs d'initialisation sont fournies entre { et } par:e
• L'affectation des initialisations suit l'ordre d'apparition des champs dans la • Accès pour modifica:on des valeurs des champs des structures :
structure p1.x = -2; p1.y = 0;
p2.x = p1.y; p2.y = 2*p1.x;
• La Nième valeur est affectée au champ introduit à la Nième position dans la
définition de la structure

21 22

INITIALISATION ET ACCÈS AUX CHAMPS INITIALISATION ET ACCÈS AUX CHAMPS

PROGRAMMATION C PROGRAMMATION C
#include<stdio.h> #include<stdio.h>
/* Différentes initialisations */ /* Différentes initialisations */
struct point { struct point {
int x; int x;
int y; int y;
}; };

int main() { int main() {

struct point a = {2,3}, b = {2}; struct point a = {2,3}, b = {2};

struct point c = {} , d ; struct point c = {} , d ;

printf("a = (%d ,%d)\n", a.x, a.y); printf("a = (%d ,%d)\n", a.x, a.y);
printf("b = (%d ,%d)\n", b.x, b.y); printf("b = (%d ,%d)\n", b.x, b.y);
printf("c = (%d ,%d)\n", c.x, c.y); printf("c = (%d ,%d)\n", c.x, c.y);
printf("d = (%d ,%d)\n", d.x, d.y); printf("d = (%d ,%d)\n", d.x, d.y);

return 0; return 0;
} }

23 24

6
 01/02/2021

OPÉRATIONS SUR LES CHAMPS STRUCTURES IMBRIQUÉES

PROGRAMMATION C PROGRAMMATION C
• afficher les coordonnées du point A : • Une structure peut comporter parmi ses champs d'autres structures, dans ce cas on

printf("A = (%d ,%d)\n", A.x, A.y); parle de structures imbriquées

• Exemple:

• Calcul de la distance du point A de l'origine (0,0) : • Un rectangle peut être représenté par deux points (coins opposés
diagonalement)
float dist; struct rectangle {
dist = (float) sqrt((float)A.x*A.x +(float)A.y*A.y);
struct point p1;
struct point p2;

};
• La structure rectangle con:ent deux structures de type point

25 26

STRUCTURES IMBRIQUÉES STRUCTURES IMBRIQUÉES

PROGRAMMATION C PROGRAMMATION C
• Déclara:on d'une variable de type rectangle :

struct rectangle { • Modifica:on des données membres de la variable rect :

rect.p1.x = -2; rect.p1.y = 3 /* point p1 */

struct point p1;
struct point p2;
rect.p2.x = -21; rect.p2.y = 13 /* point p2 */
};
struct rectangle rect; /* sans initialisation*/
struct rectangle rect = {{1,2},{3,4}}; /* avec initialisation*/

• rect.p1.x se réfère à la variable x membre du point p1

27 28

7
 01/02/2021

STRUCTURES IMBRIQUÉES STRUCTURES IMBRIQUÉES

PROGRAMMATION C PROGRAMMATION C
• Autre exemple d’imbrica:on : une donnée membre étant un tableau à une dimension • Autre exemple d’imbrication:

• Pas d’ambigüité dans la ligne struct id id;

#include<stdio.h>
#define MAX 12 de la structure people:

struct vecteur{ § id est une variable membre de la

structure people
int taille;
float tab[MAX]; § Le type de id est struct id
};
int main() {
struct vecteur A = {3, {1,2,3}};
return 0;
}

29 30

CHOIX DES CHAMPS STRUCTURES ET FONCTIONS

PROGRAMMATION C PROGRAMMATION C
• On peut me8re n'importe quel type pour lequel la taille est connue par le compilateur • Une structure peut être utilisée comme argument ou résultat d'une fonction
pour les champs d’une structures
• A8en:on : On ne peut pas me8re la structure elle-même • Trois possibilités pour le passage des structures aux fonctions :

• Passer les champs (membres) séparément

Erreur de compila.on:
le champ suivant a un type incomplet • Passer la structure entière
• Passer un pointeur sur la structure
• On peut me8re comme membre un pointeur sur la structure elle-même puisque la taille
d'un pointeur est connue

31 32

8
 01/02/2021

STRUCTURES ET FONCTIONS STRUCTURES ET FONCTIONS

PROGRAMMATION C PROGRAMMATION C
Exemple : une fonc:on qui prend deux en:ers et retourne une structure point Exemple : les arguments et la valeur de retour sont des structures
struct point creation_point ( int x, int y) struct point ajouter_point ( struct point p1 , struct point p2 )
{ {
struct point p_new; p1.x += p2.x;
p1.y += p2.y;
p_new.x = x;
return p1;
p_new.y = y;
}

return p_new; main() {

}
struct point A,B,C;
A8en:on : il ne faut pas confondre la variable x fournie en argument avec celle qui est A = creation_point (2,3);
membre de la structure p_new ( de même pour la variable y ) B = creation_point (0,-1);
C = ajouter_point (A,B);
}

33 34

NOUVEAU TYPES : TYPEDEF NOUVEAU TYPES : TYPEDEF

PROGRAMMATION C PROGRAMMATION C
• Le langage C permet de créer de nouveaux types de données par typedef • La structure point :

• Par exemple la déclara:on: typedef int Length; fait que Length cons:tue un typedef struct point POINT;
synonyme de int • Ce qui fait que POINT constitue un synonyme de struct point
• Déclara:on des variables du nouveau type Length : • Exemple de déclarations :
Length Len, MaxLen; /* varables simples */ POINT p1, p2; /* déclaration de deux points */

POINT p3[10]; /* tableau de 10 points */

35 36

9
 01/02/2021

NOUVEAU TYPES : TYPEDEF NOUVEAU TYPES : TYPEDEF

PROGRAMMATION C PROGRAMMATION C
• Différentes façons de définir les nouveaux types : • Différentes façons de définir les nouveaux types :

struct point { • Défini:on de la structure struct point typedef struct point { • Une seule instruction pour définir la structure
int x; int x;
int y; • typedef fait appel à struct point pour int y; struct point et le nouveau type point
}; } point ;
créer le nouveau type point • Définition de la structure struct point a
typedef struct point point;
• Pas d’ambiguïté: le nouveau type point peut l'intérieur de l'instruction typedef
main() {
main() { prendre le même nom que celui de la structure point p,q = {3,-6};
point p,q = {3,-6}; struct point point tab[10];
point tab[10]; }
}

37 38

NOUVEAU TYPES : TYPEDEF EXERCICE APPLICATIF

PROGRAMMATION C PROGRAMMATION C
• Différentes façons de définir les nouveaux types :
• On souhaite réaliser une liste des étudiants de la filière LES-Informa:que S3
typedef struct { • Autre façon de déclarer une structure • Chaque étudiant est caractérisé par :
int x;
int y; • Nom et prénom
} point ;
• Date de naissance qui est elle aussi une structure représentée par 3
en:ers (jour, mois, année)
main() {
point p,q = {3,-6}; • CNE (en:er)
point tab[10];
} • Donner la structure Etudiant correspondante

39 40

10
 01/02/2021

INTRODUCTION : LES POINTEURS

PROGRAMMATION C
• Les pointeurs sont des variables très u:lisées en C

• Ils doivent être considérés comme des variables, il n’y a rien de sorcier derrière les
pointeurs

• Cependant, les pointeurs ont un domaine d’applica:on très vaste

Les Pointeurs • La no:on du pointeur est liée à une autre no:on : l’adresse

41 42

INTRODUCTION : NOTION D’ADRESSE INTRODUCTION : NOTION DE POINTEUR

PROGRAMMATION C PROGRAMMATION C
• Tout objet manipulé par l’ordinateur est stocké dans la mémoire cons:tuée d’une série • Une adresse est une valeur
de cases, dans lesquelles sont stockées les valeurs des variables • Ce8e valeur peut donc être stockée dans une variable
• Pour pouvoir accéder à un objet ou encore la valeur d’une variable càd au contenu de la • Les pointeurs sont donc des variables qui con&ennent l’adresse d’autres objets qui peuvent
case mémoire dans laquelle cet objet est enregistré, il faut connaître le l’adresse de être des variables ou autres ...
ce8e case dans la mémoire • On dit que le pointeur pointe sur la variable pointée
• Toute case mémoire a une adresse unique • Ici, pointer signifie faire référence à
• Lorsqu’on u:lise une variable, le compilateur manipule l’adresse de ce8e dernière pour
y accéder. C’est lui qui connaît ce8e adresse, le programmeur n’a pas à s’en soucier

43 44

11
 01/02/2021

INTRODUCTION : NOTION DE POINTEUR DÉCLARATION DES POINTEURS

PROGRAMMATION C PROGRAMMATION C
• Les adresses sont généralement des valeurs constantes, car en général un objet ne se • Pour déclarer un pointeur on doit définir type de l’objet/variable qu’il doit pointer, suivi
déplace pas en mémoire de l’iden:ficateur de pointeur précédé d’une étoile
• Toutefois, la valeur d’un pointeur peut changer :
• Syntaxe de déclara:on de pointeur : type * identificateur ;
• Cela ne signifie pas que la variable pointée est déplacée en mémoire, mais
• Interpréta:on : le pointeur nommé identificateur peut pointer sur des objets de
plutôt que le pointeur pointe sur autre chose
type type
• Les pointeurs disposent d’un type afin de savoir ce qui est pointé par un pointeur,
• Autrement dit, identificateur peut contenir des adresse des objets de type type
• Ce type est construit à par:r du type de l’objet pointé
• Le type des pointeurs se lit pointeur de ... • Exemple : int *pi; // pi est un pointeur d’entier
int *pi1, *pi2, j, *pi3;

45 46

DÉCLARATION DES POINTEURS DÉCLARATION DES POINTEURS

PROGRAMMATION C PROGRAMMATION C
• Utilisation de deux opérateurs : & et * • Exemple :
float * px; /* px est un pointeur de réel */
• L’opérateur & : &i signifie adresse de la variable i
char * pc ; /* pc est un pointeur de caractère */ @p ppi
• L’opérateur * : *adresse accéder à la valeur qui se trouve dans cette adresse
• Exemple : Exemple : Pointeur de pointeur
int i; int i =20;
@i p @i pi
int * p; /* déclaration d'une adresse d'entier */ int * pi ;
i=20; int * ppi ; /* pointeur de pointeur */
p=&i; /* p pointe sur i */ pi = &i;

printf("%d\n",i); == > 20 i ppi = &pi; 20 i

20
printf("%d\n",*p); == > 20

47 48

12
 01/02/2021

AFFICHAGE DES POINTEURS LES OPÉRATIONS SUR LES POINTEURS

PROGRAMMATION C PROGRAMMATION C
• Affichage d’une : Pointeur de pointeur • Soit p= &x ( p pointe sur x)

int i =20; int * pi ; int ** ppi ; • les notations ci-dessous sont équivalentes :
pi = &i; @p ppi
ppi = &pi; • Var1=*p <--> Var1 = x

• (*p)++ <--> x++

printf(" i = %d\n",i);
printf("pi = %d\n",*pi); @i pi • *p+=3 <--> x+=3
printf("ppi = %d\n",**ppi);
• Z=*p+2 <--> Z=x+2
printf("i = %d\n",&i);
printf("pi = %d\n",pi);
20 i
printf("ppi = %d\n",ppi);

49 50

LES OPÉRATIONS SUR LES POINTEURS

PROGRAMMATION C
• Soit deux pointeurs p1 et p2 de même type

• p1 = p2 : p1 et p2 pointent sur le même objet

• Exemple :
int *p1,*p2;
int x=9; Les Fonctions
p1=&x;
p2 = p1; >>>> *p1 = 9 et *p2 = 9
• Par contre *p2=*p1 signifie que le contenu de l’objet pointé par p2 reçoit le contenu
de l’objet pointé par p1

51 52

13
 01/02/2021

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C

Rappel : Fonc&on & Procédure : Rappel : Fonction & Procédure :

§ Les fonc&ons sont des groupements d’instruc:ons qui peuvent prendre des
paramètres en entrée et qui retournent une valeur
§ Elles peuvent être appelées plusieurs fois, avec des valeurs de paramètres
différentes.
§ Elles perme8ent donc d’implémenter un algorithme de calcul et de le réu:liser
pour différents jeux de paramètres.
§ Les procédures sont des groupements d’instructions qui effectuent une tâche,
mais qui n’ont a priori pas pour but de calculer quelque chose
§ Elles ne retournent donc pas de valeur
§ Toutefois, elles peuvent prendre des arguments, dont les valeurs permettent
d’en modifier le comportement

53 54

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C
Intérêt des fonc-ons : La défini&on d’une fonc&on se fait comme suit :

§ Une fonc:on permet de : type identificateur(paramètres)

{
§ Une fonc:on permet de factoriser un certain nombre de lignes de /* Instructions de la fonction */
return valeur;
code en un endroit du programme }

§ Une fois définie, elle peut être u:lisée autant de fois que nécessaire à § type est le type de la valeur valeur renvoyée
par:r de n'importe quel autre point du programme
§ identificateur est le nom de la fonc:on
§ Découper un programme en sous-programmes
§ paramètres est la liste de paramètres
§ Alléger et organiser un programme
§ La valeur de la fonc:on à renvoyer est spécifiée en u:lisant le mot clé return,
§ Remplacer et rassembler une par:e qui se répète dans un programme dont la syntaxe est : return valeur;

55 56

14
 01/02/2021

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C
La définition d’une procédure se fait comme suit : Exemples :

§ Les procédures sont réalisées en définissant une fonction qui ne retourne pas § void nom_fonction( ): La fonc:on ne prend aucun paramètre et ne
de valeur; Pour cela, on utilise le type de retour void retourne pas de valeur

§ Il n’est pas nécessaire de mettre une instruction return en fin de procédure § int nom_fonction(void) : La fonc:on ne prend aucun paramètre et

§ Cela est cependant faisable, il suffit de ne pas donner de valeur dans retourne une valeur en:ère à l'aide de l'instruc:on return
l’instruction return § void nom_fonction(void) : La fonc:on ne prend aucun paramètre et ne

void identificateur(paramètres)
void identificateur(paramètres) retourne pas de valeur
{
{
/* Instructions */
/* Instructions */
return;
}
}

57 58

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C
Exemples : Exemples :

§ int somme(int a, int b): La fonc:on prend deux paramètres et int somme(int i, int j)
void bonjour()
retourne une valeur en:ère à l'aide de l'instruc:on return { {
printf("Bonjour"); return i+j;
§ float calcul(float r) : La fonc:on prend un paramètre et retourne } }

une valeur réelle à l'aide de l'instruc:on return

§ Void afficher(char t): La fonc:on prend un paramètre et ne retourne
int double(int nombre) double aireRect(double larg, double haut)
pas de valeur { {
return 2 * nombre; return larg * haut;
} }

59 60

15
 01/02/2021

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C
Appel des fonc&ons :

A+en-on § L’appel d’une fonc:on ou d’une procédure se fait en donnant son nom, puis les

Une fonc-on ne doit jamais être définie à l’intérieure de la fonc-on valeurs de ses paramètres entre parenthèses

principale main
§ S’il n’y a pas de paramètres, il faut quand même me8re les parenthèses, sinon la
fonc:on n’est pas appelée

61 62

LES FONCTIONS LES FONCTIONS

PROGRAMMATION C PROGRAMMATION C
Règles de déclara&on et d'appel (1)

§ Toute fonc:on ne peut appeler que des fonc:ons déclarées avant elle ou elle-
même A+en-on
... fct1 (..) {
Exemple : ...
§
} La fonc-on main ne peut pas s'appeler elle-même et ne peut pas
§ Dans l’ordre de défini:on à coté : ... fct2 (...) {

}
... être appelée ailleurs, c’est la fonc-on principale par défaut !!
§ La fonc:on main peut appeler fct1,fct2,fct3
... fct3 (..) {
§ La fonc:on fct3 peut appeler fct1,fct2,fct3 ...
}
§ La fonc:on fct2 peut appeler fct1, fct2 int main (...) {
...
§ La fonc:on fc1 ne peut appeler que fct1 return 0;
}

63 64

16
 01/02/2021

LES FONCTIONS DÉCLARATION D’UNE FONCTION

PROGRAMMATION C PROGRAMMATION C
Exemple : # include <stdio .h> No&on de déclara&on :
# define PI 3.14159
/* définition de la fonction calcul */ § Toute fonc:on doit être déclarée avant d’être appelée pour la première fois
float calcul( float r)
{ § La défini:on peut faire office de déclara:on, toutefois il peut se trouver des
float S;
S = PI * r * r; situa:ons où une fonc:on doit être appelée dans une autre fonc:on définie
return S;
}
avant elle

Void main () {
§ Comme ce8e fonc:on n’est pas définie au moment de l’appel, elle doit être
float r, surface; déclarée
printf (" Rayon = ? ");
scanf ("%f", & r); § Quand la fonc:on est définie dans un autre fichier. Il est donc aussi nécessaire
surface = calcul ( r); // Appel de la fonction calcul
printf (" Surface = %f\n", surface ); de la déclarer dans le fichier ou on souhaite l’appeler
}

65 66

DÉCLARATION D’UNE FONCTION DÉCLARATION D’UNE FONCTION

PROGRAMMATION C PROGRAMMATION C
No&on de déclara&on : No&on de déclara&on :

§ La déclara:on d’une fonc:on ou aussi appelé prototype d’une fonc:on § Comment ?

§ Pourquoi la déclara&on ? § La syntaxe de la déclara:on d’une fonc:on est la suivante :

§ Le rôle des déclara:ons est donc de signaler l’existence des fonc:ons type identificateur(paramètres);

au compilateur afin de pouvoir les u:liser, tout en reportant leurs § où type est le type de la valeur renvoyée par la fonc:on,
défini:ons plus loin ou dans un autre fichier
§ identificateur est son nom
§ Cela permet de vérifier que les paramètres fournis à une fonc:on § paramètres la liste des types des paramètres que la fonc:on admet,
correspondent bien à ce qu’elle a8end, et que la valeur de retour est
§ Remarque : les deux écritures sont correctes :
correctement u:lisée après l’appel
int fonct_1(int); int fonct_1(int a);

67 68

17
 01/02/2021

DÉCLARATION D’UNE FONCTION DÉCLARATION D’UNE FONCTION

PROGRAMMATION C PROGRAMMATION C
# include <stdio .h>
No&on de déclara&on : Exemple : # define PI 3.14159

§ Résultat ? float calcul ( float r); /*Prototype de la fonction calcul*/

§ De ce8e façon, on peut placer la défini:on de la fonc:on n’importe Void main () {

float r, surface;
ou dans le fichier mais toujours en dehors de la fonc:on main printf (" Rayon = ? ");
scanf ("%f", & r);
§ Néanmoins, pour le prototype, il doit aussi subir la même règle surface = calcul ( r); // Appel de la fonction calcul
printf (" Surface = %f\n", surface );
concernant l’ordre : C.à.d qu’une fonc:on ne peut appeler que des }
/* définition de la fonction calcul */
fonc:ons ayant le prototype avant float calcul( float r)
{
float S;
S = PI * r * r;
return S;
}

69 70

DÉCLARATION D’UNE FONCTION FONCTION STATIQUE

PROGRAMMATION C PROGRAMMATION C
Autre exemple : # include <stdio .h>
Qu’est ce qu’une fonc&on sta&que :

int Minimum ( int, int); /*déclaration de la fonction définie

§ Par défaut, lorsqu’une fonc:on est définie dans un fichier C, elle peut être
plus loin*/ u:lisée dans tout autre fichier pourvu qu’elle soit déclarée avant son u:lisa:on
/* Fonction principale */ § Dans ce cas, la fonc:on est dite externe
int main (void) {
int i = Minimum(2,3); § Il peut cependant être intéressant de définir des fonc:ons locales à un fichier,
return 0;
} soit afin de résoudre des conflits de noms (entre deux fonc:ons de même nom

/* définition de la fonction Minimum */ et de même signature mais dans deux fichiers différents), soit parce que la
int Minimum(int i, int j)
{
fonc:on est uniquement d’intérêt local
return i<j ? i : j; }
}

71 72

18
 01/02/2021

FONCTION STATIQUE FONCTION STATIQUE

PROGRAMMATION C PROGRAMMATION C
Qu’est ce qu’une fonc&on sta&que : Exemple : # include <stdio .h>
§ Dans ce sens, le langage C fournit le mot clé static qui, une fois placé devant static int Minimum ( int, int); /*déclaration de la fonction
la défini:on et les éventuelles déclara:ons d’une fonc:on, la rend unique et statique */

u:lisable uniquement dans ce fichier /* Fonction principale */

int main (void) {
§ À part ce détail, les fonc:ons sta:ques s’u:lisent exactement comme des int i = Min(2,3);
return 0;
fonc:ons classiques }

/* définition de la fonction Minimum */

static int Minimum(int i, int j)
{
return i<j ? i : j; }
}

73 74

Fin
Cours – Programma4on C

75

19