Cycle: Année Préparatoire (AP)

Niveau: 2ème année (AP2)

ENSAH
A.U: 2021/2022
Semestre : Autonome
Module : Informatique 2
1. Introduction
2. Présentation des fonctions
3. Appel d’une fonction
4. Déclaration d’une fonction
5. Variable locale et variable globale
❑ C permet de découper un programme en plusieurs parties nommées souvent «
modules ». Cette programmation dite modulaire se justifie pour de multiples raisons :
✓ Un programme écrit d’un seul tenant devient difficile à comprendre dès qu’il
dépasse une ou deux pages de texte.
✓ La programmation modulaire permet d’éviter des séquences d’instructions
répétitives.
✓ Les modules sont des groupes d'instructions qui fournissent une solution à des
parties bien définies d'un problème plus complexe.

3
Les modules ont plusieurs intérêts :
✓ Ils permettent de "factoriser" les programmes, c-à-d de mettre en commun les
parties qui se répètent.
✓ Ils permettent une structuration et une meilleure lisibilité des programmes.
✓ Ils facilitent la maintenance du code (il suffit de modifier une seule fois)
✓ Ils peuvent éventuellement être réutilisées dans d'autres programmes.

4
La structuration de programmes en sous-programmes se fait en C à l'aide des
fonctions.
❑ Une seule de ces fonctions existe obligatoirement ; c’est la fonction principale
appelée main. Cette fonction principale peut, éventuellement, appeler une ou
plusieurs fonctions secondaires.
❑ De même, chaque fonction secondaire peut appeler d’autres fonctions secondaires.

5
On peut distinguer, en langage C,
❑ les fonctions prédéfinies des bibliothèques (telles que printf()
ou scanf()), livrées avec le compilateur et « intégrées » au
programme lors de l’édition des liens,
❑ et les fonctions que le programmeur écrit lui-même en tant que
partie du code source.

6
La syntaxe de définition d’une fonction a la forme suivante :

type nomFonction(liste des types et noms des arguments)

{
Corps de la fonction
}

Où :
▪ type : est le type de la valeur retournée: int, double..void,
▪ nomFonction : est le nom de la fonction,
▪ la liste des types et nom des arguments séparés par des virgules,
▪ le corps de la fonction : les instructions entre accolades
7
Exemples :
int Som(int x, int y ) {
return (x+y); Calcule et retourne la somme de deux variables
} entières

void AfficheSom(float x, float y) {

printf (" %f", x+y ); Calcule et affiche la somme de deux variables
} réelles

int RenvoieEntier() {
int n;
printf (" Entrez n \n"); Renvoie un entier saisi au clavier
scanf (" %d ", &n);
return n;
}

8
❑ Lors de l'appel d'une fonction, les paramètres sont appelés paramètres
effectifs : ils contiennent les valeurs pour effectuer le traitement.
❑ Lors de la définition, les paramètres sont appelés paramètres formels.
❑ L'ordre et les types des paramètres effectifs doivent correspondre à ceux
des paramètres formels.

9
 Définition
Appel
int Som(int x, int y ) {
return (x+y); int main( )
} { double z;
z=Som(2.5, 7.3);
AfficheSom(2.5, 7.3);
void AfficheSom(float x, float y) { return 0;
printf (" %f", x+y ); }
}

10
❑ Il est nécessaire pour le compilateur de connaître la définition d'une
fonction au moment où elle est appelée.
❑ La déclaration d'une fonction se fait par son prototype qui indique les types
de ses paramètres et celui de la fonction :
❑ type nom_fonction (type1,…, typeN)

11
❑ Il est interdit en C de définir des fonctions à l'intérieur d'autres fonctions. En
particulier, on doit définir les fonctions soit avant, soit après la fonction principale
main.
❑ Une fonction possède un et un seul point d'entrée, mais éventuellement plusieurs
points de sortie (à l'aide du mot return).
❑ L'imbrication de fonctions n'est pas autorisée: une fonction ne peut pas être
déclarée à l'intérieur d'une autre fonction. Par contre, une fonction peut appeler
une autre fonction. Cette dernière doit être déclarée avant celle qui l'appelle.

12
Exemple :
#include<stdio.h>
float ValeurAbsolue(float); /* déclaration : prototype de la fonction ValeurAbsolue */
int main( )
{
float x=-5.7, y;
y = ValeurAbsolue(x); /*L’appel de cette fonction*/
printf("La valeur absolue de %f est : %f \n " , x, y);
Return 0;
}
float ValeurAbsolue(float a) { /*Définition de la fonction ValeurAbsolue */
if (a<0)
a=-a;
return a;
}

13
Exemple :
#include<stdio.h>
float ValeurAbsolue(float a) { /*Définition de la fonction ValeurAbsolue */
if (a<0)
a=-a;
return a;
}

int main( )
{
float x=-5.7, y;
y = ValeurAbsolue(x); /*L’appel de cette fonction*/
printf("La valeur absolue de %f est : %f \n " , x, y);
Return 0;
}

14
❑ On peut manipuler 2 types de variables dans un programme C : des variables
locales et des variables globales. Elles se distinguent par ce qu'on appelle leur
portée (leur "espace de visibilité", leur "durée de vie") :
✓ Une variable définie à l'intérieur d’une fonction est une variable locale, elle n’est
connue qu'à l'intérieur de cette fonction. Elle est créée à l'appel de la fonction et
détruite à la fin de son exécution.
✓ Une variable définie à l’extérieur des fonctions est une variable globale. Elle est
définie durant tout le programme et peut être utilisée et modifiée par les différentes
fonctions du programme.

15
❑ Les variables déclarées au début de la fonction principale main ne sont pas des variables
globales, mais elles sont locales à main.

❑ Une variable locale cache la variable globale qui a le même nom.

➔ Il faut utiliser autant que possible des variables locales. Ceci permet d'économiser la
mémoire et d'assurer l'indépendance des fonctions.
➔ En C, une variable déclarée dans un bloc d'instructions est uniquement visible à l'intérieur
de ce bloc. C’est une variable locale à ce bloc, elle cache toutes les variables du même
nom des blocs qui l'entourent.

16
#include<stdio.h>
int x = 5;
int f(int);
int g(int);
int main( )
{
printf("x = %d\t", x);
int x = 10;
? x=5
x=10
printf("x = %d\t", x);
f(10)=19
printf("f(%d) = %d\t", x, f(x));
g(10) = 50
printf("g(%d) = %d\t", x, g(x));
}
int f(int a){
int x = 9; return (a+x);
}
int g(int a) {
return (a * x);
} 17
#include<stdio.h>
void f();
int i=7;
int main()
{ int k = 5, i=3;
f();
f();
? i=7 et k=1
printf("i = %d et k=%d \n", i,k); i=8 et k=1
return 0; i=3 et k=5
}

void f()
{ int k = 1;
printf("i = %d et k=%d \n", i,k);
i++;
k++;
} 18
19