Краткое введение

Простейшая реализация

template<class ...TParams>
class AbstractEventHandler
{
    public:
        virtual void call( TParams... params ) = 0;
    protected:    
        AbstractEventHandler() {}
};

template<class ...TParams>
class TEvent
{
    using TEventHandler = AbstractEventHandler<TParams...>;
    public:
        TEvent() :
            m_handlers()
        {
        }
        ~TEvent()
        {
            for( TEventHandler* oneHandler : m_handlers )
                delete oneHandler;
            m_handlers.clear();
        }
        void operator()( TParams... params )
        {
            for( TEventHandler* oneHandler : m_handlers )
                oneHandler->call( params... );
        }
        void operator+=( TEventHandler& eventHandler )
        {
            m_handlers.push_back( &eventHandler );
        }
    private:
        std::list<TEventHandler*> m_handlers;
};

template<class TObject, class ...TParams>
class MethodEventHandler : public AbstractEventHandler<TParams...>
{
    using TMethod = void( TObject::* )( TParams... );
    public:
        MethodEventHandler( TObject& object, TMethod method ) :
            AbstractEventHandler<TParams...>(),
            m_object( object ),
            m_method( method )
        {
            assert( m_method != nullptr );
        }
        virtual void call( TParams... params ) override final
        {
            ( m_object.*m_method )( params... );
        }
    private:
        TObject& m_object;
        TMethod m_method;
};

template<class TObject, class ...TParams>
AbstractEventHandler<TParams...>& createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) )
{
    return *new MethodEventHandler<TObject, TParams...>( object, method );
}

#define METHOD_HANDLER( Object, Method ) createMethodEventHandler( Object, &Method )
#define MY_METHOD_HANDLER( Method ) METHOD_HANDLER( *this, Method )

class TestWindow
{
    . . .
    public:
        TEvent<const std::string&, unsigned int> onButtonClick;
    . . .
};
class ClickEventHandler
{
    . . .
    public:
        void testWindowButtonClick( const std::string&, unsigned int ) { ... }
    . . .
};
int main( int argc, char *argv[] )
{
    . . .
    TestWindow testWindow;
    ClickEventHandler clickEventHandler;

    testWindow.onButtonClick += METHOD_HANDLER( clickEventHandler, ClickEventHandler::testWindowButtonClick );
    . . .
}

Сравнение обработчиков

template<class ...TParams>
class AbstractEventHandler
{
    . . .
    using MyType = AbstractEventHandler<TParams...>;
    public:
        bool operator==( const MyType& other ) const
        {
            return isEquals( other );
        }
        bool operator!=( const MyType& other ) const
        {
            return !( *this == other );
        }
    protected:
        virtual bool isEquals( const MyType& other ) const = 0;
    . . .
};

template<class TMethodHolder, class ...TParams>
class MethodEventHandler : public AbstractEventHandler<TParams...>
{
    . . .
    using TMethod = void( TObject::* )( TParams... );
    protected:
        virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const override
        {
            const MyType* _other = dynamic_cast<const MyType*>( &other );
            return ( _other != nullptr && &m_object == &_other.m_object && m_method == _other.m_method );
        }
    private:
        TObject& m_object;
        TMethod m_method;
    . . .
};

template<class ...TParams>
class TEvent
{
    . . .
    using TEventHandler = AbstractEventHandler<TParams...>;
    using TEventHandlerIt = typename std::list<TEventHandler*>::const_iterator;
    public:
        bool operator+=( TEventHandler& eventHandler )
        {
            if( findEventHandler( eventHandler ) == m_handlers.end() )
            {
                m_handlers.push_back( &eventHandler );
                return true;
            }
            return false;
        }
        bool operator-=( TEventHandler& eventHandler )
        {
            auto it = findEventHandler( eventHandler );
            if( it != m_handlers.end() )
            {
                TEventHandler* removedEventHandler = *it;
                m_handlers.erase( it );
                delete removedEventHandler;
                return true;
            }
            return false;
        }
    private:
        inline TEventHandlerIt findEventHandler( TEventHandler& eventHandler ) const
        {
            return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandler* oneHandler )
            {
                return ( *oneHandler == eventHandler );
            } );
        }
        std::list<TEventHandler*> m_handlers;
    . . .
};

Удаление обработчика внутри обработчика

class TestWindow
{
    . . .
    public:
        TEvent<const std::string&, unsigned int> onButtonClick;
        static TestWindow& instance();
    . . .
};
class ClickEventHandler
{
    . . .
    public:
        void testWindowButtonClick( const std::string&, unsigned int )
        {
            TestWindow::instance().onButtonClick -= MY_METHOD_HANDLER( ClickEventHandler::testWindowButtonClick );
        }
    . . .
};
int main( int argc, char *argv[] )
{
    . . .
    ClickEventHandler clickEventHandler;
    TestWindow::instance().onButtonClick += METHOD_HANDLER( clickEventHandler, ClickEventHandler::testWindowButtonClick );
    . . .
}

• событие срабатывает и начинает перебирать (с помощью итераторов) обработчики, вызывая их;
• очередной обработчик внутри себя вызывает удаление себя;
• событие удаляет данный обработчик, делая соответствующий ему итератор невалидным;
• после завершения данного обработчика событие возвращается к перебору остальных, однако текущий итератор (соответствующий удалённому обработчику) уже невалиден;
• событие пытается обратиться к невалидному итератору, вызывая падение.

Потокобезопасность

template<class ...TParams>
class TEvent
{
    using TEventHandler = AbstractEventHandler<TParams...>;
    using TEventHandlerIt = typename std::list<TEventHandler*>::const_iterator;
    public:
        TEvent() :
            m_handlers(),
            m_currentIt(),
            m_isCurrentItRemoved( false ),
            m_handlerListMutex()
        {
        }
        void operator()( TParams... params )
        {
            m_handlerListMutex.lock_shared();
            
            m_isCurrentItRemoved = false;
            m_currentIt = m_handlers.begin();
            while( m_currentIt != m_handlers.end() )
            {
                m_handlerListMutex.unlock_shared();
                ( *m_currentIt )->call( params... );
                m_handlerListMutex.lock_shared();

                if( m_isCurrentItRemoved )
                {
                    m_isCurrentItRemoved = false;

                    TEventHandlerIt removedIt = m_currentIt;
                    ++m_currentIt;

                    deleteHandler( removedIt );
                }
                else
                {
                    ++m_currentIt;
                }
            }

            m_handlerListMutex.unlock_shared();
        }
        bool operator+=( TEventHandler& eventHandler )
        {
            std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );

            if( findEventHandler( eventHandler ) == m_handlers.end() )
            {
                m_handlers.push_back( std::move( eventHandler ) );
                return true;
            }
            return false;
        }
        bool operator-=( TEventHandler& eventHandler )
        {
            std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );

            auto it = findEventHandler( eventHandler );
            if( it != m_handlers.end() )
            {
                if( it == m_currentIt )
                    m_isCurrentItRemoved = true;
                else
                    deleteHandler( it );

                return true;
            }
            return false;
        }
    private:      
        // использовать под залоченным для чтения 'm_handlerListMutex'
        inline TEventHandlerIt findEventHandler( TEventHandler& eventHandler ) const
        {
            return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandler* oneHandler )
            {
                return ( *oneHandler == eventHandler );
            } );
        }
        // использовать под залоченным для записи 'm_handlerListMutex'
        inline void deleteHandler( TEventHandlerIt it )
        {
            TEventHandler* removedEventHandler = *it;
            m_handlers.erase( it );
            delete removedEventHandler;
        }
        
        std::list<TEventHandler*> m_handlers;

        // использовать под залоченным 'm_handlerListMutex'
        mutable TEventHandlerIt m_currentIt;
        mutable bool m_isCurrentItRemoved;

        mutable std::shared_mutex m_handlerListMutex;
};

Проблема видимости события

template<class ...TParams>
class IEvent
{
    protected:
        using TEventHandler = AbstractEventHandler<TParams...>;
    public:
        bool operator+=( TEventHandler& eventHandler )
        {
           return addHandler( eventHandler );
        }
        bool operator-=( TEventHandler& eventHandler )
        {
            return removeHandler( eventHandler );
        }
    protected:
        IEvent() {}
        virtual bool addHandler( TEventHandler& eventHandler ) = 0;
        virtual bool removeHandler( TEventHandler& eventHandler ) = 0;
};

