从可变模板类推导类型包，并声明相同类型包的参数

Deduce types pack from a variadic-templated class and declare an argument of the same types pack

本文关键字：声明 同类型 参数 类型      更新时间：2023-10-16

首先，很抱歉问题标题不清楚，如果您想到更好的陈述方式，请随时编辑。

我有一堂课：

template <typename ...Arguments>
class CSignal
{
    template <typename ...ActualArguments>
    void invoke(ActualArguments&&... args) const {}
};

另一个，这是我有问题的地方：

class SomeClass
{
    template<typename ...Arguments>
    void invokeQueued(CSignal<Arguments...>& signal, const Arguments&... args)
    {
        m_queue.emplace_back([=](){signal.invoke(args...);});
    }
    std::deque<std::function<void (void)>> m_queue;
};

问题：

CSignal<float> signal;
int i = 0;
SomeClass().invokeQueued(signal, i);

错误：

template parameter 'Arguments' is ambiguous
could be 'float'
or       'int'

可能的幼稚解决方案

template<typename ...FormalArguments, typename ...ActualArguments>
void invokeQueued(CSignal<FormalArguments...>& signal, const ActualArguments&... args)
{
    m_queue.emplace_back([=](){signal.invoke(args...);});
}

在这种特定情况下是不可接受的，因为我需要按值捕获参数(将它们复制到 lambda 中(，并且从 ActualArguments 到 FormalArguments 的转换必须在调用 invokeQueued 时发生，而不是在调用 lambda 时发生。

如果我能在CSignal类中typedef参数包，我会这样做：

template<typename ...FormalArguments>
void invokeQueued(CSignal<FormalArguments...>& signal, const CSignal<FormalArguments...>::argument_types&... args)
{
    m_queue.emplace_back([=](){signal.invoke(args...);});
}

但这似乎是不可能的。解决 方案？

你遇到的错误是因为参数的类型不同，而编译器对每个这样的参数对只有一个类型模板参数：从CSignal的签名中它看到float，而从第二个参数的推导类型它看到int，并且两者都必须与Arguments包的单个元素匹配。这就是歧义的来源。

要解决此问题，您可以通过引入非推导上下文从模板参数推导中排除其中一个参数，就像下面的标识技巧一样：

template <typename T> struct identity { using type = T; };
template <typename T> using identity_t = typename identity<T>::type;
class SomeClass
{
public:
    template <typename... Arguments>
    void invokeQueued(CSignal<Arguments...>& signal,
                      const identity_t<Arguments>&... args)
    //                      ~~~~~~~~~^
    {
        m_queue.emplace_back([=](){signal.invoke(args...);});
    }
    std::deque<std::function<void(void)>> m_queue;
};

编译器不会尝试推导任何作为嵌套名称说明符语法一部分的模板参数，这基本上就是identity所做的 - 它引入了identity<T>::type语法，因此T留给范围解析运算符，但它仍然可以在函数声明中完整使用。

演示

或者，您可以在 lambda 表达式中存储捕获参数时转换为正确类型的参数的衰减副本 (C++14(：

#include <utility>
#include <type_traits>
#include <cstddef>
class SomeClass
{
public:
    template <typename... FormalArguments, typename... ActualArguments>
    void invokeQueued(CSignal<FormalArguments...>& signal, ActualArguments&&... args)
    {
        invokeQueued(signal, std::index_sequence_for<ActualArguments...>{}, std::forward<ActualArguments>(args)...);
    }
    template <typename... FormalArguments, typename... ActualArguments, std::size_t... Is>
    void invokeQueued(CSignal<FormalArguments...>& signal, std::index_sequence<Is...>, ActualArguments&&... args)
    {
        m_queue.emplace_back(
          [signal, t = std::tuple<std::decay_t<FormalArguments>...>(std::forward<ActualArguments>(args)...)]
          (){signal.invoke(std::get<Is>(t)...);});
    }
    std::deque<std::function<void(void)>> m_queue;
};

演示 2

使用身份技巧为Arguments&&...创建非推导上下文。

template <typename T>
class Identity
{
public:
using type = T;
};
template<typename ...Arguments>
void invokeQueued(CSignal<Arguments...>& signal, const typename Identity<Arguments>::type &... args)
{
    m_queue.emplace_back([=](){signal.invoke(args...);});
}
相关文章：