Cours C Fonctions Passage darguments Surcharge de slection

Cours C++ • Fonctions – 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 adresse Par valeur void fct(int a) { a = 4; } // Copie de a // a vaut 4 void fct(int *pa) { *pa = 4; } • // *pa vaut 4 Par référence void fct(int& a) { a = 4; } // Appel int b(3); fct(b); int b = 3; fct(&b); int b = 3; fct(b); // b vaut 3 // b vaut 4 // Pas de copie de a // a vaut 4 // b vaut 4

Fonctions : passage d’arguments (2) Une fonction membre est implantée sous la forme : type Nom. Classe: : nom_fonction(type 1 arg 1, type 2 arg 2, type 3 arg 3) • 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 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 v 1(3, 5), v 2(6, 7); v 1. Deplace(8, 9); v 1. Deplace(v 2); v 1. 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; }; main. cpp int main() { Complex z 1(3, 5); Complex z 2(6, 8); Complex z 3, z 4; z 3 = z 1 + z 2; // Opérateur = et opérateur + z 4 = z 3; // Opérateur = if (z 3 == z 4) // Opérateur = = std: : cout << « Complexes identiques ; c’est normal !n "; return 0; } complex. cpp 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 }