Simulation Numérique

Transcription

1 Ecole Nationale de Techniques Avancées Simulation Numérique Chapitre 4 Surcharge des opérateurs Eric Lunéville Surcharge des opérateurs Le C++ utilise des opérateurs prédéfinis tels que + - * / sur les types primaires (int, float) Il autorise la redéfinition de la plupart de ces opérateurs sur des objets définis par l'utilisateur. On parle de surcharge des opérateurs Redéfinition liée à la classe, implémentée par l'utilisateur Le mécanisme de compilation (analyse syntaxique) recherche s'il y a des implémentations correspondantes Dans le contexte du calcul scientifique, leur utilisation augmente la lisibilité des codes : int main() {matrice A,B,C; matrice D=plus(A,B);D=plus(D,C); int main() {matrice A,B,C; matrice D=A+B+C; développement de la classe plus complexe et plus rigoureux! Sim. Numérique chapitre 4-1

2 Plan Syntaxe de la surcharge d'opérateur Surcharge interne et externe Modèle de programmation Principaux opérateurs Opérateur = et opérateur de conversion Opérateurs de flux Exemples Résumé Sim. Numérique chapitre 4-2 Syntaxe de la surcharge On utilise le mot réservé operator : arg_retour operator nom_operateur (args_entrée) nombre d'arguments d'entrée lié au type d'opérateur (unaire, binaire) argument de sortie dépend des objectifs fixés Exemple : multiplication d'un point par un réel int dim; double pcor; POINT(int d, double v=0); POINT(const POINT & P); POINT operator (double d); ; POINT POINT::operator (double d) {POINT Q(dim); for(int i=0;i<dim;i++) Q.pCor[i]=pCor[i] d; return Q; int main() {POINT P(3,1); POINT Q=P 2.; ; sémantiquement : P*2. P.(operator *)(2.) opérateur unaire 2*P n est pas possible! (op binaire) Sim. Numérique chapitre 4-3

3 Surcharge externe Déclaration dans une classe : surcharge interne ne fonctionne pas pour l'opération : double * POINT Déclaration à l extérieur d une classe : surcharge externe opérateur binaire (à 2 arguments) POINT operator (double d,const POINT & P) {POINT Q(dim); for(int i=0;i<dim;i++) Q.pCor[i]=P.pCor[i] d; return Q; int main() { POINT M(3,1); POINT P=M 2; POINT Q=3 M; // interne // externe Pas d'ambigüité : arguments d'entrée distincts entre les deux versions Dans l'écriture M*2 ou 3*M, 2 et 3 sont des entiers, il y a conversion automatique en double Sim. Numérique chapitre 4-4 Surcharge interne ou externe? On peut également n'utiliser que des surcharges externes POINT * double (externe) POINT operator (const POINT &P, double d) {POINT Q(dim); for(int i=0;i<dim;i++) Q.pCor[i]=P.pCor[i] d; return Q; double*point (externe) POINT operator (double d, const POINT &P) {POINT Q(dim); for(int i=0;i<dim;i++) Q.pCor[i]=P.pCor[i] d; return Q; Aucune règle absolue pour le choix externe ou interne! Une suggestion : opération externe si l'opération n'induit pas de modification des données membre de l objet en entrée meilleure visibilité plus de cohérence pcor doit être public ici Sim. Numérique chapitre 4-5

