Vous êtes sur la page 1sur 18

Universit de MSILA Dpartement dlectronique Master 1CI

2010/2011
















Sommaire
1. SYNTAXE ELEMENTAIRE .................................................................................................................................1
2. TYPES .........................................................................................................................................................2
3. OPERATEURS ...............................................................................................................................................3
4. STRUCTURES CONDITIONNELLES ......................................................................................................................5
5. STRUCTURES DE BOUCLES ..............................................................................................................................5
6. FLUX D'ENTREE CIN ET DE SORTIE COUT ............................................................................................................7
7. PORTES DES VARIABLES .................................................................................................................................8
8. POINTEURS / REFERENCES .............................................................................................................................9
9. TABLEAU .................................................................................................................................................. 11
10. FONCTIONS .............................................................................................................................................. 13





Chapitre I :
Programmation
classique en C++
Aide mmoire et lments du
langage de programmation C++
1
1. Syntaxe lmentaire

Dans cette section, nous donnons les principales rgles d'criture d'un programme en C++. En effet, pour
qu'un compilateur puisse interprter un code en C++, il est ncessaire de respecter un certain nombre de
rgles rsumes dans les trois paragraphes suivants.
1.1. Instructions
Toutes les instructions en C++ se terminent par ; . La dfinition
d'un bloc d'instructions (plusieurs instructions) se fait avec des accolades :
La dure de vie (cration et destruction) ainsi que la porte (possibilit
d'utilisation /d'accs ...) de tout ce qui est dfini l'intrieur d'un bloc est
limite ce bloc (sauf pour les variables static et les variables alloues
dynamiquement).
1.2. Commentaires
Deux styles de commentaire sont disponibles en C++ :
// permet de mettre en commentaire tout ce qui est situ aprs ce caractre et jusqu'au
prochain saut de ligne ;
/* et */ permettent de dlimiter un bloc de commentaires (plusieurs lignes en gnral).
Voici un exemple d'utilisation de commentaires en C++ :
1 int b; // variable utilise pour compter des notes
2 nb = 10; /* par dfaut on connait
3 le nombre de notes qui est :
4 10... et toutes ces lignes sont en commentaires */
1.3. Casse et mots rservs
Le compilateur prend en compte la casse (majuscule ou minuscule) pour :
les noms des fichiers ;
les noms des variables et des fonctions ;
les mots cls du langage C++ et les directives du prprocesseur.
Il est noter que les mots cls et les directives du prprocesseur ne peuvent pas tre utiliss par le
programmeur pour nommer les variables, les objets et fonctions. Les tableaux suivant fournissent une liste
complte des mots cls et directives du prprocesseur.

Liste des 48 mots cls du langage C++
1 {
2 instruction1;
3 instruction2;
4 ;
5 }

2

Liste des 12 directives du prprocesseur
Exemple :
1 // Ces 3 directives sont necessaire a tous fichiers ".h", la
2 // variable "_MaClasse_H_" doit etre differente pour chaque fichier
3 #ifndef _MaClasse_H_
4 #define _MaClasse_H_
5
6 #define PI 3.14 // pas de type devant la variable ni de "=" ni de ";"
7
8 // le reste du fichier .h
9 class MaClasse
10 {
11 ...
12 };
13
14 #endif

2. Types
Dans cette section, nous donnons les principales notions connatre sur les types et la dclaration de
variables.
2.1. Types fondamentaux en C++
Le tableau suivant fournit une liste des principaux types utiliss en programmation C++.

Types fondamentaux en C++