template<class ...TParams>
class TEvent : public IEvent<TParams...>
{
    . . .
    public:
        TEvent() :
            IEvent<TParams...>()
            . . .
        {
        }
    protected:
        virtual bool addHandler( TEventHandler& eventHandler ) override
        {
            // код, который был ранее в 'TEvent::operator+='
        }
        virtual bool removeHandler( TEventHandler& eventHandler ) override
        {
            // код, который был ранее в 'TEvent::operator-='
        }
    . . .
};

class TestWindow
{
    . . .
    public:
        TestWindow() :
            onButtonClick( m_onButtonClick ),
            m_onButtonClick()
        {
        }
        IEvent<const std::string&, unsigned int>& onButtonClick;
    protected:
        TEvent<const std::string&, unsigned int> m_onButtonClick;
    . . .
};

Соответствие параметров события и его обработчиков

template<class TSource>
class MyClass
{
    . . .
    public:
        TEvent<const TSource&> onValueChanged;
    . . .
};

MyClass<bool> myBoolClass;
. . .
template<class TSource>
class MyHandlerClass
{
    . . .
    private:
        void handleValueChanged1( const bool& newValue );
        void handleValueChanged2( bool newValue );
    . . .
};
. . .
MyHandlerClass myHandlerClass;
myBoolClass.onValueChanged += METHOD_HANDLER( myHandlerClass, MyHandlerClass::handleValueChanged1 );  // OK
myBoolClass.onValueChanged += METHOD_HANDLER( myHandlerClass, MyHandlerClass::handleValueChanged2 );  // compile error

template<class TFunctor, class ...TParams>
class FunctorEventHandler : public AbstractEventHandler<TParams...>
{
    public:
        FunctorEventHandler( TFunctor& functor ) :
            AbstractEventHandler<TParams...>(),
            m_functor( functor )
        {
        }
        virtual void call( TParams... params ) override final
        {
            m_functor( params... );
        }
    private:
        TFunctor& m_functor;
};

template<class TFunctor, class ...TParams>
AbstractEventHandler<TParams...>& createFunctorEventHandler( TFunctor&& functor )
{
    return *new FunctorEventHandler<TFunctor, TParams...>( functor );
}

#define FUNCTOR_HANDLER( Functor ) createFunctorEventHandler( Functor )

class TestWindow
{
    . . .
    public:
        TEvent<const std::string&, unsigned int> onButtonClick;
    . . .
};
struct ClickEventHandler
{
    void operator()( const std::string&, unsigned int ) { . . . }
};
int main( int argc, char *argv[] )
{
    . . .
    TestWindow testWindow;
    ClickEventHandler clickEventHandler;

    testWindow.onButtonClick += FUNCTOR_HANDLER( clickEventHandler );
    . . .
}

testWindow.onButtonClick += createFunctorEventHandler<ClickEventHandler, const std::string&, unsigned int>( clickEventHandler );

Соединение события с обработчиками разных типов

template<class TFunctor> class FunctorHolder;

template<class TFunctor, class ...TParams>
class FunctorEventHandler : public AbstractEventHandler<TParams...>
{
    public:
        FunctorEventHandler( FunctorHolder<TFunctor>& functorHolder ) :
            AbstractEventHandler<TParams...>(),
            m_functorHolder( functorHolder )
        {
        }
        virtual void call( TParams... params ) override
        {
            m_functorHolder.m_functor( params... );
        }    
    private:
        FunctorHolder<TFunctor>& m_functorHolder;
    . . .
};

template<class TFunctor>
class FunctorHolder
{
    public:
        FunctorHolder( TFunctor& functor ) :
            m_functor( functor )
        {
        }
        template<class ...TCallParams>
        operator AbstractEventHandler<TCallParams...>&()
        {
            return *new FunctorEventHandler<TFunctor, TCallParams...>( *this );
        }
    private:
        TFunctor& m_functor;
    . . .
    template<class TFunctor, class ...TParams> friend class FunctorEventHandler;
};

template<class TFunctor>
FunctorHolder<TFunctor>& createFunctorEventHandler( TFunctor&& functor )
{
    return *new FunctorHolder<TFunctor>( functor );
}

#define     FUNCTOR_HANDLER( Functor )              createFunctorEventHandler( Functor )
#define     LAMBDA_HANDLER( Lambda )                FUNCTOR_HANDLER( Lambda )
#define     STD_FUNCTION_HANDLER( StdFunction )     FUNCTOR_HANDLER( StdFunction )
#define     FUNCTION_HANDLER( Function )            FUNCTOR_HANDLER( &Function )

template<class ...TParams>
class IEvent
{
    protected:
        using TEventHandler = AbstractEventHandler<TParams...>;
    public:
        template<class TSome>
        bool operator+=( TSome&& some )
        {
           return addHandler( static_cast<TEventHandler&>( some ) );
        }
        template<class TSome>
        bool operator-=( TSome&& some )
        {
            return removeHandler( static_cast<TEventHandler&>( some ) );
        }
    protected:
        IEvent() {}
        virtual bool addHandler( TEventHandler& eventHandler ) = 0;
        virtual bool removeHandler( TEventHandler& eventHandler ) = 0;
};

class TestWindow
{
    . . .
    public:
        TEvent<const std::string&, unsigned int> onButtonClick;
    . . .
};
struct Functor
{
    void operator()( const std::string&, unsigned int ) {}
};
struct Functor2
{
    void operator()( std::string, unsigned int ) {}
};
struct Functor3
{
    void operator()( const std::string&, const unsigned int& ) {}
};
struct Functor4
{
    void operator()( std::string, const unsigned int& ) {}
};
struct Functor5
{
    void operator()( std::string&, unsigned int& ) {}
};
struct Functor6
{
    void operator()( const std::string&, unsigned int& ) {}
};
struct Functor7
{
    void operator()( std::string&, const unsigned int& ) {}
};
int main( int argc, char *argv[] )
{
    . . .
    TestWindow testWindow;
    
    Functor functor;
    Functor2 functor2;
    Functor3 functor3;
    Functor4 functor4;
    Functor5 functor5;
    Functor6 functor6;
    Functor7 functor7;

    testWindow.onButtonClick += FUNCTOR_HANDLER( functor );     // ok
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor2 );    // ok
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor3 );    // ok
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor4 );    // ok
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor5 );    // compile error
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor6 );    // ok
    testWindow.onButtonClick += FUNCTOR_HANDLER( functor7 );    // compile error
    . . .
}

Error	C2664	'void Functor5::operator ()(std::string &,unsigned int &)': cannot convert argument 1 from 'const std::string' to 'std::string &'

namespace
{
    template<class TFunctor, class ...TParams>
    struct IsFunctorParamsCompatible
    {
        private:
            template<class TCheckedFunctor, class ...TCheckedParams>
            static constexpr std::true_type exists( decltype( std::declval<TCheckedFunctor>()( std::declval<TCheckedParams>()... ) )* = nullptr );
            
            template<class TCheckedFunctor, class ...TCheckedParams>
            static constexpr std::false_type exists( ... );
        public:
            static constexpr bool value = decltype( exists<TFunctor, TParams...>( nullptr ) )::value;
    };
} //

template<class TFunctor, class ...TParams>
class FunctorEventHandler : public AbstractEventHandler<TParams...>
{
    . . .
    public:
        virtual void call( TParams... params ) override
        {
            static_assert( IsFunctorParamsCompatible<TFunctor, TParams...>::value, "Event and functor arguments are not compatible" );

            m_functorHolder->m_functor( params... );
        }
    . . .
};

Error	C2338	Event and functor arguments are not compatible
Error	C2664	'void Functor5::operator ()(std::string &,unsigned int &)': cannot convert argument 1 from 'const std::string' to 'std::string &'

Сравнение функторов

template<class ...TParams>
class AbstractEventHandler
{
    . . .
    using MyType = AbstractEventHandler<TParams...>;
    public:
        bool operator==( const MyType& other ) const
        {
            return isEquals( other );
        }
        bool operator!=( const MyType& other ) const
        {
            return !( *this == other );
        }
    protected:
        virtual bool isEquals( const MyType& other ) const = 0;
    . . .
};

template<class TFunctor, class ...TParams>
class FunctorEventHandler : public AbstractEventHandler<TParams...>
{
    . . .
    using MyType = FunctorEventHandler<TFunctor, TParams...>;
    protected:
        virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const override
        {
            const MyType* _other = dynamic_cast<const MyType*>( &other );
            return ( _other != nullptr && *m_functorHolder == *_other->m_functorHolder );
        }
    private:
        FunctorHolder<TFunctor>& m_functorHolder;
    . . .
};

