Chapitre3 1

Initiation à la programmation : Langage C++
Chapitre 3 : Les fonctions
Pr. Driss ABADA
Filière SMP - S4
Faculté des Sciences El Jadida
Année Universitaire : 2019/2020

Plan
1 Généralités
2 Fonctions
3 Paramètres d’une fonction
Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 2 / 38

Généralités
1 Généralités
Pour en faciliter et en améliorer la gestion, les programmes complexes sont
décomposés en sous-programmes plus élémentaires et plus simples appelés
fonctions.
En programmation, l’utilisation des fonctions a pour but de :
I Simplifier la réalisation et la maintenance des programmes.
I Éviter les répétitions.
I Favoriser la réutilisabilité des codes.
Le découpage d’un programme en fonctions (modules) est appelée
programmation modulaire.

Fonctions
2 Fonctions
Définition
I Une fonction est un sous programme du C++ permet de regrouper des
instructions et de lancer leur exécution grâce à un nom.

I Une fonction est un sous-programme qui agit sur des données (paramètres)
et retourne une valeur.

Déclaration d’une fonction
I La déclaration d’une fonction (prototypage) est désignée sous le nom de
prototype de la fonction.
I Un prototype (en-tête de la fonction) donne le nom, le nombre et le type
d’arguments d’entrée ainsi que le type de la valeur retournée par la fonction.

Syntaxe de déclaration :
type_retourné nom_fonction ( type1 arg1, type2 arg2, ... ) ;
I Toute fonction utilisée dans le programme principal doit être déclarée avant le
main().
Fonctions
Exemples
// calculer la somme de deux nombre entiers

int somme ( int a , int b ) ;
// calculer le volume
double volume ( double , double , double ) ;
bool ou_exclusif ( bool a , bool b ) ;
// retourner un caract è re à partir du clavier
char lireCaractere () ;
// calculer afficher le carr é d ’ un nombre r é el
void afficherCarre ( double a ) ;
Remarque
Si une fonction ne retourne aucun résultat, son type de retour
est void. C’est l’équivalent d’une procédure en algorithmique.
Fonctions
Définition d’une fonction

I La définition d’une fonction revient à écrire le corps de la fonction dans le
bloc {}. Cela définira la suite d’instructions qui sera exécutée à chaque appel
de la fonction.
Syntaxe de définition :
type_retourné nom_fonction ( type1 arg1, type2 arg2, ... ) // En-tête
{
// Corps de la fonction
Bloc d’instructions ;
return expression ;
}
I La sortie d’une fonction est effectuée avec l’instruction return.

I Si le type de retour d’une fonction est void, on met l’instruction return ; .

Fonctions
Exemples
// d é fintion de la fonction somme

int somme ( int a , int b )
{
int S ;
S = a + b ;
return S ;
}
// d é finition de la fonction volume
double volume ( double a , double b , double c )
{
return a * b * c ;
}
// d é finition de la fonction ou_exclusif
bool ou_exclusif ( bool a , bool b )
{
return ( a && ! b ) || ( b && ! a );
}

Fonctions
Exemples
// d é finition de la fonction lireCaractere

char lireCaractere ()
{
char c ;
cin >> c ;
return c ;
}
// d é finition de la fonction afficherCarre
void afficherCarre ( double a )
{
double car = a * a ;
cout << ’\ t ’ << a << " \ t carr é = " << car << ’\ n ’;
return ; // on peut l ’ omettre c ’ est facultatif
}

Fonctions
Appel d’une fonction

I Un appel à une fonction signifie qu’on lui demande d’exécuter son traitement.
I L’appel d’une fonction doit correspondre à sa déclaration.
I L’appel d’une fonction se fait en mentionnant son nom et ses paramètres
entre parenthèses.
Syntaxe d’appel :
nom_fonction ( arg1, arg2, arg3, ... );
Exemple d’appel des fonctions:
int a , i =1 , j =8 ;
double x =2.0 , y =3.0 ;
int a = somme (i , j ); // 1. appel de la fonction somme (...);
cout << volume (x , y , i ); // 2. appel de la fonct volume (...);
afficherCarre (8.0) ; // 3. appel de la fonct afficherCarre (...)

Fonctions
Exemple : la fonction caree ()

Déclaration :
// Calcule et retourne le carr é d ’ un nombre r é el

double caree ( double x ) ;
// le nom du param è tre n ’ est pas obligatoire
Définition :
// le nom du param è tre est obligatoire

double carre ( double x )
{
return x * x ; // x est une variable locale
}