3
2.2. Dclaration de variables
La syntaxe de dclaration d'une variable en C++ est la suivante :
1 Type variable;
2 Type var1, var2, var3;
Les noms de variables doivent commencer par une lettre ou par _ . La casse (majuscule ou minuscule)
est prise en compte (var1 est diffrent de Var1). En C++, tous les types sont des classes et toutes les classes
sont des types, mme les classes cres par l'utilisateur.
Exemples :
1 int i,j,k;
2 float Valeur;
2.3. Dclaration de variables avec affectation
La dclaration d'une variable avec affectation d'une valeur (ou initialisation) se fait de la faon suivante :
1 type var1 = 0;
Qui est quivalent 2 :
1 type var1;
2 var1 = 0;
Voici une liste d'exemples de dclaration de variables avec affectation :
1 float a=3.002;
2 unsigned short b=1,c=2;
3 double un_mille(1.609e3);
L'opration d'a_ectation peut se faire entre des variables de mme type
1 int a,b;
2 a=4;
3 b=a; // la valeur de a est copie dans b: b vaut 4
Ou entre des variables de type diffrent (dans ce cas, attention aux pertes lors de la conversion) :
1 float a=3.1415;
2 char b;
3 double c;
4 b = a; // b vaut 3, un warning est gnr la compilation
5 c = a; // c vaut 3.1415, pas de warning ici car la prcision du type double est suprieure a
6 // prcision du type float (pas de perte de prcision)
3. Oprateurs
Nous abordons dans cette partie les dfinitions et les diffrentes proprits lies aux oprateurs en C++.
3.1. Oprateur unaire, binaire et ternaire
Un oprateur unaire est un oprateur ne possdant qu'un seul oprande. Voici un exemple d'un tel
oprateur :
1 int a; // dclaration de a
2 &a; // & est un oprateur unaire, il renvoie l'adresse mmoire de a
Un oprateur binaire possde deux oprandes ( ne pas confondre avec les oprateurs ralisant des
oprations en binaire). Voici un exemple d'un tel oprateur :
1 int a; // dclaration de a
2 a = 1; // = est un oprateur binaire, il affecte la valeur 1 a
Il n'existe qu'un seul oprateur ternaire, l'oprateur de condition ? : . Voici un exemple d'utilisation
de cet oprateur :
1 q = (p > n ? n : p) // q prend la valeur n si la condition (p > n) et vrai sinon q = p

4
3.2. Priorit


Liste et proprits des oprateurs en C++
5
4. Structures conditionnelles
Les conditions servent comparer (ou valuer) des variables ou des valeurs retournes par des fonctions.
4.1. if / else
La syntaxe d'une condition if est la suivante (les crochets signalent des blocs non ncessaires) :
1 if ( test ) // test est une variable boolenne (true ou false)
2 {
3 // instructions effectues si test est vrai
4 }
5 [
6 else // bloc else: n'est pas obligatoire
7 {
8 // instructions effectues si test est faux
9 }
10 ]