template<class TFunctor>
class FunctorHolder
{
    . . .
    using MyType = FunctorHolder<TFunctor>;
    public:
        bool operator==( const MyType& other ) const
        {
            return ( m_functor == other.m_functor );
        }
        bool operator!=( const MyType& other ) const
        {
            return !( *this == other );
        }
    private:
        TFunctor& m_functor;
    . . .
};

namespace
{
    template<class TEqu, class TEnabled = void>
    struct EqualityChecker;

    template<class TEquatable>
    struct EqualityChecker<TEquatable, typename std::enable_if<is_equatable<TEquatable>::value>::type>
    {
        static constexpr bool isEquals( const TEquatable& operand1, const TEquatable& operand2 )
        {
            return ( operand1 == operand2 );
        }
    };

    template<class TNonEquatable>
    struct EqualityChecker<TNonEquatable, typename std::enable_if<!is_equatable<TNonEquatable>::value>::type>
    {
        static constexpr bool isEquals( const TNonEquatable& operand1, const TNonEquatable& operand2 )
        {
            return ( &operand1 == &operand2 );
        }
    };
} //
template<class TFunctor>
class FunctorHolder
{
    . . .
    using MyType = FunctorHolder<TFunctor>;
    public:
        bool operator==( const MyType& other ) const
        {
            return EqualityChecker<TFunctor>::isEquals( m_functor, other.m_functor );
        }
    private:
        TFunctor& m_functor;
    . . .
};

template<class T>
class is_equatable
{
    private:
        template<class U>
        static constexpr std::true_type exists( decltype( std::declval<U>() == std::declval<U>() )* = nullptr );

        template<class U>
        static constexpr std::false_type exists( ... );
    public:
        static constexpr bool value = decltype( exists<T>( nullptr ) )::value;
};

Сборка мусора

template<class ...TParams>
class AbstractEventHandler
{
    . . .
    public:
        virtual ~AbstractEventHandler() {}
    . . .
};

template<class ...Types>
using THandlerPtr = std::unique_ptr<AbstractEventHandler<Types...>>;

namespace
{
    template<class TSome>
    struct HandlerCast
    {
        template<class ...Types>
        static constexpr THandlerPtr<Types...> cast( TSome& some )
        {
            return static_cast<THandlerPtr<Types...>>( some );
        }
    };
    template<class TPtr>
    struct HandlerCast<std::shared_ptr<TPtr>>
    {
        template<class ...Types>
        static constexpr THandlerPtr<Types...> cast( std::shared_ptr<TPtr> some )
        {
            return HandlerCast<TPtr>::cast<Types...>( *some );
        }
    };
} //
template<class ...TParams>
class IEvent
{
    public:
        template<class TSome>
        bool operator+=( TSome&& some )
        {
           return addHandler( HandlerCast<TSome>::cast<TParams...>( some ) );
        }
        template<class TSome>
        bool operator-=( TSome&& some )
        {
            return removeHandler( HandlerCast<TSome>::cast<TParams...>( some ) );
        }
    protected:
        using TEventHandlerPtr = THandlerPtr<TParams...>;
        IEvent() {}
        virtual bool addHandler( TEventHandlerPtr eventHandler ) = 0;
        virtual bool removeHandler( TEventHandlerPtr eventHandler ) = 0;
};
template<class ...TParams>
class TEvent : public IEvent<TParams...>
{
    using TEventHandlerIt = typename std::list<TEventHandlerPtr>::const_iterator;
    public:

        TEvent()
        {
            . . .
        }
        ~TEvent()
        {
            // empty
        }
    protected:
        virtual bool addHandler( TEventHandlerPtr eventHandler ) override
        {
            std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );
            if( findEventHandler( eventHandler ) == m_handlers.end() )
            {
                m_handlers.push_back( std::move( eventHandler ) );
                return true;
            }
            return false;
        }
        virtual bool removeHandler( TEventHandlerPtr eventHandler ) override
        {
            . . .
        }
    private:
        // использовать под залоченным для чтения 'm_handlerListMutex'
        inline TEventHandlerIt findEventHandler( const TEventHandlerPtr& eventHandler ) const
        {
            return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TEventHandlerPtr& oneHandler )
            {
                return ( *oneHandler == *eventHandler );
            } );
        }
        // использовать под залоченным для записи 'm_handlerListMutex'
        inline void deleteHandler( TEventHandlerIt it )
        {
            m_handlers.erase( it );
        }
        std::list<TEventHandlerPtr> m_handlers;
    . . .
};

template<class TMethodHolder, class ...TParams>
class MethodEventHandler : public AbstractEventHandler<TParams...>
{
    . . .
    using TMethodHolderPtr = std::shared_ptr<TMethodHolder>;
    public:
        MethodEventHandler( TMethodHolderPtr methodHolder ) :
            AbstractEventHandler<TParams...>(),
            m_methodHolder( methodHolder )
        {
            assert( m_methodHolder != nullptr );
        }
    private:
        TMethodHolderPtr m_methodHolder;
    . . .
};
template<class TObject, class ...TParams>
class MethodHolder
{
    using MyType = MethodHolder<TObject, TParams...>;
    using TMethod = void( TObject::* )( TParams... );
    public:
        MethodHolder( TObject& object, TMethod method )
        {
            . . .
        }
        template<class ...TCallParams>
        operator THandlerPtr<TCallParams...>()
        {
            return THandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( /* ЧТО СЮДА ПЕРЕДАТЬ? */ ) );
        }
    . . .
};
template<class TObject, class ...TParams>
std::shared_ptr<MethodHolder<TObject, TParams...>> createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) )
{
    return std::shared_ptr<MethodHolder<TObject, TParams...>>( new MethodHolder<TObject, TParams...>( object, method ) );
}
#define METHOD_HANDLER( Object, Method ) createMethodEventHandler( Object, &Method )
#define MY_METHOD_HANDLER( Method ) METHOD_HANDLER( *this, Method )

template<class TObject, class ...TParams>
class MethodHolder
{
    using MyType = MethodHolder<TObject, TParams...>;
    using TMethod = void( TObject::* )( TParams... );
    public:
        template<class ...TCallParams>
        operator THandlerPtr<TCallParams...>()
        {
            return THandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( m_me.lock() ) );
        }
        template<class TObject, class ...TParams>
        static std::shared_ptr<MyType> create( TObject& object, TMethod method )
        {
            std::shared_ptr<MyType> result( new MyType( object, method ) );
            result->m_me = result;
            return result;
        }
    private:
        MethodHolder( TObject& object, TMethod method ) :
            m_object( object ),
            m_method( method )
        {
            assert( m_method != nullptr );
        }
        TObject& m_object;
        TMethod m_method;
        std::weak_ptr<MyType> m_me;
};
template<class TObject, class ...TParams>
std::shared_ptr<MethodHolder<TObject, TParams...>> createMethodEventHandler( TObject& object, void( TObject::*method )( TParams... ) )
{
    return MethodHolder<TObject, TParams...>::create( object, method );
}

• событие удаляет элемент из списка (m_handlers.erase( it );), что приводит к вызову его деструктора;
• вызывается деструктор std::unique_ptr, который приводит к вызову деструктора управляемого объекта;
• вызывается деструктор MethodEventHandler, который удаляет все поля объекта, в том числе поле m_methodHolder, являющееся std::shared_ptr;
• вызывается деструктор std::shared_ptr; он видит, что счётчик владельцев достиг нуля (т.к. на момент удаления из события он был единственным владельцем) и вызывает деструктор управляемого объекта (MethodHolder); однако уничтожение блока управления не вызывается, потому что счётчик ссылок std::weak_ptr пока не равен нулю;
• вызывается деструктор MethodHolder, который приводит к уничтожению всех полей, в том числе, поля m_me, являющегося std::weak_ptr;
• вызывается деструктор std::weak_ptr; его управляемый объект уже уничтожен; т.к. счётчик ссылок std::weak_ptr стал равным нулю, вызывается уничтожение блока управления;
• профит.

Соединение события и обработчика

template<class ...Types>
using THandlerPtr = std::shared_ptr<AbstractEventHandler<Types...>>;

