== et! = Sont-ils mutuellement dépendants?

J'apprends la surcharge des opérateurs en C ++, et je le vois ==et ce !=sont simplement des fonctions spéciales qui peuvent être personnalisées pour les types définis par l'utilisateur. Cependant, je me demande pourquoi deux définitions distinctes sont nécessaires? Je pensais que si a == best vrai, alors a != bautomatiquement faux, et vice versa, et il n'y a pas d'autre possibilité, parce que, par définition, l' a != best !(a == b). Et je ne pouvais imaginer aucune situation dans laquelle ce n'était pas vrai. Mais peut-être que mon imagination est limitée ou que j'ignore quelque chose?

Je sais que je peux définir l'un en fonction de l'autre, mais ce n'est pas ce que je demande. Je ne demande pas non plus la distinction entre comparer des objets par valeur ou par identité. Ou si deux objets pourraient être égaux et non égaux en même temps (ce n'est certainement pas une option! Ces choses s'excluent mutuellement). Ce que je demande, c'est ceci:

Y at - il possible dans la situation où poser des questions sur deux objets étant ne égale du sens, mais poser des questions sur les pas être ne correspond pas de sens? (soit du point de vue de l'utilisateur, soit du point de vue de l'implémentateur)

S'il n'y a pas une telle possibilité, alors pourquoi diable C ++ at-il ces deux opérateurs définis comme deux fonctions distinctes?

Vous ne voudriez pas que la langue se réécrive automatiquement a != bcomme !(a == b)lorsqu'elle a == bretourne autre chose qu'un a bool. Et il y a plusieurs raisons pour lesquelles vous pourriez le faire.

Vous pouvez avoir des objets de générateur d'expression, où a == bne fait pas et n'est pas destiné à effectuer une comparaison, mais construit simplement un nœud d'expression représentant a == b.

Vous pouvez avoir une évaluation paresseuse, où a == bn'a pas et n'est pas destiné à effectuer une comparaison directement, mais renvoie à la place une sorte de lazy<bool>cela qui peut être converti boolimplicitement ou explicitement à un moment ultérieur pour effectuer réellement la comparaison. Peut être combiné avec les objets du générateur d'expression pour permettre une optimisation complète de l'expression avant l'évaluation.

Vous pouvez avoir une optional<T>classe de modèle personnalisée , où des variables facultatives sont fournies tet que uvous souhaitez autoriser t == u, mais faites-la revenir optional<bool>.

Il y a probablement plus de choses auxquelles je n'ai pas pensé. Et même si, dans ces exemples, l'opération a == bet a != bles deux ont un sens, ce a != bn'est toujours pas la même chose !(a == b), des définitions distinctes sont donc nécessaires.

S'il n'y a pas une telle possibilité, alors pourquoi diable C ++ at-il ces deux opérateurs définis comme deux fonctions distinctes?

Parce que vous pouvez les surcharger, et en les surchargeant, vous pouvez leur donner un sens totalement différent de leur original.

Prenons, par exemple, l'opérateur <<, à l'origine l'opérateur de décalage gauche au niveau du bit, maintenant généralement surchargé en tant qu'opérateur d'insertion, comme dans std::cout << something; sens totalement différent de celui d'origine.

Donc, si vous acceptez que la signification d'un opérateur change lorsque vous le surchargez, il n'y a aucune raison d'empêcher l'utilisateur de donner à l'opérateur une signification ==qui n'est pas exactement la négation de l'opérateur !=, bien que cela puisse prêter à confusion.

Cependant, je me demande pourquoi deux définitions distinctes sont nécessaires?

Vous n'avez pas besoin de définir les deux.
S'ils s'excluent mutuellement, vous pouvez toujours être concis en ne définissant ==et à <côté de std :: rel_ops

Fom cppreference:

#include <iostream>
#include <utility>

struct Foo {
    int n;
};

bool operator==(const Foo& lhs, const Foo& rhs)
{
    return lhs.n == rhs.n;
}

bool operator<(const Foo& lhs, const Foo& rhs)
{
    return lhs.n < rhs.n;
}

int main()
{
    Foo f1 = {1};
    Foo f2 = {2};
    using namespace std::rel_ops;

    //all work as you would expect
    std::cout << "not equal:     : " << (f1 != f2) << '\n';
    std::cout << "greater:       : " << (f1 > f2) << '\n';
    std::cout << "less equal:    : " << (f1 <= f2) << '\n';
    std::cout << "greater equal: : " << (f1 >= f2) << '\n';
}

Y a-t-il une situation possible dans laquelle poser des questions sur deux objets égaux a du sens, mais poser des questions sur leur égalité n'a pas de sens?

