Ich habe eine Klassenhierarchie, bei der ich die Daten der einzelnen Objekte mithilfe einer Funktion (readAttributes) setze. Also in etwa so:

class Base{
 public:
  virtual void readAttributes(Attriubtes* data){
   // setze Membervariablen von Base entsprechend der Werte in Data
  }
}

Wenn ich jetzt die Attribute für ein abgeleitetes Objekt erstellen möchte, müssen natürlich auch die Daten des übergeordneten Objekts gesetzt werden. D.h., die Abgeleitete Klasse macht folgendes:

class Derived:public Base{
 public:
  virtual void readAttributes(Attriubtes* data){
   Base::readAttributes(data);
   // setze Membervariablen von Base entsprechend der Werte in Data
  }
}

Im Prinzip funktionier diese Implementierung, nur finde ich es etwas unschön, dass in jeder abgeleiteten Klasse explizit die Funktion der Basisklasse aufgerufen werden muss (da man dass auch recht einfach vergessen kann^^).

Daher meine Frage:
Gibt es vielleicht eine Möglichkeit, die "eleganter" zu lösen, insbesondere, da dieses Beispiel nicht die einzige Gruppe von Funktionen ist, bei denen ein derartiges Verhalten notwendig ist, sodass eine allgemeine Lösung recht hilfreich wäre.

Im Prinzip ist es ja so, ich habe die Funktion als virtuelle Funktion, was ja heißt, dass die abgeleitete Klasse eine völlig neue Funktionalität zur Verfügung stellen kann. Was ich aber tatsächlich möchte, ist, dass die abgeleitete Klasse die Funktionalität der Basisklasse erweitert. Ausspalten in zwei Methoden (eine virtuelle, protected und eine nicht virtuelle public) ist aufgrund der Tiefe der Klassenhierarchie auch nicht sinnvoll (bis 5 ebenen).

Bei 5 Hirarchie Ebenen und Aufrufen von Funktionen aus der Basis Klasse würde ich mir aber an deiner Stelle mal überlegen ob das Design Konzept stimmt.

Außerdem: wenn du die Methode aus der Basis Klasse jedes mal aufrufst, liegt meiner Meinung nach der Design Fehler schon darin das eine Methode die dauernd benutzt wird trotzdem abgeleitet wird. Ich würde die Methode dann eher protected machen in der Basis Klasse und eine Extra Methode virtual...=0; zusätzlich einbauen.

#edit: Ok, Nexus war schneller und hat sogar eine Lösung. Über dein Design solltest du meiner Meinung nach trotzdem mal nachdenken, 5 Ebenen sind meiner Meinung nach sehr viel.

Du kommst so aber nicht um Mehrfache Funktionen nicht rum. Allerdings ist dann die Basisklasse für das Aufrufen verantwortlich und nicht die abgeleitete.

Allerdings haben die mich nicht so sehr weitergebracht, auch wenn ich mir NVI mal angeschaut habe.

Vielleicht habe ich das Beispiel zu sehr reduziert...

Für alle Objekte im Programm, deren Daten aus einer Datei eingelesen bzw. in eine Datei geschrieben werden sollen, gibt es eine abstrakte Basisklasse:

class IAttributesObject{
 public:
  virtual void readAttributes(const Attributes* data) = 0;
  virtual void writeAttributes(Attributes* data) const = 0;
}

Dann gibt es z.B. die Objekte einer Szene, die z.B. alle durch Position, Rotation u. Skalierung. Davon abgeleitet gibt es z.B. Klassen für Lichtquellen, Darstellbare Objekte, .... Davon abgeleitet gibt es dann erst die konkrete Implementierung. Auf diese Art und Weise kommt dann schon eine recht große Hierarchietiefe zustande, die aber wohl schwierig vermeidbar ist. (ich bin mir jetzt nicht ganz sicher ob es auch irgnedwo 5 ebenen sind, aber die meisten implementierungen sind auf der 4. Ebene)

Die Methode von Nexus scheint mir daher auch ideal, da in jeder Ebene weitere Daten hinzukommen, sodass ich diese Funktionen in jeder Ebene erneuern müsste, was dann auch kein Vorteil wäre.

Ich hätte halt gedacht dass man sowas vielleicht mit templates lösen könnte. Zumindest theoretisch könnte man es ja folgendermaßen machen:

class IAttributesObject{
 public:
  virtual void readAttributes(const Attributes* data) = 0;
  virtual void writeAttributes(Attributes* data) const = 0;
 protected:
  virtual void doReadAttributes(const Attributes* data) = 0;
  virtual void doWriteAttributes(Attributes* data) const = 0;
}