template<class ...TParams>
class IEvent
{
    . . .
    protected:
        using TEventHandlerPtr = THandlerPtr<TParams...>;
        virtual bool isHandlerAdded( const TEventHandlerPtr& eventHandler ) const = 0;
        virtual bool addHandler( TEventHandlerPtr eventHandler ) = 0;
        virtual bool removeHandler( TEventHandlerPtr eventHandler ) = 0;
    friend class HandlerEventJoin<TParams...>;
    . . .
};
template<class ...TParams>
class TEvent : public IEvent<TParams...>
{
    . . .
    protected:
        virtual bool isHandlerAdded( const TEventHandlerPtr& eventHandler ) const override
        {
            std::shared_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );
            return ( findEventHandler( eventHandler ) != m_handlers.end() );
        }
        virtual bool addHandler( TEventHandlerPtr eventHandler ) override { . . . }
        virtual bool removeHandler( TEventHandlerPtr eventHandler ) override { . . . }
    private:
        // использовать под залоченным для чтения 'm_handlerListMutex'
        inline TEventHandlerIt findEventHandler( const TEventHandlerPtr& eventHandler ) const { . . . }
        
        std::list<TEventHandlerPtr> m_handlers;
        mutable std::shared_mutex m_handlerListMutex;
    . . .
};

template<class ...TParams>
class HandlerEventJoin
{
    public:
        HandlerEventJoin( IEvent<TParams...>& _event, THandlerPtr<TParams...> handler ) :
            m_event( _event ),
            m_handler( handler )
        {
        }
        inline bool isJoined() const
        {
            return m_event.isHandlerAdded( m_handler );
        }
        inline bool join()
        {
            return m_event.addHandler( m_handler );        
        }
        inline bool unjoin()
        {
            return m_event.removeHandler( m_handler );        
        }
    private:
        IEvent<TParams...>& m_event;
        THandlerPtr<TParams...> m_handler;
};

class AbstractEventJoin
{
    public:
        virtual ~AbstractEventJoin() {}

        virtual bool isJoined() const = 0;
        virtual bool join() = 0;
        virtual bool unjoin() = 0;
    protected:
        AbstractEventJoin() {}
};

template<class ...TParams>
class HandlerEventJoin : public AbstractEventJoin
{
    . . .
    public:
        virtual inline bool isJoined() const override { . . . }
        virtual inline bool join() override { . . . }
        virtual inline bool unjoin() override { . . . }
    . . .
};

class EventJoinWrapper
{
    public:
        template<class TSome, class ...TParams>
        inline EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler ) :
            m_eventJoin( std::make_shared<HandlerEventJoin<TParams...>>( _event, HandlerCast<TSome>::cast<TParams...>( handler ) ) )
        {
        }
        constexpr EventJoinWrapper() :
            m_eventJoin( nullptr )
        {
        }
        ~EventJoinWrapper()
        {
            if( m_eventJoin != nullptr )
                delete m_eventJoin;
        }
        operator bool() const
        {
            return isJoined();
        }
        bool isAssigned() const
        {
            return ( m_eventJoin != nullptr );
        }
        bool isJoined() const
        {
            return ( m_eventJoin != nullptr && m_eventJoin->isJoined() );
        }
        bool join()
        {
            return ( m_eventJoin != nullptr ? m_eventJoin->join() : false );
        }
        bool unjoin()
        {
            return ( m_eventJoin != nullptr ? m_eventJoin->unjoin() : false );
        }
    private:
        AbstractEventJoin* m_eventJoin;
};
using EventJoin = EventJoinWrapper;

class EventJoinWrapper
{
    public:
        EventJoinWrapper( EventJoinWrapper&& other ) :
            m_eventJoin( std::move( other.m_eventJoin ) )
        {
        }
        EventJoinWrapper( EventJoinWrapper& other ) :
            m_eventJoin( other.m_eventJoin )
        {
        }
        ~EventJoinWrapper() { /*empty*/ }        
        EventJoinWrapper& operator=( EventJoinWrapper&& other )
        {
            m_eventJoin = std::move( other.m_eventJoin );
            return *this;
        }
        EventJoinWrapper& operator=( const EventJoinWrapper& other )
        {
            m_eventJoin = other.m_eventJoin;
            return *this;
        }
        . . .
    private:
        std::shared_ptr<AbstractEventJoin> m_eventJoin;
};

template<class ...TParams>
class IEvent
{
    . . .
    public:
        template<class TSome>
        EventJoin operator+=( TSome&& some )
        {
            EventJoin result( *this, std::forward<TSome>( some ) );
            result.join();
            return result;
        }
    . . .
};

struct EventHolder
{
    TEvent<const std::string&> onEvent;
};
struct MethodsHolder
{
    void method1( const std::string& ) {}
    void method2( std::string ) {}
    void method3( std::string&& ) {}
    void method4( std::string& ) {}
    void method5( const int& ) {}
};
int main( int argc, char* argv[] )
{
    EventHolder _eventHolder;
    MethodsHolder _methodsHolder;

    EventJoin join1 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method1 ) );  // ok
    EventJoin join2 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method2 ) );  // ok
    EventJoin join3 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method3 ) );  // error
    EventJoin join4 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method4 ) );  // error
    EventJoin join5 = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( _methodsHolder, MethodsHolder::method5 ) );  // error
    
    return 0;
}

struct EventHolder
{
    TEvent<const std::string&, unsigned int> onEvent;
};
struct MethodsHolder
{
    void handleEvent( const std::string& text, unsigned int count )
    {
        std::cout << "Text '" << text << "' handled " << count << " times." << std::endl;
    }
};
int main__( int argc, char* argv[] )
{
    EventHolder _eventHolder;
    MethodsHolder methodsHolder;
    EventJoin eventJoin = EventJoin( _eventHolder.onEvent, METHOD_HANDLER( methodsHolder, MethodsHolder::handleEvent ) );

    static const std::string handlingText = "testing...";
    for( int i = 0; i < 10; ++i )
    {
        if( eventJoin.isJoined() )
            eventJoin.unjoin();
        else
            eventJoin.join();
        _eventHolder.onEvent( handlingText, i );
    }

    return 0;
}

Text 'testing...' handled 0 times.
Text 'testing...' handled 2 times.
Text 'testing...' handled 4 times.
Text 'testing...' handled 6 times.
Text 'testing...' handled 8 times.

Итог

#include <iostream>
#include <functional>
#include "events/event.hpp"
#include "events/handler/methodeventhandler.hpp"
#include "events/handler/functoreventhandler.hpp"
#include "events/join/handlereventjoin.hpp"
#include "events/join/eventjoinwrapper.hpp"

class Foo
{
    public:
        Foo() :
            onMake( m_onMake ),
            m_onMake(),
            m_onMakeInner(),
            m_makeCount( 0 )
        {
            m_onMakeInner += FUNCTOR_HANDLER( m_onMake );
        }
        IEvent<unsigned int>& onMake;
        void make()
        {
            m_onMakeInner( m_makeCount++ );
        }
    private:
        TEvent<unsigned int> m_onMake, m_onMakeInner;
        unsigned int m_makeCount;
};
namespace instances
{
    Foo& getFoo()
    {
        static Foo _foo;
        return _foo;
    }
} // instances

struct FunctorHandler
{
    void operator()( unsigned int makeCount );
};
void functionHandler( unsigned int makeCount );
class ClassHandler
{
    public:
        void handle( unsigned int makeCount );
};
namespace instances
{
    FunctorHandler& getFunctorHandler()
    {
        static FunctorHandler _functorHandler;
        return _functorHandler;
    }
    std::function<void( unsigned int )>& getStdFunctionHandler()
    {
        static std::function<void( unsigned int )> _stdFunctionHandler = []( unsigned int makeCount )
        {
            std::cout << "It's std::function handler" << std::endl;
            if( makeCount >= 2 )
                instances::getFoo().onMake -= STD_FUNCTION_HANDLER( instances::getStdFunctionHandler() );
        };
        return _stdFunctionHandler;
    }
    ClassHandler& getClassHandler()
    {
        static ClassHandler _classHandler;
        return _classHandler;
    }
} // instances
void FunctorHandler::operator()( unsigned int makeCount )
{
    std::cout << "It's functor handler" << std::endl;
    if( makeCount >= 0 )
        instances::getFoo().onMake -= FUNCTOR_HANDLER( instances::getFunctorHandler() );
}
void functionHandler( unsigned int makeCount )
{
    std::cout << "It's function handler" << std::endl;
    if( makeCount >= 3 )
        instances::getFoo().onMake -= FUNCTION_HANDLER( functionHandler );
}
void ClassHandler::handle( unsigned int makeCount )
{
    std::cout << "It's method handler" << std::endl;
    if( makeCount >= 4 )
        instances::getFoo().onMake -= MY_METHOD_HANDLER( ClassHandler::handle );
}

