He's not dead, he's resting

On-Demand Loading using Smart Pointers

Previously, I explained how to implement something like the Active Object thread pattern using smart pointers. Next we’ll use the same trick to implement on-demand, lazy construction.

There’s nothing difficult here, once we realise we can reuse the ‘return a different pointer’ trick. We make use of std::tr1::function rather than a raw function pointer so that parameter values can be bound at pointer-construction time. Again, we parameterise on pointer type, not raw type.

template <typename T_>
class DeferredConstructionPtr
        mutable T_ _ptr;
        std::tr1::function<T_ ()> _f;
        mutable bool _done;

        DeferredConstructionPtr(const std::tr1::function<T_ ()> & f) :

        DeferredConstructionPtr(const DeferredConstructionPtr & other) :

        DeferredConstructionPtr &
        operator= (const DeferredConstructionPtr & other)
            if (this != &other)
                _ptr = other._ptr;
                _f = other._f;
                _done = other._done;
            return *this;

        T_ operator-> () const
            if (! _done)
                _ptr = _f();
                _done = true;

            return _ptr;

Again, some caveats:

  • Dealing with const is left to the reader.
  • Dealing with thread safety is left to the next article.
  • If the constructor in question can throw exceptions, the exception will be thrown at what could be a rather unobvious place. This may or may not be a problem.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s