Generalize Smart Pointers in C++

re: Generalize Smart Pointers in C++

Vatsan Madhavan — Fri, 06 Aug 2004 20:54:00 GMT

I like making the common case easy. Writing a Dispose() function (a Global one at that!! eeeks!) is a pain. So this is what I'd do different:

//Provide a default for the Dispose() function
template< typename T, void (__stdcall *Dispose)( T )=0, const T NullResource = 0>
class CAutoResource
{
........
~CAutoResource()
{
if ( NullResource != m_Resource )
{
if (Dispose)
Dispose( m_Resource );
else delete m_Resource; //default to delete
}
}
........
};

I tried to do something like this:

template< typename T, void (__stdcall *Dispose)( T )=operator delete, const T NullResource = 0>

but this wouldn't compile. Can this be made to work ?

re: Generalize Smart Pointers in C++

the1 — Fri, 06 Aug 2004 21:16:00 GMT

Vatson,

CAutoResource is not the right place to have a default delete function, as the resource may not be a pointer at all. CAutoPtrEx is what you want.

'operator delete' is not accepted as a function pointer. You can define a template function like this:

template < typename T >
void Delete( T * p )
{
delete p;
}

Then you can do:

template < typename T, void (* Dispose)( T * ) = Delete >
class CAutoPtrEx
{
...
};

re: Generalize Smart Pointers in C++

Simon Cooke [exMSFT] — Fri, 06 Aug 2004 21:18:00 GMT

Problem with your generic handle implementation;

It doesn't work for File handles.

Easily fixed though; just replace the Null value with INVALID_HANDLE_VALUE instead of 0.

re: Generalize Smart Pointers in C++

the1 — Fri, 06 Aug 2004 21:23:00 GMT

Simon,

There is no problem for file handles. I made the value denoting null resource a *template parameter* just for this purpose. You just need to do something like:

typedef CAutoResource< int, close, INVALID_HANDLE_VALUE > CAutoFileHandle;

assuming close() closes a file handle, and the concrete type for file handle is int.

re: Generalize Smart Pointers in C++

Rick Schaut — Fri, 06 Aug 2004 22:52:00 GMT

Rather than use a pointer to a function for releasing the resource, use functors:

// Virtual base class for release functor
class CAutoRelease
{
public:
virtual void operator()(void *) = NULL;
};

// Changes to CAutoResource:
template<typename T, const T NullResource = 0>
class CAutoResource
{
public:
    typedef T ResourceType;
      CAutoResource( CAutoRelease &Release, T Resource = NullResource )
            : m_Resource( Resource ),
m_Release(Release) {};
~CAutoResource()
{
if (NullResource != m_Resource)
m_Release(m_Resource);
};

[...]

private:
T m_Resource;
CAutoRelease &m_Release;
};

// Templated class for pointer to a type
template <class T>
class CAutoReleasePtr
{
public:
virtual void operator()(void *p)
{
T *pt = static_cast<T*>(p);
delete pt;
];
};

// Templated class for pointer to a COM interface
template <class T>
class CAutoReleaseInterface
{
public:
virtual void operator()(void *p)
{
T *pi = static_cast<T *>(p);
pi->Release();
};
};

While CAutoResource desn't have a default constructor, any subclass can have a default constructor that passes in the appropriate release functor:

// Template CAutoResource class for COM interfaces
template <class T>
class CAutoCOMPtr : public CAutoResource
{
typedef T *PInterface;
CAutoCOMPtr() : CAutoResource(CAutoReleaseInterface<PInterface>, NULL) {};

[...]
};

Of course, caveats apply since I've not compiled or run any of the above code, but it shouldn't be difficult to get it to work.

Rick

re: Generalize Smart Pointers in C++

Rick Schaut — Sat, 07 Aug 2004 00:25:00 GMT

Actually, there's a problem with the type conflict between the typedef given in CAutoResource and the operator() in the CAutoRelease virtual base class, so the idea needs a bit more work to be fleshed out completely. Nonetheless, I'd still look for a functor-based solution rather than use a pointer to function.

Rick

re: Generalize Smart Pointers in C++

indranil banerjee — Sat, 07 Aug 2004 11:39:00 GMT

There is one feature that std::auto_ptr has that your class doesn't. And that is the ability to return auto_ptr from a function.

You'd have to implement the copy constructor for that.

re: Generalize Smart Pointers in C++

David A. Mellis — Mon, 09 Aug 2004 03:06:00 GMT

What's the advantage of rewriting std::auto_ptr (and, when you decide you need more functionality, boost::shared_ptr) when you can simply wrap your resource in a class and use the existing smart pointers?

Or, what's the advantage of making the Dispose function a template parameter instead of defining its behavior with a virtual destructor?

re: Generalize Smart Pointers in C++

Dee Zsombor — Mon, 09 Aug 2004 10:37:00 GMT

With boost::shared_ptr you can get the same functionality and even better as you will use a class soon to be part of the new C++ standard!

Copy paste from shared_ptr documentation:

shared_ptr<IWhatever> make_shared_from_COM(IWhatever * p)
{
p->AddRef();
shared_ptr<IWhatever> pw(p, mem_fn(&IWhatever::Release));
return pw;
}

Note how the resource is returned from a function ...

re: Generalize Smart Pointers in C++

the1 — Fri, 20 Aug 2004 06:57:00 GMT

Rick,

Good point. I'll consider using functor as opposed to function pointer.

David & Dee,

Thanks for pointing me to shared_ptr. Why do we need CAutoResource when we can wrap the resource in a class and use existing smart pointers? The answer is that we don't want the resource to behave like a pointer. i.e. we want to say 'resource' instead of '*resource'.