Module: Programmation I

Filière: SMA-S3

Fonctions et Programmation
Modulaire
Pr. Issam QAFFOU
Laboratoire Ingénierie des Systèmes d’Information
Département d’Informatique
FSSM-UCA

Version 2015/2016
(Automne)
 Introduction
• Une fonction est un ensemble d’instructions destinées à
accomplir une tâche particulière dans une application.
• Généralement, pour résoudre un problème on pense à le
diviser en sous problèmes pour garantir une bonne maitrise
de sa solution.
• Résoudre les sous problèmes et par la suite procéder à
intégrer leurs solutions dans une solution globale est une
habitude élégante de programmeur.
• Ces solutions éléments de la solution globale est ce qu’on
appelle des fonctions.
• Cette stratégie s’appelle la programmation modulaire.
• Chaque solution à un sous problème s’appellent un module.
19/10/2015 Programmation I 2
 Introduction
• Les fonctions en langage C représentent les procédures et
les fonctions en algorithmique.
• Nous pouvons soit écrire nos propres fonctions, soit utiliser
des fonctions déjà écrites. En effet:
– Nous avons écrit tous nos programmes jusqu’à maintenant dans
la fonction main(),
– Nous avons beau utilisé des fonctions lors des programmes que
nous avons vus dans les précédents chapitres: scanf(), printf(),
sqrt(), etc.
• Dans les chapitres précédents, nous avons fait tous nos
programmes à l’intérieur de la fonction main(), dans ce
chapitre nous allons apprendre à comment programmer en
dehors de cette fonction principale.
19/10/2015 Programmation I 3
 Introduction
• La programmation modulaire (sous forme de plusieurs
fonctions) facilite la maintenance d’un programme.
• La même philosophie utilisée jusqu’à maintenant dans nos
programmes précédents est valable pour la programmation
des fonctions:
– On peut déclarer des variables
– On peut utiliser des instructions de contrôle.
– On peut initialiser des variables
– etc.
• Une fonction exécute des instructions et renvoie un résultat.
• Une fonction possède une entrée et une sortie.
• Si une fonction ne renvoie pas de valeur c’est une procédure.
19/10/2015 Programmation I 4
 Structure d’une fonction
• Forme générale
<Type_résultat> <Nom_Fonction> (Type_1 Arg_1, …, Type_n Arg_n)
{
//Bloc d’instruction;
return <variable>;
Entête de la fonction
}

Corps de la fonction

N’oubliez pas les accolades

!

19/10/2015 Programmation I 5
 Structure d’une fonction
• Forme détaillée
Obligatoire quand le
type n’est pas void

19/10/2015 Programmation I 6
 Structure d’une fonction
Exemple int somme(int x, int y) Variable propre à la
{ fonction somme

Le bloc d’instructions doit int a;

traiter les variables en a=x+y; La variable retournée
arguments ou les variables return a; doit avoir le même type
déclarée dans le corps de qui précède le nom de la
}
fonction fonction

• N.B: il n’est pas obligatoire qu’une fonction ait des

paramètres Ce "return" n’est
int affichage() pas obligatoire
int affichage()
{ même si la { }
return; fonction possède
} un type de retour

19/10/2015 Programmation I 7
 Visibilité des variables
• Toute variable déclarée dans une fonction n’est accessible qu’à
l’intérieur de cette fonction.
• Par exemple, la variable a déclarée dans l’exemple précédent
ne peut être accessible par aucune autre fonction.
• Il existe deux types de variables:
– Locales: visibles localement à l’intérieur du bloc d’instructions dans
lequel elles sont définies
– Globales: visible partout dans le programme. Elles ne sont liées à
aucune fonction.
• Attention!! Les variables globales sont à utiliser avec
précaution, puisqu'elles créent des liens invisibles entre les
fonctions. La modularité d'un programme peut en souffrir et le
programmeur risque de perdre la vue d'ensemble.
19/10/2015 Programmation I 8
 Visibilité des variables

19/10/2015 Programmation I 9
 Utilisation d’une fonction
• L’utilisation d’une fonction dans un programme global se fait
soit par son appel ou par son implémentation dans l’endroit
dans lequel elle est utilisée.
• L’appel d’une fonction se fait par la syntaxe suivante:
<nom_fonction>(arg_1, …, arg_n);
• Exemple
Appel à la fonction
somme

19/10/2015 Programmation I 10
 Déclaration des fonctions
• Nous ne sommes pas obligés d’implémenter une fonction
avant son utilisation, nous pouvons juste la déclarer avant son
utilisation et la programmer après là où nous voulons.
• Une variable est déclarée par son type et son nom. C’est pareil
pour les fonctions.
• Une fonction est déclarée par ce qu’on appelle son prototype.
• Le prototype d’une fonction est son entête suivi d’un point
virgule.
<Type_retour> <Nom_fct> (<type_1 var_1,…,type_n var_n);
• N.B. Dans le prototype, il n’est pas obligatoire de citer les
variables. Nous pouvons écrire:
<Type_retour> <Nom_fct> (<type_1,…,type_n);
19/10/2015 Programmation I 11
 Déclaration des fonctions