int main( int argc, char* argv[] )
{
    Foo& foo = instances::getFoo();

    auto lambdaHandler = []( unsigned int )
    {
        std::cout << "It's lambda handler" << std::endl;
    };

    foo.onMake += FUNCTOR_HANDLER( instances::getFunctorHandler() );
    foo.onMake += LAMBDA_HANDLER( lambdaHandler );
    EventJoin lambdaJoin = foo.onMake += LAMBDA_HANDLER( ( [ &foo, &lambdaHandler ]( unsigned int makeCount )
    {
        if( makeCount >= 1 )
            foo.onMake -= LAMBDA_HANDLER( lambdaHandler );
    } ) );
    foo.onMake += STD_FUNCTION_HANDLER( instances::getStdFunctionHandler() );
    foo.onMake += FUNCTION_HANDLER( functionHandler );
    foo.onMake += METHOD_HANDLER( instances::getClassHandler(), ClassHandler::handle );

    for( int i = 0; i < 6; ++i )
    {
        std::cout << "Make " << i << " time:" << std::endl;
        foo.make();
        std::cout << std::endl;
    }
    
    lambdaJoin.unjoin();
   
    return 0;
}

Make 0 time:
It's functor handler
It's lambda handler
It's std::function handler
It's function handler
It's method handler

Make 1 time:
It's lambda handler
It's std::function handler
It's function handler
It's method handler

Make 2 time:
It's std::function handler
It's function handler
It's method handler

Make 3 time:
It's function handler
It's method handler

Make 4 time:
It's method handler

Make 5 time:

• не оговаривалось отдельно, поэтому упомяну, что само событие в данной реализации является функтором, а значит, может выступать в качестве обработчика другого события;
• сейчас нельзя использовать в качестве обработчиков константные методы (функции-члены класса); думаю, если понадобится такая возможность, нетрудно написать для этого новый тип обработчика на основе уже имеющихся.

• тип возвращаемого значения метода (функции-члена класса) для соответствующего обработчика может быть любым, не обязательно void (для обработчиков-функторов это выполнялось и так);
• вся реализация завёрнута в namespace'ы для удобства использования в проектах (если кому-то это кажется лишним, их всегда можно убрать);
• кое-где добавлен спецификатор noexcept.

#pragma once

#include <type_traits>


template<class T>
class is_equatable
{
    private:

        template<class U>
        static constexpr std::true_type exists( decltype( std::declval<U>() == std::declval<U>() )* = nullptr ) noexcept;

        template<class U>
        static constexpr std::false_type exists( ... ) noexcept;

    public:

        static constexpr bool value = decltype( exists<T>( nullptr ) )::value;
};

#pragma once

#include "eventhandlerptr.h"


namespace events {

namespace handlers {


template<class ...TParams>
class AbstractEventHandler
{
    using MyType = AbstractEventHandler<TParams...>;

    public:

        virtual ~AbstractEventHandler() {}

        virtual void call( TParams... params ) = 0;

        bool operator==( const MyType& other ) const noexcept
        {
            return isEquals( other );
        }
        bool operator!=( const MyType& other ) const noexcept
        {
            return !( *this == other );
        }

    protected:
    
        AbstractEventHandler() {}

        virtual bool isEquals( const MyType& other ) const noexcept = 0;
};


} // handlers

} // events

#pragma once

#include <memory>


namespace events {

namespace handlers {


template<class ...TParams> class AbstractEventHandler;


template<class ...Types>
using TEventHandlerPtr = std::shared_ptr<AbstractEventHandler<Types...>>;


} // handlers

} // events

#pragma once

#include <memory>
#include <assert.h>
#include "abstracteventhandler.hpp"
#include "../helpers/is_equatable.hpp"


namespace events {

namespace handlers {


namespace
{

    template<class TFunctor, class ...TParams>
    struct IsFunctorParamsCompatible
    {
        private:

            template<class TCheckedFunctor, class ...TCheckedParams>
            static constexpr std::true_type exists( decltype( std::declval<TCheckedFunctor>()( std::declval<TCheckedParams>()... ) )* = nullptr ) noexcept;
            
            template<class TCheckedFunctor, class ...TCheckedParams>
            static constexpr std::false_type exists( ... ) noexcept;

        public:

            static constexpr bool value = decltype( exists<TFunctor, TParams...>( nullptr ) )::value;
    };

} //


template<class TFunctor> class FunctorHolder;

template<class TFunctor, class ...TParams>
class FunctorEventHandler : public AbstractEventHandler<TParams...>
{
    using MyType = FunctorEventHandler<TFunctor, TParams...>;
    using TFunctorHolderPtr = std::shared_ptr<FunctorHolder<TFunctor>>;

    public:

        FunctorEventHandler( TFunctorHolderPtr functorHolder ) :
            AbstractEventHandler<TParams...>(),
            m_functorHolder( functorHolder )
        {
            assert( m_functorHolder != nullptr );
        }

        virtual void call( TParams... params ) override
        {
            static_assert( IsFunctorParamsCompatible<TFunctor, TParams...>::value, "Event and functor arguments are not compatible" );

            m_functorHolder->m_functor( params... );
        }

    protected:

        virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const noexcept override 
        {
            const MyType* _other = dynamic_cast<const MyType*>( &other );
            return ( _other != nullptr && *m_functorHolder == *_other->m_functorHolder );
        }

    private:

        TFunctorHolderPtr m_functorHolder;
};


namespace
{

    template<class TEqu, class TEnabled = void>
    struct EqualityChecker;

    template<class TEquatable>
    struct EqualityChecker<TEquatable, typename std::enable_if<is_equatable<TEquatable>::value>::type>
    {
        static constexpr bool isEquals( const TEquatable& operand1, const TEquatable& operand2 ) noexcept
        {
            return ( operand1 == operand2 );
        }
    };

    template<class TNonEquatable>
    struct EqualityChecker<TNonEquatable, typename std::enable_if<!is_equatable<TNonEquatable>::value>::type>
    {
        static constexpr bool isEquals( const TNonEquatable& operand1, const TNonEquatable& operand2 ) noexcept
        {
            return ( &operand1 == &operand2 );
        }
    };

} //

template<class TFunctor>
class FunctorHolder
{
    using MyType = FunctorHolder<TFunctor>;

    public:

        template<class ...TCallParams>
        operator TEventHandlerPtr<TCallParams...>()
        {
            return TEventHandlerPtr<TCallParams...>( new FunctorEventHandler<TFunctor, TCallParams...>( m_me.lock() ) );
        }

        bool operator==( const MyType& other ) const noexcept
        {
            return EqualityChecker<TFunctor>::isEquals( m_functor, other.m_functor );
        }
        bool operator!=( const MyType& other ) const noexcept
        {
            return !( *this == other );
        }

        template<class TFunctor>
        static std::shared_ptr<MyType> create( TFunctor&& functor )
        {
            std::shared_ptr<MyType> result( new MyType( functor ) );
            result->m_me = result;
            return result;
        }

    private:

        FunctorHolder( TFunctor& functor ) :
            m_functor( functor ),
            m_me()
        {
        }

        TFunctor& m_functor;

        std::weak_ptr<MyType> m_me;

    template<class TFunctor, class ...TParams> friend class FunctorEventHandler;
};


template<class TFunctor>
std::shared_ptr<FunctorHolder<TFunctor>> createFunctorEventHandler( TFunctor&& functor )
{
    return FunctorHolder<TFunctor>::create( functor );
}


} // handlers

} // events


#define     FUNCTOR_HANDLER( Functor )              ::events::handlers::createFunctorEventHandler( Functor )
#define     LAMBDA_HANDLER( Lambda )                FUNCTOR_HANDLER( Lambda )
#define     STD_FUNCTION_HANDLER( StdFunction )     FUNCTOR_HANDLER( StdFunction )
#define     FUNCTION_HANDLER( Function )            FUNCTOR_HANDLER( &Function )

#pragma once

#include <memory>
#include <assert.h>
#include "abstracteventhandler.hpp"


namespace events {

namespace handlers {


namespace
{

    template<class TMethodHolder, class ...TParams>
    struct IsMethodParamsCompatible
    {
        private:

            template<class TCheckedMethodHolder, class ...TCheckedParams>
            static constexpr std::true_type exists( decltype( ( std::declval<TCheckedMethodHolder>().m_object.*std::declval<TCheckedMethodHolder>().m_method )( std::declval<TCheckedParams>()... ) )* = nullptr ) noexcept;
            
            template<class TCheckedMethodHolder, class ...TCheckedParams>
            static constexpr std::false_type exists( ... ) noexcept;

        public:

            static constexpr bool value = decltype( exists<TMethodHolder, TParams...>( nullptr ) )::value;
    };

} //


template<class TMethodHolder, class ...TParams>
class MethodEventHandler : public AbstractEventHandler<TParams...>
{
    using MyType = MethodEventHandler<TMethodHolder, TParams...>;
    using TMethodHolderPtr = std::shared_ptr<TMethodHolder>;

    public:

        MethodEventHandler( TMethodHolderPtr methodHolder ) :
            AbstractEventHandler<TParams...>(),
            m_methodHolder( methodHolder )
        {
            assert( m_methodHolder != nullptr );
        }

        virtual void call( TParams... params ) override
        {
            static_assert( IsMethodParamsCompatible<TMethodHolder, TParams...>::value, "Event and method arguments are not compatible" );

            ( m_methodHolder->m_object.*m_methodHolder->m_method )( params... );
        }

    protected:

        virtual bool isEquals( const AbstractEventHandler<TParams...>& other ) const noexcept override
        {
            const MyType* _other = dynamic_cast<const MyType*>( &other );
            return ( _other != nullptr && *m_methodHolder == *_other->m_methodHolder );
        }

    private:

        TMethodHolderPtr m_methodHolder;
};


template<class TObject, class TResult, class ...TParams>
class MethodHolder
{
    using MyType = MethodHolder<TObject, TResult, TParams...>;
    using TMethod = TResult( TObject::* )( TParams... );

    public:

        template<class ...TCallParams>
        operator TEventHandlerPtr<TCallParams...>()
        {
            return TEventHandlerPtr<TCallParams...>( new MethodEventHandler<MyType, TCallParams...>( m_me.lock() ) );
        }

        bool operator==( const MyType& other ) const noexcept
        {
            return ( &m_object == &other.m_object && m_method == other.m_method );
        }
        bool operator!=( const MyType& other ) const noexcept
        {
            return !( *this == other );
        }

        template<class TObject, class ...TParams>
        static std::shared_ptr<MyType> create( TObject& object, TMethod method )
        {
            std::shared_ptr<MyType> result( new MyType( object, method ) );
            result->m_me = result;
            return result;
        }

    private:

        MethodHolder( TObject& object, TMethod method ) :
            m_object( object ),
            m_method( method )
        {
            assert( m_method != nullptr );
        }

        TObject& m_object;
        TMethod m_method;

        std::weak_ptr<MyType> m_me;

    template<class TMethodHolder, class ...TParams> friend class MethodEventHandler;
    template<class TMethodHolder, class ...TParams> friend struct IsMethodParamsCompatible;
};


template<class TObject, class TResult, class ...TParams>
std::shared_ptr<MethodHolder<TObject, TResult, TParams...>> createMethodEventHandler( TObject& object, TResult( TObject::*method )( TParams... ) )
{
    return MethodHolder<TObject, TResult, TParams...>::create( object, method );
}


} // handlers

} // events


#define     METHOD_HANDLER( Object, Method )     ::events::handlers::createMethodEventHandler( Object, &Method )
#define     MY_METHOD_HANDLER( Method )          METHOD_HANDLER( *this, Method )

#pragma once

#include <memory>
#include "eventhandlerptr.h"


namespace events {

namespace handlers {


template<class TSome>
struct HandlerCast
{
    template<class ...Types>
    static constexpr TEventHandlerPtr<Types...> cast( TSome& some )
    {
        return static_cast<TEventHandlerPtr<Types...>>( some );
    }
};

template<class TPtr>
struct HandlerCast<std::shared_ptr<TPtr>>
{
    template<class ...Types>
    static constexpr TEventHandlerPtr<Types...> cast( std::shared_ptr<TPtr> some )
    {
        return HandlerCast<TPtr>::cast<Types...>( *some );
    }
};


} // handlers

} // events

#pragma once

#include <type_traits>
#include <list>
#include <memory>
#include <shared_mutex>
#include <algorithm>
#include <assert.h>
#include "handlers/abstracteventhandler.hpp"
#include "handlers/eventhandlerptr.h"
#include "handlers/handlercast.hpp"
#include "joins/eventjoinwrapper.hpp"


namespace events {


namespace joins
{
    template<class ...TParams> class HandlerEventJoin;
}

template<class ...TParams>
class IEvent
{
    public:

        template<class TSome>
        EventJoin operator+=( TSome&& some )
        {
            EventJoin result( *this, std::forward<TSome>( some ) );
            result.join();
            return result;
        }

        template<class TSome>
        bool operator-=( TSome&& some )
        {
            return removeHandler( handlers::HandlerCast<TSome>::cast<TParams...>( some ) );
        }

    protected:

        using TMyEventHandlerPtr = handlers::TEventHandlerPtr<TParams...>;

        IEvent() {}

        virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const = 0;
        virtual bool addHandler( TMyEventHandlerPtr eventHandler ) = 0;
        virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) = 0;

    friend class joins::HandlerEventJoin<TParams...>;
};


template<class ...TParams>
class TEvent : public IEvent<TParams...>
{
    using TEventHandlerIt = typename std::list<TMyEventHandlerPtr>::const_iterator;

    public:

        TEvent() :
            m_handlers(),
            m_currentIt(),
            m_isCurrentItRemoved( false ),
            m_handlerListMutex()
        {
        }

        void operator()( TParams... params )
        {
            m_handlerListMutex.lock_shared();
            
            m_isCurrentItRemoved = false;
            m_currentIt = m_handlers.begin();
            while( m_currentIt != m_handlers.end() )
            {
                m_handlerListMutex.unlock_shared();
                ( *m_currentIt )->call( params... );
                m_handlerListMutex.lock_shared();

                if( m_isCurrentItRemoved )
                {
                    m_isCurrentItRemoved = false;

                    TEventHandlerIt removedIt = m_currentIt;
                    ++m_currentIt;

                    deleteHandler( removedIt );
                }
                else
                {
                    ++m_currentIt;
                }
            }

            m_handlerListMutex.unlock_shared();
        }

    protected:

        virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const override
        {
            std::shared_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );

            return ( findEventHandler( eventHandler ) != m_handlers.end() );

        }
        virtual bool addHandler( TMyEventHandlerPtr eventHandler ) override
        {
            std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );

            if( findEventHandler( eventHandler ) == m_handlers.end() )
            {
                m_handlers.push_back( std::move( eventHandler ) );
                return true;
            }
            return false;
        }
        virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) override
        {
            std::unique_lock<std::shared_mutex> _handlerListMutexLock( m_handlerListMutex );

            auto it = findEventHandler( eventHandler );
            if( it != m_handlers.end() )
            {
                if( it == m_currentIt )
                    m_isCurrentItRemoved = true;
                else
                    deleteHandler( it );

                return true;
            }
            return false;
        }

    private:

        // использовать под залоченным для чтения 'm_handlerListMutex'
        inline TEventHandlerIt findEventHandler( const TMyEventHandlerPtr& eventHandler ) const noexcept
        {
            return std::find_if( m_handlers.cbegin(), m_handlers.cend(), [ &eventHandler ]( const TMyEventHandlerPtr& oneHandler )
            {
                return ( *oneHandler == *eventHandler );
            } );
        }
        // использовать под залоченным для записи 'm_handlerListMutex'
        inline void deleteHandler( TEventHandlerIt it )
        {
            m_handlers.erase( it );
        }

        std::list<TMyEventHandlerPtr> m_handlers;

        // использовать под залоченным 'm_handlerListMutex'
        mutable TEventHandlerIt m_currentIt;
        mutable bool m_isCurrentItRemoved;

        mutable std::shared_mutex m_handlerListMutex;
};


} // events

#pragma once


namespace events {

namespace joins {


class AbstractEventJoin
{
    public:

        virtual ~AbstractEventJoin();

        virtual bool isJoined() const = 0;
        virtual bool join() = 0;
        virtual bool unjoin() = 0;

    protected:

        AbstractEventJoin();
};


} // joins

} // events

#include "abstracteventjoin.h"


