Discussion :

[ggarcia]

Bonjour,

J'ai lu la FAQ sur les opérateurs et leur surcharge, qui m'a permis de comprendre en quoi la fonction libre à deux paramètres est préférable à la fonction membre à un paramètre utilisant this.

Par contre, je ne comprends pas ce qui fait que la fonction à deux paramètres ne peut pas être membre de la classe...

Quelqu'un peut-il m'éclairer ?

Merci.

PS: Je suis un honnête programmeur en C, mais je débute en C++...

[Obsidian]

Bonjour,

Par contre, je ne comprends pas ce qui fait que la fonction à deux paramètres ne peut pas être membre de la classe...

Parce que cela n'aurait pas de sens. Lorsque tu écris a + b, soit l'opérateur « + » est extérieur aux deux opérandes et, dans ce cas, il faut bien deux paramètres pour passer a et b en même temps, soit tu considères qu'il s'agit d'une extension de a et, dans ce cas, on n'a besoin de connaître que b.

C'est encore plus flagrant si tu prends le problème à l'envers : si tu considères que « + » est bien une fonction-membre de a, et que a + b est équivalent à a.operator + (b);, par quelle donnée remplacerais-tu les points d'interrogation dans la définition à deux paramètres suivante : a.operator + (b,???); ?

[koala01]

Salut,

Ce qu'il faut comprendre, c'est que, pour les fonctions membres, il y a un paramètre implicitement transmis : le pointeur this , qui n'est qu'en définitive que le pointeur sur la structure qui reçoit l'instruction.

Si tu essayes de créer un opérateur +(type const & un, type const & deux) sous la forme d'une fonction membre, et bien que ce ne soit pas explicitement écrit, tu te retrouves en réalité avec trois arguments, et donc avec un opérateur ressemblant à operator + (type *this, type const & un, type const & deux)Cela ne ferait, ni plus ni moins, qu'un paramètre de trop à ton opérateur, incompatible avec la définition globale de l'opérateur + qui indique qu'il faut deux opérandes

De plus, l'opérateur += a de bonne raison d'être une fonction membre, pour la simple et bonne raison qu'il a, sémantiquement parlant, la responsabilité de modifier l'opérande de gauche.

Par contre, l'opérateur + peut s'appliquer avec des types pour lesquels il existe un processus de conversion implicite, sur le deuxième opérande, bien sur, mais aussi sur le premier.

Tu peux, en effet, envisager, pour une type Type présentant un comportement de conversion implicite avec un entier, d'avoir un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
Type first;
/*...*/
Type result = first +4;

mais rien ne t'empêche non plus d'envisager un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Type second;
Type result = 4 + second;

voire même un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Type result = 5 + 9;

Le seul moyen d'autoriser facilement ces différentes écritures est... de passer par une fonction libre (éventuellement amie )

[ggarcia]

Bonjour,

Chacun à sa façon, les contributeurs m'ont permis de mieux comprendre, je crois, le problème:

- En tant que méthode de la classe (fonction membre), opérateur+ doit pouvoir s'appliquer à un objet et a+b se comprendrait comme a.opérateur+(b). Avec la dissymétrie évoquée dans la FAQ, qui fait préférer:

- MaClasse opérateur+(MaClasse a, MaClasse b) (ou plutot avec des références constantes), qui est symétrique. Mais si c'était une fonction membre, il y aurait un paramètre de trop, "this" qui est implicite. Ici, pour implanter opérateur+ je vais devoir accéder aux attributs de la classe et donc faire de opérateur+ une fonction amie de MaClasse.

Merci aux contributeurs. Je n'y suis peut-être pas encore, mais j'ai l'impression que je comprends mieux.

GG

[koala01]

Il faut noter que, si tu définis l'opérateur +, il est souvent aussi intéressant d'implémenter l'opérateur += comme fonction membre, et que, pour respecter le principe du DRY (Don't Repeat Yourself), l'opérateur + peut utiliser l'opérateur += (et n'a alors même pas besoin d'être déclaré comme fonction amie )...

Cela donnerait quelque chose comme

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyClass
{
    public: 
        /* ... */
        MyClass & operator +=(MyClass const & other)
        {
            /* logique à appliquer pour l'addition */
            return *this; 
        }
};
 
MyClass operator +(MyClass const & first, MyClass const & second)
{
    MyClass copy(first); // utilise le constructeur par copie, automatiquement
                         // généré par le compilateur, sauf instruction contraire
    return copy += second;
}