Fonctions
Appels corrects de la fonction caree() :
/* L ’ appel doit correspondre à la d é claration faite

au compilateur qui le v é rifie . */
double c1 = carre (2.0);
double valeur = 2.0;
double c2 = carre ( valeur ); // ( valeur est copi é dans x )
double c3 ;
// Fonction comme une op é rande dans une expression
c3 = 2 * c1 + 5.1 * carre (3* c2 ) ;
// Afficher le r é sultat obtenu par une fonction
double x ;
cin > > x ;
cout < < " Le carre de " <<x < < " est " << carre ( x ) ;

Fonctions
Appels incorrects de la fonction caree()
// Erreur : pas assez d ’ argument

int c1 = carre ();
// Erreur : parenth è ses manquantes
int c2 = carre ;
// Erreur : trop d ’ arguments
int c3 = carre (1.0 , 2.0);
// Erreur : mauvais type d ’ argument car un double attendu
int c4 = carre ( " deux " );
// Attention :
/* probablement une erreur car la valeur retour
n ’ est pas utilis é e */
carre (2.0);

Fonctions
Mécanisme d’appel
I Quand un programme rencontre un appel à une fonction :
1 il se place directement au début de la fonction,
2 exécute les instructions dans cette fonction,
3 après l’exécution, le programme revient à l’instruction qui suit l’appel de la
fonction.
I L’appel d’une fonction peut se faire dans le main() ou dans une autre
fonction.

Paramètres d’une fonction
3 Paramètres d’une fonction

Types des paramètres d’une fonction
I Les paramètres figurant dans l’en-tête de la définition d’une fonction sont
appelés paramètres formels ou paramètres.

I Les paramètres fournis lors de l’appel de la fonction se nomment des
paramètres effectifs (réels) ou arguments.
Passages des paramètres d’une fonction

I En C++, on distingue trois types de passage de paramètres :
Passage par valeur : Lors de l’appel de la fonction, c’est seulement une copie
des valeurs des paramètres effectifs qui est affectées aux paramètres formels.
Passage par référence : Dans ce cas, le paramètre formel est un alias
(synonyme) de l’emplacement mémoire du paramètre réel.
Passage par adresse : Ici, c’est l’adresse des emplacements mémoire des
paramètres réels qui est copiée dans les paramètres formels (Pointeur).
Passage des paramètres par valeur

Programme pour échanger les valeurs de deux variables : version 1
# include < iostream >

using namespace std ;
void echange ( int x , int y );
int main () {
int a = 10 , b = 20;
cout << " avant echange : " << a << " " << b << endl ;
echange (a , b ); // Param è tres effectifs
cout << " apres echange : " << a << " " << b << endl ;
return 0;
}
void echange ( int x , int y ) { // param è tres formels
int z = x ;
x = y;
y = z;
return ;
}
Résultat d’exécution de programme version 1

Passage des paramètres a et b à la fonction echange()

I les valeurs des paramètres effectifs a et b se recopient dans les paramètres
formels x et y.
Exécution des instructions de la fonction echange()

I Seules les valeurs des paramètres formels x et y qui s’échangent.
I Les paramètres effectifs a et b ne subissent aucune modification.
1. z = x; 2. x = y; 3. x = z;
Passage des paramètres par référence


void echange ( int &x , int & y );
int main () {
int a = 10 , b = 20;
echange (a , b ); // Param è tres effectifs
return 0;
}
void echange ( int &x , int & y ) { // param è tres formels
int z = x ;
x = y;
y = z;
return ;
}

Notion de référence
I Une référence est un synonyme (alias) d’une autre variable.
I On peut faire référence à la même variable (même espace mémoire) avec
plusieurs identificateurs différents.
I La référence est déclarée en ajoutant une esperluette & entre le type et le
nom de la variable. Syntaxe : type &nom_id1 = nom_id2 ;
I Comme une constante, une référence doit être initialisée dès sa déclaration.
Exemple :
int n = 33;
int & r = n ; // r est une reference a n
cout << n << " " << r << endl ; // memes valeurs
--n ; // n vaut 32 et aussi r vaut 32
cout << n << " " << r << endl ;
r *= 2; // r vaut 64 et aussi n vaut 64
cout << n << " " << r << endl ;
cout << & n << " " << & r << endl ; // adresse memoire

Passage des paramètres a et b par référence à la fonction echange()

I Dans ce cas, la fonction agit directement sur les variables a et b (même espace
mémoire) et pas sur leurs valeurs.
Exécution du corps de la fonction echange()