La variable test est forcment de type boolen (bool). Aprs l'instruction if, les accolades sont ncessaires
si plusieurs instructions sont dclares. Le bloc else n'est pas obligatoire. Il est noter que la syntaxe if(a) est
quivalent if( a!=0 ).
Exemple :
if (x != 0)
{ cout << 1/x << endl; }
else
{ cout << "Erreur! (Infinity)" << endl; }
4.2. switch / case
Quand la variable tester est de type entier (c'est dire char, short, int, long et string) la structure if/else
peut tre remplace par une structure switch case. La syntaxe d'une condition switch case est la suivante :
1 switch ( variable )
2 {
3 case constante_1 :
4 [ instructions ralises si variable == constante_1 ]
5 [ break ; ]
6 case constante_2:
7 [ instructions raliss si variable == constante_2 ]
8 [ break ; ]
9
10 [ default : instructions ralises si aucun des cas prcdents n'a pas t ralis]
11 }
5. Structures de boucles
Les boucles servent rpter un ensemble d'instructions. Il existe 3 types de boucle.
5.1. for
La syntaxe d'une boucle for en C++ est la suivante :
1 for ( [initialisations] ; [condition] ; [post-instructions] )
2 {
3 // Instructions de boucle rptes tant que la condition est vraie
4 }
L'excution d'une boucle for se passe en 3 tapes.
1. Le bloc [initialisations], est toujours excut une seule fois,
2. Le bloc [condition] est valu chaque rptition,
6
3. Si la condition est vraie, les instructions de boucle puis le bloc [post-instructions] sont excuts puis
l'tape 2 est rpte. Si l'expression est fausse, aucune instructions de boucle ni le bloc [post-
instructions] ne sont excuts et la boucle s'arrte.
Exemple :
for (int i(0) ; i<=10 ; ++i)
{
cout << i*i << endl;
}
for (int i(0 ), s(0) ; i<6 ; s+=i, ++i)
{
cout << i << s << endl;
}

5.2. while
La syntaxe d'une boucle while est la suivante :
1 while ( [condition] )
2 {
3 // Instructions de boucle rptes tant que la condition est vraie
4 }
Il est noter que le test du bloc [condition] se fait en dbut de boucle.
Exemple en multi conditions
int i=0, Taille=3, j;
while ( ( i < Taille ) && ( j != 0 ) ) // Multi conditions
{
Cout << "Ok" << endl;
j = 2 * i - i * ( Taille - i );
i++;
}
5.3. do / while
Contrairement aux boucles for et while, la boucle do while effectue les instructions de boucle avant
d'valuer l'expression d'arrt (le bloc condition).
1 do
2 {
3 // Instructions de boucle rptes tant que la condition est vrai
4 }
5 while ( [condition] )
Exemple
char choix;
do
{
cout << "Quel est votre choix: (q pour quitter) ?";
cin >> choix ; (...)
}
while ( choix != 'q' );
5.4. Ruptures de squence
C++ fournit galement des instructions de rupture de squence, permettant de contrler de faon plus
fine le droulement des structures de contrles.
Parmi ces instructions, on trouve break et continue.
Linstruction break : Elle ne peut apparatre quau sein dune boucle ou dune clause de slection. Elle
permet dinterrompre le droulement de la boucle (quelque soit ltat de la condition de continuation) ou de
linstruction de slection, en provoquant un saut vers linstruction suivant la structure de contrle.
Linstruction continue : Elle ne peut apparatre quau sein dune boucle. Elle interrompt lexcution des
instructions du bloc, et provoque la rvaluation de la condition de continuation, afin de dterminer si
lexcution de la boucle doit tre poursuivie (avec une nouvelle itration).
7


6. Flux d'entre cin et de sortie cout
Les entres et sorties sont gres par deux classes dfinies dans le fichier d'en-tte <iostream> :
ostream (Output stream) permet d'crire des donnes vers la console, un fichier, ... Cette classe
surdfinit l'oprateur <<.
istream (Input stream) permet de lire des donnes partir de la console, d'un fichier, ... Cette
classe surdfinit l'oprateur >>.
Trois instances de ces classes reprsentent les flux standards :
cout crit vers la sortie daffichage,
cerr crit vers la sortie d'erreur,
cin lit partir du clavier.

Exemple :
int n;
cout << "Entrez un nombre positif : ";
cin >> n;
if (n<0) cerr << "Erreur: Le nombre " << n << " n'est pas positif " << endl;
else cout << "Vous avez entr " << n << endl;

6.1. Flux de sortie pour l'affichage : cout
cout dsigne le flux de sortie standard qui est dirig par dfaut sur l'cran. La syntaxe est la suivante :
[std::]cout << donne__afficher [ << autres_donnes ]
Formatages de sorties :
endl : insre une fin de ligne.
setw(x) : la prochaine sortie sera sur une largeur de x caractres en ajoutant si ncessaire des
espaces pour complter.
Setprecision (x) : fixe la prcision des donnes
setfill ( c ) : utilisera c comme caractre de remplissage
left : la prochaine sortie sera cadre gauche (dfaut)
right : la prochaine sortie sera cadre droite
uppercase : la prochaine sortie sera convertie en majuscule
lowercase : la prochaine sortie sera convertie en minuscule
f ixed : prochaine sortie en virgule fixe, ex. : 0.00012
scientific : prochaine sortie en notation ingnieur, ex. : 1.2e-4
flush : vide le tampon de sortie




8
6.2. Flux d'entre clavier : cin
cin est le flux d'entre standard sur lequel est dirig par dfaut le clavier. La syntaxe est la suivante :
[std::]cin >> variable;
cin >> variable1 >> variable2;
Pour insrer une pause (attente que l'on appuie sur la touche Entre), il est conseill de d'abord purger le
buffer lu par cin qui contient souvent le dernier caractre de la saisie prcdente.
cin.sync(); // tout les caractres du buffer non lus sont ignors
cin.get(); // attente de la touche Entre
7. Ports des variables
Les rgles de porte d'une variable nous expliquent la dure de validit d'une variable, quand elle est
cre, et quand elle est dtruite. La porte d'une variable s'tend du point o elle est dfinie jusqu' la
premire accolade "fermante" qui correspond la plus proche accolade "ouvrante" prcdant la dfinition
de la variable. En d'autres termes, la porte est dfinie par le plus proche couple d'accolades entourant la
variable.

7.1. Variable globale
Les variables globales sont dfinies hors de tout corps de fonction et sont disponibles pour tous les
lments du programme (mme le code d'autres fichiers).
7.2. Variable locale
Les variables locales existent dans un champ limit ; elles sont "locales" une fonction. Ces variables sont
crs automatiquement quand on entre dans le champ et disparaissent automatiquement quand le champ
est ferm.
7.3. Variable static
Le mot-clef static a diffrentes significations. Normalement, les variables dfinies dans une fonction
disparaissent la fin de la fonction. Quand vous appelez une fonction nouveau, l'espace de stockage pour
la variable est recr et les valeurs rinitialises. Si vous voulez qu'une valeur soit tendue toute la dure
de vie d'un programme, vous pouvez dfinir la variable locale d'une fonction static et lui donner une valeur
initiale. L'initialisation est effectue uniquement la premire fois que la fonction est appele, et la donne
conserve sa valeur entre les appels la fonction. Ainsi, une fonction peut "se souvenir" de morceaux
d'information entre les appels.


9
7.4. Variable extern
La porte dune variable globale semble limite au fichier source dans lequel elle a t dfinie

Dans lexemple ci-contre les fonctions fct2 et fct3 ne peuvent pas
faire rfrence la variable globale x dclare dans le premier fichier
source. Pour parer ce problme on peut runir ces deux fichiers
source en un seul.
En fait, C++ prvoit une dclaration permettant de spcifier
quune variable globale a dj t dfinie dans un autre fichier
source. Celle-ci se fait laide du mot-cl extern. Ainsi, en faisant
prcder notre fichier source 2 de la dclaration :
extern int x ;
Il devient possible dutiliser la variable globale x (dclare dans le
fichier source 1) dans les fonctions fct2 et fct3.
Cette dclaration extern neffectue pas de rservation
demplacement de variable. Elle ne fait que prciser que la variable globale x est dfinie ailleurs.
7.5. Constante
Il est possible en C++ de dfinir des donnes constantes. Ces donnes ne peuvent tre modifies.
Il sagit gnralement de valeurs universelles :
const double Pi = 3.141592;
8. Pointeurs / Rfrences
8.1. Pointeurs
En langage C et C++, chaque variable est stocke une (et unique) adresse physique. Un pointeur est une
variable contenant l'adresse d'une autre variable. Un pointeur est typ : il pointe vers des variables d'un
certain type et ainsi permet de manipuler correctement ces variables. Avant d'tre utilis, un pointeur doit
obligatoirement tre initialis l'adresse d'une variable ou d'un espace mmoire. Il est possible d'obtenir
l'adresse d'une variable partir du caractre & :
1 int a;
2 cout << &a; // affichage de l'adresse de a
Un pointeur est une variable qui doit tre dfinie en
prcisant le type de variable pointe :
type * Nom_du_pointeur;
Le type de variable pointe peut tre aussi bien un type
primaire (tel que int, char...) qu'un type complexe (tel que
struct ou une classe). La taille des pointeurs, quel que soit le
type point, est toujours la mme. Elle est de 4 octets avec un
OS 3 32 bits (et 8 en 64 bits). Un pointeur est typ. Il est
toutefois possible de dfinir un pointeur sur void, c'est--dire
sur quelque chose qui n'a pas de type prdfini (void * PT).
Pour initialiser un pointeur, il faut utiliser l'oprateur
d'affectation = suivi de l'oprateur d'adresse & auquel est
accol un nom de variable.

1 double *x;
2 double a =5;
3 x = &a; // initialisation du pointeur!

Aprs (et seulement aprs) avoir dclar et initialis un pointeur, quon peut accder au contenu de
l'adresse mmoire pointe par le pointeur grce l'oprateur *:
source 1 source 2
int x ; fct2()
main() {
{ .....
..... }
} fct3()
fct1() {
{ .....
..... }
}

10
1 int *x;
2 int a=5;
3 cout << *x; // Affiche le contenu point par x, c'est dire 5
4 *x=4; // Affecte au contenu point par x la valeur 4, la fin des ces instructions, y=4;

8.1.1. Exemples

8.1.2. Supplment sur les pointeurs

8.2. Rfrences
Une rfrence permet de faire rfrence des variables. Le concept de rfrence a t introduit en
C++ pour faciliter le passage de paramtres une fonction, on parle alors de passage par rfrence. La
dclaration d'une rfrence se fait simplement en intercalant le caractre &, entre le type de la variable et
son nom :
type & Nom_de_la_variable = valeur;
11
Il existe deux contraintes l'utilisation des rfrences :
Une rfrence doit obligatoirement tre initialise lors de sa dclaration.
Une rfrence ne peut pas tre drfrence d'une variable une autre.
Exemple :
1 int A = 2;
2 int &refA = A; //initialisation obligatoire!
3 refA++; // maintenant A=3
4 // drfrencement impossible ==> modification de la valeur contenue:
5 int B = 5;
6 refA = B; // signifie A = 5
7 refA++;
8 // la fin de ces instructions on a : A = 6, B = 5, et refA = 6
Remarque : L'usage le plus commun des rfrences est le passage de paramtres aux fonctions.
9. Tableau
Un tableau est une variable compose de donnes de mme type, stockes de manire adjacente en
mmoire. Un tableau est donc une suite de cases mmoires de mme taille. La taille de chacune des cases
est conditionne par le type de donne que le tableau contient. Les lments du tableau peuvent tre :
Des donnes de type simple : int, char, float, long, double...
Des pointeurs, des tableaux, des structures et des classes
9.1. Tableaux statiques
Lorsque la taille du tableau est connue par avance (avant l'excution
du programme), il est possible de dfinir un tableau de la faon suivante :
variable_tableau[nb_lments];
Type variable_tableau[ ] = {lment1, lment2,
lment3...};
Exemples
float notes[10];
int premier[] = {3,5,7}; // le nombre d'lments est 3
Les tableaux statiques sont allous et dtruits de faon automatique.
Les lments d'un tableau sont indics partir de 0. La lecture ou
l'criture du i
me
lment d'un tableau se fait de la faon suivante :
A=variable_tableau[i]; // lecture du i
me
lment
variable_tableau[i]=A; // criture du i
me
lment

9.2. Tableaux et pointeurs
La syntaxe suivante :
1 int tab[] = {4,5,6};
2 cout << tab;
Affiche une adresse. Ceci montre qu'il existe un lien troit entre les tableaux et les pointeurs. Plus
prcisment une variable tableau (exemple prcdent tab) renvoie comme valeur l'adresse de la premire
case du tableau. Ainsi, le code :
1 int tab[] = {4,5,6};
2 cout << *tab; // on affiche le contenu point par tab, c'est dire
3 // la valeur de la premire case du tableau
12
Renvoie la valeur de la premire case du tableau, ici 4. Dans l'exemple suivant, nous proposons
diffrentes oprations sur les lments de tableaux :
1 int tab[] = {4,5,6};
2 cout << &(tab[1]); // affiche l'adresse de la deuxime case du tableau
3 cout << tab+1; // affiche l'adresse de la deuxime case du tableau
4 cout << tab[2]; // affiche 6
5 cout << *(tab+2); // affiche 6
Exemples
Pour illustrer ces nouvelles possibilits de notation, voici trois faons de placer la valeur 1 dans
chacun des 10 lments de notre tableau t :
int i ;
for (i = 0 ; i < 10 ; i++)
t[i] = 1;

int i ;
for (i = 0 ; i < 10 ; i++)
*(t+i) = 1 ;

int i ;
int *p ;
for (p = t, i = 0 ; i < 10 ; i++, p++)
*p = 1 ;
9.3. Tableaux dynamiques
Lorsque la taille d'un tableau n'est pas connue lors de la compilation, il est possible en C++ d'allouer un
espace mmoire la taille voulue en cours de programme. On parle d'allocation dynamique. Pour faire un
tableau dynamique, il faut d'abord crer un pointeur, puis allouer l'espace mmoire souhait par la
commande new. A la _n de l'utilisation du tableau, il ne faut pas oublier de librer l'espace allou par la
commande delete[ ]. Ci-dessous un rsum des instructions utiliser en C++ pour la gestion dynamique de
tableaux :
Dclaration d'un pointeur
type *variable_tableau;
Allocation puis affectation
variable_tableau = new type[nb_lment];
type *variable_tableau = new type[nb_lment];
Libration de l'espace allou
delete[] variable_tableau;
Exemple :
int main()
{
int i, taille;
int *t;
cout << " Donnez la taille du tableau : ";
cin >> taille;
t = new int[taille];
for(i=0; i<taille; i++)
t[i]=i*i;
for(i=0; i<taille; i++)
cout << t[i] << endl;
delete[] t;
}
13
9.4. Tableaux multidimensionnelles
Les tableaux multidimensionnels sont des tableaux de tableaux. Par exemple, en dimension 3, un tableau
statique sera dclar de la faon suivante :
type volume[L][C][P]; // L,C,P, nb de ligne, colonne et profondeur
En dimension 2, un tableau dynamique sera dclar de la faon suivante :
1 type **matrice;
2 matrice = new type*[L];
3 for( int i = 0; i < L ; i++ )
4 matrice[i] = new type[C];
Et un tableau dynamique de 2 dimensions sera dtruit de la faon suivante :
1 // destruction de matrice de l'exemple prcdent
2 for( int i = 0 ; i < L; i++ )
3 delete[] matrice[i];
4 delete[] matrice;
10. Fonctions
Une fonction est un sous-programme qui permet d'effectuer un ensemble d'instructions par un simple
appel cette fonction. Les fonctions permettent d'excuter dans plusieurs parties du programme une srie
d'instructions, ce qui permet de simplifier
le code et d'obtenir une taille de code
minimale. Il est possible de passer des
variables aux fonctions. Une fonction
peut aussi retourner une valeur
(contrairement aux procdures). Une
fonction peut faire appel une autre
fonction, qui fait elle mme appel une
autre, etc. Une fonction peut aussi faire
appel elle-mme, on parle alors de
fonction rcursive, dans ce ca il faut
toujours mettre une condition de sortie
au risque de ne pouvoir arrter le
programme.


10.1. Prototype d'une fonction
Comme les variables, avant d'tre utilise, une fonction doit tre dclare. Le prototype d'une fonction
correspond cette dclaration. Il s'agit de la description de la fonction, c'est dire donner son nom, indiquer
le type de la valeur renvoye et les types d'arguments (les noms des arguments sont optionnels, mais
peuvent servir rendre le prototype plus lisible). On place le prototype des fonctions en dbut de
programme. Cette dclaration permet au compilateur de vrifier la validit de la fonction chaque fois qu'il
la rencontre dans le programme. Une fonction est dclare de la faon suivante :
type_retour NomFonction( [type Arg1, type Arg2,...] );
Exemple :
float puissance(const float base, float exposant); // prototype de la fonction puissance qui va
// tre dfini aprs la fonction main
void main()
{
...
x = puissance(8.0,3.);
...
}
14
10.2. Dfinition d'une fonction
La dfinition d'une fonction est l'criture du programme excut par cette fonction. Une fonction est
dfinie par l'ensemble nom de fonction, nombre d'arguments en entre, type des arguments en entre et
liste d'instructions. La dfinition d'une fonction se fait selon la syntaxe suivante :
type_retour NomFonction( [type Arg1, type Arg2,...] )
{
liste d'instructions; //corps de la fonction
[return <valeur>] // valeur de retour de la fonction
}
Une instruction de rupture de squence particulire, return, permet de terminer la fonction en
retournant comme rsultat de lexcution la valeur spcifie par valeur.
Il est galement possible de dfinir des fonctions sans valeur de retour c.--d. des fonctions qui ne
renvoient rien, elles sont quivalentes de simple sous-programme.
Cette absence de valeur de retour sera indique, dans le prototype et la dfinition de la fonction, par un
type de retour particulier, le type void Dans ce cas, le mot rserv return nest pas requis,

Exemple :
#include <iostream>
// Prototypages ..........................
float moyenne(const float x1, const float x2);
void main()
{
cout << moyenne(8.0, 3.0) << endl;
}
// Dfinitions ...............................
float moyenne(const float x1, const float x2)
{
return (x1+x2)/2.0;
}

10.3. Appel de fonction
Lvaluation de lappel fonctionnel peut tre schmatise de la faon suivante:







Lvaluation de lappel fonctionnel seffectue de la faon suivante :
1) Evaluation des arguments de la gauche vers la droite, dans notre exemple x = valeur de y.
2) le bloc correspondant au corps de la fonction f est excut.
3) lexpression dfinie par le mot clef return est value, et est retourne comme rsultat de
lvaluation de lappel fonctionnel ; soit z = valeur de (. . .)
15
10.4. Passage d'arguments une fonction
Il existe trois types de passage de paramtres une fonction : le passage par valeur, par pointeur et par
rfrence. Ces passages sont dcrits ci-dessous.
10.4.1. Passage par valeur
Les arguments passs la fonction sont copis dans de nouvelles variables propres la fonction. Les
modifications des valeurs des arguments ne sont donc pas propages au niveau de la porte de la fonction
appelante.
Exemple :
void f(int x)
{
x = x + 2;
cout << "x = " << x << endl;
}

