variadic-templates 相关问题

如何将集合的参数包展平为成员初始化的 std::array ？

我想找到一种方法来编写以下内容： 组 a{1, 2}； b组{a, 3}; // 组 b{1, 2, 3} 的同义词 我已经进入了一个只能部分工作的环境，基本情况是普通的

调用时模板参数推导/替换失败

要么是我对 C++ 的理解有问题，要么是某个地方存在隐藏的拼写错误......我在这几个 LOC 上浪费了几个小时。 首先，我定义了一个 start() 方法： 模板 要么是我对 C++ 的理解有问题，要么是某个地方存在隐藏的拼写错误...我在这几个 LOC 上浪费了几个小时。 首先，我定义了一个 start() 方法： template <typename FunctionResult, typename ...FunctionArgs> inline std::shared_ptr<StoppableThread> start( std::function<FunctionResult(const bool&, FunctionArgs...)> function, FunctionArgs... args) { ... } 还有一些 threadedSearch() lambda 函数： std::function<void(const bool&, const Source&, Population&, const std::vector<Parameter>&, const size_t&, const size_t&)> threadedSearch = ... ; 但是当我尝试执行此操作时： Source source = { ... }; Population population = { ... }; const std::vector<Parameter> variationsParameters = { ... }; const size_t randomCandidatesCount = ..., lineageCount = ...; auto searchThread = start( threadedSearch, source, population, variationsParameters, randomCandidatesCount, lineageCount); 编译器不同意后者对 starŧ() 的调用，并告诉我： # with g++ error: no matching function for call to ‘start(std::function<void(const bool&, const Source&, Population&, const std::vector<Parameter>&, const long unsigned int&, const long unsigned int&)>&, Source&, Population&, const std::vector<Parameter>&, const size_t&, const size_t&)’ [...] note: candidate: ‘template<class FunctionResult, class ... FunctionArgs> std::shared_ptr<StoppableThread> start(std::function<FunctionResult(const bool&, FunctionArgs ...)>, FunctionArgs ...) note: template argument deduction/substitution failed: note: inconsistent parameter pack deduction with ‘const Source&’ and ‘Source’ # with clang++ error: no matching member function for call to 'start' note: candidate template ignored: deduced conflicting types for parameter 'FunctionArgs' (<const Source&, Population&, const std::vector<Parameter>&, const unsigned long&, const unsigned long&> vs. <Source, Population, std::vector<Parameter>, size_t, size_t>) 我的问题是：WTF？ 还有：我能做什么？在 start<...>() 调用中显式指定模板参数甚至不起作用... 我不知道如何让编译器理解它应该看到的“真实”参数类型...... 可以在这里找到完全崩溃的最小示例：https://onlinegdb.com/FtBIGmkH- 编辑 好的，用它来编译： auto searchThread = start<void, const Source&, Population&, const std::vector<Parameter>&, const size_t&, const size_t&>( threadedSearch, source, population, parameters, randomCandidatesCount, lineageCount); 谢谢你们，隔离一个最小的示例确实帮助我进行了调试！ whatever_t start(std::function<FunctionResult(const bool&, FunctionArgs...)> function, FunctionArgs... args) 这出现了两次FunctionArgs...。当属于 std::function 类型的一部分时，上下文是不可推导的，并且包将按原样从 std::function 中获取。在另一种情况下，上下文是可推导的，因此包将从实际的函数参数中推导出来。 在两种情况下，两个包都应该完全相同。然而 FunctionArgs... args 永远不会推导出引用类型，并且你的函数接受 const 引用。因此，一个包将充满 const 引用类型，而另一个包将充满非引用类型。这是替换失败。 解决该问题的一种方法是使其他事件也不可推论。 whatever_t start(std::function<FunctionResult(const bool&, FunctionArgs...)> function, std::type_identity_t<FunctionArgs>... args) 将完成这项工作（需要 C++20，但可以在紧要关头实现相当于 std::type_identity_t 的功能）。 另一种方法是将函数类型与参数解耦。 template<typename Func, typename ... Args> whatever_t start(Func&& func, Args&& ... args) （为了确保可以使用 func 调用 args，您可以使用 requires 子句或老式的 SFINAE，或者直接调用它，并在无法调用时处理不太有用的错误消息），

如何泛化任何可变参数模板类型的模板专业化？