namespace events {

namespace joins {


AbstractEventJoin::AbstractEventJoin()
{
}

AbstractEventJoin::~AbstractEventJoin()
{
}


} // joins

} // events

#pragma once

#include "abstracteventjoin.h"
#include "../handlers/eventhandlerptr.h"


namespace events {


template<class ...TParams> class IEvent;


namespace joins {


template<class ...TParams>
class HandlerEventJoin : public AbstractEventJoin
{
    public:

        HandlerEventJoin( IEvent<TParams...>& _event, ::events::handlers::TEventHandlerPtr<TParams...> handler ) :
            AbstractEventJoin(),
            m_event( _event ),
            m_handler( handler )
        {
        }

        virtual inline bool isJoined() const override;
        virtual inline bool join() override;
        virtual inline bool unjoin() override;

    private:

        IEvent<TParams...>& m_event;
        ::events::handlers::TEventHandlerPtr<TParams...> m_handler;
};


} // joins

} // events

#pragma once

#include "handlereventjoin.h"
#include "../event.hpp"


namespace events {

namespace joins {


template<class ...TParams>
bool HandlerEventJoin<TParams...>::isJoined() const
{
    return m_event.isHandlerAdded( m_handler );
}

template<class ...TParams>
bool HandlerEventJoin<TParams...>::join()
{
    return m_event.addHandler( m_handler );
}

template<class ...TParams>
bool HandlerEventJoin<TParams...>::unjoin()
{
    return m_event.removeHandler( m_handler );
}


} // joins

} // events

#pragma once

#include <memory>
#include "../handlers/eventhandlerptr.h"


namespace events {


template<class ...TParams> class IEvent;


namespace joins {


class AbstractEventJoin;


class EventJoinWrapper
{
    public:

        template<class TSome, class ...TParams>
        inline EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler );

        constexpr EventJoinWrapper() noexcept;
        EventJoinWrapper( EventJoinWrapper&& other ) noexcept;
        EventJoinWrapper( EventJoinWrapper& other ) noexcept;

        EventJoinWrapper& operator=( EventJoinWrapper&& other ) noexcept;
        EventJoinWrapper& operator=( const EventJoinWrapper& other ) noexcept;

        operator bool() const;

        bool isAssigned() const;

        bool isJoined() const;
        bool join();
        bool unjoin();

    private:

        std::shared_ptr<AbstractEventJoin> m_eventJoin;
};


} // joins


using EventJoin = joins::EventJoinWrapper;


} // events

#pragma once

#include "eventjoinwrapper.h"
#include "handlereventjoin.h"
#include "../handlers/handlercast.hpp"


namespace events {

namespace joins {


template<class TSome, class ...TParams>
EventJoinWrapper::EventJoinWrapper( IEvent<TParams...>& _event, TSome&& handler ) :
    m_eventJoin( std::make_shared<HandlerEventJoin<TParams...>>( _event, ::events::handlers::HandlerCast<TSome>::cast<TParams...>( handler ) ) )
{
}


} // joins

} // events

#include "eventjoinwrapper.h"

#include <type_traits>
#include "abstracteventjoin.h"


namespace events {

namespace joins {


constexpr EventJoinWrapper::EventJoinWrapper() noexcept :
    m_eventJoin( nullptr )
{
}

EventJoinWrapper::EventJoinWrapper( EventJoinWrapper&& other ) noexcept :
    m_eventJoin( std::move( other.m_eventJoin ) )
{
}

EventJoinWrapper::EventJoinWrapper( EventJoinWrapper& other ) noexcept :
    m_eventJoin( other.m_eventJoin )
{
}


EventJoinWrapper& EventJoinWrapper::operator=( EventJoinWrapper&& other ) noexcept
{
    m_eventJoin = std::move( other.m_eventJoin );

    return *this;
}

EventJoinWrapper& EventJoinWrapper::operator=( const EventJoinWrapper& other ) noexcept
{
    m_eventJoin = other.m_eventJoin;

    return *this;
}


EventJoinWrapper::operator bool() const
{
    return isJoined();
}


bool EventJoinWrapper::isAssigned() const
{
    return ( m_eventJoin != nullptr );
}


bool EventJoinWrapper::isJoined() const
{
    return ( m_eventJoin != nullptr && m_eventJoin->isJoined() );
}

bool EventJoinWrapper::join()
{
    return ( m_eventJoin != nullptr ? m_eventJoin->join() : false );
}

bool EventJoinWrapper::unjoin()
{
    return ( m_eventJoin != nullptr ? m_eventJoin->unjoin() : false );
}


} // joins

} // events

namespace
{
    template<class ...TParams>
    struct TypeHelper
    {
        using TEventHandlerPtr = handlers::TEventHandlerPtr<TParams...>;
        using TEventHandlerIt = typename std::list<TEventHandlerPtr>::const_iterator;
    };
} //
template<class ...TParams>
class IEvent
{
    . . .
    protected:
        using TMyEventHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr;
    . . .
};
namespace
{
    template<class ...TParams>
    struct EventCore
    {
        using TMyHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr;
        std::list<TMyHandlerPtr> handlers;
        mutable std::shared_mutex coreMutex;
    };
    template<class ...TParams>
    class HandlerRunner
    {
        using TMyEventCore = EventCore<TParams...>;
        using TMyHandlerIt = typename TypeHelper<TParams...>::TEventHandlerIt;
        public:
            HandlerRunner( TMyEventCore& eventCore ) :
                m_eventCore( eventCore ),
                currentIt(),
                wasRemoving( false )
            {
            }
            void run( TParams... params )
            {
                m_eventCore.coreMutex.lock_shared();

                currentIt = m_eventCore.handlers.begin();
                wasRemoving = false;
                while( currentIt != m_eventCore.handlers.end() )
                {
                    m_eventCore.coreMutex.unlock_shared();
                    ( *currentIt )->call( params... );
                    m_eventCore.coreMutex.lock_shared();

                    if( wasRemoving )
                        wasRemoving = false;
                    else
                        ++currentIt;
                }

                m_eventCore.coreMutex.unlock_shared();
            }
            TMyHandlerIt currentIt;
            mutable bool wasRemoving;
        private:
            TMyEventCore& m_eventCore;
    };
} //
template<class ...TParams>
class TEvent : public IEvent<TParams...>
{
    using TMyEventHandlerPtr = typename TypeHelper<TParams...>::TEventHandlerPtr;
    using TMyEventHandlerIt = typename TypeHelper<TParams...>::TEventHandlerIt;
    using TMyHandlerRunner = HandlerRunner<TParams...>;
    public:
        TEvent() :
            m_core()
        {
        }
        void operator()( TParams... params )
        {
            TMyHandlerRunner newHandlerRunner( m_core );

            m_core.coreMutex.lock_shared();
            auto it = m_handlerRunners.insert( m_handlerRunners.end(), &newHandlerRunner );
            m_core.coreMutex.unlock_shared();

            newHandlerRunner.run( params... );

            m_core.coreMutex.lock_shared();
            m_handlerRunners.erase( it );
            m_core.coreMutex.unlock_shared();
        }
    protected:
        virtual bool isHandlerAdded( const TMyEventHandlerPtr& eventHandler ) const override
        {
            std::shared_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex );
            return ( findEventHandler( eventHandler ) != m_core.handlers.end() );
        }
        virtual bool addHandler( TMyEventHandlerPtr eventHandler ) override
        {
            std::unique_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex );

            if( findEventHandler( eventHandler ) == m_core.handlers.end() )
            {
                m_core.handlers.push_back( std::move( eventHandler ) );
                return true;
            }
            return false;
        }
        virtual bool removeHandler( TMyEventHandlerPtr eventHandler ) override
        {
            std::unique_lock<std::shared_mutex> _coreMutexLock( m_core.coreMutex );

            auto it = findEventHandler( eventHandler );
            if( it != m_core.handlers.end() )
            {
                for( TMyHandlerRunner* oneHandlerRunner : m_handlerRunners )
                {
                    if( it == oneHandlerRunner->currentIt )
                    {
                        ++oneHandlerRunner->currentIt;
                        oneHandlerRunner->wasRemoving = true;
                    }
                }
                m_core.handlers.erase( it );
                return true;
            }
            return false;
        }
    private:
        // использовать под залоченным для чтения 'm_core.coreMutex'
        inline TMyEventHandlerIt findEventHandler( const TMyEventHandlerPtr& eventHandler ) const
        {
            return std::find_if( m_core.handlers.cbegin(), m_core.handlers.cend(), [ &eventHandler ]( const TMyEventHandlerPtr& oneHandler )
            {
                return ( *oneHandler == *eventHandler );
            } );
        }
        EventCore<TParams...> m_core;
        std::list<TMyHandlerRunner*> m_handlerRunners;
};

