std::tuple_cat替换失败

tuple_cat的参数必须是元组(或支持std::tuple_size和std::tuple_elementAPI的"类似元组"的东西，如std::pair或std::array)，但从错误消息来看，您似乎是用非元组类型调用它。要做到这一点，你可能需要这样的东西：

std::tuple_cat(std::make_tuple(a_non_tuple), a_tuple, another_tuple);

这将第一个参数转换为tuple<decltype(a_non_tuple)>，以便它可以与其他元组连接。

将std::tuple<T1, std::tuple<T2, std::tuple<T3, ...>>>连接到std::tuple<T1, T2, T3, ...>

这不是"串联"。我认为正确的说法是"扁平化"。

我真的不确定你在尝试什么，因为你还没有提供一个完整的例子。你用std::tuple<T1, std::tuple<T2, std::tuple<T3, ...>>>这样的参数调用foo吗？

这不会起作用，因为foo将把T推导为std::tuple<T1, std::tuple<T2, std::tuple<T3, ...>>>，并实例化odds<T1>专门化，这只是将foo的参数封装在另一个元组中！

我不知道您是否对此感兴趣，因为这是一种替代实现，而不是您问题的答案。我认为，像这样使用tuple_cat最终会在运行时进行大量的移动/复制，尽管编译器可能会为琐碎的类型避免这些操作。无论如何，这似乎是一个有趣的TMP问题。

这就是我想到的(可能过于冗长)；它肯定需要一些清理(我的clang版本——几周前的trunk——在试图编译它时断言)。

有趣的递归位在Skip中，它使用前一个元组作为模式(实际上是count)来构造下一个元组；您可以看到，最后，Odds是如何使用SkipHelper传递双参数模式来设置初始调用的。(这部分肯定需要一些工作，也许使用数字会更容易)：

namespace skip_args {
namespace detail {
// We use Tuple as a kind of generic typelist.
template<typename ...T>
using Tuple = std::tuple<T...>;
// Utility "functions"
// Pusher<T, Tuple<U...> >::type = Tuple<T, U...>
template<typename A, typename B> struct Pusher;
template<typename T, typename ...U> struct Pusher<T, Tuple<U...>> {
using type = Tuple<T, U...>;
};
template<typename A, typename B>
using push = typename Pusher<A, B>::type;
// Skip is an intermediate used to skip over ignored elements.
// To allow recursion, we declare the general form first.
// All three arguments are Tuples.
template<typename Next, typename Rest, typename This> struct Skip;
// Node is actually used to store some data item. It also inherits from the next
// following Node (if there is one) so that we end up with an inheritance chain.
// (That's the part similar to libstdc++ tuples; it makes the layout the same,
// too, as long as there's no EBO to deal with, because we don't bother here.)
template<typename Rest, typename ...This> struct Node;
template<typename ...R_, typename T, typename ...T_>
struct Node<Tuple<R_...>, T, T_...>
: Skip<Tuple<>, Tuple<R_...>, Tuple<T, T_...>>::type {
using self = Node<Tuple<R_...>, T, T_...>;
using next = typename Skip<Tuple<>, Tuple<R_...>, Tuple<T, T_...>>::type;
// Recursive construction of node types
using nodes = push<self, typename next::nodes>;
using value_type = T;
// The constructor takes all the arguments, uses the first one, skips some,
// and passes the rest to the next node.
constexpr Node<Tuple<R_...>, T, T_...>(T&& t, T_&&...t_, R_&&...r_)
: next(std::forward<R_>(r_)...), value(std::forward<T>(t)) {
}
T&& value;
};
// Base:
template<>
struct Node<Tuple<>> {
using nodes = Tuple<>;
constexpr Node<Tuple<>>() {}
};
// Skip (N...) (R R...) (T T...) => Skip (N... R) (R...) (T...)
// In other words, it drops elements from the third tuple, and for each one it
// moves an element from the second tuple to the first tuple. If it runs out of
// the third tuple, it "returns" a new Node. If it runs out of the second tuple,
// then we're done, but to satisfy the node requirements, it actually needs to
// declare a constructor (which drops all its arguments)
// General case:
template<typename ...N_, typename R, typename ...R_, typename T, typename ...T_>
struct Skip<Tuple<N_...>, Tuple<R, R_...>, Tuple<T, T_...>>
: Skip<Tuple<N_..., R>, Tuple<R_...>, Tuple<T_...>> {
};
// Ran out of pattern
template<typename ...N_, typename R_, typename T_>
struct Skip<Tuple<N_...>, R_, T_> {
using type = Node<R_, N_...>;
using nodes = typename type::nodes;
};
template<typename T> struct TupleTyper;
template<typename ...T> struct TupleTyper<Tuple<T...>> {
using type = Tuple<typename T::value_type...>;
};
template<typename A, typename B, typename C> struct TupleMaker;
template<typename Tup, typename H, typename ...T>
struct TupleMaker<Tup, H, Tuple<T...>> {
Tup operator()(H&& helper) {
return Tup(static_cast<T&>(helper).value...);
}
};
template<typename N> struct SkipHelper {
using tuple_type = typename TupleTyper<typename N::nodes>::type;
template<typename ...U>
tuple_type operator()(U&& ...u) {
return TupleMaker<tuple_type, N, typename N::nodes>()(N(std::forward<U>(u)...));
}
};
} // namespace detail
template<typename ...T> struct Odds;
template<typename T1, typename T2, typename ...T_>
struct Odds<T1, T2, T_...>
: detail::SkipHelper<detail::Node<detail::Tuple<T_...>, T1, T2>> {
};
template<typename T1>
struct Odds<T1> : detail::SkipHelper<detail::Node<detail::Tuple<>, T1>> {
};
// tuple_from_odds takes any number of arguments,
// and returns a tuple of the odd numbered ones.
template<typename...T> auto tuple_from_odds(T&&...t)
-> typename Odds<T...>::tuple_type {
return Odds<T...>()(std::forward<T>(t)...);
}
} // namespace skip_args