Département : ATE

Module : Programmation orientée objets en C++

Enseignant : M. DIBOUNE.

Chapitre 2 : Les fonctions, les pointeurs et références, les tableaux

Partie 1 : Les fonctions
Dans ce premier chapitre nous allons aborder les principes de la programmation procédurale en C++.
Au sommaire de ce chapitre :

• Qu’est-ce que la programmation procédurale ?

• Les fonctions en C++
• Qu’est-ce que les fonctions récursives en C++ ?

1. Programmation procédurale
Les problèmes simples peuvent être résolus en C++ par un seul module (la fonction main()).
Néanmoins, lorsqu’un problème est complexe, une solution de programmation composée d’un bloc
unique d’instructions devient difficilement compréhensible et suscite des problèmes de mise à niveau,
de maintenance et de débogage. Ainsi, une des solutions consiste à utiliser la programmation
procédurale, ce paradigme est basé principalement sur une analyse descendante du problème à résoudre.
Ainsi, le problème global est divisé en sous-problèmes relativement indépendants, chacun des sous
problèmes ainsi obtenus est soit directement implémenté en C++ soit décomposé à son tour en sous-
programmes jusqu’à l’obtention d’un module qu’on peut directement coder en C++.
L’implémentation des différents modules composant le problème global est faite par des fonctions. Ces
fonctions peuvent ensuite être appelées à n'importe quel point du programme principal (fonction
main()), à l'intérieur d'autres fonctions, ou même à partir de la fonction elle-même (appels récursifs).

2. Fonctions en C++
Une fonction est un sous-programme exécutant une tâche unique, pouvant être appelé à n’importe quel
endroit du programme (fonction main() ou autre fonctions) et qui retourne éventuellement un résultat.

2.1. Définition d’une fonction

Le code C++ qui permet de décrire le déroulement d’une fonction est appelé définition de la fonction.
Sa forme est la suivante :
Listing 2.1 : Définition d’une fonction en C++.
01 Type <Nom_de_fonction> (Type1 argument1, Type2 argument2, …
02 ,TypeN argumentN)
03 {
04 <Instructions de la fonctions>
05 }