void main()
{
int val(0);
f(val);
cout << "val = " << val << endl;
}
Rsultat lexcution :



10.4.2. Passage par pointeur
Dans le cas o l'on souhaite modifier dans la fonction une variable passe en paramtre, il est ncessaire
d'utiliser en C++ soit un passage par pointeur soit un passage par rfrence. Dans le cas du passage par
pointeur, les variables passes en arguments de la fonction correspondent des adresses de variables
(pointeur ou &variable). Voici la syntaxe du passage par pointeur :
Prototype d'une fonction :
void passagePointeur (int *);
Dfinition d'une fonction :
void passagePointeur (int * ptr)
{
...
}
Lors de l'appel de fonction, il faut ladresse de la variable quon veut passer la fonction. Pour ceci, il
suffit de placer le signe & devant la variable.
int a = 5; // Initialisation d'une variable a, de valeur 5
passageValeur ( a ); // Appel d'une fonction par valeur
passagePointeur ( &a ); / Appel d'une fonction par pointeur
Exemple :

void f(int* x)
{
*x = *x + 2;
cout << "x = " << *x << endl;
}

void main()
{
int val(0);
f(& val);
cout << "val = " << val << endl;
}
Rsultat lexcution :




x = 2
val = 0
x = 2
val = 2
16
10.4.3. Passage par rfrence
Passer un paramtre par rfrence a les mmes avantages que le passage d'un paramtre par pointeur.
Celui-ci est galement modifiable. La diffrence est que l'oprateur de drfrencement n'est pas utilis, car
il s'agit dj d'une rfrence.
Le passage de paramtre par rfrence utilise une syntaxe similaire au passage par pointeur dans la
dclaration de la fonction, en utilisant & au lieu de *.
Prototype d'une fonction :
void passageReference (int &);
Exemple :
void f(int& x)
{
x = x + 2;
cout << "x = " << x << endl;
}

