Aus einen Mehrfachvererbung Object erzeugen



  • Bestehende Code:

    class cA
    {
    public:
    typedef enum cAType{enUndefAType,enTypeA01,enTypeA02,enTypeA03...}t_enTypeA
    cA(t_enTypeA enTypeA)
    {
    ....
    }
    ...
    };
    

    dann

    class cB
    {
    public:
    typedef enum cBType{enUndefBType,enTypeB01,enTypeB02,enTypeB03...}t_enTypeB
    cB(t_enTypeB enTypeB)
    {
    ....
    }
    ...
    };
    

    dann

    class cC
    {
    public:
    typedef enum cCType{enUndefCType,enTypeC01,enTypeC02,enTypeC03...}t_enTypeC
    cC(t_enTypeC enTypeC)
    {
    ....
    }
    ...
    
    };
    

    und

    class cD:public cA, public cB
    {
    public:
    cD(t_enTypeA enTypeA = enTypeA01, t_enTypeB enTypeB = enTypeB01,t_enTypeC enTypeC = enTypeC01)
    {
    ....
    }
    
    };
    

    Problem ist: Wenn ich einen Object von Type cD erzeuge:

    cD *mPointer_cD = new CD();
    dann ist das Object mPointer_cD mit folgende Enumeration Type (enTypeA01,enTypeB01,enTypeC01) initialisiert und das möchte ich nicht.

    Idee wäre Objecte von Type cD flexible zu erzeugen.
    Das heisst es muss direkt beim Erzeugung des Objects, die Initialisierung folgen.
    Idee: Wie mache ich am besten mit minimalen Aufwand?

    Danke



  • Saheb schrieb:

    Das heisst es muss direkt beim Erzeugung des Objects, die Initialisierung folgen.
    Idee: Wie mache ich am besten mit minimalen Aufwand?

    Durch Aufrufe der Basisklassenkonstruktoren:

    class cD:public cA, public cB
    {
    public:
    cD(t_enTypeA enTypeA = enTypeA01, t_enTypeB enTypeB = enTypeB01,t_enTypeC enTypeC = enTypeC01)
    : cA(enTypeA),
      cB(enTypeB)
    {
    ....
    }
    
    };
    

    Und dann musst du dem Konstruktor natürlich auch die gewünschten Werte übergeben:

    cD *mPointer_cD = new CD(cA::enTypeA02, cB::enUndefBType, cD::enTypeC03);



  • @daddy_felix

    Danke
    Wenn ich von der Class:

    cD cDreferenz
    

    einen referenz machen dann mekert die Compiler:

    Error	C2512	'cD': no appropriate default constructor available
    

    Warum darf ich keinen Referenz?

    Danke



  • Eine Referenz hat erstmal nichts mit einem default-Konstruktor zu tun, da machst du irgendwas falsch. Zeig mal den relevanten Code (also wie erzeugst du die Instanz und wie willst du dann die Referenz erzeugen)



  • Bei einem Methode wurde folgende gemacht

    void etwasTun()
    {
       ...
       cD *pcD;
       cD encD_Default; // Warum ist das falsch?
       ...
    
    }
    


  • Da hast du irgendwas anderes geändert. Mit dem oben gezeigten Code sollte das funktionieren. Meine Glaskugel vermutet, dass du die default-Werte im Konstruktor von cD entfernt hast.



  • daddy_felix schrieb:

    Da hast du irgendwas anderes geändert. Mit dem oben gezeigten Code sollte das funktionieren. Meine Glaskugel vermutet, dass du die default-Werte im Konstruktor von cD entfernt hast.

    Dein Glaskugel hat vollkommen Recht 😃

    danke



  • @daddy_felix

    Eine Kurze Frage:
    Gibt es vielleicht eine bessere Vorgehen?

    Grund dafür:
    Der jetzigen Stand der SW ist eine Erbe von 10 Jahre und bei deine vorgeschlagene
    Änderung ist die SW nicht mehr Stabil.

    Danke



  • Kann ich die Mehrfachvererbung durch "Kompositum
    (Entwurfsmuster) " umändern?



  • Das kommt drauf an.

    Wenn man eine Klasse neu designed, sollte man mit Vererbung und Komposition die Tatsächliche Beziehung der Klassen zueinander abbilden.

    Zum Beispiel Komposition:
    Ein Auto hat:
    - Reifen
    - Lenkrad
    - Motor

    Vererbung:
    - Ein VW Golf ist ein Auto
    - Ein Tesla Model S ist ein Auto

    Ob du das in deinem Bestandscode ändern kannst, kannst schließlich nur du entscheiden. Aus Erfahrung würde ich sagen, dass zu ändern kann mit beliebig viel Aufwand verbunden sein, wenn zum Beispiel Funktionen und/oder Variablen der Elternklassen verwendet werden usw.

    Was bei dir sinnvoll ist, kann ich nicht beurteilen. Aber ich würde vorsichtig davon abraten, bei Refactorings ganze Designentscheidungen über den Haufen zu schmeißen. (Es sei denn man hat gute Gründe dafür)



  • In dem jetzigen Stand lässt sich die SW nicht erweitern.
    Eine Redesign ist nötig.

    In der SW wird eine neue Erweiterung geben und in der jetzigen SW Design ist das unmöglich.

    Was ich jetzt gerne hätte, ist von der jetzigen gekoppelten Abhängigkeit wegzugehen.

    Wie es oben beschrieben ist, class D erbt von A,B und C (Also eine Mehrfachvererbung) und möchte diese duch Composite Entwurfmuster ersetzen.
    Meine Frage wie tue ich das:(Nur das Klassendiagramm reicht mir).

    Danke



  • Saheb schrieb:

    Wie es oben beschrieben ist, class D erbt von A,B und C (Also eine Mehrfachvererbung) und möchte diese duch Composite Entwurfmuster ersetzen.
    Meine Frage wie tue ich das:(Nur das Klassendiagramm reicht mir).

    Lies dir zuerst das und das hier durch:
    https://de.wikipedia.org/wiki/Kompositum_(Entwurfsmuster)
    https://de.wikipedia.org/wiki/Assoziation_(UML)

    Das Composite-Pattern (Entwurfsmuster) ist nicht dasselbe wie die Composite Aggregation (Objektbeziehung).



  • @Printe

    Danke das habe ich schon gelesen und genau daran hakt schon.
    In Meine Anwendung: wenn ich mich an Kompositum "https://de.wikipedia.org/wiki/Assoziation_(UML)" mich orientiere ist Die Klasse D als Ganzes gesehen und die restliche Klassen A,B und C als Teils.
    Was ich nicht verstehen kann: Wie kann ich das in "Kompositum (Entwurfsmuster)" einsetzen?



  • Wahrscheinlich gar nicht.
    Das Kompositum-Entwurfsmuster ist ein Strukturmuster für eine spezielle Familie von Anwendungsfällen. Dabei wird eine Baumstruktur aufgebaut aus Knoten, die entweder ein Objekt vom Typ T oder eine weitere Teilbaum-Struktur enthalten. Beispiel: Verzeichnisbaum: Jedes Verzeichnis enthält Dateien oder weitere Verzeichnisse, bis zur letzten Ebene, die nur noch Dateien oder nichts enthält.

    Ich glaube nicht, dass das hier anwendbar ist. Ich glaube, du willst eher sowas:

    class D
    {
    A a;
    B b;
    C c;
    };
    

    Wobei noch fraglich ist, ob das D die anderen Objekte tatsächlich enthält oder nur Pointer oder Referenzen darauf. Das kann man nur diskutieren, wenn man weiß, was A, B, C und D sind.



  • Der IstStand ist das :

    class cD:public cA, public cB
    {
    public:
    ...
    
    };
    

    Ich möchte die Klassen entkoppeln.
    Ziel wäre: Nach Möglichkeiten zu wenig Abhängigkeiten


Log in to reply