Pourquoi les compilateurs C ++ ne définissent-ils pas l'opérateur == et l'opérateur! =?

Je suis un grand fan de laisser le compilateur faire autant de travail que possible pour vous. Lors de l'écriture d'une classe simple, le compilateur peut vous donner les éléments suivants gratuitement:

• Un constructeur par défaut (vide)
• Un constructeur de copie
• Un destructeur
• Un opérateur d'affectation ( operator=)

Mais il ne semble pas vous donner d'opérateurs de comparaison - comme operator==ou operator!=. Par exemple:

class foo
{
public:
    std::string str_;
    int n_;
};

foo f1;        // Works
foo f2(f1);    // Works
foo f3;
f3 = f2;       // Works

if (f3 == f2)  // Fails
{ }

if (f3 != f2)  // Fails
{ }

Y a-t-il une bonne raison à cela? Pourquoi effectuer une comparaison membre par membre serait un problème? Évidemment, si la classe alloue de la mémoire, vous voudrez être prudent, mais pour une classe simple, le compilateur pourrait sûrement le faire pour vous?

Le compilateur ne saurait pas si vous vouliez une comparaison de pointeurs ou une comparaison approfondie (interne).

Il est plus sûr de ne pas l'implémenter et de laisser le programmeur le faire lui-même. Ensuite, ils peuvent faire toutes les hypothèses qu'ils aiment.

L'argument selon lequel si le compilateur peut fournir un constructeur de copie par défaut, il devrait être en mesure de fournir un défaut similaire a operator==()un certain sens. Je pense que la raison de la décision de ne pas fournir un défaut généré par le compilateur pour cet opérateur peut être devinée par ce que Stroustrup a dit à propos du constructeur de copie par défaut dans "La conception et l'évolution de C ++" (Section 11.4.1 - Contrôle de la copie) :

Personnellement, je trouve regrettable que les opérations de copie soient définies par défaut et j'interdise la copie d'objets de plusieurs de mes classes. Cependant, C ++ a hérité de ses assignations par défaut et des constructeurs de copie de C, et ils sont fréquemment utilisés.

Donc, au lieu de "pourquoi C ++ n'a-t-il pas de valeur par défaut operator==() ?", La question aurait dû être "pourquoi C ++ a-t-il un constructeur d'affectation et de copie par défaut?", La réponse étant que ces éléments ont été inclus à contrecœur par Stroustrup pour une compatibilité descendante avec C (probablement la cause de la plupart des verrues de C ++, mais aussi probablement la principale raison de la popularité de C ++).

À mes propres fins, dans mon IDE, l'extrait de code que j'utilise pour les nouvelles classes contient des déclarations pour un opérateur d'affectation privé et un constructeur de copie, de sorte que lorsque je crée une nouvelle classe, je n'obtiens aucune affectation par défaut et aucune opération de copie - je dois supprimer explicitement la déclaration de ces opérations dans la private:section si je veux que le compilateur puisse les générer pour moi.

Même en C ++ 20, le compilateur ne génère toujours pas implicitement operator==pour vous

struct foo
{
    std::string str;
    int n;
};

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ill-formed

Mais vous aurez la possibilité de explicitement par défaut == depuis C ++ 20 :

struct foo
{
    std::string str;
    int n;

    // either member form
    bool operator==(foo const&) const = default;
    // ... or friend form
    friend bool operator==(foo const&, foo const&) = default;
};

Défaillant ==fait sage membre ==(de la même manière que le constructeur de copie par défaut ne construction de copie-sage membre). Les nouvelles règles fournissent également la relation attendue entre ==et !=. Par exemple, avec la déclaration ci-dessus, je peux écrire les deux:

assert(foo{"Anton", 1} == foo{"Anton", 1}); // ok!
assert(foo{"Anton", 1} != foo{"Anton", 2}); // ok!

Cette fonctionnalité spécifique (défaut operator==et symétrie entre ==et !=) provient d' une proposition qui faisait partie de la fonctionnalité de langage plus large qui est operator<=>.