I Toutes les modifications des variables x et y dans la fonction seront effectuées
sur les espaces mémoire des variables a et b, donc on change aussi leurs
valeurs de manière définitive.

Passage des paramètres par adresse


void echange ( int *x , int * y );
int main () {
int a = 10 , b = 20;
echange (& a , & b ); // Param è tres effectifs
return 0;
}
void echange ( int *x , int * y ) { // param è tres formels
int z = * x ;
*x = *y;
*y = z;
return ;
}

Notion de pointeur
I Un pointeur est une variable qui a pour valeur l’adresse mémoire d’une autre
variable.
I On peut faire référence à une variable avec une autre variable contenant son
adresse appelée pointeur.
I Le pointeur est déclaré en ajoutant une étoile * entre le type et le nom de la
variable. Syntaxe : type *nom_ptr ;
Exemple :
int j = 4;
int * ptr = 0; // declaration de pointeur
ptr = & j ; // l ’ adresse de j est stockee dans ptr
int k = * ptr ; // la valeur de j est affectee a k
cout << k << " \ t " << * ptr << endl ;
* ptr = 5; // la valeur 5 est affectee a j
cout << * ptr << " \ t " << j << endl ;

Déclaration et affectation des références et pointeurs (A.Bravar)

Passage des paramètres a et b par adresse à la fonction echange()

I Le passage par adresse appelé aussi passage par pointeur permet de
transmettre à une fonction les adresse mémoire des paramètres effectifs.
I Les adresses de a et b sont stockées dans les arguments x et y de type
pointeurs qui peuvent être par la suite utilisé pour modifier les variable
pointées a et b.
Exécution du corps de la fonction echange()

I Les changements effectués à partir des pointeurs x et y affectent aussi les
variables a et b de la fonction appelante.

Exercices corrigés
Exercice 1 :
1 Écrire en C++ une fonction qui retourne la somme de deux réels x et y et
une autre qui retourne leurs produit. Les deux paramètres sont passés par
valeurs.
2 Écrire en C++ une procédure (fonction de type void) équivalent aux deux
fonctions qui permet de renvoyer la somme et le produit de deux réels x et y.
I En utilisant 4 paramètres.
I En utilisant 2 paramètres.
3 Écrire un programme main qui permet de tester les fonctions définies.

Exercices corrigés
Corrigé de l’exercice 1 : fonction somme() et produit()

double somme ( double x , double y );
double produit ( double x , double y );
int main () {
double x , y ;
cout << " Introduisez deux r é els : " << endl ;
cin >> x >> y ;
cout << " la somme est : " << somme (x , y )
<< " le produit est : " << produit (x , y ) << endl ;
return 0;
}

Exercices corrigés
// D é finition de la fonction somme

double somme ( double x , double y )
{
return x + y ;
}
// D é finition de la fonction produit

double produit ( double x , double y )
{
return x * y ;
}

Exercices corrigés
Corrigé de l’exercice 1 : sommeproduit() passage par référence

void somprod ( double x , double y , double &s , double & p );
void sommeproduit ( double &x , double & y );
int main () {
double a , b , som , prod ;
cin >> a >> b ; somprod (a ,b , som , prod );
cout < < " Somme = " << som << " Produit = " << prod < < endl ;
sommeproduit (a , b );
cout << " Somme = " << a << " Produit = " << b << endl ;
return 0;
} Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 30 / 38
Exercices corrigés
void somprod ( double x , double y , double &s , double & p )

{
s=x + y ;
p=x * y ;
return ;
}
void sommeproduit ( double &x , double & y )
{
double z = x ;
x = x + y ;
y = z * y ;
return ;
}
Exercices corrigés
Corrigé de l’exercice 1 : sommeproduit() passage par pointeur

void somprod ( double x , double y , double *s , double * p );
void sommeproduit ( double *x , double * y );
int main () {
double a , b , som , prod ;
cin >> a >> b ;
somprod (a ,b , & som , & prod );
cout < < " Somme = " << som << " Produit = " << prod < < endl ;
sommeproduit (& a ,& b );
cout << " Somme = " << a << " Produit = " << b << endl ;
return 0;
}
Exercices corrigés
void somprod ( double x , double y , double *s , double * p )

