LES FONCTIONS

1) Notions de base

Une fonction est un sous programme qui contient une ou plusieurs instructions, et qui

exécute une tâche spécifique. La plupart des programmes contiennent une ou

plusieurs fonctions.

Le programme principal

--------- void fonct1()

--------- {
fonct1(); ---
--------- ---
--------- }
fonct1();
---------
---------
fonct1();
--------
--------

La forme générale d’une fonction :

type-de-retour nom-de-la-fonction(liste des paramètres)

//corps de la fonction

Le type retourné par une fonction peut être n’importe quel type valide sauf un tableau.

Si une fonction ne retourne aucune valeur alors son type doit être void. Le nom de la

fonction doit être un identificateur légal. Les paramètres sont les variables qui

[Date] 1
Th. K. DAGBA, ENEAM/UAC 2022
accueillent les valeurs des arguments passés à la fonction lors de l’appel. Si la fonction

n’a aucun paramètre, alors la liste sera vide.

1.1. Une fonction qui retourne une valeur

Ex1 :

//Calcul du pgcd de 2 entiers naturels

#include<iostream>
#include<cmath>
using namespace std;
int pgcd(int x, int y); // prototype de la fonction
int main()
{
int n, m, d;
double z;
cout<< "n=";
cin>> n
cout<<"m=";
cin>> m;
d =pgcd(n,m);
cout<<"le pgcd des nombres"<<n <<" et "<< m <<" est"<< d <<endl;
//z= (m+pgcd(m,n))/sqr(m+n);
return 0;
}

int pgcd(int x, int y)//x et y sont les paramètres de la fonctions

{
while(x != y)
{
if(x>y)
x-=y;
else
y -= x;
}
return x;
}

[Date] 2
Th. K. DAGBA, ENEAM/UAC 2022
Rmq :pgcd(n,m)= pgcd(n-m,m)

1.2. Une fonction qui ne retourne pas de valeur

//Calcul du pgcd de 2 entiers naturels

#include<iostream>
using namespace std;
void pgcd(int x, int y); // prototype de la fonction
int main()
{
int n, m, d;
cout<<"n=";
cin>> n
cout<<"m=";
cin>> m;
cout << "le pgcd des nombres"<<n <<" et "<< m <<" est:"
pgcd(n,m);
cout<<endl;
return 0;
}

void pgcd(int x, int y)//xet y sont les paramètres de la fonctions

{
while(x != y)
{
if(x>y)
x-=y;
else
y -= x;
}
cout<< x;
}

2) Fonction en ligne (inline)

[Date] 3
Th. K. DAGBA, ENEAM/UAC 2022
 Normalement, un appel de fonction est une rupture de séquence : à l'endroit où un

appel figure, la machine cesse d'exécuter séquentiellement les instructions en

cours et l'exécution continue ailleurs, là où se trouve le code de la fonction.

Une fonction en ligne est le contraire de cela : là où l'appel d'une telle fonction

apparait il n'y a pas de rupture de séquence. Au lieu de cela, le compilateur

remplace l'appel de la fonction par le corps de celle-ci, en mettant les arguments

affectifs à la place des arguments formels. Cela se fait dans un but d'efficacité.Un

tel traitement ne peut convenir qu'à des fonctions fréquemment appelées, de petite

taille et rapides.

En C++ on indique qu'une fonction doit être traitée en ligne en faisant précéder sa

déclaration par le mot inline :

Ex :
#include <iostream>
using namespace std;
inline void incremente(int &x)
{
++x;
}

int main()
{
int z = 0;
incremente(z);
cout<<"z="<< z <<endl;
}

3) Fonction qui retourne une référence

Une fonction peut retourner une référence. Quand une fonction retourne une

référence, elle retourne un pointeur implicite sur la valeur qu’elle a retournée. Il

existe en C++ beaucoup d’utilisation pour la référence retournée par une fonction.

L’une des applications permet à la fonction d’être utilisée à la partie gauche d’une

affectation :

[Date] 4
Th. K. DAGBA, ENEAM/UAC 2022
 Ex : Retour de référence

#include<iostream>
using namespace std;
double &f();//f() retourne une référence de type double
double val = 100.0;
int main()
{
double x;
cout <<f() <<endl; // affiche la valeur de val
x= f() ; // assigne la valeur de val à x
f() = 99.1 ; // change la valeur de val
cout <<f() <<endl ; //affiche la nouvelle valeur de val
return 0 ;
}

