How can I use covariant return types with smart pointers?

by

Firstly, this is indeed how it works in C++: the return type of a virtual function in a derived class must be the same as in the base class. There is the special exception that a function that returns a reference/pointer to some class X can be overridden by a function that returns a reference/pointer to a class that derives from X, but as you note this doesn’t allow for smart pointers (such as shared_ptr), just for plain pointers.

If your interface RetInterface is sufficiently comprehensive, then you won’t need to know the actual returned type in the calling code. In general it doesn’t make sense anyway: the reason get_r is a virtual function in the first place is because you will be calling it through a pointer or reference to the base class AInterface, in which case you can’t know what type the derived class would return. If you are calling this with an actual A1 reference, you can just create a separate get_r1 function in A1 that does what you need.

class A1: public AInterface
{
  public:
     boost::shared_ptr<RetInterface> get_r() const
     {
         return get_r1();
     }
     boost::shared_ptr<Ret1> get_r1() const {...}
     ...
};

Alternatively, you can use the visitor pattern or something like my Dynamic Double Dispatch technique to pass a callback in to the returned object which can then invoke the callback with the correct type.

More Related Contents:

  1. What is a smart pointer and when should I use one?
  2. RAII and smart pointers in C++
  3. Why can I not push_back a unique_ptr into a vector?
  4. Differences between std::make_unique and std::unique_ptr with new
  5. What C++ Smart Pointer Implementations are available?
  6. “Downcasting” unique_ptr to unique_ptr
  7. Smart pointers: who owns the object? [closed]
  8. How much is the overhead of smart pointers compared to normal pointers in C++?
  9. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  10. When should I use raw pointers over smart pointers?
  11. smart pointers and arrays
  12. How to avoid memory leak with shared_ptr?
  13. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  14. When to use shared_ptr and when to use raw pointers?
  15. Passing shared_ptr as shared_ptr
  16. Should I delete the move constructor and the move assignment of a smart pointer?
  17. Return Type Covariance with Smart Pointers
  18. How is it possible (if it is) to implement shared_ptr without requiring polymorphic classes to have virtual destructor?
  19. Can Google Mock a method with a smart pointer return type?
  20. Getting a vector into a function that expects a vector
  21. Is auto_ptr deprecated?
  22. When is C++ covariance the best solution?
  23. C++ covariant templates
  24. unique_ptr and OpenSSL’s STACK_OF(X509)*
  25. Why would I std::move an std::shared_ptr?
  26. Example to use shared_ptr?
  27. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  28. How to check memory allocation failures with new operator?
  29. How to enable_shared_from_this of both parent and derived
  30. C++ covariance in parameters

Leave a Comment