shared_ptr retourner une interface

Question

Je suis bidouiller à mon code en essayant de tourner dans une certaine demi-décent code C++ 0x utilisant GCC 4.5 ..

shared_ptr<IEngineLayer*> createEngineLayer(void) 
{ 
    try 
    { 
     CEngineLayer* engine = new CEngineLayer; 
     IEngineLayer* interface = dynamic_cast<IEngineLayer*>(engine); 

     return shared_ptr<IEngineLayer*>(interface); 
    } 
    catch(std::bad_alloc&) 
    { 
     // Unable to allocate enough memory for the engine layer. 
     return shared_ptr<IEngineLayer*>(); 
    } 
} 

et je reçois ce ..

shared_ptr_base.h:545:65: error: cannot convert ‘DEngine::IEngineLayer*’ to ‘DEngine::IEngineLayer**’ in initialization

Comment puis-je résoudre ce problème?

(également, comme une note de côté, va shared_ptr détruire l'interface et le CEngineLayer quand personne ne l'utilise plus?)

Answer 1

A shared_ptr<T> modèles un pointeur sur T, un shared_ptr<T *> modèles un pointeur sur pointeur vers T.

En supposant que CEngineLayer est un IEngineLayer, vous pouvez changer votre code:

shared_ptr<IEngineLayer> createEngineLayer() 
{ 
    try 
    { 
     return shared_ptr<IEngineLayer>(new CEngineLayer); 
    } 
    catch(const std::bad_alloc&) 
    { 
     // Unable to allocate enough memory for the engine layer. 
     return shared_ptr<IEngineLayer>(); 
    } 
} 

Notez également qu'un « dérivé à la base » conversion ne nécessite pas une distribution explicite: si CEngineLayer hérite publiquement de IEngineLayer, un pointeur vers CEngineLayer peut être implicitement converti en un pointeur vers IEngineLayer.

Also, as a side note, will shared_ptr destroy both the interface and the CEngineLayer when nobody is using it anymore?

Il y a un seul objet dont le type est CEngineLayer qui, si le destructor dans IEngineLayer est virtuel (et il devrait être), sera correctement détruit lorsque le nombre de référence atteint 0.

Answer 2

Retourner un shared_ptr<IEngineLayer> à la place.

Le casting est pas nécessaire soit:

shared_ptr<IEngineLayer> createEngineLayer() 
{ 
    try 
    { 
     CEngineLayer* engine = new CEngineLayer; 

     return shared_ptr<IEngineLayer>(engine); 
    } 
    catch(std::bad_alloc&) 
    { 
     // Unable to allocate enough memory for the engine layer. 
     return shared_ptr<IEngineLayer>(); 
    } 
} 

Answer 3

Vous pouvez également utiliser make_shared, qui est dans une perspective de meilleure performance:

std::shared_ptr<IEngineLayer> createEngineLayer(void) 
{ 
    return std::make_shared<CEngineLayer>(); 
} 

être sont également que le code suivant crée une fuite de mémoire:

std::shared_ptr<IEngineLayer> createEngineLayer(void) 
{ 
    IEngineLayer* pInterface = new CEngineLayer; 

    return std::shared_ptr<IEngineLayer>(pInterface); 
} 

Dans ce cas, le shared_ptr supprime un IEngineLayer et non CEngineLayer