Verwenden Sie eine abgeleitete Klasse automatisch

Question

Ich arbeite TTY-Kommunikation mit verschiedenen Protokollen. Ich habe angefangen, Code in C++ mit Klassen zu implementieren. Eine Elternklasse enthält einige Grundfunktionen (schreiben, lesen ...) mit einigen virtuellen Funktionen. Jedes Protokoll ist eine Kindklasse mit spezifischen Funktionen. Derzeit verwende ich in meiner Anwendung direkt meine untergeordneten Klassen, aber ich möchte das Protokoll dynamisch ändern.

Ist es in diesem Fall möglich, die Elternklasse als automatischen Selektor für die Kindklasse zu verwenden? Und um den Elternteil nach dieser Auswahl immer noch zu verwenden?

Zum Beispiel (vereinfacht):

class Parent 
{ 
    void Write(); 
    void Read(); 
    void AutomaticProtocolSelector();//depending on the response of the device 
    virtual void function1(); 
    virtual void function2(); 
}; 

class protocol1 : public Parent 
{ 
    void function1(); 
}; 

class protocol2 : public Parent 
{ 
    void function2(); 
}; 


int main(int argc, char const *argv[]) 
{ 
    Parent *p; 
    p->AutomaticProtocolSelector();//let's say protocol1 is selected 
    p->function1(); //execute the function1 in the child class 
    ... 
} 

ich schon einige Beiträge über abgeleiteten Klassen lesen und die Verwendung von dynamic_cats und static_cast, aber es ist nicht genau das, was ich suche. Ich werde das benutzen, wenn es nicht möglich ist, wie ich denke.

Answer 1

Sie scheinen in einer Art Bootstrapping-Problem zu sein. Sie möchten einen Zeiger auf Parent verwenden, um eine Implementierung der Klasse Parent zu erstellen. In Ihrem Programm deneferenzieren Sie einen Zeiger, der nicht initialisiert wurde.

int main(int argc, char const *argv[]) 
{ 
    Parent *p;      // !! Not initialized 
    p->AutomaticProtocolSelector(); // The application should crash here 
    p->function1(); 

    // ... 
} 

Vorzugsweise Ihre Zeiger als nullptr initialisieren, dass es mehr machen könnte offensichtlich, dass etwas faul vor sich geht.

---

Um die Parent Klasse lassen eine Implementierung selbst liefern, müssen Sie eine statische Factory-Methode. Diese

class Parent 
{ 
public: 
    static std::unique_ptr<Parent> createParent(); 

    void Write(); 
    void Read(); 
    virtual void function1(); 
    virtual void function2(); 
}; 

kann dann in der Anwendung wie folgt verwendet werden:

int main() 
{ 
    auto p = Parent::createParent(); 
    p->function1(); 
    p->function2(); 

    // ... 
} 

Dies bedeutet aber auch, dass in Ihrer Implementierung von Parent, müssen Sie Klassen über einige oder alle möglichen Kind kennen. Das fühlt sich ein wenig nach hinten an, Sie möchten nicht, dass Ihre Elternklassen etwas über ihre Kindklassen wissen.

Wie Alexandre Thouvenin auch empfohlen hat, wäre es vielleicht das Beste, den Bau einer Kindklasse in eine separate Fabrikklasse zu verlegen.

class ParentFactory 
{ 
public: 
    ParentFactory() = default; 

    std::unique_ptr<Parent> createParent() const; 
}; 

Bei der Durchführung der createParent Methode, Sie dann eine Instanz eines der untergeordneten Klassen erstellen.

Dann in Ihrem Anwendungscode, erstellen Sie eine Fabrik und verwenden Sie es, um eine Implementierung der Parent Klasse zu erhalten.

int main() 
{ 
    ParentFactory factory; 

    auto p = factory.createParent(); 
    p->function1(); 
    p->function2(); 

    // ... 
} 

Hinweis: ich einige C++ 11-Funktionen verwendet, ich hoffe, es Ihnen nichts ausmacht.