Université Chouaîb Doukkali
Faculté des Sciences El Jadida
LES FONCTIONS
Langage C
SMI – S4 Pr. S. EL HOUSSAINI 2019-2020
FS – EL JADIDA
Programmation en langage C
Plan
1
Rappels (Types de bases, variables, opérateurs, structures de contrôles,..)
2
Les fonctions
3
Les pointeurs et l’allocation dynamique
4
Les chaines de caractères
5
Les types composés (structures, unions, synonymes)
6
Les fichiers
Fonctions et sous-programmes
• Ecrire un programme qui résout un problème revient
toujours à écrire des sous-programmes qui résolvent des
sous parties du problème initial.
• Il existe deux types de sous-programmes :
– Les fonctions : réalisent des traitements en se servant
des valeurs de certaines variables et renvoient un résultat.
Elles se comportent comme des fonctions mathématiques :
y=f(x, y,. . . )
– Les procédures : réalisent seulement des traitements
mais ne renvoies aucun résultat
Fonctions et Procédures
• Les fonctions et les procédures sont des groupes
d'instructions indépendants désignés par un nom
(identificateur).
• Elles ont plusieurs intérêts :
• permettent de "factoriser" les programmes, c-à-d de mettre en
commun les parties qui se répètent
• permettent une structuration et une meilleure lisibilité des
programmes
• facilitent la maintenance du code (il suffit de modifier une seule
fois)
• ces procédures et fonctions peuvent éventuellement être réutilisées
dans d'autres programmes
Fonctions et Procédures
• Une procédure effectue un traitement sans renvoyer aucune valeur.
• Une fonction effectue le traitement et renvoie une valeur (en générale
le résultat du traitement).
• En programmation C, il n’y a pas de différence entre fonctions et
procédures dans la déclaration mais plutôt dans la façon d’utilisation
• Dans la suite on va adopter le mot FONCTION pour identifier soit une
fonction ou une procédure
Procédure Fonction
Paramètres Paramètres Résultat
Nom Nom
Fonction Fonction
Déclaration & Syntaxe
Déclaration
• Déclarée en dehors de la fonction principale « main »
• Peut être appelée de n’importe où
Syntaxe
<type> <nom_fonction> ([type1 arg1[,type2 arg2, …]])
{
//Corps de la fonction
[return (expression)]
}
• La première ligne c’est l’en-tête de la fonction
• type est le type du résultat retourné. Dans le cas oû la fonction ne
retourne pas de résultat, elle est de type void. Et on n’écrit pas
l’instruction return (expression)
• nom_fonction : le nom ou l’identificateur de la fonction
• entre parenthèses, on spécifie les arguments (paramètres) de la
fonction et leurs types.
• return (expression): le mot clé return suivi de la valeur à renvoyer (qui
doit être du même type que la fonction)
Déclaration & Syntaxe
Remarques
• Dans le cas oû une fonction n'a pas d’argument en entrée, on peut déclarer
la liste des paramètres comme (void) ou simplement laisser vide entre
parenthèses ( )
• Si une fonction doit retourner une valeur, on fait appel au mot clés « return ».
• Le type de retour doit être le même que le type de la fonction dans l’entête
• Peut être utilisé n’importe où dans le code (là oû on veut quitter la fonction en
retournant une valeur)
• Peut exister plusieurs fois dans une fonction
• Pour les fonctions ne retournant rien, soit on utilise l’instruction return sans
argument, soit on met rien.
• Les paramètres (arguments) des fonctions sont des variables locales au bloc
d’instructions de la fonction.
• Cependant, on peut définir d’autres variables dans le bloc
• Une fonction peut avoir des arguments de différents types
Exemples
1. SommeCarre : calcule la somme des carrées de deux réels x et y
2. Pair : détermine si un nombre est pair
Exemples
3. Affiche: affiche le message Bonjour
4. ValeurAbsolue: affiche la valeur absolue d’un entier passé en
paramètre
Prototype
• Pour certain compilateur, il est obligatoire de donner la définition d'une
fonction. Si une fonction est définie après son premier appel, elle doit être
déclarée auparavant.
• La déclaration d'une fonction se fait en haut après les inclusions « include »
par son prototype et qui indique le type de la fonction ainsi que les types
des arguments:
Type NomFonction (type1 [param1],…, typeN [paramN]);
#include <stdio.h> #include <stdio.h>
float multiplication (float, float); Ou bien float multiplication (float a, float b);
Fonction « main »
• int main () est une fonction particulière qui retourne un entier et dont
la liste des paramètres est vide. Elle est appelée la fonction
principale.
• Tout programme doit contenir obligatoirement la fonction principale,
qui est exécutée lorsque le programme est lancé.
int main ( )
{
…
return 0;
}
Appel d’une fonction
• On appelle une fonction en utilisant son nom, avec la valeur des arguments
entre parenthèses, dans l’ordre de sa définition.
NomFonction (para1,…, paraN)
Remarques:
• Il faut respecter l’ordre et les types des arguments
• Dans le cas d’une fonction ne retournant rien, l’appel de la fonction sera
direct : Affiche ();
• Dans le cas d’une fonction qui retourne une valeur, la fonction doit être
utilisée dans une instruction d’affectation :
• x=Pair(5);
• printf(”%d”, Pair(6));
• Lors de l’appel d’une fonction, les paramètres sont appelés paramètres
effectifs (ou arguments) : ils contiennent les valeurs pour effectuer le
traitement.
• Lors de la définition, les paramètres sont appelés paramètres formels
Appel d’une fonction
Exemple :
Exercice
• Ecrire une fonction Maxi2 qui retourne le maximum de
deux entiers donnés.
• Ajouter une autre fonction, nommée Maxi3 qui retourne
le maximum de 3 valeurs passés en argument, en
utilisant la fonction Maxi2.
• Ecrire un programme qui demande à l’utilisateur de
saisir trois réels et qui affiche leur max
Exercice
• Ecrire une fonction Maxi2 qui retourne le maximum de
deux réels donnés.
return a>b ? a :b;
Exercice
• Ajouter une autre fonction, nommée Maxi3 qui retourne
le maximum de 3 valeurs passés en argument, en
utilisant la fonction Maxi2.
return c>Max2(a,b)? c : Max2(a,b);
return Max2(Max2(a,b),c);
Exercice
• Ecrire un programme qui demande à l’utilisateur de
saisir trois réels et qui affiche leur max
Variables locales & globales
• Chaque variable déclarée est accessible dans son contexte de
déclaration
• Une variable définie à l'intérieur d’une fonction est une variable
locale à la fonction, et 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 toute l’application et peut être utilisée et modifiée
par toutes les fonctions du programme
• Une variable locale cache la variable globale qui a le même nom
• 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, localement, toutes les
variables du même nom des blocs qui l'entourent
Variables locales & globales
Exemple : dans affecte avant affectation a=10
dans affecte après affectation a=5
dans main a=10
Paramètres formels & effectifs
• Les paramètres servent à échanger des données entre la fonction
appelante et la fonction appelée
Vocabulaire
• Un paramètre formel : appelé paramètre
• Un paramètre effectif : appelé argument
Signification
• Les paramètres placés dans la déclaration d'une fonctions sont
des paramètres formels. Ils peuvent prendre toutes les valeurs
possibles dans le type déclaré mais ils sont abstraits (n'existent
pas réellement)
• Les paramètres placés dans l'appel d'une fonction sont des
paramètres effectifs. ils contiennent les valeurs pour effectuer le
traitement
Paramètres formels & effectifs
• Un paramètre effectif est une variable ou constante
(numérique ou définie par le programmeur)
• Le paramètre formel et le paramètre effectif sont
associés lors de l’appel de la fonctions.
Donc :
– Le nombre de paramètres effectifs doit être égal au
nombre de paramètres formels.
– L'ordre et le type des paramètres doivent correspondre
Paramètres formels & effectifs
Paramètres formels
Paramètres effectifs
Transmission des paramètres
Réflexion: quel est le résultat d’exécution des deux
programmes
#include <stdio.h> #include <stdio.h>
void affecte(int a); void affecte(int *);
int main() int main()
{ {
int a=10; int a=10;
affecte(a); affecte(&a);
printf("a = %d\n",a); printf("a=%d\n",a);
return 0; return 0;
} }
void affecte(int a) void affecte(int *a)
{ {
a=5; *a=5;
} a = 10 } a=5
Transmission des paramètres
Passage par valeur
• La transmission des paramètres en C est par défaut par valeur.
• Ainsi quand une variable passée en argument à une fonction c’est
sa valeur qui est passée
Passage par référence (adresse)
• Pour effectuer une transmission par adresse en C, on déclare le
paramètre formel de type pointeur et lors d'un appel de la fonction,
on envoie l'adresse et non la valeur du paramètre effectif.
a=1 et b=3
void Incrementation (int n, int *m) int main( )
{ {
n=n+1; int a = 1, b=2;
*m =*m+1; Incrementation(a, &b);
} printf(“a = %d et b=%d \n", a,b);
}
Transmission des paramètres
Exemple : passage d’un tableau en paramètre
La valeur de la case 0 est 0
La valeur de la case 1 est 1
La valeur de la case 2 est 2
La valeur de la case 0 est 0
La valeur de la case 1 est 0
La valeur de la case 2 est 0
Transmission des paramètres
• Types simples : int, float, char, ….
Passage par valeur
• Types : tableaux, pointeurs
Passage par référence
Récursivité
• Une fonction est récursive si
elle peut s'appeler elle-même
• Pour éviter une récursivité
infinie, il faut fixer un cas limite
(cas trivial) qui arrête la
récursivité
Exercice
• Ecrire une fonction une fonction remplirTab qui permet de remplir
un tableau de réels. Les valeurs sont saisies par l’utilisateur.
• Ecrire une fonction afficheTab qui permet d’afficher un tableau de
réels.
• Ecrire une fonction incTab qui permet d’incrémenter les valeurs
des cases d’un tableau.
• Ecrire la fonction main qui
– demande à l’utilisateur de donner le nombre de notes à saisir,
– demande à l’utilisateur de saisir les notes
– incrémente les valeurs saisies
– affiche le résultat
Exercice
• Ecrire une fonction une fonction remplirTab qui permet de remplir un
tableau de réels. Les valeurs sont saisies par l’utilisateur.
Exercice
• Ecrire une fonction afficheTab qui permet d’afficher un tableau de réels.
Exercice
• Ecrire une fonction incTab qui permet d’incrémenter les valeurs des
cases d’un tableau.
Exercice
• Ecrire la fonction main
