Vous êtes sur la page 1sur 20

Dr. Imen Boudali imen.boudali@gmail.

com 2012-2013

C++ autorise le non-respect des types des arguments dune fonction, lors dun appel cette fonction.

Le compilateur exerce implicitement des conversions de types.

#include <iostream.h> float puissance (float v, int n) { float res = 1 ; for (int =1 ; i<=n ; i++ ) res= res*v ; return (res) ; } void main() { int a = 5, b=6 ; float r, x = 2.34 ; r = puissance (x, a) ; /*pas de

conversion (2.34)5 */ r = puissance (b, a) ;/*b est converti en float (6.0)5 */ r = puissance (b, x) ;/*x est converti en int (6.0)2 */ b = puissance (1.5, 2) ; /*le rsultat est converti en int //pour tre stock dans b */ r = puissance (Bonjour, c) ; //Erreur }

En C++, on peut attribuer des valeurs par dfaut aux paramtres dune fonction. Quand on appelle la fonction sans passer un paramtre effectif, la valeur par dfaut sera considre, sinon elle sera ignore.

#include <iostream.h> float puissance (float v, int n = 2) { .... } void main() { int a = 5; float r, x = 2.34 ; r = puissance (x, a) ;//(2.34)5 r = puissance (x) ;// (2.34)2 r = puissance () ;/*Erreur : le paramtre v est obligatoire */ }

Remarque: Les paramtres ayant des valeurs par dfaut doivent tre mentionns la fin de la liste des paramtres aprs les paramtres obligatoires.

void f (char c = a, int n) ; //Faux void f (int n, char c = a) ; //correcte

En C++, il est possible de dfinir plusieurs fonctions qui portent le mme nom. Le compilateur peut diffrencier deux fonctions en regardant le type et/ou le nombre des paramtres quelles reoivent. Le type du rsultat de la fonction ne permet pas de lidentifier En cas dambigut dappel => Erreur

void test (int n=10, float x=3.7) { cout<< function 1; .... } void test (float x = 2.5, int n=1) { cout<< function 2; ..... }

void main() { int a = 4; float r = 9.8 ; test (a, r); //fonction1 test(r,a); //fonction2 test(a); //fonction1 test(r); //fonction2 test(); //Erreur test(a,a); //Erreur test(r,r); //Erreur }

Dans tout programme C++, on distingue:


Variables globales Variables locales: - automatiques - statiques

Variables globales : - Cres et initialises au dbut du programme ; - Accessibles dans tout le programme ; - Dtruites la fin du programme ; Variables locales automatiques : - Cres et initialises chaque appel de la fonction - Accessibles seulement lintrieur de la fonction - Dtruites la fin de la fonction Variables locales statiques : - Cres et initialises lors du 1er appel de la fonction - Accessibles seulement lintrieur de la fonction - Dtruites la fin du programme

int g = 10 ; void incrementation() { int a =20 ; static int s = 30 ; g ++; a ++; s ++; } void main() { incrementation () ; incrementation () ; g ++ ; a ++ ; //erreur s ++ ; //erreur }

g
10 11
20 21 20 21

30 31 31 32

12
13

C++ permet de crer des rfrences c..d des synonymes didentificateurs de variable.
Faire une rfrence une variable cest lui donner un autre identificateur (synonyme ou alias).

Il est donc impossible de dclarer une rfrence sans linitialiser.

La dclaration dune rfrence ne cre pas un nouvel objet. Les rfrences se rapportent des identificateurs dj existants. Syntaxe de dclaration dune rfrence :

type & nom_rfrence = identificateur;

int i=0; int &ri=i; // Rfrence sur la variable i ri=ri+i; // Double la valeur de i (et de ri)

i ri

Remarque Il est possible de faire des rfrences sur des valeurs numriques. les rfrences doivent tre dclares comme tant constantes:

const int &ri=3;// Rfrence sur une case contenant 3 int & r =4; //Erreur, la rf. nest pas dclare constante int & y = ri ;//Erreur car ri est dclar rfrence sur cste

Les mmes rgles sappliquent aussi aux pointeurs. Exemple:

int x =10 ; int y =20 ; int *ptr1 = &x ; int *& ptr2 = ptr1 ; /*ptr2 et ptr1 sont deux identificateurs dune mme case mmoire de type pointeur*/ ptr2 = &y ; (*ptr2) =30 ;

Remarques Toute tentative de modification du contenu dune constante nest pas permise, et une erreur est gnre dans ce cas. Une rfrence dclare sur une variable ou une constante peut tre ensuite dfinie pour une variable.

1.

2.

int x ; int & y = x ; //valide const int &y = x ; // valide ***************** const int z =3; int & w = z ; //erreur const int & w = z ; //valide ***************** int*x ; int* & y = x ; //valide

const int* &y = x ; // valide ***************** const int* z ; int* & w = z ; //erreur const int* & w = z ; //valide

En C++, trois types de passage de paramtres : passage par valeur : une copie du paramtre effectif est passe passage par adresse : ladresse du paramtre effectif est passe passage par rfrence : une rfrence du paramtre effectif est passe

void permuter (int& a, int& b) { int tmp = a; a = b; b = tmp; } void main( ) { int x =5, y = 6; permuter (x, y); //modification de x et y