E 'ok per ereditare da una su modelli tipi puntatori intelligenti unica classe

Question

non voglio scrivere in ogni classe che uso shared_ptr o unique_ptr questo:

std::shared_ptr<Foo> p = CreateFoo(); 

sto usando questo:

template <typename T> 
struct ptr_types 
{ 
    typedef std::shared_ptr<T> sptr;  
    typedef std::unique_ptr<T> uptr; 
}; 

class A: public ptr_types<A> 
{ 
public: 
    A(){} 
    int m; 
}; 

Poi, posso fare questo:

A::sptr p(new A); 

è un problema da un punto di vista del design ereditare mie classi che utilizzano puntatore intelligente S? C'è una soluzione più elegante?

EDIT:

sì posso usare:

auto p = std::make_shared<A>(); 

ma che dire se ho questo:

std::shared_ptr<A> A::CreateA() 
{ 
.... 
} 

void A::Sink(std::unique_ptr<A> p) 
{ 
... 
} 

meglio avere qualcosa di simile?

A::sptr A::CreateA() 
{ 
... 
} 

void A::Sink(A::uptr p) 
{ 
... 
} 

Forse la domanda non ha senso .. e sono io essere pigro a scrivere la std :: blabla per tutto il tempo in funzione del tipo ritorni o parametri.

Answer 1

La creazione di indicatori (smart) di classe non dovrebbe essere una responsabilità di classe. Non credo che l'aggiunta di un tale comportamento è buona idea, ma se si vuole fare questo penso che le funzioni creatore dovrebbero utilizzare l'inoltro perfetto, in modo da poter passare il parametro per le costruzioni:

template<typename T, typename... Args> 
std::unique_ptr<T> CreateA(Args&&... args) 
{ 
    return std::make_shared<T>(std::forward<Args>(args)...); 
} 

Utilizzando std :: make_shared (e std :: make_unique se hai C++ 0x14) da solo è la soluzione standard per la creazione di oggetti allocati a basso costo. Non penso che siano necessarie ulteriori soluzioni.