我有以下类型函数来计算某个类型 T 是否是 std::tuple 中类型列表的一部分： 模板 结构体IsInTuple； 模板 我有以下类型函数来计算某些类型T是否是std::tuple中类型列表的一部分： template<typename T, typename Tuple> struct IsInTuple; template<typename T, typename ...Ts> struct IsInTuple<T, std::tuple<Ts...>> { static constexpr bool value = std::disjunction_v<std::is_same<T, Ts>...>; }; 我的问题是，是否可以将此函数推广到任何采用可变参数类型列表的可变参数模板类型，以便它不仅适用于 std::tuple，还适用于 std::variant？ 是否可以将此函数推广到任何采用可变参数类型列表的可变参数模板类型，以便它不仅适用于 std::tuples，而且还适用于 std::variants？ 是的，可以。只需使用 template 模板参数 来泛化类型特征。 template<typename T, typename Class> struct IsInTypeList; template<typename T , template<typename...> class Class, typename... Ts> struct IsInTypeList<T, Class<Ts...>> { static constexpr bool value = (std::is_same_v<T, Ts> || ...); // or std::disjunction_v<std::is_same<T, Ts>...>; }; // Example usage static_assert(IsInTypeList<int, std::tuple<int, float, double>>::value, "int is not in the tuple"); static_assert(!IsInTypeList<char, std::tuple<int, float, double>>::value, "char is in the tuple"); static_assert(!IsInTypeList<char, std::variant<int, float, double>>::value, "char is in the variant"); 观看现场演示

具有可变参数专业化的模板函数

是否可以以某种方式进行模板函数专门化，如下所示： 模板 void Func(size_t id, Args...args) { std::cout << "1\n" } temp...

在模板中转换参数包而不包装结构

我有以下代码，它可以工作： 模板 结构包装器 { 模板 static void toNativeFunction(东西...

如何：捕获输入函数异常的可变参数包装函数

我正在尝试创建一个可以传递其他函数的函数，这将捕获任何错误，但否则只是返回函数的返回值。这是我尝试过的： #包括 我正在尝试创建一个可以传递其他函数的函数，它将捕获任何错误，但否则只是返回函数的返回值。这是我尝试过的： #include <iostream> using namespace std; int fun(int input) { return input; } template <typename F, typename...Args> static auto HandledCall(const F& function, Args...args) -> decltype(function(...args)) { try { return function(...args); } catch(...) { return NULL; } } int main() { std::cout << HandledCall(fun,1) << std::endl; // this should return 1 std::cout << HandledCall(fun,-1) << std::endl; // this should return 0 return 0; } 希望意图比较明确；我希望 HandledCall 能够接收任何类型的函数，并返回其返回值（只要 NULL 在发生错误时可以隐式转换为该值）。然而，当我尝试编译上面的代码时，我收到了这些类型的错误； prog.cpp:10:78: 错误：“...”标记之前需要主表达式 静态自动 HandledCall(const F& 函数, Args...args) -> decltype(函数(...args)) 显然我没有正确地执行这个可变参数模板...有什么建议吗？ 函数调用的返回类型可以使用 std::result_of 确定。 template<typename F, typename... Args> typename std::result_of<F(Args...)>::type HandledCall(F&& func, Args&&... args) { using result_type = typename std::result_of<F(Args...)>::type; try { return std::forward<F>(func)(std::forward<Args>(args)...); } catch(...) { return result_type(); } } 现场演示 有这样的事吗？ #include <iostream> using namespace std; int fun(int input) { return input; } template <typename T> struct ReturnType; template<class Ret, class... Args> struct ReturnType<Ret(Args...)> { typedef Ret type; }; template <typename F, typename...Args> static auto HandledCall(const F& function, Args...args) -> typename ReturnType<F>::type { try { return function(args...); } catch(...) { return typename ReturnType<F>::type{0}; } } int main() { std::cout << HandledCall(fun,1) << std::endl; // this should return 1 std::cout << HandledCall(fun,-1) << std::endl; // this should return 0 return 0; } 更新 HandledCall的改进版本（感谢Mankarse）： template <typename F, typename...Args> static auto HandledCall(const F& function, Args&&...args) -> typename ReturnType<F>::type { try { return function(std::forward<Args>(args)...); } catch(...) { return typename ReturnType<F>::type{0}; } } 这是一个基于 @Praetorian 提出的解决方案的版本，但它也适用于具有 void 返回类型的函数。其他答案无法处理这种情况的原因是 void 类型的对象的显式实例化。 template<typename T> T default_value(){return {};} template<> void default_value<void>(){} template<typename F, typename... Args> typename std::result_of<F(Args...)>::type HandledCall(F&& func, Args&&... args) { try { return std::forward<F>(func)(std::forward<Args>(args)...); } catch(...) { return default_value<typename std::result_of<F(Args...)>::type>(); } } 这样做的原因是因为标准允许在具有 void 返回类型的函数中显式返回 void 值。 包装的函数通常在编译时就已知，因此我建议通过如下所示的方式来利用它（> = c ++ 17）： #include <cstdlib> #include <stdexcept> #include <type_traits> #include <utility> template <auto F, typename... Args> auto nonThrowingFunWrapper(Args... args) { using result_type = std::invoke_result_t<decltype(F), Args...>; constexpr std::integral_constant<decltype(F), F> fun_object; try { return fun_object(std::forward<Args>(args)...); } catch (...) { std::abort(); return result_type(); } } int foo(int bar) { throw std::runtime_error("foo failed"); return bar; } int main() { return nonThrowingFunWrapper<foo>(43); }

类如何声明其所有可变参数模板参数？

如果我有一个类采用模板参数的可变参数包，我怎样才能将它们声明为朋友？ 这是我想以伪代码形式执行的操作： 模板 班级

如何泛化任何可变参数模板类型的模板专业化？

我有以下类型函数来计算某个类型 T 是否是元组中类型列表的一部分： 模板 结构体IsInTuple； 模板 我有以下类型函数来计算某种类型T是否是元组中类型列表的一部分： template<typename T, typename Tuple> struct IsInTuple; template<typename T, typename ...Ts> struct IsInTuple<T, std::tuple<Ts...>> { static constexpr bool value = std::disjunction_v<std::is_same<T, Ts>...>; }; 我的问题是，是否可以将此函数推广到任何采用可变参数类型列表的可变参数模板类型，以便它不仅适用于元组，而且还适用于变体？ 是否可以将此函数推广到任何采用可变参数类型列表的可变参数模板类型，以便它不仅适用于 std::tuples，而且还适用于 std::variants？ 是的，可以。只需使用模板模板参数来概括情况即可。 template<typename T, typename Class> struct IsInTypeList; template<template<typename...Ts> class Class, typename T, typename ...Ts> struct IsInTypeList<T, Class<Ts...>> { static constexpr bool value = (std::is_same_v<T, Ts> || ...); }; // Example usage static_assert(IsInTypeList<int, std::tuple<int, float, double>>::value, "int is in the tuple"); static_assert(!IsInTypeList<char, std::tuple<int, float, double>>::value, "char is not in the tuple"); static_assert(!IsInTypeList<char, std::variant<int, float, double>>::value, "char is not in the tuple");

如果类型包包含特定类型，如何仅向类添加方法？

我正在尝试创建一个可以包含类型包的类。 // 包.hpp 模板 班级包决赛 { Pack(const std::tuple items) : items_(std::move(item...

使用可变参数模板指定友元类

我正在尝试使用可变参数模板来指定友元类。我尝试使用以下语法，但它不起作用。 模板 结构体A { 朋友参数...； }; 我尝试鳕鱼...

如何从可变参数模板类创建元组并在 C++ 中调用每个元素作为参数的成员函数？

我有一个带有可变参数模板参数的类，我正在尝试编写一个成员函数来创建一个包含可变参数的容器。我的方法是从

std::pair 构造函数重载采用元组如何判断元组内容是否是 r-val 引用？

对于措辞尴尬的问题表示歉意。我的不确定性基于可以大致简化为以下场景的情况。 我有一个 Foo 类，我想要一个 std::pair

寻找一种根据条件使用不同可变参数函子的方法

我有一个运行时布尔详细信息，如果为 false，则会排除一些打印到标准输出的信息。 要确定想法，请考虑有很多部分，例如： void add(const int a, const int b, const bool verbose) { //......

如何从 std::array 为可变参数构造函数生成初始值设定项列表

作为简化，假设我们有两种不同类型的引脚和一个容纳其中一种的板 // 板引脚 结构 BoardPin { }; // 另一种引脚 结构特殊引脚 { }; // 一块板...

通用成员函数指针作为模板参数

考虑以下代码： #包括 使用命名空间 std； 班级你好{ 民众： 无效 f(){ 计算<<"f"< 考虑这段代码： #include <iostream> using namespace std; class hello{ public: void f(){ cout<<"f"<<endl; } virtual void ff(){ cout<<"ff"<<endl; } }; #define call_mem_fn(object, ptr) ((object).*(ptr)) template<R (C::*ptr_to_mem)(Args...)> void proxycall(C& obj){ cout<<"hello"<<endl; call_mem_fn(obj, ptr_to_mem)(); } int main(){ hello obj; proxycall<&hello::f>(obj); } 当然，这不会在第 16 行编译，因为编译器不知道 R、C 和 Args 是什么。但还有另一个问题：如果试图在 ptr_to_mem 之前定义这些模板参数，他会遇到这种糟糕的情况： template<typename R, typename C, typename... Args, R (C::*ptr_to_mem)(Args...)> // ^variadic template, but not as last parameter! void proxycall(C& obj){ cout<<"hello"<<endl; call_mem_fn(obj, ptr_to_mem)(); } int main(){ hello obj; proxycall<void, hello, &hello::f>(obj); } 令人惊讶的是，g++ 并没有抱怨 Args 不是模板列表中的最后一个参数，但无论如何它无法将 proxycall 绑定到正确的模板函数，只是指出它是一个可能的候选者。 有什么解决办法吗？我的最后一招是将成员函数指针作为参数传递，但如果我可以将它作为模板参数传递，它将更适合我的代码的其余部分。 编辑： 正如一些人指出的那样，这个例子似乎毫无意义，因为 proxycall 不会传递任何参数。在我正在处理的实际代码中，情况并非如此：参数是通过一些模板技巧从 Lua 堆栈中获取的。但这部分代码与问题无关，而且相当冗长，所以我不会将其粘贴到这里。 你可以尝试这样的事情： template <typename T, typename R, typename ...Args> R proxycall(T & obj, R (T::*mf)(Args...), Args &&... args) { return (obj.*mf)(std::forward<Args>(args)...); } 用途：proxycall(obj, &hello::f); 或者，要将 PTMF 变成模板参数，请尝试专业化： template <typename T, T> struct proxy; template <typename T, typename R, typename ...Args, R (T::*mf)(Args...)> struct proxy<R (T::*)(Args...), mf> { static R call(T & obj, Args &&... args) { return (obj.*mf)(std::forward<Args>(args)...); } }; 用途： hello obj; proxy<void(hello::*)(), &hello::f>::call(obj); // or typedef proxy<void(hello::*)(), &hello::f> hello_proxy; hello_proxy::call(obj); 在现代 C++ 中，可以使用 template<auto> 和通用 lambda 包装器： #include <utility> #include <functional> template<auto mf, typename T> auto make_proxy(T && obj) { return [&obj] (auto &&... args) { return (std::forward<T>(obj).*mf)(std::forward<decltype(args)>(args)...); }; } struct R {}; struct A {}; struct B {}; struct Foo { R f(A &&, const B &) { return {}; } //R f(A &&, const B &) const { return {}; } }; int main() { Foo foo; make_proxy<&Foo::f>(foo)(A{}, B{}); //make_proxy<static_cast<R (Foo::*)(A &&, const B &) const>(&Foo::f)>(std::as_const(foo))(A{}, B{}); //make_proxy<static_cast<R (Foo::*)(A &&, const B &)>(&Foo::f)>(foo)(A{}, B{}); } 如果存在重载，应该像注释代码中那样显式指定成员函数类型。

如何在 C++20 中定义一个概念来检查类型是否与类型列表中的任何类型匹配

我想用C++定义一个概念（<= C++20) to check if a type matches any of the types define in a type-list struct. The following is my attempt so far: template 结构

在发送到 std::vformat 之前如何转换可变参数的类型

我想在将来自可变参数的特定类型的值发送到 std::vformat() 之前对其进行转换，但我似乎找不到一种方法来实现它。 我尝试获取格式参数...

在C++中，如何使用模板接受任意格式的聚合初始化列表？

例如，考虑函数 foo，可以按如下方式调用它： 富（ {{1.0f}, 123}, {'C'， {}} ）； 函数中的每个参数位置都可以采用聚合初始化 l...

如何使用折叠表达式实现“多米诺骨牌”或“级联”更新功能？

我正在编写一个可变参数模板函数，它应该实现“多米诺骨牌”更新。也就是说：给定一个谓词 p，它应该迭代多个 lval（通过引用传递）和 ass...

如何在 C++ 中创建不同类型的多个向量的组合，而无需硬编码循环

以下问题询问如何查找相同类型的 n 个向量的“所有组合”，例如std::string：如何在 C++ 中创建多个向量的组合而无需硬编码循环？...