Template oder Polymorphie benutzen



  • Hallo,
    ich möchte mir gerne eine Modulstruktur erarbeiten. Was heißt das?
    Ich habe eine Menge x an Objekten die Fähig sein sollen, eine Menge x an verschiedenen Modulen benutzen zu können aber nicht müssen. Wie viele Klassen oder Module es gibt bzw. was die nun genau machen sollen ist erstmal unerheblich.

    Meine Frage dazu stellt sich jetzt wie ich genau das Hinzufügen eines Moduls zu einem Objekt gestallte und das Handling dazu mache.

    Grundsätzlich war meine erste Überlegung, dass sämtliche Module von einer Klasse >>Modul<< abgeleitet werden, in der die Grundfunktionalität gegeben ist.

    Nun war mein erster Versuch, dass ich im jeweiligem abgeleitetem Konstruktor eine Refenz vom Objekt dem Modul mit gebe. Schnell hab ich aber gemerkt, das ich immer noch eine entsprechende Modulinstanz griffbereit benötige um entsprechend damit Handeln zu können. --> Will ich nicht; // aber vlt. habt ihr ein paar Gegenvorschläge für den Weg

    Mein Zweiter Versuch ist nun so aufgebaut, dass ich in meinen Objekten einen Pointer, unique_ptr, oder was auch immer ... ; zu jedem Modul habe und entsprechend dann die Module dem Objekt hinzufüge und so die Pointer initialisiere.

    Hier stellt sich nun meine Frage:
    Um ein Modul meinem Objekt hinzuzufügen, ist es sinnvoller dies über ein template zu gestallten oder sollte ich eine pointer zur Basisklasse Modul als Parameter wählen und dann die Polymorphie nutzen?
    Hier könnte ich dann über dynamic_cast kontrollieren ob die Module auch "benutztbar" sind.

    //T wäre in dem Fall immer ein unique_ptr<> der das entsprechende Modul beinhaltet
    template <typename T>
    void setModul(T modul);
    
    void setModul(Modul* modul);
    


  • Ich habe nicht wirklich verstanden, was du eigentlich willst, aber nur die setModul Funktion mit einem Template zu versehen wird doch nicht reichen. Du willst dir den Wert doch merken und verwenden.



  • Das ist mir schon klar, darauf kommt es in meiner Frage aber gerade nicht drauf an.

    Versuche ich es nochmal...
    Ich habe eine Basisklasse von der eine zum jetzigem Zeitpunkt noch unbekannte Menge an Ableitungen kommen, die Module.
    In einer Objektklasse (man stelle sich jetzt einfach einen Klasse Mensch vor) ist ein Array, ein Vektor oder irgendeine andere Art von Container, der die Pointer zu den verschiedenen Modulen enthält. (Module können dann für die Klasse Mensch verschiedene Verbesserungen oder irgendeine highend Spielzeug sein, wie gesagt das ist eigentlich jetzt nicht relevant)

    Die Frage ist nun:
    Ist es sinnvoll so ein Konstrukt als templates zu realisieren, d.h. in fabricfunktionen verwende ich dann die konkreten Klassen...
    Oder ist es sinnvoll mit Pointer auf die Basisklasse zu arbeite und die polymorphie zu verwenden.
    Ich hoffe das war jetzt irgendwie einleuchtender.



  • Wie willst du denn dann verschiedene Template-Klassen in einen Container unterbringen (dann wieder void* oder Base* benutzen?)?
    M.E. macht hier nur Polymorphie Sinn, wenn du sowieso eine Basisklasse für die Module hast.



  • wenn ich dich richtig verstanden habe und sich die module nur gering unterscheiden kannst die polymorphie auch weglassen.
    oder falls nicht kannst es auch ähnlich aber mit polymorphie machen.

    in etwa so:
    (nur beispiel)

    Modulklasse
    {
        ...
    };
    
    Objektklasse
    {
        vector Objekte;
        ...
    };
    
    int main()
    {
        Objektklasse objekthalter();
        for(was weiß ich)
        {
            Modulklasse modul;
    
            // mach i.was mit modul
    
            // hier übergibst du dann modul der reihe nach und speicherst in deinen vector...
            objekthalter.setModulVector(modul); 
        }
    
       // zugriff
       vector modulevector = objekthalter.getModulVector();
       ...
    }
    

    hoff konnte helfen, 🙄

    lg


Log in to reply