Nous associons souvent ces opérateurs à l'égalité.
Bien que c'est ainsi qu'ils se comportent sur les types fondamentaux, il n'y a aucune obligation que ce soit leur comportement sur les types de données personnalisés. Vous n'avez même pas besoin de retourner un bool si vous ne le souhaitez pas.

J'ai vu des gens surcharger les opérateurs de manière bizarre, seulement pour découvrir que cela avait du sens pour leur application spécifique au domaine. Même si l'interface semble montrer qu'elles s'excluent mutuellement, l'auteur peut vouloir ajouter une logique interne spécifique.

(soit du point de vue de l'utilisateur, soit du point de vue de l'implémentateur)

Je sais que vous voulez un exemple spécifique,
alors voici celui du cadre de test Catch que je pensais pratique:

template<typename RhsT>
ResultBuilder& operator == ( RhsT const& rhs ) {
    return captureExpression<Internal::IsEqualTo>( rhs );
}

template<typename RhsT>
ResultBuilder& operator != ( RhsT const& rhs ) {
    return captureExpression<Internal::IsNotEqualTo>( rhs );
}

Ces opérateurs font des choses différentes, et il ne serait pas logique de définir une méthode comme un! (Pas) de l'autre. La raison pour laquelle cela est fait, est que le cadre puisse imprimer la comparaison effectuée. Pour ce faire, il doit capturer le contexte de l'opérateur surchargé utilisé.

Il existe des conventions très bien établies dans lesquelles (a == b)et qui (a != b)sont toutes deux fausses ne sont pas nécessairement opposées. En particulier, en SQL, toute comparaison avec NULL donne NULL, pas vrai ou faux.

Ce n'est probablement pas une bonne idée de créer de nouveaux exemples si cela est possible, car c'est si peu intuitif, mais si vous essayez de modéliser une convention existante, il est agréable d'avoir la possibilité de faire en sorte que vos opérateurs se comportent "correctement" pour cela le contexte.

Je ne répondrai qu'à la deuxième partie de votre question, à savoir:

S'il n'y a pas une telle possibilité, alors pourquoi diable C ++ at-il ces deux opérateurs définis comme deux fonctions distinctes?

L'une des raisons pour lesquelles il est logique de permettre au développeur de surcharger les deux est la performance. Vous pouvez permettre des optimisations en implémentant à la fois ==et !=. Alors, x != yça pourrait être moins cher que ça !(x == y). Certains compilateurs peuvent être en mesure de l'optimiser pour vous, mais peut-être pas, surtout si vous avez des objets complexes avec beaucoup de branchements impliqués.

