Y a-t-il réellement une raison pour laquelle surchargé && et || ne court-circuitez pas?

Le comportement de court-circuit des opérateurs &&et ||est un outil étonnant pour les programmeurs.

Mais pourquoi perdent-ils ce comportement lorsqu'ils sont surchargés? Je comprends que les opérateurs ne sont que du sucre syntaxique pour les fonctions, mais les opérateurs pour boolont ce comportement, pourquoi devrait-il être limité à ce type unique? Y a-t-il un raisonnement technique derrière cela?

Tous les processus de conception aboutissent à des compromis entre des objectifs incompatibles entre eux. Malheureusement, le processus de conception de l' &&opérateur surchargé en C ++ a produit un résultat final déroutant: la fonctionnalité même que vous attendez &&- son comportement de court-circuit - est omise.

Les détails de la façon dont ce processus de conception s'est terminé dans cet endroit malheureux, ceux que je ne connais pas. Il est cependant pertinent de voir comment un processus de conception ultérieur a pris en compte ce résultat désagréable. En C #, le surcharge &&opérateur est court - circuit. Comment les concepteurs de C # ont-ils réalisé cela?

Une des autres réponses suggère le "levage lambda". C'est:

A && B

pourrait être réalisé comme quelque chose d'équivalent moral à:

operator_&& ( A, ()=> B )

où le deuxième argument utilise un mécanisme pour l'évaluation paresseuse de sorte que lorsqu'il est évalué, les effets secondaires et la valeur de l'expression sont produits. L'implémentation de l'opérateur surchargé ne ferait l'évaluation paresseuse que si nécessaire.

Ce n'est pas ce que l'équipe de conception C # a fait. (A part: bien que le levage lambda soit ce que j'ai fait quand est venu le temps de faire une représentation arborescente d'expression de l' ??opérateur, ce qui nécessite que certaines opérations de conversion soient effectuées paresseusement. Décrire cela en détail serait cependant une digression majeure. Autant dire: levage lambda fonctionne mais est suffisamment lourd pour que nous souhaitions l'éviter.)

Au contraire, la solution C # décompose le problème en deux problèmes distincts:

• devrions-nous évaluer l'opérande de droite?
• si la réponse à ce qui précède était "oui", alors comment combiner les deux opérandes?

Par conséquent, le problème est résolu en rendant illégale la surcharge &&directe. Au contraire, en C #, vous devez surcharger deux opérateurs, dont chacun répond à l'une de ces deux questions.

class C
{
    // Is this thing "false-ish"? If yes, we can skip computing the right
    // hand size of an &&
    public static bool operator false (C c) { whatever }

