Programmation en C++ les opérateurs 

Les opérateurs 

fonctions globales ou méthodes d’une classe Il est possible de surcharger la plupart des opérateurs. Cela signifie qu’on va pouvoir décrire quels traitements les opérateurs doivent réaliser. C’est notamment le cas pour l’opérateur = permettant l’affectation entre objets d’une même classe (voir section précédente). Cette surcharge n’est toutefois possible que sur les types créés par le programmeur : il n’est pas possible de redéfinir les opérateurs agissant sur les types élémentaires tels que int, float, etc.

La pluralité des opérateurs du C++
Selon le nombre d’opérandes dont l’opérateur a besoin, l’opérateur sera qualifié d’opérateur unaire (1 seul opérande) ou d’opérateur binaire (2 opérandes). Par exemple, l’opérateur « = » est un opérateur binaire, la syntaxe d’utilisation de cet opérateur étant Op1 = Op2. L’ opérateur « ++ » en revanche est un opérateur unaire. En effet, il s’applique à un seul opérande : Op1++.
Remarque : il y a en fait deux opérateurs « ++ ». Celui qui pré-incrémente et qui s’utilise ++Op1 et celui qui post-incrémente et qui s’utilise Op1++. Idem pour les opérateurs de décrément «–» .
Enfin, de même qu’avec l’opérateur « ++ » où le même signe peut représenter deux opérateurs différents (la syntaxe d’utilisation permet au compilateur de les distinguer), certains opérateurs peuvent avoir une version unaire et une version binaire. C’est le cas par exemple de l’opérateur « – ».
#include<iostream> using namespace std; void main() { int a=4, b=5; cout << (a-b) << endl; // opérateur – binaire cout << -a; // opérateur – unaire }
La syntaxe a-b utilise l’opérateur – binaire (soustraction) tandis que –a utilise l’opérateur unaire (opposé).

Les opérateurs avec traitement par défaut
Lorsque l’on définit de nouveaux types, par exemple des types structurés, certains opérateurs réalisent un traitement par défaut. C’est le cas de l’opérateur « = » et de l’opérateur « & ».
Le traitement par défaut de l’opérateur = Lorsque l’on définit un nouveau type structuré (c’est le cas des classes), le traitement réalisé par défaut pour l’opérateur « = » est une copie membre à membre. Cette caractéristique s’appliquait déjà en langage C sur les types structurés.
Le traitement par défaut de l’opérateur & Lorsque l’on définit un nouveau type, l’opérateur & (opérateur unaire) retourne l’adresse de l’objet auquel il s’applique.

Les opérateurs que l’on peut surcharger en C++
Les différents opérateurs que l’on peut surcharger en C++ sont les suivants :
Unaire + – ++ — ! ~ * & new new[] delete (cast) Binaire * / % + – << >> < > <= >= == != Binaire & | && || Binaire += -= *= /= %= &= ^= |= <<= >>= ,
Les opérateurs membres d’une classe On verra ci-après que la définition des opérateurs passe simplement par l’écriture de fonctions ayant un nom particulier comportant le mot clé operator suivi du signe de l’opérateur. En outre, le programmeur aura le choix entre la possibilité de définir ces opérateurs comme fonctions membres d’une classe ou comme fonctions non membres. Néanmoins (le C++ est un langage truffé d’exceptions!) certains opérateurs ne peuvent être définis que s’ils appartiennent à une classe. Il s’agit alors nécessairement de méthodes d’une classe. C’est le cas pour l’opérateur = vu au chapitre précédent.