Cours C++

1. 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) • 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 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; }