variadic-templates 相关问题

Typescript - 如何从动态创建的对象推断正确的子类类型

这是这个问题的后续。 我想要达到的目标是： 将多个子类传递给函数是否有一种方法可以返回一个对象，该对象作为具有 sub-

在 C++20 中实现可变参数 Max 函数

尽管事实上，我们有 std::max，但我想尝试是否可以制作一个接受可变参数并递归调用 Max 来查找最大元素的 Max 版本。 我看到类似的...

可变模板类

C++ 中有没有一种方法可以创建一个模板类，该类在构造函数中接受任意数量的参数，并且可以在需要时获取这些参数？ 例子： #包括 模板 C++ 中有没有一种方法可以创建一个模板类，该类在构造函数中接受任意数量的参数，并且可以在需要时获取这些参数？ 示例： #include <string> template<size_t Size, typename... Types> class Container { public: Container(Types... args) { // add checks to see if Size = no args } void get(Types&... args) { // getter method } }; int main() { Container<3, int, double, std::string> container(10, 2.5, "smth"); int a{}; double b{}; std::string c {}; container.get(a, b, c); // expect a = 10, b = 2.5, c = "smth" return 0; } 是的，您的问题的解决方案已经以std::tuple的形式存在： // note: size_t parameter isn't needed, we can simply get the size using // sizeof...(Types) template<typename... Types> class Container { public: std::tuple<Types...> stuff; // note: in practice, this should use forwarding references and // std::forward instead of taking everything by value Container(Types... args) : stuff(args...) {} void get(Types&... args) { // std::tie creates a tuple of references, letting us // assign all members at once std::tie(args...) = stuff; } }; 你可以实现一个包装std::tuple的容器，但它并没有真正提供std::tuple还没有的任何实用工具，所以我们可以直接使用它： int main() { std::tuple<int, double, std::string> container(10, 2.5, "smth"); // not so good: decompose using three variables and std::tie int a {}; double b {}; std::string c {}; std::tie(a, b, c) = container; // better: use structured bindings (C++17) auto [aa, bb, cc] = container; } 请记住，在泛型编程之外，您最好创建自己的 struct，并为类型和成员提供有意义的名称。 // aggregate type struct Container { int a; double b; std::string c; }; int main() { Container container{10, 2.5, "smth"}; // structured bindings also work for aggregate types (C++17) auto [a, b, c] = container; } C++ 中有没有一种方法可以创建一个模板类，该类在构造函数中接受任意数量的参数，并且可以在需要时获取这些参数？ 是的，只需在这里使用std::tuple即可。是否应该将其包装到类模板中，取决于进一步的要求。 #include <tuple> // std::tuple auto container{ std::make_tuple(10, 2.5, "smth"s) }; // Structured bindings since C++17 auto [a, b, c] = std::tuple<int, double, std::string>(container); 在 godbolt.org 中观看现场演示

获取函数参数类型作为元组

问题 给定任何函数（或可调用）类型 Function，如何获取其所有参数类型作为元组类型？ 例如，我需要一个特征 function_traits::arguments，其中： 我...

C++20：将参数包编码和解码为由 varargs 使用的变量

经过漫长而详尽的搜索后，不确定以下内容在 C++20 中是否可能，但无论如何还是要问： 使用 C++20 代替 C 的 va_list，我可以： (1) 对传递给变量的任意参数列表进行编码...

C++ 推导出通用可变参数模板函数的不完整包

