Warum wird Ungleichung in vielen C ++ - Standardbibliothekscodes als (! (A == b)) getestet?

Dies ist der Code aus dem C ++ - Standardbibliothekscode remove. Warum wird Ungleichheit als if (!(*first == val))statt getestet 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;
 }

Weil dies bedeutet, dass die einzige Anforderung an T darin besteht, eine zu implementieren operator==. Sie könnten T benötigen, um eine zu haben, operator!=aber die allgemeine Idee hier ist, dass Sie den Benutzer der Vorlage so wenig wie möglich belasten sollten und andere Vorlagen benötigen operator==.

Die meisten Funktionen in STL funktionieren nur mit operator<oder operator==. Dies erfordert, dass der Benutzer nur diese beiden Operatoren (oder manchmal mindestens einen von ihnen) implementiert. Zum Beispiel std::setverwendet operator<(genauer gesagt, std::lesswas operator<standardmäßig aufgerufen wird) und nicht operator>, um die Bestellung zu verwalten. Die removeVorlage in Ihrem Beispiel ist ein ähnlicher Fall - sie wird nur verwendet operator==und nicht, operator!=sodass die operator!=nicht definiert werden muss.

Dies ist der Code aus der C ++ - Standardbibliothek zum Entfernen von Code.

Falsch. Es ist nicht der C ++ - Standardbibliothekscode remove. Dies ist eine mögliche interne Implementierung der C ++ - Standardbibliotheksfunktion remove. Der C ++ - Standard schreibt keinen tatsächlichen Code vor. Es schreibt Funktionsprototypen und erforderliche Verhaltensweisen vor.

Mit anderen Worten: Aus strenger sprachlicher Sicht existiert der Code, den Sie sehen , nicht . Möglicherweise stammt es aus einer Header-Datei, die mit der Standardbibliotheksimplementierung Ihres Compilers geliefert wird. Beachten Sie, dass der C ++ - Standard nicht einmal erfordert, dass diese Header- Dateien vorhanden sind. Dateien sind nur eine bequeme Möglichkeit für Compiler-Implementierer, die Anforderungen für eine Zeile wie #include <algorithm>(dh das Bereitstellen std::removeund andere verfügbare Funktionen) zu erfüllen .

Warum wird Ungleichheit als if (!(*first == val))statt getestet if (*first != val)?

Weil nur operator==von der Funktion benötigt wird.

Wenn es um das Überladen von Operatoren für benutzerdefinierte Typen geht, können Sie mit der Sprache alle möglichen seltsamen Dinge tun. Sie können sehr gut eine Klasse erstellen, die überladen, operator==aber nicht überladen ist operator!=. Oder noch schlimmer: Sie könnten überladen, operator!=aber völlig unabhängige Dinge tun lassen.

Betrachten Sie dieses Beispiel:

#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());
  // ...
}

Bei std::removeVerwendung operator!=wäre das Ergebnis ganz anders.

Einige gute Antworten hier. Ich wollte nur eine kleine Notiz hinzufügen.

Wie alle guten Bibliotheken basiert die Standardbibliothek auf (mindestens) zwei sehr wichtigen Prinzipien:

1. Übernehmen Sie den Benutzern Ihrer Bibliothek die geringste Verantwortung, mit der Sie durchkommen können. Ein Teil davon hat damit zu tun, dass sie bei der Verwendung Ihrer Benutzeroberfläche den geringsten Arbeitsaufwand haben. (wie das Definieren von so wenigen Operatoren, wie Sie durchkommen können). Der andere Teil hat damit zu tun, dass sie nicht überrascht werden oder dass sie Fehlercodes überprüfen müssen (also die Schnittstellen konsistent halten und Ausnahmen auslösen, <stdexcept>wenn etwas schief geht).

2. Beseitigen Sie alle logischen Redundanzen . Alle Vergleiche können lediglich abgeleitet operator<werden. Warum also verlangen, dass Benutzer andere definieren? z.B:

   (a> b) ist äquivalent zu (b <a)

   (a> = b) ist äquivalent zu! (a <b)

   (a == b) ist äquivalent zu! ((a <b) || (b <a))

   und so weiter.

   In diesem Sinne könnte man sich natürlich fragen, warum dies unordered_maperforderlich ist operator==(zumindest standardmäßig) und nicht operator<. Die Antwort ist, dass in einer Hash-Tabelle der einzige Vergleich, den wir jemals benötigen, ein Vergleich für die Gleichheit ist. Daher ist es logisch konsistenter (dh für den Bibliotheksbenutzer sinnvoller), von ihm die Definition eines Gleichheitsoperators zu verlangen. Das Erfordernis eines operator<wäre verwirrend, da nicht sofort klar ist, warum Sie es benötigen würden.

Das EqualityComparableKonzept erfordert nur die operator==Definition.

Folglich kann sich jede Funktion, die behauptet, mit befriedigenden Typen zu arbeiten, EqualityComparable nicht auf die Existenz von operator!=Objekten dieses Typs verlassen. (es sei denn, es gibt zusätzliche Anforderungen, die das Vorhandensein von implizieren operator!=).

Der vielversprechendste Ansatz besteht darin, eine Methode zu finden, mit der ermittelt werden kann, ob operator == für einen bestimmten Typ aufgerufen werden kann, und diese dann nur zu unterstützen, wenn sie verfügbar ist. In anderen Situationen wird eine Ausnahme ausgelöst. Bisher ist jedoch kein Weg bekannt, um festzustellen, ob ein beliebiger Operatorausdruck f == g geeignet definiert ist. Die beste bekannte Lösung weist die folgenden unerwünschten Eigenschaften auf:

• Schlägt zur Kompilierungszeit für Objekte fehl, auf die auf operator == nicht zugegriffen werden kann (z. B. weil es privat ist).
• Schlägt zur Kompilierungszeit fehl, wenn der Aufruf von operator == nicht eindeutig ist.
• Scheint korrekt zu sein, wenn die Deklaration operator == korrekt ist, obwohl operator == möglicherweise nicht kompiliert werden kann.

Von Boost FAQ: Quelle

Da Sie wissen, dass das Erfordernis der ==Implementierung eine Belastung darstellt , möchten Sie niemals eine zusätzliche Belastung schaffen, indem Sie auch die !=Implementierung erfordern .

Für mich persönlich geht es um SOLID (objektorientiertes Design) L-Teil - Liskov-Substitutionsprinzip: „Objekte in einem Programm sollten durch Instanzen ihrer Subtypen ersetzt werden können, ohne die Richtigkeit dieses Programms zu ändern.“ In diesem Fall ist es der Operator ! = , Den ich in der booleschen Logik durch == und boolean inverse ersetzen kann .