Le code précédant l’accolade ouvrante { est dit l’entête de la fonction (header), les instructions entre
les accolades forment le corps de la fonction.
La spécification du type qui précède le nom de la fonction est le type return et détermine le type de la
valeur que la fonction renvoie à la fin de son exécution. Si la fonction ne retourne aucune valeur, alors
ce type est void.

1
2.2. L’instruction return
L’instruction return est une instruction de contrôle du flux, en effet, lorsque l’instruction return
est exécutée, la fonction actuelle est terminée et le contrôle est passé au point ou la fonction actuelle a
été invoquée. De plus, la valeur de l’expression qui suit le mot clé return est renvoyée au point d’appel
de la fonction, le type de cette valeur doit être de même type ou de type convertible au type de retour de
l’entête de la fonction.
L’instruction return a la forme suivante : return expression;
Exemples:
return 0;
return (a + b);
Listing 2.2 : L’instruction return dans la fonction maximum
01 int maximum(int val1, int val2)
02 {
03 if (val1 > val2)
04 return val1;
05 else
06 return val2;
07 }

Une bonne pratique de la programmation consiste à n’utiliser dans une fonction qu’une seule instruction
return et qui sera le point de sortie de la fonction.
Ainsi il serait plus conviviale d’écrire le code du listing 2.2 comme suit :
Listing 2.3 : Programme C++ «Hello World»
01 int maximum(int val1, int val2)
02 {
03 int max;
04 if (val1 > val2)
05 max = val1;
06 else
07 max = val2;
08 return max;
09 }

2.3. Prototype d’une fonction

Le prototype d’une fonction permet de déclarer une fonction, la déclaration des fonctions est
faite en générale juste avant la fonction principale main().
Le prototype d’une fonction précise son type, son nom ainsi que sa liste d’arguments dont on
définira aussi le type.
Syntaxe :
Listing 2.4 : Programme C++ «Hello World»
01 Type <Nom_de_fonction> (Type1 argument1,
02 Type2 argument2, … ,
03 TypeN argumentN)

2.4. Portée des variables

Une fonction peut accéder :

• à ses différents arguments,

2
• à ses variables déclarées localement,
• aux variables globales
Une bonne pratique de la programmation exige de minimiser l’utilisation des variables globales
au maximum.
L’ensemble des variables qu’une fonction F peut accéder est appelé environnement de la
fonction F. Ainsi, les environnements des différentes fonctions sont indépendants les uns des
autres et permettent une meilleure structuration des programmes.
2.5. Arguments par défaut
Un paramètre formel d’une fonction peut prendre un argument par défaut, usuellement c’est une constant
qui apparait fréquemment à l’appel de la fonction. L’usage de l’argument par défaut permet d’éviter
l’écriture de la valeur par défaut à chaque invocation.
Syntaxe :
Listing 2.5 : Déclaration d’un argument par défaut en C++
01 Type <Nom_de_fonction> (Type1 argument1, Type2 argument2, … TypeI
02 argumentI = Valeur_par_défaut, … , TypeN argumentN)
03 {
04 <Instructions de la fonctions>
05 }

Exemple :
Listing 2.6 : Déclaration d’un argument par défaut en C++ (Exemple)
01 void author_ship(string date, string version, string programmer =
02 "Denis Richie")
03 {
04 cout << programmer << endl;
05 cout << "Version Number is " << version << endl;
06 cout << date << endl;
07 }
A l’appel de la fonction author_ship avec et sans la valeur de l’argument programmer :
• author_ship("11/11/2019","1.3"); // Denis Richie is the programmer
• author_ship("11/11/2019","2.7","Unknown");//Unknown is the
programmer
2.6. Fonction comme argument d’une autre fonction
Les fonctions en C++ peuvent être considérées comme des adresses de codes compilés dans la mémoire
(ce concept sera abordé en détail dans le chapitre 5), alors les fonctions forment des pointeurs et peuvent
êtres passées comme arguments à d’autres fonctions.
Exemple :
Le code suivant permet de tracer une fonction en affichant les images de n valeurs :

3
 Listing 2.7 : Passer une fonction en argument à une autre fonction
01 double f(double x) { return (x * x + 1.0 / x); }
02 void plot(double fcn(double), double x0, double incr, int
03 n)
04 {
05 for (int i = 0; i < n; ++i) {
06 cout << " x :" << x0 << " f(x) : " << fcn(x0) <<
07 endl;
08 x0 += incr;
09 }
10 }
11 int main()
12 {
13 cout << "mapping function x * x + 1.0 / x " << endl;
14 plot(f, 0.01, 0.01, 100);
15 return 0;
16 }

2.7. Exercices
1. Écrire un programme C++ qui permet de vérifier si une année est bissextile. (Une année est
bissextile si elle est multiple de 4 et non multiple de 100, et si elle est multiple de 100 elle doit
être multiple de 1000).
2. Analyser selon une approche descendante puis écrire un programme qui permet de calculer le
nombre de jours séparant deux dates (une date est de forme jjmmaaaa).

3. Fonctions récursives
Considérons la suite Fibonacci :

0 1 1 2 3 5 8 13 21

Le fonction C++ qui permet de calculer le terme de la suite de Fibonacci est donnée par le listing 2.8.
Listing 2.8 : La fonction calculant le n-ieme terme de Fibonacci
01 int fib(int n){
02 int A = 0;
03 int B = 1;
04 int F = 0;
05 if (n<2) F = n;
06 else
07 for(int i = 0; i<n; i++){
08 F = A + B;
09 B = A; A = F;
10 }
11 return F;
12 }

On sait que la suite Fibonacci est définie comme suit : = 0, = 1, = + > 1.

Cette suite est récursive car elle est définie par elle-même.
Exemple :
Calculer
=3+2= + .

4
 =3+2= + .

=1+1= + .

= 1+0= + .

= 1, =0.

Chaque terme est défini par deux termes plus réduit. Les deux derniers termes ( ) définissent
directement la valeur (1 0 .). A partir de et on définit , ensuite à partir de et on
définit , on remonte jusqu’à ce qu’on calcule le terme .
On peut réécrire la fonction de Fibonacci sous forme récursive comme suit :
Listing 2.9 : Forme récursive de la fonction de Fibonacci
01 int fib_rec(int n){
02 if (n <= 1)
03 return(n);
04 else
05 return fib_rec(n-1)+fib_rec(n-2);
06 }

Exercice :
Ecrire en C++ une fonction récursive qui permet de calculer le factoriel d’un nombre entier
positif N. N ! = 1 si N = 0, sinon N ! = 1 * 2 * … *N.