Question

我有一个问题，我不能把头包裹起来。我有两个回调类型定义（后来由lambdas使用）：

typedef std::function<void(Payload1 Payload)> Callback1;
typedef std::function<void(Payload2 Payload)> Callback2;

Payload1和Payload2是包含事件有效负载数据的不同结构。然后我得到了两个数组（我正在使用，那些是TArrays，但这并不重要），其中包含回调：

TArray<Callback1> Callback1Array;
TArray<Callback2> Callback2Array;

一个模板化函数，它应该将回调添加到适合的数组中：

template<typename CallbackType>
void SubscribeToEvent(CallbackType Callback)
{
    // If CallbackType is Callback1
    Callback1Array.Add(Callback);

    // Else If CallbackType is Callback2
    Callback2Array.Add(Callback);
}

我不确定如何表达我在评论中所写的陈述。如果它试图将Callback2类型添加到Callback1数组中，它显然会失败，所以我需要检查类型，只将它添加到正确的数组中，并且不要尝试将其添加到其他数组中。这可能吗？

谢谢：）

Answer 1

使用std::tuple，您可以执行以下操作：

template <typename ... Ts>
class Foo
{
public:
    template <typename T>
    using Callback = std::function<void(T)>;

    template <typename T>
    using EventArray = TArray<Callback<T>>;


    template <typename T>
    void SubscribeEvent(Callback<T> callback)
    {
        GetCallbackArray<T>().Add(callback);
    }

private:
    template <typename T>
    EventArray<T>& GetCallbackArray() { return std::get<EventArray<T>>(eventCallbacks); }

private:
    std::tuple<EventArray<Ts>...> eventCallbacks;
};

using MyClass = Foo<FRpcEventPayload_Ready /*, ...*/>;

Answer 2

要直接回答这个问题，可以写下您评论的内容

template<typename CallbackType>
void SubscribeToEvent(CallbackType Callback)
{
    if constexpr(std::is_same_v<CallbackType, Callback1>)
        Callback1Array.Add(Callback);

    if constexpr(std::is_same_v<CallbackType, Callback2>)
        Callback2Array.Add(Callback);
}

但这看起来像是对if constexpr

的严重滥用

这通常是您重载SubscribeToEvent而非使用模板的地方。

void SubscribeToEvent(Callback1 Callback)
{
    Callback1Array.Add(Callback);
}

void SubscribeToEvent(Callback2 Callback)
{
    Callback2Array.Add(Callback);
}

仅将模板化参数添加到数组中（如果它是特定类型的参数）

2 个答案: