Smart pointers gotchas

Several questions about using smart pointers in modern C++

• Why auto_ptr is deprecated?
• Why unique_ptr finally works good?
• How to use arrays with unique_ptr?
• Why create shared_ptr with make_shared?
• How to use arrays with shared_ptr?
• How to pass smart pointers to functions?

Some predefines

Just a simple Test class with one member to present further concepts:

class Test
{
public:
    Test():m_value(0) { std::cout << "Test::Test" << std::endl; }
    ~Test() { std::cout << "Test::~Test destructor" << std::endl; }

    int m_value;
};

typedef std::auto_ptr<Test>   TestAutoPtr;
typedef std::unique_ptr<Test> TestUniquePtr;
typedef std::shared_ptr<Test> TestSharedPtr;

Why auto_ptr is deprecated?

void doSomethig(TestAutoPtr myPtr) {
    myPtr->m_value = 11;
}

void AutoPtrTest() {
    TestAutoPtr myTest(new Test());
    doSomethig(myTest);
    myTest->m_value = 10;
}

Why unique_ptr finally works good?

doSomethig(std::move(myTest));

How to use arrays with unique_ptr?

First thing to know:

std::unique_ptr<int> p(new int[10]);  // will not work!

std::unique_ptr<int[]> p(new int[10]);  
p[0] = 10; 

For our particular example we can write:

std::unique_ptr<Test[]> tests(new Test[3]);

And we will get the desired output:

Test::Test
Test::Test
Test::Test
Test::~Test destructor
Test::~Test destructor
Test::~Test destructor

As expected :)

Why create shared_ptr with make_shared?

When we do:

std::shared_ptr<Test> sp(new Test());
std::shared_ptr<Test> sp2 = std::make_shared<Test>();

We will get the output as expected:

Test::Test
Test::Test
Test::~Test destructor
Test::~Test destructor

How to use arrays with shared_ptr?

Arrays are a bit trickier that when using unique_ptr, but we can use our own deleter and have full control over them.

std::shared_ptr<Test> sp(new Test[2], [](Test *p) { delete [] p; });

We need to use custom deleter (here as a lambda expression). Additionally we cannot use make_shared construction.
Unfortunately using shared pointers for arrays is not so nice. I suggest taking boost instead. For instance: http://www.boost.org/doc/libs/1520/libs/smartptr/sharedarray.htm

How to pass smart pointers to functions?

void testSharedFunc(std::shared_ptr<Test> sp) {
    sp->m_value = 10;
}

void testSharedFuncRef(const std::shared_ptr<Test> &sp) {
    sp->m_value = 10;
}

void SharedPtrParamTest() {
    std::shared_ptr<Test> sp = std::make_shared<Test>();

    testSharedFunc(sp);
    testSharedFuncRef(sp);
}

Some additional comments

Links

• "The C++ Standard Library" Second Edition was main reference for this post.
• http://stackoverflow.com/questions/8114276/how-do-i-pass-a-unique-ptr-argument-to-a-constructor-or-a-function
• http://stackoverflow.com/questions/14027079/stop-heap-allocation-via-make-shared
• http://stackoverflow.com/questions/9302296/is-make-shared-really-more-efficient-than-new
• http://ootips.org/yonat/4dev/smart-pointers.html

CodeProject