Même à Haskell, où les développeurs prennent très au sérieux les lois et les concepts mathématiques, on est toujours autorisé à surcharger les deux ==et /=, comme vous pouvez le voir ici ( http://hackage.haskell.org/package/base-4.9.0.0/docs/Prelude .html # v: -61--61- ):

$ ghci
GHCi, version 7.10.2: http://www.haskell.org/ghc/  :? for help
λ> :i Eq
class Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool
        -- Defined in `GHC.Classes'

Cela serait probablement considéré comme une micro-optimisation, mais cela pourrait être justifié dans certains cas.

Y a-t-il une situation possible dans laquelle poser des questions sur deux objets égaux a du sens, mais poser des questions sur leur égalité n'a pas de sens? (soit du point de vue de l'utilisateur, soit du point de vue de l'implémentateur)

Voilà une opinion. Peut-être que non. Mais les concepteurs de langage, n'étant pas omniscients, ont décidé de ne pas restreindre les personnes qui pourraient trouver des situations dans lesquelles cela pourrait avoir du sens (du moins pour eux).

En réponse à l'édition;

Autrement dit, s'il est possible pour certains types d'avoir l'opérateur ==mais pas le !=, ou vice versa, et quand est-il logique de le faire.

En général , non, cela n'a pas de sens. L'égalité et les opérateurs relationnels se présentent généralement en ensembles. S'il y a égalité, alors l'inégalité aussi; inférieur à, puis supérieur à et ainsi de suite avec <=etc. Une approche similaire est également appliquée aux opérateurs arithmétiques, ils se présentent généralement sous forme d'ensembles logiques naturels.

Cela est démontré dans l' std::rel_opsespace de noms. Si vous implémentez l'égalité et moins d'opérateurs, l'utilisation de cet espace de noms vous donne les autres, implémentés en termes de vos opérateurs implémentés d'origine.

Cela dit, existe-t-il des conditions ou des situations dans lesquelles l'une ne signifierait pas immédiatement l'autre ou ne pourrait pas être mise en œuvre en fonction des autres? Oui, il y en a , sans doute peu, mais ils sont là; encore une fois, comme en témoigne l' rel_opsêtre un espace de noms qui lui est propre. Pour cette raison, leur mise en œuvre indépendante vous permet de tirer parti du langage pour obtenir la sémantique dont vous avez besoin ou dont vous avez besoin d'une manière toujours naturelle et intuitive pour l'utilisateur ou le client du code.

L'évaluation paresseuse déjà mentionnée en est un excellent exemple. Un autre bon exemple est de leur donner une sémantique qui ne signifie pas du tout l'égalité ou l'inégalité. Un exemple similaire à cela est les opérateurs de décalage de bits <<et >>utilisés pour l'insertion et l'extraction de flux. Bien qu'il puisse être mal vu dans les cercles généraux, dans certains domaines spécifiques, il peut avoir un sens.

Si les opérateurs ==et !=n'impliquent pas réellement l'égalité, de la même manière que les opérateurs <<et >>stream n'impliquent pas de décalage de bits. Si vous traitez les symboles comme s'ils signifiaient un autre concept, ils ne doivent pas être mutuellement exclusifs.

En termes d'égalité, cela pourrait avoir un sens si votre cas d'utilisation justifie de traiter les objets comme non comparables, de sorte que chaque comparaison doit retourner faux (ou un type de résultat non comparable, si vos opérateurs retournent non booléen). Je ne peux pas penser à une situation spécifique où cela serait justifié, mais je pouvais voir que c'était assez raisonnable.

Avec une grande puissance vient très bien de manière responsable, ou du moins de très bons guides de style.

==et !=peut être surchargé pour faire tout ce que vous voulez. C'est à la fois une bénédiction et une malédiction. Il n'y a aucune garantie que cela !=signifie !(a==b).

enum BoolPlus {
    kFalse = 0,
    kTrue = 1,
    kFileNotFound = -1
}

BoolPlus operator==(File& other);
BoolPlus operator!=(File& other);

Je ne peux pas justifier cette surcharge d'opérateur, mais dans l'exemple ci-dessus, il est impossible de définir operator!=comme "l'opposé" de operator==.

En fin de compte, ce que vous vérifiez avec ces opérateurs, c'est que l'expression a == bou a != brenvoie une valeur booléenne ( trueou false). Cette expression renvoie une valeur booléenne après comparaison plutôt que de s'exclure mutuellement.

[..] Pourquoi faut-il deux définitions distinctes?

Une chose à considérer est qu'il pourrait y avoir la possibilité de mettre en œuvre l'un de ces opérateurs plus efficacement que d'utiliser simplement la négation de l'autre.

(Mon exemple ici était des ordures, mais le point tient toujours, pensez aux filtres de floraison, par exemple: ils permettent des tests rapides si quelque chose n'est pas dans un ensemble, mais tester si c'est dans peut prendre beaucoup plus de temps.)

[..] par définition, a != best !(a == b).

Et c'est votre responsabilité en tant que programmeur de maintenir cette prise. Probablement une bonne chose pour laquelle passer un test.

En personnalisant le comportement des opérateurs, vous pouvez leur faire faire ce que vous voulez.

Vous voudrez peut-être personnaliser les choses. Par exemple, vous souhaiterez peut-être personnaliser une classe. Les objets de cette classe peuvent être comparés simplement en vérifiant une propriété spécifique. Sachant que c'est le cas, vous pouvez écrire du code spécifique qui ne vérifie que le minimum, au lieu de vérifier chaque bit de chaque propriété de l'objet entier.

Imaginez un cas où vous pouvez comprendre que quelque chose est différent tout aussi rapidement, sinon plus vite, que vous pouvez découvrir que quelque chose est le même. Certes, une fois que vous avez déterminé si quelque chose est identique ou différent, vous pouvez savoir le contraire simplement en retournant un peu. Cependant, retourner ce bit est une opération supplémentaire. Dans certains cas, lorsque le code est beaucoup réexécuté, l'enregistrement d'une opération (multiplié par plusieurs) peut entraîner une augmentation globale de la vitesse. (Par exemple, si vous enregistrez une opération par pixel d'un écran mégapixel, alors vous venez d'enregistrer un million d'opérations. Multiplié par 60 écrans par seconde, et vous enregistrez encore plus d'opérations.)

La réponse de hvd fournit quelques exemples supplémentaires.

Oui, car l'un signifie "équivalent" et un autre "non équivalent" et ces termes s'excluent mutuellement. Toute autre signification pour ces opérateurs prête à confusion et doit être évitée par tous les moyens.

Peut-être une règle incomparable, où a != bétait faux et a == bétait faux comme un bit apatride.

if( !(a == b || a != b) ){
    // Stateless
}