Operatorüberladung mit Vererbung



  • Hi,

    ich habe zwei Klassen Anton und Berta, wobei Berta von Anton erbt. Beide Klassen sollen nun den + Operator überladen:

    class Anton {
    public:
      friend Anton operator+(const Anton &ant1, const Anton &ant2);
    private:
      int wert1;
      int wert2;
    }
    
    Anton operator+(const Anton &ant1, const Anton &ant2) {
      Anton result = ant1;
      result.wert1 += ant2.wert1;
      return result;
    }
    

    Der überladene Operator soll wert1 summieren, wert2 jedoch komplett übernehmen.
    Angenommen Berta fügt nun noch zwei weitere Membervariablen wert3 und wert4 hinzu:

    class Berta:Anton {
    public:
      friend Berta operator+(const Berta &ber1, const Berta &ber2);
    private:
      int wert3;
      int wert4;
    
    }
    
    Berta operator+(const Berta &ber1, const Berta &ber2) {
      Berta result = ber1;
      ... //Hier brauche ich Hilfe
    }
    

    Auch hier soll gelten, dass wert4 übernommen, wert3 summiert wird.

    Wie kann ich nun erreichen, dass ich in der +Operatorüberladung von Berta nicht noch einmal die Operation von der +Operatorüberladung von Anton neu implementieren muss? Der Grund für meine Frage ist, dass in meiner Software genau dieser Fall auftritt und die Implementierung des +Operators der Antonklasse schon recht umfangreich ist und ich versuche, Codeduplikate zu vermeiden.

    Schönen Gruß,
    Christoph



  • Wie versprochen: snip! ^^



  • Da hab ich auch schon drüber nachgedacht, bloß dann wäre es fast sauberer, ganz auf die Überladung zu verzichten und gleich eine eigene Memberfunktion zu veröffentlichen, die die Summation übernimmt.



  • toffkriss schrieb:

    wäre es fast sauberer, ganz auf die Überladung zu verzichten und gleich eine eigene Memberfunktion zu veröffentlichen, die die Summation übernimmt.

    Stimmt, z.B. einen operator+=:

    class Anton : public boost::addable<Anton>
    {
    public:
      Anton& operator+=(Anton const& rhs)
      {
        /* ... */
        return *this;
      }
    private:
      int wert1;
      int wert2;
    };
    
    class Berta : public boost::addable1<Berta, Anton>
    {
    public:
      Berta& operator+= (Berta const& rhs)
      {
        Anton::operator+=(rhs); //aufruf für den Basisklassenteil
        /* ... */
        return *this;
      }
    private:
      int wert3;
      int wert4;
    }:
    

    für die boost-Teile siehe meine beiden Artikel über boost::operators, die einem die Arbeit abnehmen. Achtung: bei berta muss explizit addable1 genutzt werden (siehe hier, Punkt 3.3)



  • Hmm, das scheint mir im Moment die beste Lösung zu sein. Das wäre natürlich schade, denn der +Operator würde meinem Projekt wesentlich besser zu Gesicht stehen. Naja, man kann ja seinen Quellcode immer noch schöndokumentieren. Falls ich doch noch ne andere Lösung finde, dann werde ich sie hier posten. Vielen Dank erstmal.



  • schau dir die artikel an - du bekommst den operator+ durch die boost-sache mit. Alternativ kannst du den operator immer ganz einfach durch oerator+= implementieren:

    A operator+ (A const& lhs, A const& rhs)
    {
      A tmp(lhs);
      tmp += rhs;
      return tmp;
    }
    

    steht im ersten Artikel der Reihe auch drin 🙂



  • Jau, ich werd mich dann erstmal den +=Operator zur Hilfe nehmen. Vielleicht fällt mir ja irgendwann noch was anderes ein oder so. Schönen Dank für die Hilfe!


Log in to reply