Question

There is this code:

#include <iostream>

class CleverClass{
public:
    CleverClass() : number(55){}
    void cleverOperation(){
        std::cout << number << std::endl;
    }
private:
    int number;
};

class NotCleverClass{
public:
    NotCleverClass(CleverClass* cc) : cleverClass(cc){}
    void callCleverOperation(){
            // throw exception when cleverClass object doesn't exist anymore
        cleverClass->cleverOperation();
    }
private:
    CleverClass* cleverClass;
};

NotCleverClass returnNCC(){
    CleverClass CC;
    NotCleverClass NCC(&CC);
    NCC.callCleverOperation(); // prints 55
    return NCC;
}

int main()
{
    NotCleverClass returnedNCC = returnNCC();
    returnedNCC.callCleverOperation(); // prints -858993460
    return 0;
}

Object of class NotCleverClass is dependent to object of class CleverClass. When object of class CleverClass exists then object of class NotCleverClass can use its function cleverOperation() and everything works okey. However, when object of class CleverClass is going to lose existence, then calling its function may cause troubles.

One of the solutions is to keep in NotCleverClass weak pointer (boost::weak_ptr) of CleverClass object with reference checker, but there is still a problem when object of cleverClass is not going to be placed on free store (for example on stack). Are there some design patterns to monitor whether used object still exist and that calling its functions has any sense?

Answer 1

You can still use a weak_ptr even if the object has automatic storage duration; you can give the shared_ptr a custom deleter that does nothing; and make sure it is destroyed immediately before the object itself, by placing it in the same scope as the object. Something like this:

class NotCleverClass{
public:
    NotCleverClass(weak_ptr<CleverClass> cc) : cleverClass(cc){}
    void callCleverOperation(){
        // throw bad_weak_ptr when cleverClass object doesn't exist anymore
        shared_ptr<CleverClass>(cleverClass)->cleverOperation();
    }
private:
    weak_ptr<CleverClass> cleverClass;
};

struct null_delete { void operator()(void*) const {} };

NotCleverClass returnNCC(){
    CleverClass CC;
    shared_ptr<CleverClass> shared_cc(&CC, null_delete());

    NotCleverClass NCC(shared_cc);
    NCC.callCleverOperation(); // prints 55
    return NCC;

    // shared_cc destroyed here: NCC::cleverClass is safely invalidated
    // CC destroyed here: no dangling references remain
}

This should work with either Boost or C++11 smart pointers. In C++11, you can replace the null_delete functor with a lambda, [](void*){}.