struct CSkinedWndEventsSink
{
  virtual void OnClose( ) = 0;
  virtual void OnChotToTam( ) = 0;
};

class CSkinedWnd //это вроде как твой класс
{
  void Connect( CSkinedWndEventsSink *pSink );
  void Disconnect( CSkinedWndEventsSink *pSink );
}

// аналог __closure для функции с одним аргументом
template <typename T, typename R, typename A1>
class closure1_t
{
    T &m_this;
    R (T::*m_f)(A1);
public:
    closure1_t(T &t, R (T::*f)(A1)):m_this(t), m_f(f){}
    R operator () (A1 a1){ return (m_this.*m_f)(a1);}
};    
...
closure1_t<X, int, char> closure1(x, &X::f);
    closure1('a'); // вот чего мы хотели

template <typename R, typename A1>
class unk_closure1_t
{
    class T{};

    T &m_this;
    R (T::*m_f)(A1);
public:
    template <typename UnkT>
    unk_closure1_t(UnkT &t, R (UnkT::*f)(A1))
            :m_this(reinterpret_cast<T &>(t)), 
             m_f(reinterpret_cast<R (T::*)(A1)>(f)){}
    R operator () (A1 a1){ return (m_this.*m_f)(a1);}
};    
...
unk_closure1_t<int, char> __closure1(x, &X::f);
    __closure1('a');  // типа должно работать ;)

V>// аналог __closure для функции с одним аргументом
V>template <typename T, typename R, typename A1>
V>class closure1_t
V>{
V>    T &m_this;
V>    R (T::*m_f)(A1);
V>public:
V>    closure1_t(T &t, R (T::*f)(A1)):m_this(t), m_f(f){}
V>    R operator () (A1 a1){ return (m_this.*m_f)(a1);}
V>};    
V>...
V>closure1_t<X, int, char> closure1(x, &X::f);
V>    closure1('a'); // вот чего мы хотели
V>

struct AbstractSignal
{
  virtual ~AbstractSignal() { }
};

template<class R, class A1>
struct AbstractSignal1
{
  virtual R operator()(A1) const = 0;
};

// RTTI-обертка для AbstractSignal1, предназначена для использования конечным пользователем
template<class R, class A1>
class Signal1
{
public:
  Signal1(AbstractSignal1<R, A1>* signal = 0) : m_signal (signal) { }

  R operator()(A1 a1) const { return (*m_signal)(a1); }

private:
  // *** здесь должен быть какой-нибудь smart-pointer с подсчетом ссылок ***
  AbstractSignal1<R, A1>* m_signal;
};

template<class R, class T, class A1>
class MemFun1Closure1 : public AbstractSignal1<R, A1>
{
public:
  MemFun1Closure1(R (T::*f)(A1), T& t) : m_f (f), m_this (t) { }

  R operator()(A1 a1) const { return (m_this.*m_f)(a1); }

private:
  R (T::*m_f)(A1);
  T& m_this;
};

template<class R, class A1, class T>
Signal1<R, A1> closure(R (T::*f)(A1), T& t)
{
  return Signal1<R, A1>(new MemFun1Closure1<R, T, A1>(f, t));
}

class X
{
public:
  int foo(double);
};

int main()
{
  // В этой точке информация о классе X не нужна: Signal1 может быть проинициализирован и обычной функцией, если реализовать соответствующий PtrFunXClosure1.
  Signal1<int, double> signal;

  // . . .

  // Это единственное место, где пользователь упоминает класс X.
  X x;
  signal = closure(&X::foo, x);

  // . . .

  // В этой точке информация о существовании класса X пользователю тоже не нужна.
  return signal(0.5);
}

1. указатель на объект (void*)
   
2. указатель на функцию, которая вызывает конкретный метод, конкретного класса

result_type method_caller(object_type* object,arg_list)
{
 return object->method(arg_list)
}

1. Класс для хранения данных __closure
   
2. Класс, в котором будет статический метод вызова указанного метода — *object_type::mem_func(arg_list). Указатель на обслуживаемый метод естественно должен храниться в статическом члене этого класса
   
3. Шаблонная функция, которая автоматизирует процесс создания содержимого __closure. Например, такого вида
   

   template<class object_type,/*перечисляем типы из arg_list*/>
   closure_variable_type make_closure(object_type* obj,void (object_type::*method)(arg_list))