C++ : fonctions et opérateurs Passage d'arguments Surcharge Surcharge d'opérateurs

Fonction : passage d'argument Par référence (propre au C++) void fct(int& a) // Pas de copie de a { a = 4; // a vaut 4 } // Appel de la fonction int b = 3; fct(b); // b vaut 4 Les arguments peuvent être passés à une fonction sous trois formes : Par valeur : ne permet pas de modifier la variable car la fonction travaille sur une copie de la variable d'origine et non sur la variable elle-même ; à éviter absolument avec un type complexe comme une classe car faire une copie de classe n'est pas anodin Par adresse : permet de pallier la limite du passage par valeur mais lourd d'un point de vue syntaxique Par référence : permet de pallier la limite du passage par valeur sans la lourdeur syntaxique ; pour plus de clarté, on rajoute le mot clé "const "si la variable n'est pas modifiée dans la fonction (utile pour les classes) Par adresse void fct(int *pa) // Adresse *pa = 4; // *pa vaut 4 fct(&b); Par valeur void fct(int a) // Copie de a // b vaut toujours 3

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(const Vecteur& v); }; Vecteur::deplace(int x, int y) { m_x += x; m_y += y; } Vecteur::deplace(const 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); return 0; }

Surcharge d’opérateurs Permet de redéfinir les opérateurs pour toute classe 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 ) Cas particulier : le compilateur génère un opérateur d’affectation ("=") par défaut ; il est souvent nécessaire de le redéfinir La plupart des opérateurs peuvent être redéfinis pour n’importe quelle classe

Surcharge d’opérateurs : exemple vecteur.h 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;} bool operator==(const Vecteur & v); Vecteur & operator=(const Vecteur & v); Vecteur & operator+(const Vecteur & v); friend std::ostream& operator<<(std::ostream& os, const Vecteur& v); }; vecteur.cpp #include "vecteur.h" bool Vecteur ::operator==(const Vecteur & v) { return (m_x == v. m_x && m_y == v. m_y); } Vecteur & Vecteur ::operator=(const Vecteur & v) m_x = v. m_x ; m_y = v. m_y ; return *this; // this contient l’adresse de l’objet lui-même Vecteur Vecteur::operator+(const Vecteur & v) Vecteur vv(m_x + z.m_x, m_y + z.m_y); return vv; // Attention, syntaxe particulière pour << et >> std::ostream& operator<< (std::ostream& os, Vecteur& v) os << « Abscisse " << v.m_x << "\n"; os << « Ordonnée " << v.m_y << "\n"; return os; main.cpp int main() { Vecteur v1(3, 5), v2(6, 8), v3, v4; v3 = v1 + v2; // Opérateur = et opérateur + v4 = v3; // Opérateur = if (v3 == v4) // Opérateur = = std::cout << « Vecteurs identiques ; c’est normal !\n "; std::cout << v4; // Affichage à l'écran ofstream f(« fichier.txt »); f << v4; // Affichage dans un fichier texte f.close(); return 0; }

Surcharge d’opérateurs Opérateurs pouvant être redéfinis + - * / % = ! += -= *= /= %= ++ -- < > <= >= == != && || & | ^ << >> [] new delete