Have smart pointer react to exception ?

I'm trying to make a smart pointer that can invalidate
its reference in the presence of certain exceptions.
The idea is, if the reference is "stale", then I'd
refresh the reference. But I don't want to wrap every
use of the reference in a try-catch block.

See ~Temp below for the closest that I've come.

#include <iostream>

struct Something
{
};

struct Foo
{
         // note, it may not actually reach here
         // just sample code to throw a Something()
         void func()
         {
                 throw Something();
         }
};

struct SmartPtr;

// a temporary object to live for the duration
// of the operator->
struct Temp
{
         SmartPtr& _sp;
         Foo* _p;

         Temp(
                 SmartPtr& sp,
                 Foo* p)
                 :_sp(sp)
                 ,_p(p)
         {
         }

         Foo* operator->()
         {
                 return _p;
         }

         ~Temp();
};

struct SmartPtr
{
         Foo* _p;

         SmartPtr(
                 Foo* p)
                 :_p(p)
         {
         }

         Temp operator->()
         {
                 if (p == 0)
                         refresh_reference_to_a_foo();

                 return Temp(*this, _p);
         }
};

Temp::~Temp()
{
         // If this could actually say:

// if (exception_type_is(Something))

         // then that would be perfect.

         if (std::uncaught_exception())
         {
                 // clear it just in case its a Something
                 _sp._p = 0;
         }
}

int main()
{
         SmartPtr w(get_reference_to_a_Foo());

         // just to make gcc happy
         try
         {
                 w->func();
         }
         catch (...)
         {
         }
}

Unfortunately, ~Temp is not in the path of execution
so I can't surround it with a try-catch block. I've
tried function-try-blocks around Temp::operator->()
and ~Temp() but they obviously do nothing.

One idea is to simply put the SmartPtr's onto a linked
list if the exception is thrown, and clear everything
on that linked list when we reach the specific handler, but,
due to some other aspects of the program, I can't really
guarantee that the handler will be reached before
I want the SmartPtr cleared.

Is there any way to accomplish this ?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]