Início / coding / Perguntas / 79577615
Accepted
Patrick Wright
Asked: 2025-04-16 23:59:18 +0800 CST

Como escrever um modelo com uma política padrão e parâmetros variáveis

  • 772

Estou experimentando escrever uma classe leve de sinais/observadores que tem a seguinte interface (implementação removida para simplificação):

template <typename ... ARGS>
class Signal
{
public:
    void connect(AbstractSlot<ARGS...>& slot);
    void disconnect(AbstractSlot<ARGS...>& slot);
    void emit(const ARGS&...args);

    //...
};

Que é usado, por exemplo, assim:

Signal<> signal1; //A signal with no parameters
Signal<int, int> signal2; //A signal with two int parameters

signal1.emit();
signal2.emit(10, 20);

Quero poder tornar minha classe opcionalmente thread-safe. Pensei em modificar meu modelo para aceitar uma classe de "política de bloqueio" que, por padrão, é "vazia".

struct NoLock
{
    void lock() {}
    void unlock() {}
};

Na minha cabeça, eu gostaria de poder usar o modelo de sinal modificado assim:

Signal<> signal1;
Signal<std::mutex> signal1Locked;
Signal<int, int> signal2;
Signal<int, int, std::mutex> signal2Locked;

O que exigiria que eu escrevesse o modelo assim:

template <typename ... ARGS, typename LockPolicy = NoLock>
class Signal;

Exceto que isso não é C++ válido (e eu entendo o porquê; como o compilador saberia a diferença entre os argumentos policy e variadic).

Minha pergunta é: como posso alcançar o que desejo em uma sintaxe que não seja muito confusa/complexa de usar?

c++

2 respostas

  1. Best Answer

    Que tal

    template <typename Signature, typename LockPolicy = NoLock> class Signal;

template <typename... Args, typename LockPolicy>
class Signal<void(Args...), LockPolicy>
{
// ...
};


Signal<void()> signal1;
Signal<void(int, int), std::mutex> signal2;

    ou usar alias (e alterar a ordem):

    template <typename LockPolicy , typename... Args> class LockSignal
{
// ...
};

template <typename... Args>
using Signal = LockSignal<NoLock, Args...>;

Signal<> signal1;
LockSignal<std::mutex, int, int> signal2;
    • 6

  2. Para um sinal como o seu, eu esperaria algo mais parecido com isso. E deixe std::function trabalhar para você. Depois, use um enum e if constexprpara instanciar o código correto.

    #include <functional>
#include <iostream>
#include <vector>
#include <mutex>

enum class SignalPolicy
{
    NotThreadSafe,
    ThreadSafe
};

template<SignalPolicy Policy, typename signature_t>
class Signal;

template<SignalPolicy Policy, typename... args_t>
class Signal<Policy, void(args_t...)>
{
public:
    Signal()
    {
    }

    auto operator()(args_t&&... args)
    {
        if constexpr (Policy == SignalPolicy::ThreadSafe)
        {
            std::scoped_lock lock{ get_mutex() };
        }

        for (const auto& callback : m_callbacks)
        {
            callback(std::forward<args_t>(args)...);
        }
    }

    // TODO : return a RAII registration object??
    template<typename fn_t>
    void subscribe(fn_t&& fn)
    {
        if constexpr (Policy == SignalPolicy::ThreadSafe)
        {
            std::scoped_lock lock{ get_mutex() };
        }

        m_callbacks.emplace_back(std::move(fn));
    }

private:
    // use a function that optionally can return a mutex
    // so it can be optimized away for Non threadsafe instance
    auto get_mutex()
    {
        if constexpr (Policy == SignalPolicy::ThreadSafe)
        {
            static std::mutex mtx;
            return mtx;
        }
    }

    std::vector<std::function<void(args_t...)>> m_callbacks;
};


int main()
{
    Signal<SignalPolicy::NotThreadSafe, void(int)> signal;
    signal.subscribe([](int value) { std::cout << "signal 1 raised with value " << value << "\n"; });
    signal.subscribe([](int value) { std::cout << "signal 2 raised with value " << value << "\n"; });
    signal(42);
}
    • 1

relate perguntas