Cours C++

• Fonctions– Passage d’arguments

– Surcharge de sélection

• Surcharge d’opérateurs

Françoise Lefebvre, IPN, SII

2

Fonctions : passage d’arguments (1)

• Par valeur

void fct(int a) // Copie de a

{a = 4; // a vaut 4

}

// Appelint b(3);fct(b); // b

vaut 3

• Par référence

void fct(int& a) // Pas de copie de a

{a = 4; // a vaut 4

}

// Appelint b = 3;fct(b); // b vaut

4

Les arguments peuvent être passés sous trois formes : • par valeur (identique au C) • par adresse (identique au C) • par référence (propre au C++)

•Par adresse

void fct(int *pa) {

*pa = 4; // *pa vaut 4}

// Appelint b = 3;fct(&b); // b vaut 4

3

Fonctions : passage d’arguments (2)

Une fonction membre est implantée sous la forme :

type NomClasse::nom_fonction(type1 arg1, type2 arg2, type3 arg3)

•Valeurs par défaut : il est possible de définir une valeur par défaut pour les n derniers arguments dans le prototype de la fonctionEx :

class Figure{… void Transforme(int x, int y, int angle = 0);…};

int main(){ Figure f; f.Transforme(3, 4, 30); f.Transforme(5, 6);}

•Dans l’implantation de la classe, il est conseillé d’omettre le nom de la variable si elle n’est pas utilisée dans la fonctionde rappeler la valeur par défaut en commentaires

Ex : si la variable y n’est pas utilisée dans la fonctionvoid Figure::Transforme(int x, int, int angle/* = 0*/);

4

Fonction : surcharge de sélection

La surcharge de sélection consiste à implanter plusieurs méthodes de même nom dans une même classe à condition que la liste des arguments diffère

class Vecteur{protected:

int m_x, m_y;public :

Vecteur() {m_x = m_y = 0;}Vecteur(int x, int y) {m_x = x; m_y = y;}void Deplace(int x, int y);void Deplace(Vecteur v);

};

int main(){

Vecteur v1(3, 5), v2(6, 7);v1. Deplace(8, 9);v1. Deplace(v2);v1. Deplace(10); // Impossiblereturn 0;

}

Vecteur::Deplace(int x, int y){

m_x += x;m_y += y;

}Vecteur:: Deplace(Vecteur v){

m_x += v.m_x;m_y + = v.m_y;

}

5

Surcharge d’opérateurs

Permet de redéfinir les opérateurs pour un objet quelconque

Opérateurs pouvant être redéfinis

+ - * / % = !

+= -= *= /= %= ++ --

< > <= >= == != && ||

& | ^ << >>

[] new delete

Cas particulier : le compilateur génère un opérateur d’affectation par défaut ; il est souvent nécessaire de le redéfinir

Si est un opérateur unaire, n peut s’interpréter comme n.operator ()Ex : n++ s’interprète comme n.operator++()

Si est un opérateur binaire, n m peut s’interpréter comme n.operator (m)Ex : n + m s’interprète comme n.operator+(m)

En C++, la plupart des opérateurs peuvent être redéfinis pour n’importe quelle classe

6

Surcharge d’opérateurs : exemple

Complex Complex::operator+(const Complex& z){

Complex zz(m_re + z.m_re, m_im + z.m_im);return zz;

}bool Complex ::operator==(const Complex & c){

return (m_re == c. m_re && m_im == c. m_im);}Complex & Complex ::operator=(const Complex & c){

m_re = c. m_re ;m_im = c. m_im ;return *this; // this contient l’adresse de l’objet lui-même

}

class Complex{public :

Complex(double re = 0.0, double im = 0.0) {m_re = re; m_im = im;}

Complex operator+(const Complex& z);bool operator==(const Complex & c);Complex & operator=(const Complex & c);

protected:double m_re;double m_im;

};

int main(){ Complex z1(3, 5); Complex z2(6, 8); Complex z3, z4; z3 = z1 + z2; // Opérateur = et opérateur + z4 = z3; // Opérateur = if (z3 == z4) // Opérateur = = std::cout << « Complexes identiques ; c’est normal !\n ";

return 0;}

complex.h

main.cpp

complex.cpp