• Exemple
Déclaration de la fonction somme par
son prototype.

Nous appelons la fonction même si

son corps n’existe pas encore.

Nous pouvons laisser

l’implémentation de la fonction
jusqu’à la fin

19/10/2015 Programmation I 12
 Le type void pour les déclarations

• Les deux cas d’utilisation

– Pas de valeur de retour
void fct (double a, int b ) ; /* fct n’a pas de valeurs de
retour*/

– Pas d’arguments
int g (void ) ; // g fonction sans arguments
int h (); /* h fonction dont le nombre d’arguments
n’est pas précisé dans la déclaration */

19/10/2015 Programmation I 13
 Passage des paramètres

• Passage par valeur

– Lors de l’appel de la fonction, les arguments sont
passés par valeur.
– La fonction appelée travaille sur des copies des
arguments.
– Elle ne peut pas modifier les arguments passés en
paramètres.
– Utile pour les paramètres d’entrée

19/10/2015 Programmation I 14
 Passage des paramètres
• Exemple de passage par valeur

Printf("%d",a); // l’affichage est 3

19/10/2015 Programmation I 15
 Passage des paramètres
• Le passage par référence:
– Lors de l’appel de la fonction, les arguments sont
passés par référence.
– Un lien est créé entre les arguments passés en
paramètre et les variables correspondantes créées
par la fonction.
– La fonction peut alors modifier les arguments
passés en paramètres.
– Utile pour les paramètres de sortie et d’entrée /
sortie
19/10/2015 Programmation I 16
 Passage des paramètres
• Exemple de passage par référence

Printf("%d",a); // l’affichage est 3

19/10/2015 Programmation I 17
 Valeur par défaut

Printf("%d",x);

19/10/2015 Programmation I 18
 Valeur par défaut

19/10/2015 Programmation I 19
 Fonctions prédéfinies

19/10/2015 Programmation I 20
 Programmation modulaire
• Une règle dit « diviser pour régner ».
• Au lieu de mettre tout notre code dans un seul fichier,
il vaut mieux le diviser et mettre chaque partie dans un
fichier.
• Le fait de découper tout le code en petits codes
séparés s’appelle la programmation modulaire.
• Ceci permet de bien contrôler nos programmes.
• Ceci permet aussi une bonne maintenance de notre
code.
• Ceci aidera facilement d’autres personnes à bien
comprendre nos codes et pouvoir y travailler.
19/10/2015 Programmation I 21
 Programmation modulaire
• Dans ce qui précède dans ce chapitre, nous avons vu
qu’il est impossible d’appeler une fonction dans le
main() alors qu’elle n’est programmé qu’après.
• Pour remédier à ce problème nous avons dit qu’il faut la
déclarer avant son utilisation.
• La déclaration se fait par le prototype de la fonction.
• Même si nous allons découper notre code en plusieurs
sous codes enregistrés dans des fichiers différents, nous
devons toujours travailler dans un seul projet.
• Un projet, c'est l'ensemble des fichiers constituant notre
programme.
19/10/2015 Programmation I 22
 Programmation modulaire
• Généralement un projet est constitué de deux types de fichiers
– Fichiers headers (extension .h): contiennent les prototypes de
fonctions.
– Fichiers sources (extension .c): contiennent les fonctions elles-
mêmes.
• À chaque fichier .c est associé un fichier .h
• Pour que le fichier source qui utilise et appelle les fonctions
sache que les fonctions sont déjà déclarée, nous devons inclure
dans son début le fichier .h associé avec une directive du
préprocesseur (#include).
• Une petite différence dans la syntaxe avec les #include
habituel, c’est qu’on met les noms des fichiers .h entre
guillemets (" et ").
19/10/2015 Programmation I 23
 Programmation modulaire
Création des fichiers .h
• Ça dépend des environnements de développement.
Généralement nous suivons le chemin: fichier/nouveau/fichier…
• Exemple sur Code::Blocks

19/10/2015 Programmation I 24
 Programmation modulaire
• Une fois créé, nous pouvons écrire dans le fichier .h les
prototypes des fonctions utilisées dans le programme principal.
• Nous pouvons aussi même implémenter les fonctions dans les
fichiers .h et ne faire que leur appel dans les fichiers .c.
• Exemple: nous créons un fichier "fonction.h" qui contient la
fonction somme(). Dans le fichier du main() nous appelons cette
fonction

19/10/2015 Programmation I 25
 Programmation modulaire
• Même si le fichier .h possède un nom, mais quand
on le défini on utilise un autre nom après la
directive #define. Par exemple #define XYZ.
• #define permet de définir le fichier comme ce qui
suit.
• Avant de le définir, on teste s’il n’y a pas de fichier
XYZ dans le même projet. C’est pourquoi on utilise
#ifndef XYZ pour dire: if not defined.
• La directive #endif pour dire qu’on est arrivé à la
fin du fichier que nous écrivons.
19/10/2015 Programmation I 26