4 Surcharge interne conseillée Pour les opérateurs unaires «auto-écrasants» += -= *= /= surcharge interne (données membre modifiées) Exemple POINT *=double POINT & operator = ( double d); ; POINT & POINT::operator = (double d) {for(int i=0;i<dim;i++) pcor[i] =d; return this; On retourne une référence sur l'objet lui-même (*this), autorise : M=(P*=2) Sim. Numérique chapitre 4-6 Modèle de programmation POINT & operator = ( double d); ; *= surcharge interne POINT & POINT::operator = (double d) {for(int i=0;i<dim;i++) pcor[i] =d; return this; //double P et P double externes POINT operator (double d,const POINT & P) {return POINT(P =d); POINT operator (const POINT & P,double d) {return POINT(P =d); * surcharge externe l opérateur * appelle l opérateur *= plus robuste, une seule implémentation rmq : P*=d retourne une référence transmise au constructeur par copie Sim. Numérique chapitre 4-7

5 Quoi retourner? La plupart des opérations retourne un objet, comment le retourner : par valeur (classe), par référence (classe &), par pointeur (classe *)? Jamais par pointeur interdit l enchainement des opérations A + (B+C) objet pointeur (A+D) + (B+C) pointeur pointeur Par référence pour les opérations unaires (surcharge interne) opération sur l objet courant A+=B équivalent à A.(operator +=)(B) Par valeur pour les opérations binaires (surcharge externe) création d un nouvel objet résultat A +B C on ne doit pas retourner une référence dans ce cas! D=(A+B) + C objet référence sur un objet temporaire alloué dynamiquement, ne sera pas détruit! Sim. Numérique chapitre 4-8 Opérateurs surchargeables Principaux opérateurs + - * / % ^ & ~ = += -= *= /= %= ^= &= = ++ --! ==!= < > <= >= && << >> () [] * Opérateurs unaires ou binaires suivant les cas new et delete sont également surchargeables Sim. Numérique chapitre 4-9

6 Surcharge rationnelle Utiliser le sens usuel des opérateurs Eviter des surcharges fantaisistes //division de 2 points!!! POINT operator/( const POINT &,const POINT &); Eviter toutes confusions possibles, par exemple : Opérateur d accès à un élément d un tableau ou vecteur : operator ( )(int i ) : i=1 à n, notation mathématique operator [ ](int i ) : i=0 à n-1, notation informatique class vect double val; //tableau de valeurs double & operator()(int i) {return val[i+1]; double & operator[](int i) {return val[i]; Sim. Numérique chapitre 4-10 Opérateur = L opérateur = est défini par défaut pour tout type : recopie des données membre pour une classe Si la construction induit des op. d allocation dynamique il est impératif de le surcharger (idem constructeur par copie) Exemple : int dim; double pcor; POINT(int d, double v=0); POINT(const POINT & P); POINT& operator = (const POINT &); ; POINT& POINT:: operator=( const POINT &P) {if(this==&p) return this; //P=P if(dim!=p.dim) //réallocation {delete [] pcor; pcor=new double[p.dim]; dim=p.dim; for(int i=0;i<dim;i++) pcor[i]=p.pcor[i ]; return this; Sim. Numérique chapitre 4-11

7 Opérateur de conversion Cas particulier de l «opérateur» de conversion/transtypage Syntaxe générale : operator type_sortie () (type_entrée) Exemple : operator POINT()(const vect & V); vect V(3,1.); POINT P=POINT(V); Pas d argument de retour, s apparente à un constructeur Est utilisé implicitement par le compilateur s'il y a un transtypage par exemple : fonction attendant un POINT et recevant un vect Attention d'une utilisation délicate, augmente les ambiguïtés; Il est plus simple d'utiliser un constructeur de la classe POINT : POINT(const vect &); Sim. Numérique chapitre 4-12 Opérateurs de flux Flux (stream) : canal par lequel transitent des informations succeptibles d être transformées traitement Opérations basiques : ouvrir (open) un flux fermer (close) un flux envoyer une information : opérateur << extraire une information : opérateur >> flux.open(); flux.close(); flux << information flux >> information Flux standards : std::cout : flux d écriture (écran) classe ostream std::cin : flux de lecture (clavier) classe istream Flux de fichiers : classes ofstream, ifstream et fstream Sim. Numérique chapitre 4-13

8 Opérateurs de flux Surcharge des opérateurs << et >> pour un flux d écriture ou de lecture {; ostream & operator <<(ostream &out, const POINT &P) {out<< Point : ; for(int i=0;i<p.dim;i++) out<<p(i)<< ; out<<endl; return out; istream & operator >>(istream &in,const POINT &P) {for(int i=0;i<p.dim;i++) in>>p(i); return in; flux non const en entrée on retourne le flux (référence!) Sim. Numérique chapitre 4-14 Flux : insertion dans une liste Insertion dans une liste de points à l aide de << class liste POINT POINT liste ; //tableau de pointeurs unsigned int nb points; //nb de points liste POINT(unsigned int l=10); //constructeur liste POINT(); //destructeur void allonge(); //augmente la taille du tableau de 10 POINT & operator(const int &); //acces au i eme point add(const POINT &); //ajout d un point ; liste POINT & operator <<(liste POINT &L,const POINT &P) {L.add(P);return L; POINT P(3,1); liste POINT liste (); liste<<p; Sim. Numérique chapitre 4-15

9 Exemple "complet" de surcharge Surcharge des opérateurs de la classe POINT double& operator()(int i ); POINT & operator = (const POINT &); POINT & operator += (const POINT &); POINT & operator = (const POINT &); POINT & operator = (const double &); POINT & operator /= ( const double &); bool operator==(const POINT &); bool operator!=(const POINT &); ; POINT operator+( const POINT &); POINT operator (const POINT &); POINT operator+(const POINT &,const POINT &); POINT operator (const POINT &,const POINT &); POINT operator (const POINT &,const double &); POINT operator/(const POINT &,const double &); POINT operator ( const double &, const POINT &); POINT operator/( const double &, const POINT &); + et (opposé) unaire (+ pour la compatibilité) ostream & operator <<(ostream &,const POINT &); istream & operator >>(istream &,const POINT &); Sim. Numérique chapitre 4-16 Surcharge externe et données privées Un opérateur défini en surcharge externe ne peut pas accéder aux données privées de la classe! utiliser l attribut friend pour qu il y ait accès : {private int dim; double pcor; public friend ostream& operator <<(ostream&, const POINT &); ; ostream & operator<<(ostream & out,const POINT & P) {for(int i=0;i<p.dim;i++) out<<p.pcor[i]<<<< ; return out; Sim. Numérique chapitre 4-17

10 Un exemple plus complexe Supposons que l'on dispose d'une classe de matrices (matrice) On souhaite faire une combinaison linéaire de plusieurs grosses matrices. Calcul de M=2*A+4*D-5*C : T1=5*C, T2=4*D, T3=T1-T2, T4=2*A et enfin T5=T4+T3 soit 5 générations de matrices temporaires avec recopie! Solution : utiliser une classe intermédiaire (combinaison) décrivant la combinaison linéaire et n'effectuer le calcul qu'au moment du = : 5*C C1, 4*D C2, C3=C1-C2, 2*A C4 C4+C3 M une seule recopie finale! Sim. Numérique chapitre 4-18 Un exemple plus complexe class matrice{; // classe matrice class combinaison // pointeurs matrice et coeffs int nb matrice; matrice liste matrice ; double liste coefficients ; combinaison operator (double,const matrice&); combinaison operator (const matrice&,double); combinaison operator+(const matrice&,const matrice&); combinaison operator (const matrice&,const matrice&); combinaison& operator+(const matrice&,combinaison&); combinaison& operator+(combinaison&,const matrice&); combinaison& operator (const matrice&,combinaison&); combinaison& operator (combinaison&,const matrice&); combinaison& operator+(combinaison&, const combinaison& ); combinaison& operator (combinaison&, const combinaison& ); combinaison& operator (combinaison&,double); combinaison& operator (double,combinaison&); matrice matrice::operator=(const combinaison&); Sim. Numérique chapitre 4-19

11 Résumé Ne jamais surcharger un opérateur avec un autre sens que le sens commun Limiter le nombre d'implémentations pour des opérations similaires (+ et +=) ne pas renvoyer de pointeurs, résultat inutilisable dans une autre opération renvoyer des références pour des opérateurs en surcharge interne pour une classe personnelle ne surcharger que l'essentiel pour une classe générale, prévoir toutes les surcharges possibles (complétude) la surcharge des opérateurs n'est pas obligatoire elle apporte un confort et augmente la lisibilité pour l utilisateur Sim. Numérique chapitre 4-20