    // If we didn't skip the RHS, how do we combine them?
    public static C operator & (C left, C right) { whatever }
    ...

(À part: en fait, trois. C # exige que si l'opérateur falseest fourni, l'opérateur truedoit également être fourni, ce qui répond à la question: est-ce que cette chose est "vraie"? nécessite les deux.)

Considérez un énoncé du formulaire:

C cresult = cleft && cright;

Le compilateur génère du code pour cela comme vous pensiez avoir écrit ce pseudo-C #:

C cresult;
C tempLeft = cleft;
cresult = C.false(tempLeft) ? tempLeft : C.&(tempLeft, cright);

Comme vous pouvez le voir, le côté gauche est toujours évalué. S'il est déterminé qu'il est "faux-ish", alors c'est le résultat. Sinon, le côté droit est évalué et l' opérateur désireux défini par l'utilisateur &est appelé.

L' ||opérateur est défini de manière analogue, comme une invocation de l'opérateur true et de l' |opérateur impatient :

cresult = C.true(tempLeft) ? tempLeft : C.|(tempLeft , cright);

En définissant les quatre opérateurs - true, false, &et |- C # vous permet de dire non seulement , cleft && crightmais aussi non court-circuit cleft & cright, et aussi if (cleft) if (cright) ..., et , c ? consequence : alternativeet while(c), et ainsi de suite.

Maintenant, j'ai dit que tous les processus de conception sont le résultat de compromis. Ici, les concepteurs de langage C # ont réussi à obtenir un court-circuit &&et à ||raison, mais cela nécessite de surcharger quatre opérateurs au lieu de deux , ce que certaines personnes trouvent déroutant. La fonctionnalité d'opérateur vrai / faux est l'une des fonctionnalités les moins bien comprises de C #. L'objectif d'avoir un langage sensé et simple qui est familier aux utilisateurs de C ++ a été opposé par le désir d'avoir des courts-circuits et le désir de ne pas implémenter le levage lambda ou d'autres formes d'évaluation paresseuse. Je pense que c'était une position de compromis raisonnable, mais il est important de se rendre compte qu'il est une position de compromis. Juste un différent position de compromis sur laquelle les concepteurs de C ++ ont atterri.

Si le sujet de la conception du langage pour de tels opérateurs vous intéresse, pensez à lire ma série sur les raisons pour lesquelles C # ne définit pas ces opérateurs sur des booléens nullables:

http://ericlippert.com/2012/03/26/null-is-not-false-part-one/

Le fait est que (dans les limites de C ++ 98) l'opérande de droite serait passé à la fonction opérateur surchargée en tant qu'argument. Ce faisant, il serait déjà évalué . Il n'y a rien que le code operator||()or operator&&()puisse ou ne puisse pas faire pour éviter cela.

L'opérateur d'origine est différent, car ce n'est pas une fonction, mais implémenté à un niveau inférieur du langage.

Des fonctionnalités de langage supplémentaires auraient pu rendre syntaxiquement possible la non-évaluation de l'opérande de droite . Cependant, ils ne se sont pas dérangés car il n'y a que quelques cas où cela serait sémantiquement utile. (Tout comme ? :, qui n'est pas du tout disponible pour la surcharge.

(Il leur a fallu 16 ans pour intégrer les lambdas dans la norme ...)

Quant à l'utilisation sémantique, considérez:

objectA && objectB

Cela se résume à:

template< typename T >
ClassA.operator&&( T const & objectB )

Pensez à ce que vous aimeriez faire exactement avec objectB (de type inconnu) ici, autre que d'appeler un opérateur de conversion à bool, et comment vous le mettriez en mots pour la définition du langage.

Et si vous êtes appelez la conversion à bool, eh bien ...

objectA && obectB

fait la même chose, maintenant? Alors pourquoi la surcharge en premier lieu?

Une fonctionnalité doit être pensée, conçue, implémentée, documentée et expédiée.

Maintenant que nous y avons pensé, voyons pourquoi cela pourrait être facile maintenant (et difficile à faire alors). Gardez également à l'esprit qu'il n'y a qu'une quantité limitée de ressources, donc l'ajouter peut avoir haché autre chose (à quoi aimeriez-vous renoncer?).

En théorie, tous les opérateurs pourraient autoriser un comportement de court-circuit avec une seule fonctionnalité de langage supplémentaire "mineure" , à partir de C ++ 11 (lorsque les lambdas ont été introduits, 32 ans après le lancement de "C avec classes" en 1979, un 16 après c ++ 98):

C ++ aurait juste besoin d'un moyen d'annoter un argument comme évalué paresseux - un lambda caché - pour éviter l'évaluation jusqu'à ce que cela soit nécessaire et autorisé (pré-conditions remplies).

À quoi ressemblerait cette fonctionnalité théorique (rappelez-vous que toute nouvelle fonctionnalité devrait être largement utilisable)?

Une annotation lazy, qui s'applique à un argument de fonction, fait de la fonction un modèle attendant un foncteur, et fait que le compilateur compile l'expression dans un foncteur:

A operator&&(B b, __lazy C c) {return c;}

// And be called like
exp_b && exp_c;
// or
operator&&(exp_b, exp_c);

Il ressemblerait sous la couverture comme:

template<class Func> A operator&&(B b, Func& f) {auto&& c = f(); return c;}
// With `f` restricted to no-argument functors returning a `C`.

// And the call:
operator&&(exp_b, [&]{return exp_c;});

Veuillez noter que le lambda reste caché et sera appelé au plus une fois.
Il ne devrait y avoir aucune dégradation des performances à cause de cela, mis à part des chances réduites d'élimination de sous-expression commune.

Outre la complexité de l'implémentation et la complexité conceptuelle (chaque fonctionnalité augmente les deux, à moins qu'elle ne facilite suffisamment ces complexités pour certaines autres fonctionnalités), examinons une autre considération importante: la compatibilité descendante.

Bien que cette fonctionnalité de langage ne briserait aucun code, elle modifierait subtilement toute API en tirant parti, ce qui signifie que toute utilisation dans les bibliothèques existantes serait un changement de rupture silencieux.

BTW: Cette fonctionnalité, bien que plus facile à utiliser, est strictement plus puissante que la solution C # de fractionnement &&et ||en deux fonctions chacune pour une définition distincte.

Avec une rationalisation rétrospective, principalement parce que

• afin d'avoir un court-circuit garanti (sans introduire de nouvelle syntaxe), les opérateurs devraient être limités à résultatsle premier argument réel convertible en bool, et

• le court-circuit peut être facilement exprimé par d'autres moyens, si nécessaire.

Par exemple, si une classe Ta des opérateurs associés &&et ||, alors l'expression

auto x = a && b || c;

où a, bet csont des expressions de type T, peuvent être exprimées par court-circuit comme

auto&& and_arg = a;
auto&& and_result = (and_arg? and_arg && b : and_arg);
auto x = (and_result? and_result : and_result || c);

ou peut-être plus clairement comme

auto x = [&]() -> T_op_result
{
    auto&& and_arg = a;
    auto&& and_result = (and_arg? and_arg && b : and_arg);
    if( and_result ) { return and_result; } else { return and_result || b; }
}();

La redondance apparente préserve tous les effets secondaires des invocations d'opérateurs.

Alors que la réécriture lambda est plus verbeuse, sa meilleure encapsulation permet de définir de tels opérateurs.

Je ne suis pas tout à fait sûr de la conformité standard de tout ce qui suit (encore un peu d'influence), mais il se compile proprement avec Visual C ++ 12.0 (2013) et MinGW g ++ 4.8.2:

#include <iostream>
using namespace std;

void say( char const* s ) { cout << s; }

struct S
{
    using Op_result = S;

    bool value;
    auto is_true() const -> bool { say( "!! " ); return value; }

    friend
    auto operator&&( S const a, S const b )
        -> S
    { say( "&& " ); return a.value? b : a; }

    friend
    auto operator||( S const a, S const b )
        -> S
    { say( "|| " ); return a.value? a : b; }

    friend
    auto operator<<( ostream& stream, S const o )
        -> ostream&
    { return stream << o.value; }

};

template< class T >
auto is_true( T const& x ) -> bool { return !!x; }

template<>
auto is_true( S const& x ) -> bool { return x.is_true(); }

#define SHORTED_AND( a, b ) \
[&]() \
{ \
    auto&& and_arg = (a); \
    return (is_true( and_arg )? and_arg && (b) : and_arg); \
}()

#define SHORTED_OR( a, b ) \
[&]() \
{ \
    auto&& or_arg = (a); \
    return (is_true( or_arg )? or_arg : or_arg || (b)); \
}()

auto main()
    -> int
{
    cout << boolalpha;
    for( int a = 0; a <= 1; ++a )
    {
        for( int b = 0; b <= 1; ++b )
        {
            for( int c = 0; c <= 1; ++c )
            {
                S oa{!!a}, ob{!!b}, oc{!!c};
                cout << a << b << c << " -> ";
                auto x = SHORTED_OR( SHORTED_AND( oa, ob ), oc );
                cout << x << endl;
            }
        }
    }
}

Production:

000 -> !! !! || faux
001 -> !! !! || vrai
010 -> !! !! || faux
011 -> !! !! || vrai
100 -> !! && !! || faux
101 -> !! && !! || vrai
110 -> !! && !! vrai
111 -> !! && !! vrai

Ici, chaque !!bang-bang montre une conversion en bool, c'est- à -dire un contrôle de valeur d'argument.

Puisqu'un compilateur peut facilement faire la même chose et l'optimiser en plus, il s'agit d'une implémentation possible démontrée et toute revendication d'impossibilité doit être placée dans la même catégorie que les revendications d'impossibilité en général, à savoir généralement des conneries.

tl; dr : cela ne vaut pas la peine, en raison de la très faible demande (qui utiliserait la fonctionnalité?) par rapport à des coûts plutôt élevés (syntaxe spéciale nécessaire).

La première chose qui me vient à l'esprit est que la surcharge d'opérateurs est juste une façon sophistiquée d'écrire des fonctions, alors que la version booléenne des opérateurs ||et &&sont des trucs buitlin. Cela signifie que le compilateur a la liberté de les court-circuiter, tandis que l'expression est non x = y && zbooléenne yet zdoit conduire à un appel à une fonction comme X operator&& (Y, Z). Cela signifierait que ce y && zn'est qu'une manière sophistiquée d'écrire operator&&(y,z)qui n'est qu'un appel d'une fonction au nom étrange où les deux paramètres doivent être évalués avant d'appeler la fonction (y compris tout ce qui jugerait un court-circuit approprié).

Cependant, on pourrait soutenir qu'il devrait être possible de rendre la traduction des &&opérateurs un peu plus sophistiquée, comme c'est le cas pour l' newopérateur qui se traduit par l'appel de la fonction operator newsuivi d'un appel du constructeur.

Techniquement ce ne serait pas un problème, il faudrait définir une syntaxe de langage spécifique à la condition préalable qui permet le court-circuit. Cependant, l'utilisation de courts-circuits serait limitée aux cas où il Yest convétible de X, ou bien il devait y avoir des informations supplémentaires sur la façon de faire réellement le court-circuit (c'est-à-dire calculer le résultat à partir du seul premier paramètre). Le résultat devrait ressembler un peu à ceci:

X operator&&(Y const& y, Z const& z)
{
  if (shortcircuitCondition(y))
    return shortcircuitEvaluation(y);

  <"Syntax for an evaluation-Point for z here">

  return actualImplementation(y,z);
}

On veut rarement surcharger operator||et operator&&, parce qu'il y a rarement un cas où l'écriture a && best réellement intuitive dans un contexte non booléen. Les seules exceptions que je connais sont les modèles d'expression, par exemple pour les DSL intégrés. Et seule une poignée de ces quelques cas bénéficierait d'une évaluation des courts-circuits. Les modèles d'expression ne le font généralement pas, car ils sont utilisés pour former des arbres d'expressions qui sont évalués ultérieurement, vous avez donc toujours besoin des deux côtés de l'expression.

En bref: ni les rédacteurs de compilateurs ni les auteurs de normes n'ont ressenti le besoin de sauter à travers les obstacles et de définir et d'implémenter une syntaxe supplémentaire encombrante, simplement parce qu'un sur un million pourrait avoir l'idée qu'il serait bien d'avoir un court-circuit sur l'utilisateur défini operator&&et operator||- juste pour arriver à la conclusion que ce n'est pas moins d'effort que d'écrire la logique par main.

Lambdas n'est pas le seul moyen d'introduire la paresse. L'évaluation paresseuse est relativement simple à l'aide de modèles d'expression en C ++. Il n'y a pas besoin de mot clé lazyet il peut être implémenté en C ++ 98. Les arbres d'expression sont déjà mentionnés ci-dessus. Les modèles d'expression sont des arbres d'expression médiocres (mais intelligents). L'astuce consiste à convertir l'expression en un arbre d'instanciations imbriquées récursivement du Exprmodèle. L'arbre est évalué séparément après la construction.

Le code suivant met en œuvre à court-circuitées &&et les ||opérateurs pour la classe Saussi longtemps qu'il offre logical_andet logical_orfonctions libres et il est convertible bool. Le code est en C ++ 14 mais l'idée est également applicable en C ++ 98. Voir l' exemple en direct .

#include <iostream>

struct S
{
  bool val;

  explicit S(int i) : val(i) {}  
  explicit S(bool b) : val(b) {}

  template <class Expr>
  S (const Expr & expr)
   : val(evaluate(expr).val)
  { }

  template <class Expr>
  S & operator = (const Expr & expr)
  {
    val = evaluate(expr).val;
    return *this;
  }

  explicit operator bool () const 
  {
    return val;
  }
};

S logical_and (const S & lhs, const S & rhs)
{
    std::cout << "&& ";
    return S{lhs.val && rhs.val};
}

S logical_or (const S & lhs, const S & rhs)
{
    std::cout << "|| ";
    return S{lhs.val || rhs.val};
}


const S & evaluate(const S &s) 
{
  return s;
}

template <class Expr>
S evaluate(const Expr & expr) 
{
  return expr.eval();
}

struct And 
{
  template <class LExpr, class RExpr>
  S operator ()(const LExpr & l, const RExpr & r) const
  {
    const S & temp = evaluate(l);
    return temp? logical_and(temp, evaluate(r)) : temp;
  }
};

struct Or 
{
  template <class LExpr, class RExpr>
  S operator ()(const LExpr & l, const RExpr & r) const
  {
    const S & temp = evaluate(l);
    return temp? temp : logical_or(temp, evaluate(r));
  }
};


template <class Op, class LExpr, class RExpr>
struct Expr
{
  Op op;
  const LExpr &lhs;
  const RExpr &rhs;

  Expr(const LExpr& l, const RExpr & r)
   : lhs(l),
     rhs(r)
  {}

  S eval() const 
  {
    return op(lhs, rhs);
  }
};

template <class LExpr>
auto operator && (const LExpr & lhs, const S & rhs)
{
  return Expr<And, LExpr, S> (lhs, rhs);
}

template <class LExpr, class Op, class L, class R>
auto operator && (const LExpr & lhs, const Expr<Op,L,R> & rhs)
{
  return Expr<And, LExpr, Expr<Op,L,R>> (lhs, rhs);
}

template <class LExpr>
auto operator || (const LExpr & lhs, const S & rhs)
{
  return Expr<Or, LExpr, S> (lhs, rhs);
}

template <class LExpr, class Op, class L, class R>
auto operator || (const LExpr & lhs, const Expr<Op,L,R> & rhs)
{
  return Expr<Or, LExpr, Expr<Op,L,R>> (lhs, rhs);
}

std::ostream & operator << (std::ostream & o, const S & s)
{
  o << s.val;
  return o;
}

S and_result(S s1, S s2, S s3)
{
  return s1 && s2 && s3;
}

S or_result(S s1, S s2, S s3)
{
  return s1 || s2 || s3;
}

int main(void) 
{
  for(int i=0; i<= 1; ++i)
    for(int j=0; j<= 1; ++j)
      for(int k=0; k<= 1; ++k)
        std::cout << and_result(S{i}, S{j}, S{k}) << std::endl;

  for(int i=0; i<= 1; ++i)
    for(int j=0; j<= 1; ++j)
      for(int k=0; k<= 1; ++k)
        std::cout << or_result(S{i}, S{j}, S{k}) << std::endl;

  return 0;
}

Le court-circuitage des opérateurs logiques est autorisé car il s'agit d'une "optimisation" dans l'évaluation des tables de vérité associées. C'est une fonction de la logique elle-même, et cette logique est définie.

Y a-t-il réellement une raison pour laquelle surchargé &&et ||ne pas court-circuit?

Les opérateurs logiques surchargés personnalisés ne sont pas obligés de suivre la logique de ces tables de vérité.

Mais pourquoi perdent-ils ce comportement lorsqu'ils sont surchargés?

Par conséquent, la fonction entière doit être évaluée comme d'habitude. Le compilateur doit le traiter comme un opérateur (ou une fonction) surchargé normal et il peut toujours appliquer des optimisations comme il le ferait avec n'importe quelle autre fonction.

Les gens surchargent les opérateurs logiques pour diverses raisons. Par exemple; ils peuvent avoir une signification spécifique dans un domaine spécifique qui n'est pas la logique «normale» à laquelle les gens sont habitués.

Le court-circuit est dû à la table de vérité de "et" et "ou". Comment sauriez-vous quelle opération l'utilisateur va définir et comment sauriez-vous que vous n'aurez pas à évaluer le deuxième opérateur?

mais les opérateurs pour bool ont ce comportement, pourquoi devrait-il être limité à ce type unique?

Je veux juste répondre à cette partie. La raison en est que les expressions intégrées &&et ||ne sont pas implémentées avec des fonctions comme le sont les opérateurs surchargés.

Il est facile d'avoir la logique de court-circuit intégrée à la compréhension du compilateur d'expressions spécifiques. C'est comme n'importe quel autre flux de contrôle intégré.

Mais la surcharge d'opérateurs est implémentée avec des fonctions à la place, qui ont des règles particulières, dont l'une est que toutes les expressions utilisées comme arguments sont évaluées avant l'appel de la fonction. De toute évidence, des règles différentes pourraient être définies, mais c'est un travail plus important.