Vous êtes sur la page 1sur 9

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 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>
usingnamespacestd;
intpgcd(int x, inty); // prototype de la fonction
intmain()
{
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;
}

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


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

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>
Usingnamespacestd;
voidpgcd(int x, inty); // 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;
}

voidpgcd(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)


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 courset 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;
}

intmain()
{
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 :

Ex : Retour de référence

#include<iostream>
usingnamespacestd;
double &f();//f() retourne une référence de type double
double val = 100.0;
intmain()
{
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()
{
returnval;
}
Ex :
#include <iostream>
inttoto=0;
int&f()
{ returntoto;}

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(inti);
doublevals[] = {1.1, 2.2, 3.3, 4.4, 5.5};
int main()
{
int i;
cout<< "Avant modifications:";
for(i=0; i<5; i++)
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(inti)

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 parvaleur :

Ex :

voidpermute(int x, inty)

inttmp = x;

x = y;

y = tmp;

intmain()

int a = 1, b = 10;

cout<< "a =" << a <<", b =" << b <<endl;

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 :

voidpermute(int& x, int&y)

inttmp = x;
x = y;

y = tmp;

intmain()

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 :

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(inti= 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) ;}

floatminimum(float a, float b)
{ return ((a<b) ? a :b) ;}

double minimum(double a, double b)


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

charminimum(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 min générique

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

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

Exemple2 :
template<class T1, class T2>
voidcarre(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