No directamente, pero puede falsificarlo haciendo que las funciones virtuales reales sean inaccesibles desde fuera de la clase y envolviendo la llamada de función virtual en una función no virtual. Lo malo es que tendrá que recordar implementar esta función de contenedor en cada clase derivada. Pero podría evitar esto colocando tanto la declaración de la función virtul como la envoltura en la macro.
using namespace boost; // for shared_ptr, make_shared and static_pointer_cast.
// "Fake" implementation of the clone() function.
#define CLONE(MyType) \
shared_ptr<MyType> clone() \
{ \
shared_ptr<Base> res = clone_impl(); \
assert(dynamic_cast<MyType*>(res.get()) != 0); \
return static_pointer_cast<MyType>(res); \
}
class Base
{
protected:
// The actual implementation of the clone() function.
virtual shared_ptr<Base> clone_impl() { return make_shared<Base>(*this); }
public:
// non-virtual shared_ptr<Base> clone();
CLONE(Base)
};
class Derived : public Base
{
protected:
virtual shared_ptr<Base> clone_impl() { return make_shared<Derived>(*this); }
public:
// non-virtual shared_ptr<Derived> clone();
CLONE(Derived)
};
int main()
{
shared_ptr<Derived> p = make_shared<Derived>();
shared_ptr<Derived> clone = p->clone();
return 0;
}
posible duplicado de http://stackoverflow.com/questions/196733/how-can-i-use-covariant-return-types-with-smart-pointers –