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

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)

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

steht im ersten Artikel der Reihe auch drin