Cours C++ Fonctions Surcharge d’opérateurs Passage d’arguments Surcharge de sélection Surcharge d’opérateurs Françoise Lefebvre, IPN, SII

Fonctions : passage d’arguments (1) 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 valeur void fct(int a) // Copie de a { a = 4; // a vaut 4 } // Appel int b(3); fct(b); // b vaut 3 Par adresse void fct(int *pa) { *pa = 4; // *pa vaut 4 } // Appel int b = 3; fct(&b); // b vaut 4 Par référence void fct(int& a) // Pas de copie de a { a = 4; // a vaut 4 } // Appel int b = 3; fct(b); // b vaut 4

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 fonction Ex : 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 fonction de rappeler la valeur par défaut en commentaires Ex : si la variable y n’est pas utilisée dans la fonction void Figure::Transforme(int x, int, int angle/* = 0*/);

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); }; 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; int main() { Vecteur v1(3, 5), v2(6, 7); v1. Deplace(8, 9); v1. Deplace(v2); v1. Deplace(10); // Impossible return 0; }

Surcharge d’opérateurs Permet de redéfinir les opérateurs pour un objet quelconque Si D est un opérateur unaire, Dn peut s’interpréter comme n.operator D() Ex : n++ s’interprète comme n.operator++() Si D est un opérateur binaire, n D m peut s’interpréter comme n.operator D(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 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

Surcharge d’opérateurs : exemple complex.h 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; }; complex.cpp 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 main.cpp 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; }