Re: covariant return types and std::unique_ptr
Am 25.09.2012 22:33, schrieb Christof Meerwald:
I was just wondering the other day what the preferred way of rewriting
the following code fragment (using covariant return types) in C++11
(using std::unique_ptr for the return types) would be:
[..]
Obviously, just replacing the raw pointers with std::unique_ptr won't
work (without some additional casts) - but what's the cleanest way to
make it work (with the emphasis being on "cleanest")?
You might want to read the following thread where I responded to a
similar question:
http://preview.tinyurl.com/36l4flc
In short: I would ensure that the actual virtual function still creates
a raw pointer (make this virtual function protected which is mostly
useful anyway and is known as "non-virtual interface" idiom), than make
provide non-virtual function (templates) that are implemented in terms
of the virtual functions, returning the smart pointer of your interest.
Example: Instead of your
struct A
{
virtual A* createAnother() = 0;
};
provide
struct ABase
{
protected:
virtual A* doCreateAnother() = 0;
};
plus a template
template<class Derived>
struct A : ABase
{
// Note: Not virtual!
std::unique_ptr<Derived> createAnother() final {
static_assert(std::is_base_of<A, Derived>(), "Need derived type");
return
std::unique_ptr<Derived>(static_cast<Derived*>(this->doCreateAnother()));
}
};
Your derived types could now derive from the template instead:
struct B : A<B>
{
protected:
virtual B* doCreateAnother() override { ... }
};
See the referenced link for further possible extensions of that idea.
HTH & Greeting from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]