C++ 菊花链可变模板类

我有一个类模板管道：

template <typename A, typename B> class Pipeline;

现在是否有可能以可变的方式对它们进行端到端的约束

// I would like to write something like:
Pipeline<Args[0], Args[len(Args)-1]> compose(Pipeline<Args[i], Args[i+1]> ps...);

//我想写一些类似于：
管道组成（管道ps…）；

我假设您的

管道类似于：

template <typename A, typename B>
struct Pipeline {
    using first = A;
    using second = B;
};

当然，我们需要索引序列技巧：

template <typename... Pipelines,
          typename R = decltype(detail::daisy_chain(
                                    std::make_index_sequence<sizeof...(Pipelines)-1>(),
                                    std::declval<Pipelines>()...))
         >
R compose(Pipelines... pipelines)
{
    return {};
}

模板
R组合（管道…管道）
{
返回{}；
}

大部分工作在此处进行检查：

namespace detail {
    template <size_t... Is,
              typename... Pipelines,
              typename T = std::tuple<Pipelines...>,
              typename R = std::enable_if_t<
                          // ensure that all our pairwise pipelines are valid links
                                all_true<
                                    is_valid_link<std::tuple_element_t<Is,T>,
                                                  std::tuple_element_t<Is+1,T>>::value...
                                    >::value,
                           // pick out the first and last types
                                Pipeline<typename std::tuple_element_t<0, T>::first,
                                         typename std::tuple_element_t<sizeof...(Pipelines)-1, T>::second>
                            >>
    R daisy_chain(std::index_sequence<Is...>, Pipelines... pipelines);
}

名称空间详细信息{
模板：：值，
//挑出第一个和最后一个类型
管道
>>
R菊花链（标准：：索引顺序，管道…管道）；
}

这让我们做到：

int main() {
    Pipeline<int, double> p = compose(Pipeline<int, char>{}, Pipeline<char, double>{});
}

intmain（）{
管道p=compose（管道{}，管道{}）；
}

这样写的好处是你仍然拥有SFINAE——如果你想要的话。以便：

auto invalid = compose(Pipeline<int, char>{}, Pipeline<float, double>{});

auto-invalid=compose（管道{}，管道{}）；

将触发过载解决故障：

main.cpp:46:31: error: no matching function for call to 'compose'
    Pipeline<int, double> p = compose(Pipeline<int, char>{}, Pipeline<float, double>{});
                              ^~~~~~~
main.cpp:40:3: note: candidate template ignored: substitution failure [with Pipelines = <Pipeline<int, char>, Pipeline<float, double>>]: no matching function for call to 'daisy_chain'
R compose(Pipelines... pipelines)
  ^
1 error generated.

main.cpp:46:31:错误：调用“编写”时没有匹配的函数
管道p=compose（管道{}，管道{}）；
^~~~~~~
main.cpp:40:3:注意：已忽略候选模板：替换失败[管道=]：没有用于调用“daisy_chain”的匹配函数
R组合（管道…管道）
^
生成1个错误。
您能否将其显示为管道的定义？当然可以。这可能有点冗长。
template struct Pipeline{B run（a）；}
应该可以做到这一点。它基本上是一个详细的函数“a->B”，我想写函数组合。从一个从列表中获取一对的元函数开始：
pair==T2，T3
，等等。最终你想要的是类似于
f（pair…
的东西是
Pipeline
本身是一个可变模板，还是两种类型？从你问题的措辞看不清楚。
int main() {
    Pipeline<int, double> p = compose(Pipeline<int, char>{}, Pipeline<char, double>{});
}

auto invalid = compose(Pipeline<int, char>{}, Pipeline<float, double>{});

main.cpp:46:31: error: no matching function for call to 'compose'
    Pipeline<int, double> p = compose(Pipeline<int, char>{}, Pipeline<float, double>{});
                              ^~~~~~~
main.cpp:40:3: note: candidate template ignored: substitution failure [with Pipelines = <Pipeline<int, char>, Pipeline<float, double>>]: no matching function for call to 'daisy_chain'
R compose(Pipelines... pipelines)
  ^
1 error generated.