{
*s=x + y ;
*p=x * y ;
return ;
}
void sommeproduit ( double *x , double * y )
{
double z = * x ;
*x = *x + *y ;
*y = z * *y ;
return ;
}
Exercices corrigés
Exercice 2 :
1 Écrire le programme C++ d’une fonction qui retourne la solution d’équation
de premier degré ax + b = 0. La fonction a deux paramètres a et b qui
représentent les coefficients.
2 Écrire en C++ une fonction qui retourne true si l’équation ax + b = 0 admet
une solution, false si non. La solution est renvoyé par la fonction par un
troisième paramètre passé par référence ou par adresse.
3 Écrire un programme main qui permet de tester les fonctions définies.

Exercices corrigés
Corrigé de l’exercice 2 :

double equationpremdeg1 ( double , double ) ;
int main () {
double a , b , x ;
cout << " Entrer les deux coefficients : " << endl ;
cin >> a >> b ;
x = equationpremdeg1 (a , b );
cout < < " la solution est : " << x << endl ;
return 0;
}

Exercices corrigés
double equationpremdeg1 ( double a , double b )

{
if ( a ==0)
{
cout < < " L ’ equation n ’ admet aucune solution " << endl ;
exit ( -1) ;
/* L ’ instruction exit () permet de terminer
l ’ ex é cution de programme */
}
return -b / a ;
}

Exercices corrigés
Corrigé de l’exercice 2 :

bool equationpremdeg2 ( double , double , double &) ;
int main () {
double a , b ;
cout << " Entrer les deux coefficients : " << endl ;
cin >> a >> b ;
bool i = equationpremdeg1 (a ,b , s );
if ( i )
cout < < " la solution est : " << s << endl ;
else
cout < < " pas de solution " << endl ;
return 0;
} Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 37 / 38
Exercices corrigés
bool equationpremdeg2 ( double a , double b , double & s )
if ( a !=0)
s=-b/a;
return true ;
s = -1;
return false ;

Chapitre3 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Chapitre3 1

Transféré par

Droits d'auteur :

Formats disponibles

Initiation à la programmation : Langage C++

Chapitre 3 : Les fonctions

Pr. Driss ABADA

Faculté des Sciences El Jadida

Année Universitaire : 2019/2020

3 Paramètres d’une fonction

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 2 / 38

Pour en faciliter et en améliorer la gestion, les programmes complexes sont

décomposés en sous-programmes plus élémentaires et plus simples appelés

En programmation, l’utilisation des fonctions a pour but de :

I Simplifier la réalisation et la maintenance des programmes.

I Éviter les répétitions.

I Favoriser la réutilisabilité des codes.

Le découpage d’un programme en fonctions (modules) est appelée

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 3 / 38

instructions et de lancer leur exécution grâce à un nom.

et retourne une valeur.

d’arguments d’entrée ainsi que le type de la valeur retournée par la fonction.

// calculer la somme de deux nombre entiers

Définition d’une fonction

I La sortie d’une fonction est effectuée avec l’instruction return.

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 6 / 38

// d é fintion de la fonction somme

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 7 / 38

// d é finition de la fonction lireCaractere

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 8 / 38

Appel d’une fonction

I L’appel d’une fonction doit correspondre à sa déclaration.

I L’appel d’une fonction se fait en mentionnant son nom et ses paramètres

Exemple d’appel des fonctions:

double x =2.0 , y =3.0 ;

int a = somme (i , j ); // 1. appel de la fonction somme (...);

cout << volume (x , y , i ); // 2. appel de la fonct volume (...);

afficherCarre (8.0) ; // 3. appel de la fonct afficherCarre (...)

Exemple : la fonction caree ()

// Calcule et retourne le carr é d ’ un nombre r é el

// le nom du param è tre est obligatoire

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 10 / 38

Appels corrects de la fonction caree() :

/* L ’ appel doit correspondre à la d é claration faite

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 11 / 38

Appels incorrects de la fonction caree()

// Erreur : pas assez d ’ argument

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 12 / 38

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 13 / 38

3 Paramètres d’une fonction

appelés paramètres formels ou paramètres.

paramètres effectifs (réels) ou arguments.

Passages des paramètres d’une fonction

Passage par référence : Dans ce cas, le paramètre formel est un alias

(synonyme) de l’emplacement mémoire du paramètre réel.

Passage des paramètres par valeur

# include < iostream >

Résultat d’exécution de programme version 1

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 16 / 38

Passage des paramètres a et b à la fonction echange()

Exécution des instructions de la fonction echange()

Passage des paramètres par référence

# include < iostream >

Résultat d’exécution de programme version 2

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 19 / 38

Driss ABADA Initiation à la programmation : Langage C++ Année Universitaire : 2019/2020 20 / 38

Passage des paramètres a et b par référence à la fonction echange()

void somprod ( double x , double y , double s , double p )