lifetime of const references...

Here is the code which should compile fine; program output and my question
follows:
____________________________________________________________________
#include <cstdio>

namespace func_ptr {
  namespace sys {
    typedef void (callback_type) (void const* const);

    class base_pod {
    protected:
      callback_type* mp_callback;

    public:
      void execute() const {
        mp_callback(this);
      }
    };

    template<typename T, typename T_mfptr, typename T_p1>
    class param_1 : public base_pod{
      T m_obj;
      T_mfptr m_mfptr;
      T_p1 m_p1;

    public:
      param_1(T obj, T_mfptr mfptr, T_p1 p1)
       : m_obj(obj), m_mfptr(mfptr), m_p1(p1) {
        mp_callback = sys_callback;
        std::printf("(%p)-param_1::param_1()\n",
          reinterpret_cast<void*>(this));
      }

      ~param_1() throw() {
        std::printf("(%p)-param_1::~param_1()\n",
          reinterpret_cast<void*>(this));
      }

    private:
      void callback() const {
        (m_obj->*(m_mfptr))(m_p1);
      }

      static void sys_callback(void const* const state) {
        static_cast<param_1 const*>(state)->callback();
      }
    };
  }

  typedef sys::base_pod const& handle;

  template<typename T, typename T_mfptr, typename T_p1>
  sys::param_1<T, T_mfptr, T_p1>
  create(T _this, T_mfptr mfptr, T_p1 p1) {
    return sys::param_1<T, T_mfptr, T_p1>(_this, mfptr, p1);
  }
}

struct object {
  void func(int i) {
    std::printf("(%p)-object::func1(%d)\n",
      reinterpret_cast<void*>(this), i);
  }
};

struct holder {
  func_ptr::handle m_fptr;
  holder(func_ptr::handle fptr) : m_fptr(fptr) {}
};

int main() {
  object obj;

  {
    std::puts("Scope 1:\n");
    func_ptr::handle h(func_ptr::create(&obj, &object::func, 123));
    h.execute();
  }

  std::puts("\n\n--------------------------------------------");

  {
    std::puts("Scope 2:\n");
    holder h(func_ptr::create(&obj, &object::func, 123));
    h.m_fptr.execute();
  }

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  std::puts("\n\n--------------------------------------------\n\
Press <ENTER> to exit...");
  std::getchar();
  return 0;
}

____________________________________________________________________

Here is the output I get:
____________________________________________________________________
Scope 1:

(0022FF30)-param_1::param_1()
(0022FF5F)-object::func1(123)
(0022FF30)-param_1::~param_1()

--------------------------------------------
Scope 2:

(0022FF30)-param_1::param_1()
(0022FF30)-param_1::~param_1()
(0022FF5F)-object::func1(123)

--------------------------------------------
Press <ENTER> to exit...

____________________________________________________________________

I am wondering why the const reference in 'Scope 2' (e.g., holder::m_fptr)
is getting destructed _before_ the call to 'h.m_fptr.execute()'? I thought
the output should be identical to that of 'Scope 1'... What exactly am I
doing wrong here? I am screwing something up somewhere... What can be done
to resolve this issue?

Yikes! ;^(...

Thanks.

--
Chris M. Thomasson
http://appcore.home.comcast.net