Preferred syntax 
GNU C++ 2.95.x, 3.0.x, 3.1.x

Comeau C++ 4.2.45.2

SGI MIPSpro 7.3.0

Intel C++ 5.0, 6.0

Compaq's cxx 6.2
 Any compiler supporting the preferred syntax

Portable syntax 

Microsoft Visual C++ 6.0, 7.0

Borland C++ 5.5.1

Sun WorkShop 6 update 2 C++ 5.3

Metrowerks CodeWarrior 8.1

class CProxy_IххххххххEvents : public IConnectionPointImpl<...>
{
public:
     HRESULT Fire_xxxxxxxxx()

  //и т.д. с перебором точек соединения и вызовом для каждой pDispatch->Invoke

Делегаты на C++
Автор: Александр Шаргин
The RSDN Group
Опубликовано: 28.01.2002
Версия текста: 1.0

October 10, 2002 - Version 1.29.0
Signals Library added - Managed signals & slots callback implementation, from Doug Gregor.

Signal Return Values (Advanced)
Just as slots can receive arguments, they can also return values. These values can then be returned back to the caller of the signal through a combiner. The combiner is a mechanism that can take the results of calling slots (there many be no results or a hundred; we don't know until the program runs) and coalesces them into a single result to be returned to the caller. The single result is often a simple function of the results of the slot calls: the result of the last slot call, the maximum value returned by any slot, or a container of all of the results are some possibilities.

Generally, any place in which a function pointer would be used to defer a call or make a callback, Boost.Function can be used instead to allow the user greater flexibility in the implementation of the target. Targets can be any 'compatible' function object (or function pointer), meaning that the arguments to the interface designated by Boost.Function can be converted to the arguments of the target function object.

------ Rebuild All started: Project: DelegatesDemo, Configuration: Debug Win32 ------
Deleting intermediate and output files for project 'DelegatesDemo', configuration 'Debug|Win32'
Compiling...
demo.cpp
d:\research\delegates\delegate_impl.h(19) : warning C4346: 'DelegateRetVal<T>::Type' : dependent name is not a type
        prefix with 'typename' to indicate a type
        d:\research\delegates\delegate_impl.h(21) : see reference to class template instantiation 'IDelegate0<TRet>' being compiled
d:\research\delegates\delegate_impl.h(19) : error C2146: syntax error : missing ';' before identifier 'Invoke'
d:\research\delegates\delegate_impl.h(19) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
d:\research\delegates\delegate_impl.h(19) : warning C4183: 'Invoke': missing return type; assumed to be a member function returning 'int'
d:\research\delegates\delegate_impl.h(31) : warning C4346: 'DelegateRetVal<T>::Type' : dependent name is not a type
        prefix with 'typename' to indicate a type
        d:\research\delegates\delegate_impl.h(44) : see reference to class template instantiation 'CStaticDelegate0<TRet>' being compiled
d:\research\delegates\delegate_impl.h(31) : error C2146: syntax error : missing ';' before identifier 'Invoke'
d:\research\delegates\delegate_impl.h(31) : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
d:\research\delegates\delegate_impl.h(31) : warning C4183: 'Invoke': missing return type; assumed to be a member function returning 'int'
d:\research\delegates\delegate_impl.h(52) : warning C4346: 'DelegateRetVal<T>::Type' : dependent name is not a type
        prefix with 'typename' to indicate a type
        d:\research\delegates\delegate_impl.h(69) : see reference to class template instantiation 'CStaticDelegateVoid0<TRet>' being compiled

А>Версия делегатов для VC 6.0 не компилится под VC 8.0 Хотелось бы иметь общую рабочую для обоих студий версию

DelegateRetVal<TRet>::Type

typename DelegateRetVal<TRet>::Type

bool SomeClass::on_button_click() { .. }

void SomeClass::func()
{
    boost::function< bool (const IButton* from_me) >  callback = boost::bind(on_button_click, this);
}

bool sort_func(const BigArray& a, int value1, int value2)
{
    return a[value1] < a[value2];
}

void some()
{
    BigArray arr;
    std::vector<int> indexes;

    std::sort(indexes.begin(), indexes.end(), boost::bind(sort_func, arr, _1, _2));
}

#include "boost/lambda.hpp"
std::vector<WindowBase*>  windows;


template<typename WNDCLASS>
void callback_func(Event event)
{
    WindowBase* wnd = *std::find_if(windows.begin(), windows.end(), typeid(*_1) == typeid(WNDCLASS));
    wnd->on_event(event)
}


//где то ещё..

WindowBase::WindowBase()
{
    windows.push_back(this);
}
WindowBase::~WindowBase()
{
    windows.erase(std::find(windows.begin(), windows.end(), this));
}

template <class TObj, class TRet TEMPLATE_PARAMS>
I_DELEGATE<TRet TEMPLATE_ARGS>* NewDelegate(TObj* pObj, TRet (TObj::*pMethod)(PARAMS))
{
  return new C_METHOD_DELEGATE<TObj, TRet TEMPLATE_ARGS> (pObj, pMethod);
}

NewDelegate(&obj, &CMyClass::func);

CMethodDelegate0 del(&obj, &CMyClass::func);

_>NewDelegate(&obj, &CMyClass::func);
_>

_>CMethodDelegate0 del(&obj, &CMyClass::func);
_>

template<class>
struct A
{
  template<class t>
  A(t){}
};
//...
A a(1); // Какой здесь тип у a ?

for(it = m_DelegateList.begin(); it != --m_DelegateList.end(); ++it)
       static_cast<IDelegate*> (*it)->Invoke(ARGS);

if ( !m_DelegateList.empty() )
{
    for(it = m_DelegateList.begin(); it != --m_DelegateList.end(); ++it)
       static_cast<IDelegate*> (*it)->Invoke(ARGS);
}

class A
{
  virtual int method(const Type& .. ) const;
  ..
};

int A::method(const Type& .. ) const
{
}

TRet Invoke(PARAMS)
{
  if(!m_DelegateList.empty())
  {
      for(......) (*it)->Invoke(ARGS);
      return m_DelegateList.back()->Invoke(ARGS);
  }
  else
  {
    // на выбор
    assert(! "нечего вызывать, нечего возвращать, щас вылечу нафиг");
    throw SomeDelegateException();
    return TRet();
  }
}

vector<IDelegate*> snapshot; // вектор дешевле списка, поэтому копировать удобнее в него
snapshot.reserve(m_DelegateList.size());
snapshot.insert(m_DelegateList.begin(), m_DelegateList.end());
// далее - как с гусём :)

DelegateList::iterator m_next;
.....
void Remove(IComparableDelegate* pDelegate)
{
  .....
  if(it == m_next)
    ++m_next;
  m_DelegateList.erase(it);
  .....
}
void RemoveAll()
{
  .....
  m_next = m_DelegateList.end();
}
TRet Invoke(PARAMS)
{
  DelegateList::iterator it = m_DelegateList.begin();
  while(true)
  {
    if(it == m_DelegateList.end()) { assert(!"всё-таки вылетели!!!"); return TRet(); }
    m_next = it; ++m_next;
    if(m_next == m_DelegateList.end()) { return (*it)->Invoke(ARGS); }
    (*it)->Invoke(ARGS);
    it = m_next;
  }
}

    C_DELEGATE(const C_DELEGATE<TRet TEMPLATE_ARGS>& x_right)
    {
        this.RemoveAll();
        gslIDelegate* delegate_ptr=x_right.GetDelegates(true);
        while(delegate_ptr!=0)
        {
            this.operator+=(delegate_ptr); //Здесь копируются указатели
            delegate_ptr=x_right.GetDelegates();
        };
    };

    C_DELEGATE<TRet TEMPLATE_ARGS>& operator=(C_DELEGATE<TRet TEMPLATE_ARGS>& x_right)
    {
        RemoveAll();
        gslIDelegate* delegate_ptr=x_right.GetDelegates(true);
        while(delegate_ptr!=0)
        {
            operator+=(delegate_ptr); //Здесь копируются указатели
            delegate_ptr=x_right.GetDelegates();
        };

        return *this;
    };

        void RemoveAll()
        {
                DelegateList::iterator it;
                for(it = m_DelegateList.begin(); it != m_DelegateList.end(); ++it)
                   delete (*it); //Здесь указатели прибиваются

                m_DelegateList.clear();
        InitIteratorDelegates();
       }

       ~C_DELEGATE() { RemoveAll(); }

   class Object
   {
      C_DELEGATE* object_delegate;

      Object()
      {
         object_delegate=new C_DELEGATE();
      };

      Object(const Object& x_right)
      {
         object_delegate=new C_DELEGATE();
         *object_delegate=*(x_right.object_delegate); //Здесь скопируются указатели
      };

      Object& operator=(const Object& x_right)
      {
          *object_delegate=*(x_right.object_delegate); //Здесь скопируются указатели
          return *this;
      };

      C_DELEGATE* get_delegate() const
      {
         return object_delegate;
      };

      ~Object()
      {
         delete object_delegate;
      };
   };

   class Events
   {
       void Test();
   };

   //Тогда код:

   Events events;

   void main()
   {
      Object object2;

      {
         Object object1;
         object1.get_delegate()->operator +=(NewDelegate(events, &Events::Test));

         Object object2=object1; //Хочу скопировать объект вместе с его делегатами;
      }; //Здесь object1 рушится вместе с указателями в ~C_DELEGATE, а указатели делегатов в object2 становятся не валидными 
      
      object2.get_delegate()->operator ()(); //CRASH! потому как object1 забрал в небытие указатели на делегаты с собой.
   };

  //Тогда код:

   Events events;

   void main()
   {
      Object object2;

      {
         Object object1;
         object1.get_delegate()->operator +=(NewDelegate(events, &Events::Test));

         object2=object1; //Хочу скопировать объект вместе с его делегатами;
      }; //Здесь object1 рушится вместе с указателями в ~C_DELEGATE, а указатели делегатов в object2 становятся не валидными 
      
      object2.get_delegate()->operator ()(); //CRASH! потому как object1 забрал в небытие указатели на делегаты с собой.
   };