Pourquoi l'inégalité est-elle testée comme (! (A == b)) dans beaucoup de code de bibliothèque standard C ++?

Il s'agit du code du code de la bibliothèque standard C ++ remove. Pourquoi les inégalités sont-elles testées au if (!(*first == val))lieu de if (*first != val)?

 template <class ForwardIterator, class T>
      ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val)
 {
     ForwardIterator result = first;
     while (first!=last) {
         if (!(*first == val)) {
             *result = *first;
             ++result;
         }
         ++first;
     }
     return result;
 }

Parce que cela signifie que la seule exigence sur T est d'implémenter un operator==. Vous pourriez demander à T d'avoir un, operator!=mais l'idée générale ici est que vous devriez mettre le moins de charge possible sur l'utilisateur du modèle et que d'autres modèles en ont besoin operator==.

La plupart des fonctions de STL fonctionnent uniquement avec operator<ou operator==. Cela oblige l'utilisateur à implémenter uniquement ces deux opérateurs (ou parfois au moins l'un d'entre eux). Par exemple std::setutilise operator<(plus précisément std::lessqui invoque operator<par défaut) et non operator>pour gérer la commande. Le removemodèle dans votre exemple est un cas similaire - il utilise uniquement operator==et non operator!=donc le operator!=n'a pas besoin d'être défini.

Il s'agit du code de la bibliothèque standard C ++ remove code.

Faux. Ce n'est pas leremove code de la bibliothèque standard C ++ . C'est une implémentation interne possible de la removefonction de bibliothèque standard C ++ . La norme C ++ ne prescrit pas de code réel; il prescibe les prototypes de fonction et les comportements requis.

En d'autres termes: du point de vue du langage strict, le code que vous voyez n'existe pas . Cela peut provenir d'un fichier d'en-tête fourni avec l'implémentation de la bibliothèque standard de votre compilateur. Notez que la norme C ++ n'exige même pas que ces fichiers d'en- tête existent. Les fichiers sont juste un moyen pratique pour les implémenteurs de compilateurs de répondre aux exigences d'une ligne comme #include <algorithm>(c'est-à-dire rendre std::removeet d'autres fonctions disponibles).

Pourquoi les inégalités sont-elles testées au if (!(*first == val))lieu de if (*first != val)?

Parce que seul operator==est requis par la fonction.

En ce qui concerne la surcharge d'opérateurs pour les types personnalisés, le langage vous permet de faire toutes sortes de choses étranges. Vous pouvez très bien créer une classe qui a un fichier surchargé operator==mais pas surchargé operator!=. Ou pire encore: vous pourriez surcharger operator!=mais lui faire faire des choses totalement indépendantes.

Prenons cet exemple:

#include <algorithm>
#include <vector>

struct Example
{
    int i;

    Example() : i(0) {}

    bool operator==(Example const& other) const
    {
        return i == other.i;
    }

    bool operator!=(Example const& other) const
    {
        return i == 5; // weird, but nothing stops you
                       // from doing so
    }

};

int main()
{
  std::vector<Example> v(10);
  // ...
  auto it = std::remove(v.begin(), v.end(), Example());
  // ...
}

Si std::removeutilisé operator!=, le résultat serait tout à fait différent.

Quelques bonnes réponses ici. Je voulais juste ajouter une petite note.

Comme toutes les bonnes bibliothèques, la bibliothèque standard est conçue avec (au moins) deux principes très importants à l'esprit:

1. Mettez le moins de responsabilité possible sur les utilisateurs de votre bibliothèque avec lesquels vous pouvez vous en tirer. Une partie de cela a à voir avec leur donner le moins de travail à faire lors de l'utilisation de votre interface. (comme définir le moins d'opérateurs possible). L'autre partie est de ne pas les surprendre ou de les obliger à vérifier les codes d'erreur (alors gardez les interfaces cohérentes et jetez des exceptions <stdexcept>lorsque les choses tournent mal).

2. Éliminez toute redondance logique . Toutes les comparaisons peuvent être déduites simplement de operator<, alors pourquoi exiger que les utilisateurs définissent les autres? par exemple:

   (a> b) équivaut à (b <a)

   (a> = b) équivaut à! (a <b)

   (a == b) équivaut à! ((a <b) || (b <a))

   etc.

   Bien sûr sur cette note, on pourrait se demander pourquoi unordered_maprequiert operator==(au moins par défaut) plutôt que operator<. La réponse est que dans une table de hachage, la seule comparaison dont nous ayons jamais besoin est celle pour l'égalité. Il est donc plus cohérent logiquement (c'est-à-dire plus logique pour l'utilisateur de la bibliothèque) de lui demander de définir un opérateur d'égalité. Exiger un operator<serait déroutant car il n'est pas immédiatement évident de savoir pourquoi vous en auriez besoin.

Le EqualityComparableconcept ne demande qu'à operator==être défini.

Par conséquent, toute fonction qui prétend travailler avec des types satisfaisants EqualityComparable ne peut pas s'appuyer sur l'existence de operator!=for objets de ce type. (sauf s'il existe des exigences supplémentaires qui impliquent l'existence de operator!=).

L'approche la plus prometteuse consiste à trouver une méthode pour déterminer si l'opérateur == peut être appelé pour un type particulier, puis à ne le prendre en charge que lorsqu'il est disponible; dans d'autres situations, une exception serait levée. Cependant, à ce jour, il n'existe aucun moyen connu de détecter si une expression d'opérateur arbitraire f == g est correctement définie. La meilleure solution connue a les qualités indésirables suivantes:

• Échec lors de la compilation pour les objets où l'opérateur == n'est pas accessible (par exemple, parce qu'il est privé).
• Échoue à la compilation si l'appel de l'opérateur == est ambigu.
• Semble être correct si la déclaration de l'opérateur == est correcte, même si l'opérateur == ne peut pas être compilé.

De Boost FAQ: source

Sachant que la ==mise en œuvre est un fardeau , vous ne voulez jamais créer de charge supplémentaire en exigeant également la !=mise en œuvre.

Pour moi personnellement, il s'agit de SOLID (conception orientée objet) Partie L - principe de substitution de Liskov: «les objets d'un programme doivent être remplaçables par des instances de leurs sous-types sans altérer l'exactitude de ce programme.». Dans ce cas c'est l'opérateur ! = Que je peux remplacer par == et l' inverse booléen en logique booléenne.