Класс сигнала на Variadic Template

#ifndef SIGNAL_H
#define SIGNAL_H
 
// STD
#include <vector>
#include <functional>
 
template <typename ...T>
class Signal
{
public:
    Signal();
 
    size_t addCallback(std::function<void(T...)> callback) const;   // Возвращаем id callback'а
 
    void removeCallback(size_t index) const;                        // Удаление при помощи id быстрее, чем по значению
    void removeCallback(std::function<void(T...)> callback) const;
 
    void emit(T... arguments) const;
 
private:
    mutable std::vector<void(T...)> callbacks;
};
 
template<typename ...T>
inline Signal<T...>::Signal()
{
    callbacks.reserve(5);
}
 
template<typename ...T>
inline size_t Signal<T...>::addCallback(std::function<void(T...)> callback) const
{
    callbacks.push_back(callback);
    return callbacks.size() - 1;
}
 
template<typename ...T>
inline void Signal<T...>::removeCallback(size_t index) const
{
    callbacks.erase(callbacks.begin() + index);
}
 
template<typename ...T>
inline void Signal<T...>::removeCallback(std::function<void(T...)> callback) const
{
    for (size_t i = 0; i < callbacks.size(); i++)
    {
        if (callback == callbacks.at(i)) {
            callbacks.erase(callbacks.begin() + i);
        }
    }
}
 
template<typename ...T>
inline void Signal<T...>::emit(T... arguments) const
{
    for (auto& callback : callbacks)
    {
        if (callback != nullptr) {
            callback(arguments...);
        }
    }
}
 
#endif // !SIGNAL_H

#include <iostream>
using namespace std;
 
#include "Signal.h"
 
int main()
{
    Signal<> signal;
    signal.addCallback([]() { cout << "Hello world!" << endl; });
    signal.emit();
 
    return 0;
}

mutable std::vector<std::function<void(T...)>> callbacks;

#ifndef SIGNAL_H
#define SIGNAL_H
 
// STD
#include <vector>
#include <functional>
 
template <typename ...T>
class Signal
{
    using callback_t = std::function<void(T&&...)>;
public:
    Signal()
        :callbacks()
    { this->callbacks.reserve(5); }
        
 
    template<class Callable>
    size_t addCallback(Callable&& callback)
    {
        this->callbacks.emplace_back(
            std::forward<Callable>(callback)
        );
        return callbacks.size() - 1;
    }
 
    template<class... Args>
    void emit(Args&&... args) const
    {
        for (const auto& callback : this->callbacks)
            if (callback)
                callback(std::forward<Args>(args)...);
    }
 
private:
    std::vector<callback_t> callbacks;
};
 
 
#endif // !SIGNAL_H
 
 
#include <iostream>
 
 
int main()
{
    Signal<> signal;
    signal.addCallback([]() { std::cout << "Hello world!" << std::endl; });
    signal.emit();
}