使用模板而不是虚拟方法的管道模式

这是...一段旅程。我甚至不得不休息一下，然后回来真正理解我刚刚写的内容。

这个想法是每个管道节点(A、B、C(都是一个带有一个类型参数的类模板。此参数包含有关整个管道的信息，并且是节点类也必须从中继承的策略。由于我们不想陷入无限递归，因此我们将节点类型作为模板进行处理，直到必要时才实例化它们(这是在第 2 阶段查找中，其中所有内容都已正确定义(。我们走吧：

首先，我们定义一组工具，一些简单的元函数：

// Stores a class template to be instantiated later
template <template <class...> class T>
struct tlift {
// Instantiate the template
template <class... Args>
using apply = T<Args...>;
};
// Identity function
template <class T>
struct identity {
using type = T;
};

。以及一组类模板及其函数集：

// Pack of class templates
template <template <class> class...>
struct tpack { };
// Get the Nth element
template <class Pack, std::size_t N>
struct tpack_at;
template <template <class> class P0, template <class> class... P, std::size_t N>
struct tpack_at<tpack<P0, P...>, N> : tpack_at<tpack<P...>,  N - 1> { };
template <template <class> class P0, template <class> class... P>
struct tpack_at<tpack<P0, P...>, 0> {
using type = tlift<P0>;
};
// Get the size of the pack
template <class Pack>
struct tpack_size;
template <template <class> class... P>
struct tpack_size<tpack<P...>>
: std::integral_constant<std::size_t, sizeof...(P)> { };

请注意，由于模板不能裸露，因此tpack_at返回包含实际模板的tlift。

然后是解决方案的实质：策略类，最初未命名为Context。首先，我们四处看看我们的邻居是谁：

// Base class and template parameter for pipeline nodes
template <class Pipeline, std::size_t Index>
struct Context {
// Type of the previous node, or void if none exists
using Prev = typename std::conditional_t<
Index == 0,
identity<tlift<std::void_t>>,
tpack_at<Pipeline, Index - 1>
>::type::template apply<Context<Pipeline, Index - 1>>;
// Type of the next node, or void if none exists
using Next = typename std::conditional_t<
Index == tpack_size<Pipeline>::value - 1,
identity<tlift<std::void_t>>,
tpack_at<Pipeline, Index + 1>
>::type::template apply<Context<Pipeline, Index + 1>>;

这些有点复杂的 typedefs 中的每一个都会检查我们是否是管道中的第一个(或最后一个(节点，然后检索包含我们上一个(或下一个(节点的tlift。然后将此tlift与已有的Pipeline和相邻Index一起解开包装，以生成完整的节点类型。如果这个邻居不存在，则tlift包含std::void_t，它将在解包时忽略其参数并返回void。

一旦这种类型的体操完成，我们可以为我们的两个邻居存储两个指针：

private:
Prev *_prev;
Next *_next;

注意：第一个和最后一个Context分别包含其不存在的邻居的未使用void *。我没有花时间优化它们，但这也可以做到。

然后我们实现两个将由节点继承的函数，并允许它在邻居上调用prev和next。由于它不会增加复杂性，而且无论如何我都需要一个if constexpr模板，所以我在混合中添加了参数转发：

// Call the previous node's prev() function with arguments
template <class... Args>
void callPrev(Args &&... args) {
if constexpr(!std::is_void_v<Prev>)
_prev->prev(std::forward<Args>(args)...);
}
// Call the next node's next() function with arguments
template <class... Args>
void callNext(Args &&... args) {
if constexpr(!std::is_void_v<Next>)
_next->next(std::forward<Args>(args)...);
}

最后，Context的构造函数期望对所有节点的元组的引用，并从内部选择它的邻居：

// Construction from the actual tuple of nodes
template <class... T>
Context(std::tuple<T...> &pipeline) {
if constexpr(std::is_void_v<Prev>)  _prev = nullptr;
else                                _prev = &std::get<Index - 1>(pipeline);
if constexpr(std::is_void_v<Next>)  _next = nullptr;
else                                _next = &std::get<Index + 1>(pipeline);
}

剩下唯一要做的就是将我们需要的奇怪初始化包装到一个 maker 函数中：

template <template <class> class... Nodes, std::size_t... Idx>
auto make_pipeline(std::index_sequence<Idx...>) {
using Pack = tpack<Nodes...>;
std::tuple<Nodes<Context<Pack, Idx>>...> pipeline{{((void)Idx, pipeline)}...}; // (1)
return pipeline;
}
template <template <class Context> class... Nodes>
auto make_pipeline() {
return make_pipeline<Nodes...>(std::make_index_sequence<sizeof...(Nodes)>{});
}

注意(1)处的递归点，pipeline会将自己的引用传递给各个节点的构造函数，以便它们可以各自将其转发给它们的Context。((void)Idx, pipeline)技巧是让表达式依赖于模板参数包，以便我实际上可以打包扩展它。

最后，可以这样定义节点：

template <class Context>
struct NodeA : Context {
// Forward the context's constructor, or implement yours
using Context::Context;
void prev() {
// Do something
Context::callPrev();
}
void next() {
// Do something
Context::callNext();
}
};

。用法如下所示：

int main() {
auto pipeline = make_pipeline<NodeA, NodeB, NodeC>();
std::get<0>(pipeline).next(); // Calls the whole chain forward
std::get<2>(pipeline).prev(); // Calls the whole chain backwards
}

请注意，管道中的指针仍然有效，这要归功于从make_pipeline返回时发生的复制省略。但是，您不应该进一步复制它(正确的复制预防作为练习(。

仅此而已，伙计们。在科里鲁现场观看

按照昆汀的回答，使用完整的管道是要走的路。 但是prev/next对您的使用来说似乎是多余的，然后可以简化代码。

template <typename ... Nodes>
class pipeline
{
public:
explicit pipeline(const std::tuple<Nodes...>& nodes) : nodes(nodes) {}
template <typename ... Ts>
void traverse(Ts&&... args) {
std::apply([&](auto&&... flatNodes){ (flatNodes(args...), ...); }, nodes);
}
template <typename ... Ts>
void rev_traverse(Ts&&... args) {
rev_traverse_impl(std::index_sequence_for<Nodes...>(), std::forward<Ts>(args)...);
}
private:
template <typename ... Ts, std::size_t ... Is>
void rev_traverse_impl(std::index_sequence<Is...>, Ts&&...args)
{
constexpr auto size = sizeof...(Nodes);
(std::get<size - 1 - Is>(nodes)(args...), ...);
}
private:
std::tuple<Nodes...> nodes;
};

节点类似于：

class A
{
public:
A(/*...*/);
void operator()() const { /*..*/ }     
};

和用法：

pipeline<A, B, B, C> p({A{}, B{0}, B{1}, C{}});
p.traverse(); 
p.rev_traverse();

演示

甚至使用 lambda：

pipeline p(std::tuple(A{}, B{0}, B{1}, [](){ std::cout << "Lambda"; }));

演示

假设我们可以按照您想要的方式实例化这些模板，例如Start->A->End。

在中间，我们将需要一个实例化A，特别是

A<Start<*>, End<*>>

除了我们没有要放入*的类型，因为这是我们尝试实例化的类型。我们有一个没有基本情况的递归定义。

您要求的内容无法在C++类型中表达