迭代C++可变参数模板
Iterate over C++ variadic template
>我有以下内容:
template<typename FIRST, typename SECOND>
Sender *createSenderChain() {
return new FIRST(new SECOND());
}
是否可以使模板可变:
template<typename FIRST, typename ...Args>
Sender *createSenderChain() {
return new FIRST(new SECOND(new THIRD(new ...)) <-- This is the pattern I want,
but how should it be done
using the args list?
}
你可以为此使用递归!
猜测你对Sender
的定义:
struct Sender { ~Sender() {} };
struct A : Sender { A(Sender* = nullptr) {} };
struct B : Sender { B(Sender* = nullptr) {} };
struct C : Sender { C(Sender* = nullptr) {} };
// Base case
template <typename T>
Sender* createSenderChain()
{
return new T();
}
// Recursive case
template <typename T1, typename T2, typename ...Ts>
Sender* createSenderChain()
{
return new T1(createSenderChain<T2, Ts...>());
}
int main()
{
auto ptr = createSenderChain<A, B, C>();
}
(现场演示(
您可以使用不同的模板参数调用相同的可变参数模板函数:
template<typename FIRST, typename SECOND, typename ...Args>
Sender* createSenderChain() {
return new typename FIRST(createSenderChain<SECOND, Args...>());
}
template<typename FIRST>
Sender* createSenderChain() {
return new typename FIRST();
}
在第一个函数中,我们不仅显式声明typename FIRST
,而且还typename SECOND
以避免将此实现与createSenderChain<T>
调用匹配,因为可变参数部分可能与空的类型列表匹配。
由于您的问题未指定使用哪种C++变体,因此此解决方案使用 C++17。 这意味着它可以避免递归。
我们通过二进制折叠来解析函数的组合。 为此,我们首先需要将函数对象转换为可以通过二进制操作组合的对象:
template<class F>
struct compose_t {
F f;
template<class Lhs, class Rhs>
auto operator*( compose_t<Lhs> lhs, compose_t<Rhs> rhs ) {
auto r =
[lhs = std::move(lhs).f, rhs = std::move(rhs).f](auto&&...args)
->decltype(auto)
{ return lhs(rhs(decltype(args)(args)...)); }
return compose_t<decltype(r)>{ std::move(r) };
}
template<class...Args>
decltype(auto) operator()(Args&&...args){
return f(std::forward<Args>(args)...);
}
};
template<class F>
compose_t<F> compose(F f) { return {std::forward<F>(f)}; }
这将创建一个可组合的函数对象,该对象与 *
组成。
接下来,我们需要一个表示"在堆上构造 T"的对象,而不指定对象如何完成它:
template<class T>
auto maker() {
return [](auto&&...args) {
return std::make_unique<T>( decltype(args)(args)...) )
};
}
maker
返回一个函数对象,该对象表示稍后提供的一组参数的调用make_unique<T>
。 我可以用原始指针来做到这一点,但我拒绝。
template<typename ...Args>
std::unique_ptr<Sender> createSenderChain() {
return (compose( maker<Args>() ) * ...)();
}
并完成。 请注意,我使用 unique_ptr<Sender>
s 而不是 Sender*
s,因为我拒绝提供您不应该使用的垃圾代码。
相关文章:
- 在不传递参数数量且只有3个点的情况下,如何使用变差函数
- 如何使用可变参数模板强制转换每个变体类型
- 关于如何在具有单个参数的变体构造中选择替代方案?
- 调用参数排列不变函数 f(i++, i++)
- 参数归纳与标准::变体
- 模板化回调参数的逆变,如 C# 中的逆变
- 如何在没有参数包的情况下编写变差函数
- 通过具有嵌套类的工厂类获取多个变异类模板参数包
- 获取模板参数的成员变量值列表
- 保留短 lambda 用作函数的中间参数,使用 clang 格式保持不变
- 如何定义变体<x,y,z>提取模板参数的子类型
- 正确对齐内存模板,参数顺序不变
- 递归中不同参数类型的变元模板函数
- 通过函数指针传递给变差函数的参数会更改其值
- 提升预定义为带有参数的全局 lambda 的变体访问者
- 使用可变参数模板参数提升变体访问者
- boost ::变体 - 为什么模板参数比const字符串参数具有更高的优先级
- 将变参数包中的值加载到临时数组中
- 使用额外参数提升变体访客
- 正在将动态数组元素解析为参数?(变音符)