Wie die Umsetzung in C++ (un -) Gleichheit Operatoren für Aggregat-Strukturen?

Manchmal habe ich Strukturen wie diese --

struct aggregate1 {
  std::string name;
  std::vector<ValueT> options;
  size_t foobar;
  //...
};

-- wo (un -) Gleichheit ist einfach definiert als (un -) Gleichheit aller Mitglieder: lhs_name == rhs_name && lhs_options == rhs_options && lhs_foobar == rhs_foobar.

Was ist der "beste" Weg, um dies zu implementieren? (Am besten wie in: (Laufzeit-)Effizienz, Wartbarkeit, Lesbarkeit)

  • operator== im Hinblick auf operator!=
  • operator!= im Hinblick auf operator==
  • Separate Implementierungen für == und !=
  • Als Mitglied oder als freie Funktionen?

Beachten Sie, dass diese Frage nur über die (un -) Gleichheit ops, wie der Vergleich (<, <=, ...) nicht viel Sinn zu machen für solche Aggregate.

InformationsquelleAutor Martin Ba | 2011-02-14

  1. 6

    Member oder free-Funktion ist eine Frage des Geschmacks, und schreiben getrennte Implementierungen von == und != scheint mir langweilig, fehleranfällig (man vergisst ein Mitglied in nur einem der beiden Betreiber, und es wird einige Zeit dauern, um zu bemerken), ohne etwas in Bezug auf die Effizienz (das aufrufen der anderen Betreiber und anwenden ! hat einen vernachlässigbaren Kosten).

    Die Entscheidung beschränkt sich auf "ist es besser zu implementieren operator== im Hinblick auf operator!= oder das Gegenteil?

    Meiner Meinung nach, in Bezug auf die Wartbarkeit/Lesbarkeit/Effizienz es ist das gleiche; ich würde nur empfehlen, es zu tun in der gleichen Weise überall für den sack von der Konsistenz. Der einzige Fall, wo Sie wollen lieber eine oder die andere als die "Basis-Vermittlung" ist, wenn Sie wissen, dass die Typen, die in Ihrer Struktur, die von einem Betreiber ist schneller als seine negation, aber ich weiß nicht, Wann dies geschehen könnte.

    InformationsquelleAutor Matteo Italia

  2. 8

    Ich würde dies tun, aber vielleicht bewegen operator== definition cpp-Datei. Lassen Sie operator!= zu inline -

    Erinnern, zu vergleichen, member-Variablen, die am ehesten unterscheiden sich ersten so der rest sind kurzgeschlossen und die Leistung ist besser.

    struct aggregate1 {
  bool operator==(const aggregate1& rhs) const
  {
     return (name == rhs.name)
     && (options == rhs.options)
     && (foobar == rhs.foobar);
  }
  bool operator!=(const aggregate1& rhs) const
  {
    return !operator==(rhs);
  }

  std::string name;
  std::vector<ValueT> options;
  size_t foobar;

  //...
};
    Stimmen. Wenn Sie immer noch Probleme mit der runtime-Effizienz, könnten Sie in Erwägung ziehen, wenn einige Mitglieder sind eher anders zu sein, als andere, und vergleichen Sie diese zuerst.

    InformationsquelleAutor T33C

  3. 1

    IMHO, implementieren, wie Freunde und Umsetzung der operator== (STL-algorithmen werden verlassen Sie sich auf diesen zum Beispiel) und die operator!= umgesetzt werden sollte, als die negation des ist-gleich-operator.

    InformationsquelleAutor Nim

  4. 0

    (-: Selbst beantworten 🙂

    Ich möchte hervorheben, dass ein Aspekt der Aggregate WRT Effizienz:

    Die Reihenfolge der Auswertung von op== und op!= ist irrelevant für die (Durchschnittliche) Leistung.

    Vorausgesetzt, separate Implementierungen für jetzt und angesichts der beiden Extreme (a-eq) alle Unterelemente gleich und (b-neq) alle Unterelemente inequal, wir haben diese Fälle:

    • (a-eq) + operator== : Muss vergleichen alle sub-Elemente den Wert true zurück
    • (a-eq) + operator!= : Muss vergleichen alle sub-Elemente den Wert false zurück
    • (b-neq) + operator== : Gibt false zurück, nach 1. sub-element ist bestimmt inequal
    • (b-neq) + operator!= : Gibt true zurück, nach 1. sub-element ist bestimmt inequal

    Da die Leistung im Durchschnitt ist die gleiche so oder so scheint es -- zumindest für mich -- natürlich weitere Umsetzung op!= im Hinblick auf op==, wie es fühlt sich natürlicher zu mir, zur Umsetzung der Gleichstellung op.

    Ich verstehe nicht, wie Sie kommen zu Ihrem Abschluss. operator== und operator!= wird immer die gleiche Menge an Zeit zu berechnen, und es spielt keine Rolle, wie herum Sie Sie umsetzen. Denken Sie daran, um die eine, die Sie schreiben in Bezug auf inline so, dass Sie nicht zahlen, jede Berufung Strafe.

    InformationsquelleAutor Martin Ba

Schreibe einen Kommentar