Discussion :

[white_tentacle]

Bonjour tous.

Je me pose une question existentielle très bête. Comment faire pour surcharger correctement l'opérateur &&. Par correctement, j'entends que dans l'opération a && b, b ne sera évalué que si a.

J'ai bien tenté d'écrire :

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
class A
{
public:
        int x;
        A() {
                x = 0;
                std::cout << "création A" << std::endl; };
        operator bool() { return x != 0; }
        A operator&&(const A& other) {
                if(!x)
                        return *this;
                A result;
                result.x = x && other.x;
                return result;
        };
};

mais voila, ce qui me gène c'est que :

Code :

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

1
2
3
4
5
6
 
        A a;
        a.x = 0;
        A b;
        bool c = a && A(); // ligne qui me pose un problème
        return 0;

A() est tout de même appelé, alors que si je fais :

Code :

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

1
2
3
4
5
6
 
        A a;
        a.x = 0;
        A b;
        bool c = (bool)a && A(); // ligne qui me pose problème
        return 0;

A() n'est plus appelé.

Existe-t-il un moyen d'écrire la surcharge de l'opérateur && afin de garder le comportement standard du langage (ne pas évaluer l'opérande droite s'il n'y en a pas besoin) ?

[Médinoc]

Franchement, j'en serais étonné, car je ne vois pas comment on pourrait savoir s'il faut évaluer l'argument de droite avant d'appeler la fonction operator&&(), et si on appelle la fonction operator&&(), il faudra forcément évaluer les deux arguments.

[Jean-Marc.Bourguet]

Existe-t-il un moyen d'écrire la surcharge de l'opérateur && afin de garder le comportement standard du langage (ne pas évaluer l'opérande droite s'il n'y en a pas besoin) ?

Non. C'est une des raisons qui font qu'il faut reflechir une fois de plus que d'habitude avant de surcharger && et ||.

[loufoque]

Le seul contexte où tu peux surcharger &&, c'est si ton membre de droite est une expression qui s'évalue de manière retardée.
Par exemple, Boost.Bind, Boost.Lambda et Boost.Phoenix le surchargent.

[white_tentacle]

Le seul contexte où tu peux surcharger &&, c'est si ton membre de droite est une expression qui s'évalue de manière retardée.
Par exemple, Boost.Bind, Boost.Lambda et Boost.Phoenix le surchargent.

Je n'avais pas pensé à ce cas. Je comprends donc mieux pourquoi c'est autorisé, et comment le faire correctement. Merci !

quoique, je chipote mais ça me semble limite, même avec une expression retardée, puisque l'évaluation d'éventuelles sous-expressions aura quand même lieu, ce qui n'est pas le cas avec &&, non ?

[Luc Hermitte]

La sous-expression utilisera l'opérateur non surchargé.

Il y a 3 ans, j'avais posté ici un exemple de ce genre pour écrire du pseudo SQL en C++ (Alp, tu ne cherchais pas un MSEL ?)