Ist es OK, von einem Templat-Smart-Pointer-Typen vererben wollen nur Klasse

Question

ich nicht in jeder Klasse zu schreiben, die ich Shared_ptr verwenden oder unique_ptr dies:

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

Ich benutze dieses:

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; 
}; 

Dann kann ich dies tun:

A::sptr p(new A); 

Ist es ein Problem von einem Design-Standpunkt aus meinen Klassen erbt, die Smart-Pointer verwenden s? Gibt es eine elegantere Lösung?

EDIT:

Ja ich verwenden kann:

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

aber was ist, wenn ich dieses:

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

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

besser, so etwas zu haben?

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

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

Vielleicht ist die Frage nicht sinnvoll .. und es ist mir faul die std zu schreiben :: blabla die ganze Zeit in Funktionstyp Returns oder Parameter.

Answer 1

Erstellen (intelligente) Zeiger der Klasse sollte nicht diese Klassenverantwortung sein. Ich glaube nicht, dass ein Verhalten, so ist das Hinzufügen gute Idee, aber wenn Sie wollen, zu tun, dass ich denke, dass Ihre Schöpfer Funktionen perfekt Weiterleitung verwendet werden soll, so dass Sie Parameter für Konstruktionen passieren kann:

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

std :: make_shared (und std :: make_unique, wenn Sie C++ 0x14 haben) ist die Standardlösung zum Erstellen von billig zugewiesenen Objekten. Ich glaube nicht, dass zusätzliche Lösungen benötigt werden.