Enforce safe use of class containing reference or raw pointer

Question

Suppose we have a class that looks like the following.

class DoStuffWithRef
{
    DoStuffWithRef(LargeObject& lo) : lo_(lo) {}

    // a bunch of member functions, some of them useful
    // [...]

private:
    LargeObject& lo_;
};

The class is designed such that the only sane use is when at least one other entity has ownership of the object that lo_ references. If client code uses the class appropriately, there's no need for DoStuffWithRef to have ownership of the LargeObject.

Is there a way to enforce this usage or signal an error if the class is being misused? Can anything be done besides documenting the intended use of DoStuffWithRef?

For example, an automatically stored DoStuffWithRef might refer to an automatically stored LargeObject.

void foo()
{
    LargeObject lo;
    DoStuffWithRef dswr(lo);
    // some code that makes use of the DoStuffWithRef instance
    return;
}

This is the primary usage I have in mind although there are other possible cases where someone else might be guaranteed to have ownership.

The problem is that it's very possible for client code to create a DoStuffWithRef instance that will end up with a dangling reference. If no one else has ownership of a LargeObject referred to by a DoStuffWithRef, then chaos ensues when the the DoStuffWithRef tries to access the LargeObject. Worse yet, chaos may ensue only long after the error has been made.

When this has come up in the past, I've used a boost::shared_ptr<> instead of a reference (this was in C++03). That doesn't quite express the semantics of the class appropriately. The premise is that DoStuffWithRef doesn't need ownership -- it is meant to act on objects owned by others and if no one else owns the object then the functionality provided by DoStuffWithRef makes no sense. Giving ownership to DoStuffWithRef has unnecessary overhead and forces shared ownership semantics. weak_ptr<> would also have the wrong semantics because we shouldn't be asking at runtime if the pointer is valid.

I've never had this scenario come up in a performance sensitive section of code or in a case where shared ownership was a significant burden so it just hasn't really mattered but I wish I knew of a way to accurately express this in C++. The costs are small but they're also unnecessary. More importantly, a shared_ptr<> will hide incorrect use of the class. If a DoStuffWithRef, modified to use a shared_ptr<>, is the only remaining owner of a LargeObject, then the dangling reference has been averted in the short term but the client code ends up in uncharted territory.

Answer 1

Is DoStuffWithRef otherwise stateful? If not, it seems like it is a bucket of utility functions. The reference to LargeObject could just as well be passed as an argument to each function. That also resolves the question of ownership.

Otherwise, if it is stateful, this is a clear case of shared ownership, since DoStuffWithRef really does need to extend the lifetime of a single live instance of LargeObject to that of itself. Or, use a weak pointer and eat the cost of the runtime check...