Cours C++ Fonctions Surcharge d’opérateurs Passage d’arguments

Présentation au sujet: "Cours C++ Fonctions Surcharge d’opérateurs Passage d’arguments"— Transcription de la présentation:

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

2 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

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 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*/);

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); }; 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; }

5 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

6 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; }