Aide avec ceci (pointeurs et polymorphisme)

Question

Voici mon problème. Je crée ma propre interface graphique. Tous les Widgets sont dans un conteneur qui a des fonctions d'ajout et de suppression. Les widgets dérivent d'une classe de widget de base. Voici où je suis incertain. Je voudrais idéalement un flux comme celui-ci: l'utilisateur crée un pointeur (widget souhaité dérivant de la classe de base), le conteneur alloue et gère les ressources, l'utilisateur a un pointeur vers le widget et peut y effectuer des appels.

Cependant, le polymorphisme rend cette confusion. Comment pourrais-je obtenir mon conteneur pour créer le bon type de nouveau? Le problème ici est que n'importe qui peut créer un nouveau widget (comme SuperTextBoxWidget), c'est pourquoi fournir une chaîne et faire un changement ne résoudrait pas cela.

Mon autre solution de correction rapide est de rendre l'utilisateur responsable de faire le nouveau, et de fournir le pointeur vers la fonction d'ajout du conteneur. Mais cela ne me semble pas idiot, et il semble étrange que l'utilisateur fasse l'allocation initiale, mais alors le conteneur gère le reste, y compris l'effacement.

Quel serait le meilleur et le plus propre à cet égard?

Merci

juste une idée de ce que j'ai jusqu'à présent:

class AguiWidgetContainer 
{ 

    std::vector<AguiWidgetBase*> widgets; 
    public: 
     AguiWidgetContainer(void); 
     ~AguiWidgetContainer(void); 
     void handleEvent(ALLEGRO_EVENT* event); 
     int add(AguiWidgetBase *widget); 
     bool remove(int widgetId); 
}; 

Answer 1

Mon autre alternative quick-fix est de rendre l'utilisateur responsable de faire nouveau, et en fournissant le pointeur sur la fonction d'ajout du conteneur.Mais ce ne me semble pas idiot, et il semble étrange que l'utilisateur fasse l'allocation initiale , mais le conteneur gère le reste, y compris l'effacement .

Pourquoi cela vous semble-t-il étrange?

Si un conteneur commence à prendre la responsabilité de l'allocation des objets à contenir, il enfreint SRP. Je vous recommande de concevoir vos interfaces pour accepter les pointeurs vers les objets Widget alloués par les utilisateurs. Le conteneur est uniquement responsable de les contenir/stocker/les récupérer.

L'utilisateur prend également la responsabilité de supprimer les objets alloués.

La plupart des conteneurs STL fonctionnent de cette manière.

Answer 2

je suggère l'emprunt de COM et de rendre votre classe widget de base d'une interface virtuelle pure qui comprend une fonction pour se détruire. Ensuite, les implémenteurs de votre widget n'ont même pas besoin d'utiliser le même allocateur (important si vous avez déjà croisé des limites DLL).

EDIT: Exemple:

class IWidget 
{ 
public: 
    virtual Size Measure() = 0; 
    virtual void Draw(Point) = 0; 
    //and so on 

    virtual void Release() = 0; 
}; 

class TextBoxWidget : public IWidget 
{ 
    TextBoxWidget() {} 
    ~TextBoxWidget() {} 
public: 
    // implement IWidget functions, etc, etc 

    static TextBoxWidget* Create() { return new TextBoxWidget(); } 
    virtual void Release() { delete this; } 
}; 

Maintenant TextBoxWidget ne peut être créé avec TextBoxWidget::Create() et libéré avec someTBW->Release(), et utilise toujours new et delete dans la même DLL, garantissant qu'ils correspondent.

Answer 3

Je peux penser à au moins deux façons de le faire.

1. Fournir une version du modèle de add:

template<class T> 
int add() { 
    widgets.push_back(new T); 
} 

2. Utilisez une classe d'usine:

Vous pouvez avoir une base factory class qui définit les méthodes d'allouer (et peut-être aussi libre) widgets. Vos utilisateurs fournissent alors leur propre sous-classe de l'usine qui crée le type correct de widget. Par exemple:

class AguiWidgetFactory { 
    AguiWidgetBase *createWidget() = 0; 
}; 

class AguiSuperWidgetFactory : public AguiWidgetFactory { 
    AguiWidgetBase *createWidget() { 
    return new SuperTextBoxWidget(); 
    } 
}; 

Votre méthode add prend alors un objet usine en entrée et utilise pour créer un nouveau widget.