Click here to Skip to main content
Click here to Skip to main content

Scheming Code: The Dispose Pattern in C++

, 8 Mar 2012
Rate this:
Please Sign up or sign in to vote.
Welcome to the first article in the Scheming Code series. The series is meant to be a focus on the creation of various patterns in various programming languages. This particular article will describe the Dispose pattern, and how to employ it in C++. Please note: this is not an introduction to C++. T

Welcome to the first article in the Scheming Code series. The series is meant to be a focus on the creation of various patterns in various programming languages. This particular article will describe the Dispose pattern, and how to employ it in C++. Please note: this is not an introduction to C++. The topics and code presented here are done so with the assumption that the reader knows how to write basic data structures in C++. Also, with most of my background in .NET, C++ best practices are followed to the extent of my abilities.

Why not just use the destructor?

It is written [MSDN: Implementing a Dispose Method], “the pattern for disposing an object, referred to as a dispose pattern, imposes order on the lifetime of an object.” Using the Dispose pattern, the developer can determine when an object is destroyed. In .Net, it is generally only used for objects that access unmanaged resources. Since C++ is unmanaged, memory management is our priority and responsibility. One of the points this gets to is properly destroying objects. Memory leaks can occur when improperly destroying objects (or when failing to destroy them). I, along with many other developers, cannot prevent 100% of memory leaks. We can take measures to get as close to that point as possible but, odds are there will be at least one somewhere in the vastness of the code. One measure that can be taken is implementing the Dispose pattern and using it appropriately. It makes managing memory more explicit and allows for a higher-level mechanism for managing an object’s lifetime.

How is it done in .NET?

Implementing the Dispose pattern in .NET requires deriving from System.IDisposable:

public interface IDisposable
{
    void Dispose();
}
public sealed class DisposableObject : IDisposable
{
    private bool _disposing;
    public override Dispose()
    {
        this.Dispose(!this._disposing);
        GC.SuppressFinalize(this);
    }
    private void Dispose(bool disposing)
    {
        if(disposing)
        {
            this._disposing = true;
            //… release resources here …
        }
    }
}

Implementing the dispose pattern in this way basically marks the object as “dead”. By doing this, it allows the Garbage Collector to free the memory used by the object without the need to perform costly finalization. It is best practice to create a protected (or private if the class is not inheritable) dispose method accepting a boolean value indicating if the object is disposing. Doing this allows further control of object disposal.

Proper OOD (Object-Oriented Design) is employed here by separating the interface from its implementation (please see the Separation PDF). Microsoft did well with this one. With the IDisposable interface, multiple objects can be “Disposable” and mechanisms can be created to track these kinds of objects.

How is it done in C++?

In C++ the Dispose pattern is used to explicitly release resources used by the internals of the object. To properly implement this, an interface must be created:

public class IDisposable
{
    void dispose() = 0;
};

This looks much like the interface in .NET but with a few C++ semantics to enforce what we are intending. By making the dispose() method virtual, we force the user of this interface to implement it in their subclass:

public class DisposableObject : public IDisposable
{
    private bool _disposing;
    public override dispose()
    {
        if(this.dispose(!this->_disposing))
        {
            //… more disposing-dependent logic here …
        }
    }
    protected bool dispose(bool disposing)
    {
        if(disposing)
        {
            this->_disposing = true;
            //… release resources here …
        }
        return this->_disposing;
    }
};

Again, this looks a lot like the .NET version but with a few changes for C++ compliance. The code also includes a variation of the protected dispose method to demonstrate the ability for even further disposal control.

How is it used in C++?

Generally the dispose method is called within the object’s destructor. By tracking whether the object is disposed or not, other tracking mechanisms can be used to explicitly dispose the object. Below is a basic custom auto_ptr implementation created based on various sources (A Sample auto_ptr implementation, Scott Meyers Update on auto_ptr):

template<typename TObject, typename R, R (TObject::*Dispose)()>
class AutoPtr
{
public:

	explicit AutoPtr(TObject* pointerToWrap = NULL)
		: wrapper(pointerToWrap)
	{
	}

	AutoPtr(AutoPtr& Other)
		: wrapper(Other.Release())
	{
	}

	AutoPtr& operator=(AutoPtr& Other)
	{
		Reset(Other.Release());
		return (*this);
	}

	~AutoPtr()
	{
		if(wrapper)
		{
			(wrapper->*Dispose)();
			wrapper = NULL;
		}
	}

	TObject& operator*() const
	{
		return (*wrapper);
	}

	TObject** operator&()
	{
		Reset();
		return &wrapper;
	}

	TObject* operator->() const
	{
		return GetPointer();
	}

	operator bool() const
	{
		return wrapper != NULL;
	}

	TObject* GetPointer() const
	{
		return wrapper;
	}

	TObject* Release()
	{
		TObject* tempPtr = wrapper;
		wrapper = NULL;
		return tempPtr;
	}

	void Reset(TObject* p = NULL)
	{
		if(p != wrapper)
		{
			if(wrapper)
			{
				(wrapper->*Dispose)();
			}
		}

		wrapper = p;
	}

private:
	TObject* wrapper; //the wrapped pointer
};

With this code we can do something like:

typedef AutoPtr<DisposableObject, void, &DisposableObject::Dispose> DisposablePtr;

And use it like this (note that “work” is assumed to be an instance method of DisposableObject):

DisposablePtr obj(new DisposableObject());
obj->work();

Above is an AutoPtr implementation that automatically disposes objects when the AutoPtr instance goes out of scope. This is an example of a high-level mechanism of memory management making good use of the Dispose pattern.

Conclusion

This was an exhaustive look at how the Dispose pattern can be implemented in C++ to encourage easier memory management. First, the .NET version of the pattern was examined. Then, moving on to C++, the Dispose pattern was implemented and then used in a custom auto_ptr implementation. Memory management is a very important aspect of C++. This article describes one way to make it a little easier.


License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

About the Author

Caleb McElrath
Software Developer Magenic Technologies Inc
United States United States
Developer for Magenic Technologies Inc.
 
Caleb began his trek at the age of 16 starting with Turbo Pascal (wanting to expand his horizons from the basics of HTML). Realizing this was not nearly a modern industry standard programming language, he moved on to Visual C++. There he was met with many object-oriented and data structure problems and solutions. His horizons took on the world from there where he explored everything from Ruby, Python, PHP, Flash, to .NET, Java, and jQuery.
 
In Microsoft technologies is where Caleb finds most of his time spent. His days and long nights are filled with the .NET Framework and SQL Server.

Comments and Discussions

 
QuestionGreat article! Pinmemberely_bob9-Mar-12 4:48 
GeneralRe: Great article! PinmemberCaleb McElrath9-Mar-12 4:58 
AnswerRe: Great article! PinmemberN-O-R-B-E-R-T11-Mar-12 22:44 
QuestionWhat's wrong with RAII? PinmemberPablo Aliskevicius8-Mar-12 4:03 
AnswerRe: What's wrong with RAII? PinmemberCaleb McElrath8-Mar-12 7:08 
QuestionRe: What's wrong with RAII? PinmemberSam Cragg8-Mar-12 22:49 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web01 | 2.8.140721.1 | Last Updated 8 Mar 2012
Article Copyright 2012 by Caleb McElrath
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid