struct Foo : Pte<Foo> {
    void SomeAction()  { INTERLOCKED { ... } }
};

Ptr<Foo> ptr;

// thread 1:
{
    Foo foo;
    ptr = &foo;
} // A1: foo have been destroyed

// thread 2
if (ptr) // A2
    ptr->SomeAction(); // A3

struct Ctrl
{
    struct Base; // implementation

    Ctrl() : base(new Base) {} // at cpp file
    bool IsForeground() const { return base->IsForeground(); } // at cpp file
    void SetForeground() { base->SetForeground(); } // at cpp file
    ...
protected:
    Ctrl(Base* b) : base(b) {} // at cpp file

private:
    shared_ptr<Base> base;
};

struct Pusher : Ctrl
{
    struct Base : Ctrl::Base { ... };

    Pusher() : Ctrl(new Base) {}
    ...
};

void SetterThread()
{
    while (true)
    {
        Data d;
        *DataAccess() = &d;
    }
}

void AccesserThread()
{
    while (true)
    {
        Ptr<Data> d = *DataAccess();
        if (d)
            d->a = 2;
    }
}

void SetterThread()
{
    while (true)
    {
        shared_ptr<Data> d(new Data);
        *DataAccess() = d;
    }
}

void AccesserThread()
{
    while (true)
    {
        shared_ptr<Data> d = DataAccess()->lock();
        if (d)
            d->a = 2;
    }
}

CtrlCore.h:

	static  Ptr<Ctrl> focusCtrl;
	static  Ptr<Ctrl> focusCtrlWnd;
	static  Ptr<Ctrl> lastActiveWnd;
	static  Ptr<Ctrl> caretCtrl;

struct FileObject
{
    FileObject() : impl(new Impl) {}
    typedef weak_ptr<Impl> Ref;
    
    bool IsOpened() const { return impl->file; }
    void Close() { impl->file.reset(); }
    void Open(const char* fname) { impl->file.reset(new File(fname)); }
    
private:
    struct Impl
    {
        shared_ptr<File> file;
    };
    
    shared_ptr<Impl> impl;
};

void SetterThread()
{
    for (int i = 0; i < cycles; ++ i)
    {
        // create file object
        FileObject file;
        // assign reference to global variable
        *DataAccess::Access() = file;
        // create file itself
        file.Open("file.txt");
        // write some text, file will be opened because accesser doesn't use close
        // (try ... catch is not needed)
        file.Write(String().Cat() << "[" << i << "] setter");
        // close the file, accesser now cannot write into file
        file.Close();
    }
}

void AccesserThread()
{
    for (int i = 0; i < cycles; ++ i)
    {
        try
        {
            // try to get the real object from global reference
            FileObject file = DataAccess::Access()->Get();
            for (int j = 0; j < internalCycles; ++ j)
            {
                // try to write into file
                file.Write(String().Cat() << "[" << i << "," << j << "] accesser");    
            }
        }
        catch(Exc& e)
        {
            Out(String().Cat() << "[" << i << "] Accesser error: " << e);
        }
    }
}