void main()
{
int val(0);
f(val);
cout << "val = " << val << endl;
}

Rsultat lexcution :




10.4.4. Passage par rfrence constante
Les avantages lis au passage par rfrence sont que cet appel ncessite moins de charge de travail pour
la machine, de mme si largument qui est transmis la fonction exige un grand espace de stockage (une
image par exemple de 1 Mo) le passage par rfrence empche la duplication de ces donnes.
Linconvnient majeur et que les objets passs en rfrence peuvent tre accidentellement modifi dans
lappel de la fonction. La solution et de pass ces paramtres en lecture seule ceci est ralis en ajoutant le
mot-cl const devant le type des paramtres quon veut prserver du changement.
Exemple :
void passageReference (const int & ref)
{
ref = 9; // <- maintenant interdit
}
Remarque : se rsonnement est applicable au passage par pointeur constant.
10.5. Surcharge (Surdfinition) de fonction
C++ permet dutiliser le mme nom pour diffrentes fonctions. Tant quelles possdent des listes
diffrentes de type darguments. Pour tre diffrencies par le compilateur, les fonctions doivent se
distinguer par le nombre ou par le type des paramtres.

int max (int a, int b)
{ return (a > b ? a : b ) }

double max (double a, double b)
{ return (a > b ? a : b ) }

