template<class T, class M> class CRN
{
public:
    CRN(T* pObject)
    {
        m_pObject = pObject;
    }

    void Notify()
    {
        m_pObject->M();
    }

protected:

    T*        m_pObject;
};

class C {
...
void SetEventHandler(CRN* pHandler);
...
void OnEvent()
{
    pHandler->Notify();
}
};

void Lalamba(C* p, Object* pObject)
{
    p->SetEventHandler(new CRN<Object, Method>(pObject))
}

#if !defined __ICOMMAND_H__
#define __ICOMMAND_H__

#include "../../System/Loki/Functor.h"

//////////////////////////////////////////////////////////////////////////
class ICommand
{
public:
    virtual ~ICommand() {}
    void execute() { do_execute(); }
protected:
    virtual void do_execute() = 0;
};
//////////////////////////////////////////////////////////////////////////
template<typename TClass>
class CommandHelperFuncPtr : public ICommand
{
public:
    CommandHelperFuncPtr(TClass &t, void (TClass::*pFunc)()) : t_(t), pFunc_(pFunc) {}
protected:
    virtual void do_execute()
    { (t_.*pFunc_)(); }
private:
    TClass t_;
    void (TClass::*pFunc_)();
};
//////////////////////////////////////////////////////////////////////////
// void TClass::foo();
// TClass parent_;
//    CommandHelper<TClass> e(parent_, TClass::foo);
//    e.execute();

//////////////////////////////////////////////////////////////////////////
template<typename TFunctor>
class CommandHelperPtr : public ICommand
{
public:
    CommandHelperPtr(TFunctor *pf) : tfunc_(pf) {}
    ~CommandHelperPtr() { delete tfunc_; }
protected:
    virtual void do_execute()
    { (*tfunc_)(); }
private:
    TFunctor *tfunc_;
};
//////////////////////////////////////////////////////////////////////////
template <typename TFunctor>
class CommandHelperRef: public ICommand
{
public:
    CommandHelperRef(TFunctor &pf) : tfunc_(pf) {}
protected:
    virtual void do_execute() { tfunc_(); }
private:
    TFunctor &tfunc_;
};
//////////////////////////////////////////////////////////////////////////
// Parent pnt;
// typedef Functor<void> my_func;
// my_func classFunctor(&pnt, &Parent::call_me);
// CommandFunctor<my_func> e(classFunctor);
// e.execute();
//////////////////////////////////////////////////////////////////////////

С>template<class T, class M> class CRN
С>{
С>public:
С>    CRN(T* pObject)
С>    {
С>        m_pObject = pObject;
С>    }

С>    void Notify()
С>    {
С>        m_pObject->M();
С>    }

С>protected:

С>    T*        m_pObject;
С>};
С>

С>class C {
С>...
С>void SetEventHandler(CRN* pHandler);
С>...
С>void OnEvent()
С>{
С>    pHandler->Notify();
С>}
С>};

С>void Lalamba(C* p, Object* pObject)
С>{
    p->>SetEventHandler(new CRN<Object, Method>(pObject))
С>}
С>

template< class T >
class CRN2
{
  CRN2( T* src, ClassMethod ahandler ) : ptr( src ), handler( ahandler ) {};

  void Notify( void )
  {
      (ptr->*handler)();
  }

private:
   typedef void (T::*ClassMethod)(void);
   T* ptr;
   ClassMethod handler;
};

void main( void )
{
   CRN2< SomeClass > a( &SomeClassVar, &SomeClass::Method );

   a.Notity();
}

С> template<class T, class M> class CRN
С> {
С> public:
С>  CRN(T* pObject)
С>  {
С>   m_pObject = pObject;
С>  }

С>  void Notify()
С>  {
С>   m_pObject->M();
С>  }

С> protected:

С>  T*  m_pObject;
С> };
С>

template<class T, void (T::*M)()> class CRN
{
public:
    CRN(T* pObject)
    {
        m_pObject = pObject;
    }

    void Notify()
    {
        (m_pObject->*M)();
    }

protected:
    T*        m_pObject;
};

С> class C {
С> ...
С> void SetEventHandler(CRN* pHandler);
С> ...
С> void OnEvent()
С> {
С>     pHandler->Notify();
С> }
С> };

С> void Lalamba(C* p, Object* pObject)
С> {
С>     p->SetEventHandler(new CRN<Object, Method>(pObject))
С> }
С>

class C {
...
void SetEventHandler(CRN* pHandler);
...
void OnEvent()
{
    pHandler->Notify();
}
};

void Lalamba(C* p, Object* pObject)
{
    p->SetEventHandler(new CRN<Object, &Object::Method>(pObject))
}

template<class T, void(T::*M)()> 
class CRN
{
public:
    CRN(T* pObject)
    {
        m_pObject = pObject;
    }

    void Notify()
    {
        (m_pObject->*M)();
    }

protected:

    T*        m_pObject;
};
 
class G
{
public:
    void gg()
    {
        std::cout<<"hello\n";
    }
};

int main()
{
    G g;
    CRN<G, &G::gg> asd(&g);
    asd.Notify();
    return 0;
}

A>Я же не сказал что это не сделано. Я же привёл в пример библиотеку Loki. Естественно в ей подобных тоже это есть (и про boost я знаю). Я же не могу перечислять все библиотеки Но у меня к Вам вопрос — когда это библиотека boost стала стандартом?

The New C++

Generalized Function Pointers

Herb Sutter
The function facility, recently adopted by the C++ standards committee, provides a generalized way of working with arbitrary functions when all you know (or need to know) is their signature. In fact, as it turns out, you don't even need to know the target function's exact signature -- any target function with a compatible signature, meaning one where the parameter and return types are appropriately covertible, will work just fine.