using boost::scoped_ptr if possible

Question

I have something like this in pagePtr.h

typedef int (*FunPtrType)(char* sz, unsigned int max_bytes, char* arg1,
char* arg2, char* arg3, char* arg4);

and a static function which creates a object

static pagePtr* CreatePage( FunPtrType Ptr2Fun)
{
    return new pagePtr(ptr2Fun);
}

would boost::scoped_ptr help me not worry abt deleting those created abject later. if yes how should I implement in this case. And what could be the other possible better options, if available, to delete those objects created.

You need `std::unique_ptr`. `boost::scoped_ptr` cannot be passed around. — Kerrek SB, Mar 05 '13 at 13:38
You could use std::unique_ptr or std::shared_ptr: std::unique_ptr CreatePage(...)... — AnatolyS, Mar 05 '13 at 13:42
could you help me with how the implementation would look like in my case using std::unique_ptr? — cybercop, Mar 05 '13 at 13:47
What are the problems you have with the implementation using `unique_ptr`? — Arne Mertz, Mar 05 '13 at 14:07

score 5 · Answer 1 · edited May 23 '17 at 12:13

boost:scoped_ptr is not copyable so cannot be returned from CreatePage(). If C++11 is available std::unique_ptr could be used:

static std::unique_ptr<pagePtr> CreatePage( FunPtrType Ptr2Fun)
{
    return std::unique_ptr<pagePtr>(new pagePtr(ptr2Fun));
}

Is there a reason pagePtr is not copyable? If not and it is inexpensive to copy then return by value.

If pagePtr is non-copyable and std::unique_ptr is not available then you could use boost::shared_ptr to remove the responsiblity from the caller for destructing the returned pagePtr. With the downside that using shared_ptr does not indicate sole ownership and pay the price for unrequired reference counting (see What C++ Smart Pointer Implementations are available? for more information and descriptions on the available smart pointers).

From the posted code, pagePtr appears to a wrapper around a function pointer so consider using boost::function instead, which is copyable, and remove pagePtr completely:

typedef boost::function<int(char* sz,
                            unsigned int max_bytes,
                            char* arg1,
                            char* arg2,
                            char* arg3,
                            char* arg4)> FunPtrType;

Actually, `std::unique_ptr` doesn't have a copy constructor; it's the move constructor that's called. — kirbyfan64sos, May 15 '14 at 01:23

score 3 · Answer 2 · answered Mar 05 '13 at 13:47

The idiom for having a function that dynamically allocates an object and safely returns ownership to the caller is to return a std::unique_ptr:

std::unique_ptr<foo> create_foo()
{
  return std::unique_ptr<foo>(new foo());
}

This tells the caller explicitly that they are getting ownership of the object and the object will be destroyed when their std::unique_ptr is destroyed (unless ownership is further passed elsewhere).

Applied to your example:

static std::unique_ptr<pagePtr> CreatePage( FunPtrType ptr2Fun)
{
    return std::unique_ptr<pagePtr>(new pagePtr(ptr2Fun));
}

As for why other pointers are not applicable:

boost::scoped_ptr cannot pass ownership at all - it is the most restrictive of the smart pointers (pretty much equivalent to a const std::unique_ptr)
std::auto_ptr is deprecated because it provides move semantics through copying
std::shared_ptr would work but doesn't make much sense - the function certainly isn't going to be sharing ownership with the caller because the function is ending

using boost::scoped_ptr if possible

2 Answers2