template<class TSome>
struct ObjectSaver;

template<class LValue>
struct ObjectSaver<LValue&>
{
    using TObject = LValue&;
};

template<class RValue>
struct ObjectSaver<RValue&&>
{
    using TObject = RValue;
};

template<class TBase>
struct AbstractInnerHolder
{
    virtual ~AbstractInnerHolder() {}
    virtual inline TBase& get() = 0;
    inline const TBase& get() const
    {
        return const_cast<AbstractInnerHolder<TBase>&>( *this ).get();
    }
};
template<class TBase, class TInner>
struct TInnerHolder : public AbstractInnerHolder<TBase>
{
    using TInnerObject = typename ObjectSaver<TInner>::TObject;
    TInnerHolder( TInner _inner ) :
        AbstractInnerHolder<TBase>(),
        inner( std::forward<TInner>( _inner ) )
    {
    }
    virtual inline TBase& get() override
    {
        return static_cast<TBase&>( inner );
    }
    TInnerObject inner;
};
template<class TAssignBase, class TArgInner>
AbstractInnerHolder<TAssignBase>& createInnerHolder( TArgInner&& inner )
{
    using TAssignInner = decltype( inner );
    return *new TInnerHolder<TAssignBase, TAssignInner>( std::forward<TArgInner>( inner ) );
}

template<class TObject, class TResult, class ...TParams>
class MethodHolder
{
    . . .
    using MyType = MethodHolder<TObject, TResult, TParams...>;
    using TMethod = TResult( TObject::* )( TParams... );
    public:
        ~MethodHolder()
        {
            delete &m_innerHolder;
        }
        bool operator==( const MyType& other ) const
        {
            return ( &m_innerHolder.get() == &other.m_innerHolder.get() && m_method == other.m_method );
        }
        template<class TArgObject>
        static std::shared_ptr<MyType> create( TArgObject&& object, TMethod method )
        {
            std::shared_ptr<MyType> result( new MyType( std::forward<TArgObject>( object ), method ) );
            result->m_me = result;
            return result;
        }
    private:

        template<class TArgObject>
        MethodHolder( TArgObject&& object, TMethod method ) :
            m_innerHolder( createInnerHolder<TObject>( std::forward<TArgObject>( object ) ) ),
            m_method( method )
        {
            assert( m_method != nullptr );
        }
        AbstractInnerHolder<TObject>& m_innerHolder;
        TMethod m_method;
        std::weak_ptr<MyType> m_me;
    . . .
};

namespace
{
    template<class TMethodHolder, class ...TParams>
    struct IsMethodParamsCompatible
    {
        private:
            template<class TCheckedMethodHolder, class ...TCheckedParams>
            static constexpr std::true_type exists( decltype( ( std::declval<TCheckedMethodHolder>().m_innerHolder.get().*std::declval<TCheckedMethodHolder>().m_method )( std::declval<TCheckedParams>()... ) )* = nullptr );
        . . .
    };
} //
template<class TMethodHolder, class ...TParams>
class MethodEventHandler : public AbstractEventHandler<TParams...>
{
    public:
        virtual void call( TParams... params ) override
        {
            static_assert( IsMethodParamsCompatible<TMethodHolder, TParams...>::value, "Event and method arguments are not compatible" );
            ( m_methodHolder->m_innerHolder.get().*m_methodHolder->m_method )( params... );
        }
    private:
        TMethodHolderPtr m_methodHolder;
    . . .
};

template<class TObject, class TResult, class ...TParams>
std::shared_ptr<MethodHolder<typename std::decay<TObject>::type, TResult, TParams...>> createMethodEventHandler( TObject&& object, TResult( std::decay<TObject>::type::*method )( TParams... ) )
{
    return MethodHolder<std::decay<TObject>::type, TResult, TParams...>::create( std::forward<TObject>( object ), method );
}

P.S. Сравнение с механизмом сигналов/слотов Qt

Особенности обеих реализаций:

• возможность подключения сигналов (событий) к методам (функциям-членам), функторам и функциям;
• возможность подключения к сигналу (событию) слотов (обработчиков), типы аргументов которых могут отличаться видом ссылки (lvalue, rvalue);
• возможность подключения сигнала к сигналу (события к событию);
• возможность создания соединения (подключения) при подписке обработчика на событие (подключении сигнала к слоту).

Преимущества Qt:

• возможность уменьшения количества аргументов;
  в Qt предусмотрена возможность подключения к сигналам слотов с меньшим количеством аргументов; редуцироваться аргументы могут только «справа», иными словами, сигнатура слота должна соответствовать «левой части» сигнатуры сигнала; как частный случай, к любому сигналу можно подключить слот без аргументов; пожалуй, это может быть удобно в ряде случаев;
  
• возможность создания нескольких одинаковых подключений;
  по умолчанию Qt не ограничивает возможность несколько раз подключить к одному сигналу (одного и того же объекта) один и тот же слот (одного и того же объекта); такое ограничение можно задавать вручную при каждом подключении, используя Qt::UniqueConnection; хотя мне субъективно и не нравится, какое поведение выбрано в качестве поведения по умолчанию, стоит признать, что Qt всё же даёт возможность выбора в этом вопросе;
  
• возможность исполнения слота в потоке объекта, которому он принадлежит;
  задаётся такое поведение использованием Qt::QueuedConnection или Qt::BlockingQueuedConnection при подключении слота к сигналу; в этом случае код слота (обработчика) будет исполнен в потоке владельца этого слота; иначе он был бы исполнен в потоке владельца сигнала (события); на практике это означает, что обработчик будет вызван не мгновенно при срабатывании события, а в следующей итерации цикла обработки событий нужного потока; т.е. это бывает полезно, даже когда владелец сигнала и владелец слота находятся в одном потоке; правда, аргументы в этом случае специальным образом копируются.
  

Недостатки Qt:

• обязательное наследование от QObject;
  это кажется незначительным недостатком, однако, наследуясь от QObject, мы перенимаем все его ограничения, в частности, невозможность виртуального наследования (отсюда: Virtual inheritance with QObject is not supported.); в ряде случаев это, на мой взгляд, серьёзный недостаток;
  
• невозможность использования в template'ах;
  в шаблоне класса нельзя использовать сигналы и слоты, даже если он является public-наследником QObject; это ещё одно ограничение moc'а; конечно, его всегда можно
  
  обойти,

  #include <QObject>
  class AbstractProperty : public QObject
  {
      Q_OBJECT
      protected:
          AbstractProperty();
      signals:
          void valueChanged();
  };
  template<class TSource>
  class TProperty : public AbstractProperty
  {
      public:
          TProperty( const TSource& value = TSource() ) :
              AbstractProperty(),
              m_value( value )
          {
          }
          const TSource& value() const
          {
              return m_value;
          }
          void setValue( const TSource& newValue )
          {
              if( newValue != m_value )
              {
                  m_value = newValue;
                  emit valueChanged();
              }
          }
      private:        
          TSource m_value;
  };
  

  
  К сожалению, сигнал valueChanged не передаёт нового (а по желанию, и старого) значения свойства, и в обработчике приходится обращаться к нему напрямую.
  
  но, на мой взгляд, это менее удобно в использовании;
  
• невозможность нахождения декларации класса в .cpp-файле;
  подробнее;
  
• невозможность подключения по экземпляру класса QMetaObject::Connection;
  как уже отмечалось выше, в Qt функция подключения (соединения сигнала и слота) тоже возвращает некий объект, отвечающий за это подключение; с его помощью можно отключить (отсоединить) слот от сигнала, не задумываясь о том, какой это слот какого объекта и какой это сигнал какого объекта; однако с его помощью нельзя подключить слот к сигналу настолько же просто, как и создать его заранее на основе сигнала и слота; в Qt он создаётся только функцией подключения;
  
• использование дополнительно генерируемого moc'ом кода;
  это уже совсем субъективно, но решение, где на каждый класс, использующий сигналы и слоты (слоты не всегда) приходится несколько (по файлу на каждую конфигурацию) сгенерированных файлов доставляет некоторые неудобства; но скажем честно, это самый незначительный недостаток.