C fonctions et oprateurs Fonctions Passage darguments Surcharge

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

Fonction : passage d'argument 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 valeur Par adresse Par référence (propre au C++) void fct(int a) // Copie de a { a = 4; // a vaut 4 } void fct(int *pa) // Adresse { *pa = 4; // *pa vaut 4 } 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 toujours 3 // Appel de la fonction int b = 3; fct(&b); // b vaut 4 // Appel de la fonction int b = 3; fct(b); // b vaut 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(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 v 1(3, 5), v 2(6, 7); v 1. Deplace(8, 9); v 1. Deplace(v 2); return 0; } 3

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

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); friend std: : ostream& operator<<(std: : ostream& os, const Vecteur& v); }; main. cpp int main() { Vecteur v 1(3, 5), v 2(6, 8), v 3, v 4; v 3 = v 1 + v 2; // Opérateur = et opérateur + v 4 = v 3; // Opérateur = if (v 3 == v 4) // Opérateur = = std: : cout << « Vecteurs identiques ; c’est normal !n "; std: : cout << v 4; ofstream f( « fichier. txt » ); f << v 4; f. close(); return 0; } // Affichage à l'écran // Affichage dans un fichier texte 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: : 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; } 5

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