double f()
{
return val;
}

Ex :
#include <iostream>
int toto=0;
int &f()
{ return toto;}

int main ()
{
f()=8;
cout<<toto<<"";
f()++;
cout<< f() <<endl;
}

Ex : Retour de référence sur un tableau

#include <iostream>
using namespace std ;
double &changer(int i);
double vals[] = {1.1, 2.2, 3.3, 4.4, 5.5};
int main()
{
int i;
cout<< "Avant modifications:";
for(i=0; i<5; i++)

[Date] 5
Th. K. DAGBA, ENEAM/UAC 2022
 cout<<vals[i] << ‘\t’<<endl;

changer(1) = 5298.23;
changer(3) = -98.8;

cout<<"Après modifications: ";

for( i=0 ; i <5 ;i++)
cout<<vals[i] <<‘\t’<<endl ;

return 0 ;

double&changer(int i)

returnvals[i] ;

4) Transmission de paramètres

Il existe en C++, 2 modes de transmission de paramètres à une fonction :

transmission par valeur et transmission par référence.

4.1. Transmission de paramètre par valeur :

Ex :

void permute(int x, int y)

{
int tmp = x;
x = y;
y = tmp;
}

int main()
{
int a = 1, b = 10;
cout<< "a =" << a <<", b =" << b <<endl;

[Date] 6
Th. K. DAGBA, ENEAM/UAC 2022
 permute(a,b);
cout<< "a=" << a <<", b =" << b <<endl;
}

4.2. Transmission par référence :

En C++ il est possible de définir une fonction qui modifie la valeur de ses

arguments. Pour ce faire on a besoin d’utiliser les références.

Ex :

void permute(int &x, int &y)

{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 1, b = 10;
cout<<“a=”<< a <<”, b =”<< b <<endl;
permute(a,b);
cout<<"a=”<< a <<”, b =”<< b <<endl;
}

Quelques restrictions sur l’utilisation des références

- On ne peut pas créer une référence sur une variable référence

- On ne peut pas créer un tableau de références

- On ne peut pas créer un pointeur sur une référence

5) Récursivité
Une fonction récursive est une fonction qui s’appelle elle-même.
Exemples de fonctions récursives :

[Date] 7
Th. K. DAGBA, ENEAM/UAC 2022
 1) n! =n*(n-1)*(n-2)…1 ; 1!= 1 ; 0!=1 ; n! = n*(n-1)!
2) suite de Fibonacci
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)

// Calcul de n!

#include <iostream>

using namespace std;

unsigned fact(unsigned n)
{
if(n == 0)
return 1;
else
return n*fact(n-1);
}

int main()
{
for(int i= 0 ; i <5; i++)
cout<<i<<“!=”<< fact(i) <<endl;
}

6) Surcharge de fonction

La surcharge de fonction est une technique qui permet d'attribuer le même nom à

plusieurs fonctions.

Exemple : Définition de la fonction min grâce à la surcharge

int minimum(int a, int b)

{ return ((a<b) ? a :b) ;}

float minimum(float a, float b)

{ return ((a<b) ? a :b) ;}

double minimum(double a, double b)

{ return ((a<b) ? a :b) ;}

[Date] 8
Th. K. DAGBA, ENEAM/UAC 2022
 char minimum(char a, char b)
{ return ((a<b) ? a :b) ;}

7) Modèle de fonction (templates)

L’exemple de surcharge de fonction présente quelques inconvénients : définition

de 4 fonctions avec des instructions identiques.

Une autre solution est de définir un modèle de fonction (template), c’est-à-dire

générique.

Exemple : Définition de la fonction minimum générique

template<class T>
T minimum(T a, T b)
{return ((a<b) ? a : b) ;}

int main()
{
int i = minimum(10,20);
float f = minimum(10.0, 25.0);
char c = minimum(‘a’, ‘W’);
}

Exemple2 :
template<class T1, class T2>
void carre(T1 &x, T2 &y)
{
x *=x ;
y *=y ;
}

EXERCICES DE PROGRAMMATION

- Programmer la suite de Fibonacci

- Programmer la somme des n premiers entiers naturels non nuls : version itérative et version
récursive.
- Programmer le tri d’un tableau à une dimension ; utiliser un modèle de fonction pour le tri

[Date] 9
Th. K. DAGBA, ENEAM/UAC 2022