给定以下代码： 模板 概念对=要求（P对） { 类型名 P::first_type； 类型名 P::second_type； pair.first; 对.second; { pair.first } -&g...

从 std::apply 中的折叠表达式捕获返回值

我有一个简单的片段，试图说明我正在尝试做什么。 我将几个类实例打包在一个元组中，并使用 std::apply 迭代它们。 我想捕捉两个值： 如果匹配...

打包并将可变模板参数传递给另一个模板类

此代码片段实现了两个类——一个接受命令名称和受支持子命令列表的命令处理程序，以及一个包含所有此类受支持“命令”的元类。 我是

如何解压可变参数模板，以初始化各个成员？

我不熟悉可变参数模板和压缩参数等等。 我想在我的程序中有一个“实体组件系统”，在尝试向实体添加组件时，我开始意识到...

How to convert in compile time a `std::make_index_sequence<N>` to `parametrized_type<0,1,2,3,...,N-1>` [关闭]

我用整数参数化了一个模板类 模板 类 TemplClass{}; 然后我为 std::variant 定义了一个模板别名： 模板...

两个 C++ 编译器不同意我的“count_args”函数是否是 constexpr

这是一个小函数，可以计算您传入的参数数量： #包括 constexpr static int count_args() { 返回 0； } 模板 constexpr 站...

将可变模板参数解包到可变继承类中

我有简单的 3 个类，其中两个实际上是继承的： 结构A { }; 结构 B ：虚拟 A { B(整数, 整数) { } }; 结构 C : 虚拟 A { C(整数) { } }; 现在我想上一堂课......

外参数包可以用内参数包推导吗？

给定重载函数 f1： void f1(int); int f1(字符); 以及一个带有成员模板 f 的类模板 X： 模板 结构 X { 模板 静态无效 f(T(*p)(U...

如何使用 pybind11 为可变参数模板调用提供 Python 绑定？

我正在尝试使用 pybind11 为具有大量可变（成员）函数或构造函数的 C++17 库创建 Python 绑定。 // 可变成员函数 结构栏 { 模板 我正在尝试使用 pybind11 为具有大量可变（成员）函数或构造函数的 C++17 库创建 Python 绑定。 // variadic member function struct Bar { template <typename... Args> void baz(Args&&...){ /*...*/ } }; // variadic constructor struct Foo { template <typename... Args> Foo(Args&&...){ /*...*/ } }; // variadic free function template <typename... Args> void foobar(Args&&...){ /*...*/ } pybind11 supports positional *args arguments 使用这个功能对我来说似乎很自然。不幸的是，我一直无法弄清楚如何使用 pybind11::args 将参数转发给可变参数函数。 绑定代码是什么样的？ #include <pybind11/pybind11.h> namespace py = pybind11; PYBIND11_MODULE(example, m) { py::class_<Bar>(m, "Bar") .def("baz", [](py::args){ /* how do I forward to variadic Bar::baz? */ }); py::class_<Foo>(m, "Foo") .def(py::init<py::args>()); // is this right? m.def("foobar", [](py::args){ /* how do I forward to variadic foobar? */ }); } 这里有一些限制： 对于我的用例，在所有情况下都支持某种固定类型的异构参数就足够了，例如我可以只为 Foo 公开一个接受任意数量的 Bar 实例的构造函数。 我不能——或者非常不愿意——修改现有库的API。因此，必须使用接受例如一个std::initializer_list会让我难过。也就是说，绑定代码中的一些胶水代码是可以接受的，只要它是可维护的。 虽然肯定不漂亮，但我可以接受将可变参数的数量限制为最大值，比如 20，因为模板必须在绑定代码的编译时显式实例化，例如通过 template void foobar(); template void foobar(Foo&&); // ... 如果事实证明这是必要的，那么如果 python 用户能够得到一个适当的错误消息，表明已超过最大参数数量，那就太好了。 它不一定是 pybind11，如果其他库处理得更好，我愿意使用它们。 使用 py::cast 将 py::args 对象的每个元素转换为 int 并将它们作为参数传递给适当的 C++ 函数（这还需要在编译时了解类型）： Playground #include <pybind11/pybind11.h> namespace py = pybind11; struct Bar { void baz(int x, int y) { /* ... */ } }; struct Foo { Foo(int x, int y) { /* ... */ } }; void foobar(int x, int y) { /* ... */ } // Explicitly instantiate the templates for up to 2 int arguments template void Bar::baz<int, int>(int&&, int&&); template void Foo::Foo<int, int>(int&&, int&&); template void foobar<int, int>(int&&, int&&); PYBIND11_MODULE(example, m) { py::class_<Bar>(m, "Bar") .def("baz", [](Bar& self, py::args args) { if (args.size() != 2) { throw std::runtime_error("Expected 2 arguments"); } int x = py::cast<int>(args[0]); int y = py::cast<int>(args[1]); self.baz(std::move(x), std::move(y)); }); py::class_<Foo>(m, "Foo") .def(py::init<int, int>()); m.def("foobar", [](py::args args) { if (args.size() != 2) { throw std::runtime_error("Expected 2 arguments"); } int x = py::cast<int>(args[0]); int y = py::cast<int>(args[1]); foobar(std::move(x), std::move(y)); }); }

展开可变模板折叠表达式

模板 使用 Type = std::variant, std::shared_ptr, std::shared_ptr>; 我如何使用可变模板和折叠

在 c++ 中的可变参数函数中使用默认参数调用函数

我正在尝试学习可变模板函数，所以我尝试制作一个函数“timeIt”，它接受另一个函数并调用它。 #包括 #包括 #inclu...

为什么这个 type_traits 代码给我一个整数到指针转换警告？

在不赘述的情况下，我创建了一个可变参数模板函数，它根据模板参数的类型做不同的事情。我将实现简化为重新...

具有 enable_if 和 is_constructible 的可变参数构造函数

我有一个名为 NameAndTag 的类。它有构造函数： 名称和标签(); NameAndTag(std::string name_or_tag); NameAndTag(boost::uuids::uuid 标签) : 标签(标签) {} 现在，我想定义另一个

bswap_impl 中 std::index_sequence 和 void 转换的目的

这里和这里有多个关于类型转换为 void 的问题。 我的问题是，void casting (void)dummy_pack; 的目的是什么？在 en.cppreference.com/w/cpp/language/fold 中？是不是

在运行时循环可变模板类型

我将代码从 C++11 迁移到 C++17。在该代码中，我做了类似这样的（无效的）代码： 模板 std::vector 存储类型() { std::向量 我将代码从 C++11 迁移到 C++17。在该代码中，我做了类似这样的（无效的）代码： template <typename... Ts> std::vector<std::size_t> store_types() { std::vector<std::size_t> t; for(typename T : Ts) t.push_back(typeid(T).hash_code()); return t; } 目前，我的实现如下： template <typename Unused> void add_types_in(std::vector<std::size_t>&) {} template <typename Unused, typename First, typename... Others> void add_types_in(std::vector<std::size_t>& t) { t.push_back(typeid(First).hash_code()); add_types_in<Unused, Others...>(t); } template <typename... Ts> std::vector<std::size_t> store_types() { std::vector<std::size_t> t; add_types_in<void*, Ts...>(t); return t; } 我在 C++17 中看到了很多可变参数功能，但还有很多东西我还不明白。 C++17 中是否有比我的实现更优雅（又名“单行”）的东西？ 也许类似于折叠表达式的东西？