LANGAGE DE PROGRAMMATION

LE LANGAGE C

4ième partie
 CHAP. 9 - LES FONCTIONS
La structuration de programmes en sous-
programmes se fait en C à l'aide de fonctions.
Les fonctions en C correspondent aux fonctions
et procédures en langage algorithmique. Nous
avons déjà utilisé des fonctions prédéfinies
dans des bibliothèques standard (printf de
<stdio>, strlen de <string>, pow de <math>,
etc.). Dans ce chapitre, nous allons définir et
utiliser nos propres fonctions.
 CHAP. 9 - LES FONCTIONS
Jusqu'ici, nous avons résolu nos problèmes à
l'aide de fonctions prédéfinies et d'une seule
fonction : la fonction principale main().
Pour des problèmes plus complexes, nous
obtenons ainsi de longues listes d'instructions,
peu structurées et par conséquent peu
compréhensibles.
 CHAP. 9 - LES FONCTIONS
En plus, il faut souvent répéter les mêmes suites
de commandes dans le texte du programme, ce
qui entraîne un gaspillage de mémoire interne
et externe.
La plupart des langages de programmation nous
permettent de subdiviser nos programmes en
sous-programmes, fonctions ou procédures
plus simples et plus compacts qu’on désignera
par « module ».
 CHAP. 9 - LES FONCTIONS
Dans ce contexte, un module désigne une entité
de données et d'instructions qui fournissent
une solution à une (petite) partie bien définie
d'un problème plus complexe. Un module peut
faire appel à d'autres modules, leur transmettre
des données et recevoir des données en retour.
L'ensemble des modules ainsi reliés doit alors
être capable de résoudre le problème global.
 CHAP. 9 - LES FONCTIONS
Avantages
Voici quelques avantages d'un programme
modulaire:
* Meilleure lisibilité
* Diminution du risque d'erreurs
* Possibilité de tests sélectifs
* Dissimulation des méthodes
Lors de l'utilisation d'un module il faut seulement
connaître son effet, sans devoir s'occuper des
détails de sa réalisation.
 CHAP. 9 - LES FONCTIONS
* Réutilisation de modules déjà existants
Il est facile d'utiliser des modules qu'on a écrits
soi-même ou qui ont été développés par
d'autres personnes.
* Simplicité de l'entretien
Un module peut être changé ou remplacé sans
devoir toucher aux autres modules du
programme.
 CHAP. 9 - LES FONCTIONS
* Favorisation du travail en équipe
Un programme peut être développé en équipe.
Une fois développés, les modules peuvent
constituer une base de travail commune.
* Hiérarchisation des modules
Un programme peut d'abord être résolu
globalement au niveau du module principal. Les
détails peuvent être reportés à des modules sous-
ordonnés qui peuvent eux aussi être subdivisés en
sous-modules et ainsi de suite. De cette façon,
nous obtenons une hiérarchie de modules.
 CHAP. 9 - LES FONCTIONS
a) Exemple 1: Afficher un rectangle d'étoiles
Commençons par un petit programme que je vous
propose d'examiner sans autres explications:
Le programme suivant permet d'afficher à l'écran
un rectangle de longueur L et de hauteur H,
formé d'astérisques '*' :
 CHAP. 9 - LES FONCTIONS
#include <stdio.h>
#include <conio.h>
main()
{
int L, H, i, j;
printf("Entrer la longueur (>= 1): ");
scanf("%d", &L);
printf("Entrer la hauteur (>= 1): ");
scanf("%d", &H);
for(i=1;i<=L;i++)
{
for(j=1;j<=H;j++)
printf(“*”);
printf(“\n”);
}
getch();
}
 CHAP. 9 - LES FONCTIONS
Ligne(int L) #include <stdio.h>
{ #include <conio.h>
Int i; main()
for(i=1;i<=L;i++) {
printf(“*”); int L, H, i, j;
} printf("Entrer la longueur (>= 1): ");
scanf("%d", &L);
Rectangle(int L, int H) printf("Entrer la hauteur (>= 1): ");
{ scanf("%d", &H);
Int j; Rectangle(L,H);
For(j=1;j<=H;j++) getch();
Ligne(L); }
printf(“\n”);
}
 CHAP. 9 - LES FONCTIONS
En général, le nom d'une fonction apparaît à trois
endroits dans un programme:
1) lors de la déclaration
2) lors de la définition
3) lors de l'appel
Exemple
Avant de parler des détails, penchons-nous sur un
exemple. Dans le programme précédent, la fonction
main utilise les deux fonctions: Rectangle et Ligne
 CHAP. 9 - LES FONCTIONS
Déclaration:
type <nomFonct>(type arg1, type arg2,….);
Exemples:
int cube(int x);
long(float y, double k);
void ligne(int L);
double trace(int A[10], char[100]);
 CHAP. 9 - LES FONCTIONS
Définition :
type <nomFonct>(type arg1, type arg2,….)
{
[déclarations]
[traitements]
return (var);
}
Appel :
Val = <nomFonct>(arg1, arg2,….);
 CHAP. 9 - LES FONCTIONS
Exemples de fonctions :
- Ecriture dans le même fichier
- Au début (avant main)
- En fin (après main)
- Appel par #include (.c)
- Appel par #include (.h)
 CHAP. 9 - LES FONCTIONS
Variables locales :
Les variables déclarées dans un bloc d'instructions
sont uniquement visibles à l'intérieur de ce bloc. On
dit que ce sont des variables locales à ce bloc.
Exemple
La variable I se trouve à l'intérieur d'un bloc
d'instructions conditionnel. Elle n'est pas visible à
l'extérieur de ce bloc, ni même dans la fonction qui
l'entoure.
if (N>0) { int I; for (I=0; I<N; I++) ... }
 CHAP. 9 - LES FONCTIONS
Variables globales :
Les variables déclarées au début du fichier, à
l'extérieur de toutes les fonctions sont disponibles à
toutes les fonctions du programme. Ce sont alors des
variables globales. En général, les variables globales
sont déclarées immédiatement derrière les
instructions #include au début du programme.
Attention !
Les variables déclarées au début de la fonction
principale main ne sont pas des variables globales,
mais elles sont locales à main !
 CHAP. 10 - LES FICHIERS
Variables globales :