If I need polymorphism should I use raw pointers instead of unique_ptr?

Question

If I need polymorphism should I use raw pointers instead of unique_ptr ?

I saw some threads that show how to use unique_ptr for polymorphic behaviour. I am not sure it is worth the trouble, I would rather stay with raw pointers. Can you please comment on this, your opinion on raw vs smart pointers in this context?

Answer 1

The following simple code shows that std::unique_ptr works just fine from a polymorphism point of view, printing "Hello from Derived.".

#include <iostream>
#include <memory>
using std::cout;

struct Base 
{
    virtual ~Base() { }

    virtual void SayHello()
    {
        cout << "Hello from Base.\n";
    }
};

struct Derived : public Base
{
    void SayHello() override
    {
        cout << "Hello from Derived.\n";
    }
};

int main()
{
    std::unique_ptr<Base> pBase( new Derived() );
    
    // Or using std::make_unique:
    //
    // std::unique_ptr<Base> pBase = std::make_unique<Derived>();      
    
    pBase->SayHello();
}

Anyway, observing raw pointers are fine; what you must pay attention to are owning raw pointers. Owning raw pointers should be safely wrapped inside RAII boundaries (using unique_ptr, shared_ptr, or some custom resource manager).

Answer 2

• Use unique_ptr to control ownership of allocated resources, e.g. allocate on the free store inside a function and return a unique_ptr.

• Use just a reference for polymorphic behavior if ownership is not an issue. Even if a unique_ptr does the same, you spare the compiler from additional work.

• Use a pointer for polymorphic behavior within a container if ownership is not an issue. You cannot have a container of references.

Answer 3

Smart pointers are about ownership/lifetime. Where you need to manage the lifetime of a polymorphic object, use a smart pointer. If you are just using the object, prefer raw references/pointers (in that order) over smart pointers.