template<class L> Subscribe(L lambda)
{
    std::function<сигнатура вызова lambdы> f; // типа void(int, int)
    std::function<void(сигнатура параметров lambdы)> f; // типа только "int, int"
}

Subscribe([](int, int){});

B>template<class L> Subscribe(L lambda)
B>{
B>    std::function<сигнатура вызова lambdы> f; // типа void(int, int)
B>    std::function<void(сигнатура параметров lambdы)> f; // типа только "int, int"
B>}

B>Subscribe([](int, int){});
B>

namespace fn {

/**
 * \Note Function details description
 */
template<typename Sign, typename R, typename... Args>
struct traits_base {
  using signature = Sign;
  using is_method = std::is_member_function_pointer<signature>;
  using args = std::tuple<Args...>;
  using arity = std::integral_constant<unsigned, sizeof...(Args)>;
  using result = R;
};

/**
 * \Note Function details specializations
 */
template<typename T>
struct traits : traits<decltype(&T::operator())> {};
template<typename R, typename... Args>
struct traits<R(*)(Args...)> : traits_base<R(*)(Args...), R, Args...> {};
template<typename R, typename... Args>
struct traits<R(* const)(Args...)> : traits_base<R(* const)(Args...), R, Args...> {};
#if __cplusplus >= 201703
template<typename R, typename... Args>
struct traits<R(*)(Args...) noexcept> : traits_base<R(*)(Args...), R, Args...> {};
template<typename R, typename... Args>
struct traits<R(* const)(Args...) noexcept> : traits_base<R(* const)(Args...), R, Args...> {};
#endif // __cplusplus >= 201703
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...)> : traits_base<R(C::*)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...)> : traits_base<R(C::* const)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) const> : traits_base<R(C::*)(Args...) const, R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) const> : traits_base<R(C::* const)(Args...) const, R, Args...> {};
#if __cplusplus >= 201703
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) noexcept> : traits_base<R(C::*)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) noexcept> : traits_base<R(C::* const)(Args...), R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::*)(Args...) const noexcept> : traits_base<R(C::*)(Args...) const, R, Args...> {};
template<typename R, typename C, typename... Args>
struct traits<R(C::* const)(Args...) const noexcept> : traits_base<R(C::* const)(Args...) const, R, Args...> {};
#endif // __cplusplus >= 201703

} // namespace fn

// use, e.g. std::function<typename fn::traits<L>::signature> f;

    template<class ...A> struct CActiveDelegate
    {
        CDelegate<void(A...)>        Function;
        std::function<void(A...)>    Lambda;
        EListen                Listen;

        CActiveDelegate()
        {
        }
    };

    template<class X, class Y, typename...A> CActiveDelegate<A...> CreateActiveDelegate(Y* x, void (X::*func)(A...), EListen l)
    { 
        CActiveDelegate<A...> d;
        d.Function = fastdelegate<void(A...)>(x, func);
        d.Listen = l;
        return d;
    }


    template<class ...L> CActiveDelegate<typename fn::traits<L>::args> CreateLambdaDelegate(L la, EListen l)
    { 
        CActiveDelegate<typename fn::traits<L>::args> d;
        d.Lambda = la;
        d.Listen = l;
        return d;
    }

    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
    #define LambdaSubscriber(la, l)        CreateLambdaDelegate(la, l)

    template<class ...A> class CActiveEvent
    {
        public:
            void operator += (CActiveDelegate<A...> & d)
            {
                Subscribers.push_back(d);
            }

        protected:
            CArray<CActiveDelegate<A...>>    Subscribers;
    };


    class A
    {
        void AAA(CString &)
        {
            CActiveEvent<CString &> aaa;

            aaa += FunctionSubscriber(AAA, EListen::NormalAll);
            aaa += LambdaSubscriber([](CString &){}, EListen::NormalAll);

        }
    };

B>    template<class ...L> CActiveDelegate<typename fn::traits<L>::args> CreateLambdaDelegate(L la, EListen l)
B>    { 
B>        CActiveDelegate<typename fn::traits<L>::args> d;
B>        d.Lambda = la;
B>        d.Listen = l;
B>        return d;
B>    }
B>

template<class L> auto CreateLambdaDelegate(L la, EListen l) -> CActiveDelegate<typename fn::traits<L>::signature> {...}

    template<typename S> struct CActiveDelegate
    {
        fastdelegate::FastDelegate<S>    Function;
        std::function<S>        Lambda;
        int                Listen;

        CActiveDelegate()
        {
        }
    };

    template<class X, class Y, typename...A> auto CreateActiveDelegate(Y* x, void (X::*func)(A...), int l)
    { 
        CActiveDelegate<void(A...)> d;
        d.Function = fastdelegate::FastDelegate<void(A...)>(x, func);
        d.Listen = l;
        return d;
    }


    template<class L> auto CreateLambdaDelegate(L la, int l)
    { 
        CActiveDelegate<typename fn::traits<L>::signature> d;
        d.Lambda = la;
        d.Listen = l;
        return d;
    }

    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
    #define LambdaSubscriber(la, l)            CreateLambdaDelegate(la, l)

    template<class ...A> class CActiveEvent
    {
        public:
            void operator += (CActiveDelegate<void(A...)> & d)
            {
                Subscribers.push_back(d);
            }

        protected:
            std::list<CActiveDelegate<void(A...)>>    Subscribers;
    };


    class A
    {
        void AAA(std::string &)
        {
            CActiveEvent<std::string &> aaa;

            aaa += FunctionSubscriber(AAA, 1);
            aaa += LambdaSubscriber([](std::string &){}, 2);

        }
    };

B>    template<typename S> struct CActiveDelegate
B>    {
B>        fastdelegate::FastDelegate<S>    Function;
B>        std::function<S>        Lambda;
B>        int                Listen;

B>        CActiveDelegate()
B>        {
B>        }
B>    };

B>    template<class X, class Y, typename...A> auto CreateActiveDelegate(Y* x, void (X::*func)(A...), int l)
B>    { 
B>        CActiveDelegate<void(A...)> d;
B>        d.Function = fastdelegate::FastDelegate<void(A...)>(x, func);
B>        d.Listen = l;
B>        return d;
B>    }


B>    template<class L> auto CreateLambdaDelegate(L la, int l)
B>    { 
B>        CActiveDelegate<typename fn::traits<L>::signature> d;
B>        d.Lambda = la;
B>        d.Listen = l;
B>        return d;
B>    }

B>    #define FunctionSubscriber(method, l)    CreateActiveDelegate(this, &std::remove_pointer<decltype(this)>::type::method, l)
B>    #define LambdaSubscriber(la, l)            CreateLambdaDelegate(la, l)

B>    template<class ...A> class CActiveEvent
B>    {
B>        public:
B>            void operator += (CActiveDelegate<void(A...)> & d)
B>            {
B>                Subscribers.push_back(d);
B>            }

B>        protected:
B>            std::list<CActiveDelegate<void(A...)>>    Subscribers;
B>    };


B>    class A
B>    {
B>        void AAA(std::string &)
B>        {
B>            CActiveEvent<std::string &> aaa;

B>            aaa += FunctionSubscriber(AAA, 1);
B>            aaa += LambdaSubscriber([](std::string &){}, 2);

B>        }
B>    };
B>

aaa += FunctionSubscriber(AAA, 1);

aaa += FunctionSubscriber(AAA, 1);

aaa += FunctionSubscriber(AAA, 1);