Surcharge des opérateurs

1.Attributs et méthodes statiques:

Les différents objets issus d’une même classe possèdent chacun leurs propres données
membres. Une façon de permettre à plusieurs objets de partager des données consiste à les
déclarer avec le qualificatif static

Un attribut statique est partagé par toutes les instances de la même classe (on parle
aussi d’« attribut de classe »)
 C’est un attribut de la classe qui peut être privé, protégé ou public et dont la
déclaration est précédée du mot clé static
 Il existe même lorsqu’aucune instance de la classe n’est déclarée
Un attribut statique doit être initialisé explicitement à l’extérieur de la classe

int Rectangle::compteur = 0;
Similairement, si on ajoute static à une méthode : on peut accéder aussi à la méthode sans
objet, à partir du nom de la classe et de l’opérateur de résolution de portée « :: »

class A {
public:
static void methode1() { cout << "Méthode 1" << endl; }
void methode2() { cout << "Méthode 2" << endl; }
};
int main () {
A::methode1(); // OK
A::methode2(); // ERREUR
A x;
x.methode1(); // OK
x.methode2(); // OK
}

2.Surcharge d'operateurs :

C++ fournit une fonctionnalité extrêmement utile pour les applications: la possibilité
donner un sens aux opérateurs du langage (tels +, *, /, ...) appliqués à des types quelconques.
Cette fonctionnalité est habituellement appelée: surcharge des opérateurs
Elle correspond de fait aux surcharges de fonctions ou de méthodes, mais réalisée sur
les fonctions et méthodes qui implémentent le fonctionnement de ces opérateurs. On peut en
particulier donner un sens à des opérateurs appliqués aux instances d’une classe:

// Sans surcharger l’operateur // En surchargeant l’operateur +

+ int
int main( void )
main( void ) {
{ Matrix A, B, C;
Matrix A, B, C; C = A + B;
C = A.addition(B); }
}

1
  Presque tous les opérateurs sont surchargeables (sauf, parmi ceux que vous
connaissez, :: et .)
 La surcharge des opérateurs peut être réalisée soit à l’intérieur, soit à l’extérieur de la
classe à laquelle ils s’appliquent.
 Les opérateurs externes sont des fonctions ; les opérateurs internes sont des méthodes.

2.1.Surcharge interne des opérateurs:

Pour surcharger un opérateur Op dans une classe NomClasse, il faut ajouter la

méthode operatorOp dans la classe en question :
class NomClasse {
...
// prototype de l’opérateur Op
type_retour operatorOp(type_parametre);
...
};
// définition de l’opérateur Op
type_retour NomClasse::operatorOp(type_parametre)
{
...
}
Rappel : les méthodes ne doivent pas recevoir l’instance courante en paramètre

2.2.la surcharge externe:

La surcharge externe est nécessaire pour des opérateurs concernés par une
classe, mais pour lesquels la classe en question n’est pas l’opérande de gauche.

2.3.la surcharge avec une fonction amie:

Parfois, il peut être nécessaire d’autoriser les opérateurs externes d’accéder à certains
éléments private. (mais préférez passer par les accesseurs !)
Dans ce cas, ajoutez, dans la définition de la classe, leur prototype précédé du mot clé
friend :
Le mot clé friend signifie que ces fonctions, bien que ne faisant pas partie de la classe,
peuvent avoir accès aux attributs et méthodes private de la classe.
Remarque : les définitions restent hors de la classe (et sans le mot clé friend)

2
Exemple Surcharge d’opérateur avec une fonction membre :

3
Exemple : Surcharge d’opérateur avec une fonction amie

4
#include<iostream>
using namespace std;
class point{
float x, y;
public:
friend istream &operator>>(istream &, point &);
friend ostream &operator<<(ostream &, point &);
void definir(float,float);
};

istream &operator>>(istream &is, point &p){

cout<<"Donnez l'abscisse puis l'ordonnée du point:";
return is>>p.x>>p.y;
}

ostream &operator<<(ostream &os,point &p){

return os<<"("<<p.x<< ";" <<p.y<<")";
}

main()
{
point po;
cin>>po;
cout << "Point: "<<po<< endl;
system("pause");
}