Metodo statico per creare un oggetto invece di costruttore

Question

Sto creando una GUI in applicazione ++ mia C e ho una classe chiamata GUIObject che è la classe base per tutti gli altri componenti, come ad esempio Button, CheckBox, Window ecc

Ho anche una classe GUIObjectsStorage, che consiste in tutti gli GUIObject s creati. Finora ho lavorato con i puntatori prime, così ho avuto questo costruttore per GUIObject classe:

GUIObject::GUIObject() : 
{ 
    GUIObjectsStorage::Instance().addObject(this); 
} 

e non era male per le mie esigenze, perché ogni volta che volevo per accedere oggetto specifico, ho appena preso da GUIObjectsStorage. Ma ora sto cercando di spostare in uso di puntatori intelligenti, in modo che GUIObjectsStorage ora memorizza serie di std::shared_ptr<GUIObject> invece di puntatori prime e non posso usare il mio costruttore come ho usato prima:

GUIObject::GUIObject() : 
{ 
    GUIObjectsStorage::Instance().addObject(std::shared_ptr<GUIObject>(this)); 
} 

perché per esempio :

// Somewhere in code 
std::shared_ptr<Button> bt = std::shared_ptr<Button>(new Button()); 

Fondamentalmente aveva ora hanno due shared_ptr s (uno qui, secondo in GUIObjectsStorage, perché è stato aggiunto nel costruttore Button s') che hanno entrambi conteggio di riferimento = 1, tuttavia entrambi punto allo stesso oggetto in memoria. Quindi se uno di loro muore, anche l'oggetto stesso viene distrutto.

Così mi è venuta l'idea di fare forse costruttore privato per tutte le classi che ereditano da GUIObject e creare un metodo statico che creare e restituire std::shared_ptr ed è copia aggiungere GUIObjectsStorage. In questo modo ho potuto avere shared_ptr s con conteggio di riferimento = 2 che è corretto:

class Button : public GUIObject 
{ 
private: 
    // ... 
    Button(); 
public: 
    // ... 
    static std::shared_ptr<Button> create(); 
} 

std::shared_ptr<Button> Button::create() 
{ 
    std::shared_ptr<Button> bt = std::shared_ptr<Button>(new Button()); 
    GUIObjectsStorage::Instance().addObject(bt); 

    return bt; 
} 

Nascondendo costruttore posso essere sicuro che nessuno creerà un oggetto in modo diverso utilizzando create() metodo.

Ma questo è un buon modo di progettare questo? In caso contrario, quale potrebbe essere una soluzione migliore per questo problema?

Answer 1

L'uso classico di una fabbrica per realizzare oggetti.

Detto questo, potrebbe non essere necessario. Sai quando i widget non sono più necessari? I gestori di GUI come questo spesso lo fanno. Se è così, il commentatore ha ragione: designa un proprietario dell'oggetto, lascia che lo elimini e tu sia impostato.

Answer 2

È possibile considerare l'ereditarietà da enable_shared_from_this.

Quindi dopo aver condiviso un oggetto_ptr, è possibile utilizzare shared_from_this() per ottenere il parametro shared_ptr che contiene l'oggetto.