Int max (int a, int b, int c)
{ int m = (a > b ? a : b );
return (m > c ? m : c ) }

main ()
{
double d1, d2;
d1 = max (d1, d2);

int i1, i2, i3
i1 = max (i1, i2, i3);

int i = 1, j = 3;
i = max (i, j);
}

x = 2
val = 2
17
10.6. Les fonctions inline
Un appel de fonction requiert des mcanismes dappel, de passage de paramtres, dallocation de
mmoire et de retour dans le programme principal qui ncessite un temps important. Dans certain cas (tel
que des fonctions au nombre dinstruction rduit) il vaut mieux viter tout cela en spcifiant la fonction
inline.
Exemple :
inline int max(int a, int b)
{
if (a < b) return b;
else return a;
}
Lors de lappel de cette fonction le compilateur remplace lexpression [z = max(x, y)] dans le programme
principal par :
if (x < y) z = j; else z = x+y;
Lutilisation de ce spcificateur (inline) peut provoquer des effets indsirable, il faut vrifier les cas ou il
ne faut pas lutilis.
10.7. Les fonctions rcursives
Une fonction est dite rcursive lorsquelle sappelle elle-mme, ce qui est parfaitement autoris :
void fonc1(void)
{
fonc1 ();
}
En pratique, une fonction rcursive aura toujours au moins une instruction conditionnelle if ou switch,
afin que dans certains cas au moins, il ny ait pas dappel rcursif.
Un exemple traditionnel de fonction rcursive est la fonction factorielle. Cette fonction calcule la
factorielle dun entier n, cest--dire le produit de tous les nombres de 1 n. Comme visiblement la
factorielle de n est n fois la factorielle de n-1, il est tentant dcrire :

double fact(int n)
{
if (n > 1) return n*fact(n-1);
else return 1;
}