Dann würde in jeder abgeleiteten Klasse die readAttributes Funktion so aussehen:

Derived::readAttributes(const Attributes* data){
 Base::readAttributes(const Attributes* data);
 doReadAttributes();
}

, d.h. der Quelltext würde in jeder abgeleiteten Klasse gleich aussehen (ein entsprechendes typedef für Base vorrausgesetzt).
Kann man sowas mit templates irgendwie realisieren (mit Makros ginge es sicherlich, aber templates wären deutlich schöner).

Eine Variante mit Templates, die ich ausprobiert habe, die auch funktioniert, basiert darauf, dass ich eine rekursive Templatefunktion habe, die für IAttributesObjekt partiell implementiert ist und für alle anderen Typen die eine doReadAttributes Funktion sowie sich selbst mit der Basisklasse als Templateparameter aufruft.
Dieser Ansatz hat jedoch einige Nachteile.

• Zum Einen muss der Typ, bei dem die rekursion begonnen wird, explizit als templateparameter angegeben werden.
• Außerdem müssen die do... Funtkionen dann public oder die templatefunktion in jeder klasse als friend deklariert werden, was ich nicht so toll finde.

Ich hoffe, damit konnte ich etwas klarer stellen, was ich brauche.

Die Methode von Nexus scheint mir daher auch ideal, da in jeder Ebene weitere Daten hinzukommen, sodass ich diese Funktionen in jeder Ebene erneuern müsste, was dann auch kein Vorteil wäre.

Das ist genau das, was du mit dem NVI Idiom bekommst.

Finde ich auch am saubersten. Und da musst du keine Angst mehr haben, dass etwas vergessen geht, weil du das als Programmierer der Basisklasse in der Hand hast und du vergisst das da ja nicht.

für eine Hierarchieebene finde ich diese Lösung ganz gut, aber wenn es tiefer geht artet dass dann wohl doch ein bisschen aus

ich hätte dann ja

class Base{
 public:
  void readAttributes(const Attributes* att){
   // ... Basisklassenaufgaben
   readAttributesImpl(att);
  }
 protected:
  virtual void readAttributesImpl(const Attributes* att) = 0;
};

in der abgeleiteten Klasse htte ich dann

class Derived1: public Base{
 protected:
  virtual void readAttributesImpl(const Attributes* att){
   // Aufgaben von Derived1
   readAttributesImplD1(att);
  }
  virtual void readAttributesImplD1(const Attributes*) = 0;
}

und dann eben in jeder Ebene so weiter...

es garantiert auf jden Fall, dass man die Funktionsaufrufe nicht vergisst, da die ja schon in der Basisklasse stehen, aber man bekommt eben jede Ebene wieder ne neue Funktion dazu...

Eben gerade deswegen würde was templateartiges mir gefallen, zu meinem Ansatz habe ich ja im letzen Post was geschrieben.

btw:
Du kannst die zu überschreibenden Funktionen sogar private machen. Überschreiben kannst du sie trotzdem. Und aufrufen muss sie ja grundsätzlich nur die Basisklasse.

Wenn ich eine Hierarchietiefe von drei hätte, wäre dass dann ja folgendermaßen:

class Base{
 public:
  void f(){
   // gemeinsamer code
   //...

   // code, den die abgeleiteten Klassen zur Verfügung stellen
   f_impl();
  }
 private:
  virtual void f_impl() = 0;
};

class Der1: public Base{
 private:
  virtual void f_impl(){
   // gemeinsamer code für alle Der1 Objekte
   // ...

   // code, den die abgeleiteten Klassen zur Verfügung stellen
   f_impl_2();

   virtual void f_impl_2() = 0;
  }
};

class Der2: public Der1{
 private:
  virtual void f_impl_2(){
   // code für f_impl_2()
  }
}

Das Problem bei der ganzen Sache ist jetzt, dass Der2 zwar gezwungen ist, f_impl_2 zu definieren, jedoch nicht daran gehindert wird, die Implementierung von f_impl zu ändern.

Gibt es eine Möglichkeit, abzusichern, dass eine Funktion nur in der Nächsttieferen Ableitungsebene geändert werden kann, bzw. dass sie nicht mehr geändert werden kann?

Gibt es eine Möglichkeit, abzusichern, dass eine Funktion nur in der Nächsttieferen Ableitungsebene geändert werden kann, bzw. dass sie nicht mehr geändert werden kann?

Nein.