À mon humble avis, il n'y a pas de "bonne" raison. La raison pour laquelle tant de gens sont d'accord avec cette décision de conception est qu'ils n'ont pas appris à maîtriser la puissance de la sémantique basée sur les valeurs. Les gens ont besoin d'écrire beaucoup de constructeur de copie personnalisé, d'opérateurs de comparaison et de destructeurs car ils utilisent des pointeurs bruts dans leur implémentation.

Lorsque vous utilisez des pointeurs intelligents appropriés (comme std :: shared_ptr), le constructeur de copie par défaut est généralement correct et l'implémentation évidente de l'opérateur de comparaison par défaut hypothétique est aussi fine.

Il est répondu que C ++ n'a pas fait == parce que C n'a pas fait, et voici pourquoi C fournit uniquement default = mais pas == à la première place. C voulait rester simple: C implémenté = par memcpy; cependant, == ne peut pas être implémenté par memcmp en raison du remplissage. Parce que le remplissage n'est pas initialisé, memcmp dit qu'ils sont différents même s'ils sont identiques. Le même problème existe pour les classes vides: memcmp dit qu'elles sont différentes car la taille des classes vides n'est pas nulle. On peut voir d'en haut que l'implémentation de == est plus compliquée que l'implémentation de = en C. Quelques exemples de code à ce sujet. Votre correction est appréciée si je me trompe.

Dans cette vidéo Alex Stepanov, le créateur de STL répond à cette même question vers 13h00. Pour résumer, après avoir observé l'évolution du C ++, il soutient que:

• Il est regrettable que == et! = Ne soient pas implicitement déclarés (et Bjarne est d'accord avec lui). Un langage correct devrait avoir ces choses à portée de main (il va plus loin pour suggérer que vous ne devriez pas être en mesure de définir un ! = Qui rompt la sémantique de == )
• La raison pour laquelle c'est le cas a ses racines (comme beaucoup de problèmes C ++) en C. Là, l'opérateur d'affectation est implicitement défini avec une affectation bit par bit mais cela ne fonctionnerait pas pour == . Une explication plus détaillée peut être trouvée dans cet article de Bjarne Stroustrup.
• Dans la question de suivi Pourquoi alors une comparaison membre par membre n'a-t-elle pas été utilisée, il dit une chose incroyable : C était une sorte de langage local et le gars qui implémentait ces trucs pour Ritchie lui a dit qu'il trouvait cela difficile à mettre en œuvre!

Il dit ensuite que dans un avenir (lointain) == et ! = Seront implicitement générés.

C ++ 20 permet d'implémenter facilement un opérateur de comparaison par défaut.

Exemple de cppreference.com :

class Point {
    int x;
    int y;
public:
    auto operator<=>(const Point&) const = default;
    // ... non-comparison functions ...
};

// compiler implicitly declares operator== and all four relational operators work
Point pt1, pt2;
if (pt1 == pt2) { /*...*/ } // ok, calls implicit Point::operator==
std::set<Point> s; // ok
s.insert(pt1); // ok
if (pt1 <= pt2) { /*...*/ } // ok, makes only a single call to Point::operator<=>

Il n'est pas possible de définir la valeur par défaut ==, mais vous pouvez définir la valeur !=par défaut via ==laquelle vous devez généralement vous définir. Pour cela, vous devez faire les choses suivantes:

#include <utility>
using namespace std::rel_ops;
...

class FooClass
{
public:
  bool operator== (const FooClass& other) const {
  // ...
  }
};

Vous pouvez consulter http://www.cplusplus.com/reference/std/utility/rel_ops/ pour plus de détails.

De plus, si vous définissez operator< , les opérateurs pour <=,>,> = peuvent en être déduits lors de l'utilisation std::rel_ops.

Mais vous devez être prudent lorsque vous utilisez std::rel_opscar les opérateurs de comparaison peuvent être déduits pour les types auxquels vous n'êtes pas attendu.

La manière la plus préférée de déduire un opérateur lié d'un opérateur de base est d'utiliser boost :: operators .

L'approche utilisée dans boost est meilleure car elle définit l'utilisation de l'opérateur pour la classe que vous souhaitez uniquement, pas pour toutes les classes de la portée.

Vous pouvez également générer "+" à partir de "+ =", - à partir de "- =", etc ... (voir la liste complète ici )

C ++ 0x a eu une proposition de fonctions par défaut, vous pouvez donc dire que default operator==; nous avons appris que cela aide à rendre ces choses explicites.

Conceptuellement, il n'est pas facile de définir l'égalité. Même pour les données POD, on pourrait faire valoir que même si les champs sont les mêmes, mais qu'il s'agit d'un objet différent (à une adresse différente), il n'est pas nécessairement égal. Cela dépend en fait de l'utilisation de l'opérateur. Malheureusement, votre compilateur n'est pas psychique et ne peut pas en déduire.

En plus de cela, les fonctions par défaut sont d'excellents moyens de se tirer une balle dans le pied. Les valeurs par défaut que vous décrivez sont essentiellement là pour maintenir la compatibilité avec les structures POD. Cependant, ils causent plus que suffisamment de ravages, les développeurs les oubliant ou la sémantique des implémentations par défaut.

Y a-t-il une bonne raison à cela? Pourquoi effectuer une comparaison membre par membre serait un problème?

Ce n'est peut-être pas un problème sur le plan fonctionnel, mais en termes de performances, la comparaison membre par membre par défaut est susceptible d'être plus sous-optimale que l'attribution / copie membre par membre par défaut. Contrairement à l'ordre d'affectation, l'ordre de comparaison a un impact sur les performances car le premier membre inégal implique que le reste peut être ignoré. Donc, s'il y a des membres qui sont généralement égaux, vous voulez les comparer en dernier, et le compilateur ne sait pas quels membres sont plus susceptibles d'être égaux.

Considérez cet exemple, où verboseDescriptionest une longue chaîne sélectionnée parmi un ensemble relativement petit de descriptions météorologiques possibles.

class LocalWeatherRecord {
    std::string verboseDescription;
    std::tm date;
    bool operator==(const LocalWeatherRecord& other){
        return date==other.date
            && verboseDescription==other.verboseDescription;
    // The above makes a lot more sense than
     // return verboseDescription==other.verboseDescription
     //     && date==other.date;
    // because some verboseDescriptions are liable to be same/similar
    }
}

(Bien sûr, le compilateur aurait le droit de ne pas tenir compte de l'ordre des comparaisons s'il reconnaît qu'il n'y a pas d'effets secondaires, mais il est probable qu'il tirera toujours son nom du code source où il ne dispose pas de meilleures informations.)

Juste pour que les réponses à cette question restent complètes au fil du temps: depuis C ++ 20 il peut être généré automatiquement avec la commande auto operator<=>(const foo&) const = default;

Il générera tous les opérateurs: ==,! =, <, <=,> Et> =, voir https://en.cppreference.com/w/cpp/language/default_comparisons pour plus de détails.

En raison de l'apparence de l'opérateur <=>, il est appelé opérateur de vaisseau spatial. Voir aussi Pourquoi avons-nous besoin de l'opérateur <=> du vaisseau spatial en C ++? .

EDIT: également en C ++ 11 un substitut assez soigné qui est disponible avec std::tievoir https://en.cppreference.com/w/cpp/utility/tuple/tie pour un exemple de code complet avec bool operator<(…). La partie intéressante, modifiée pour fonctionner avec ==est:

#include <tuple>

struct S {
………
bool operator==(const S& rhs) const
    {
        // compares n to rhs.n,
        // then s to rhs.s,
        // then d to rhs.d
        return std::tie(n, s, d) == std::tie(rhs.n, rhs.s, rhs.d);
    }
};

std::tie fonctionne avec tous les opérateurs de comparaison et est complètement optimisé par le compilateur.

Je suis d'accord, pour les classes de type POD, le compilateur pourrait le faire pour vous. Cependant, ce que vous pourriez considérer comme simple, le compilateur peut se tromper. Il est donc préférable de laisser le programmeur le faire.

J'ai eu un cas POD une fois où deux des champs étaient uniques - donc une comparaison ne serait jamais considérée comme vraie. Cependant, la comparaison dont j'avais besoin n'a jamais été comparée que sur la charge utile - quelque chose que le compilateur ne comprendrait jamais ou ne pourrait jamais comprendre par lui-même.

D'ailleurs - ils ne tardent pas à écrire, n'est-ce pas?!