Ошибка замены std :: tuple_cat
я использую std::tuple_cat сделать подмножество выбора списков аргументов в кортежи, например так:
template <class...>
struct odds;
template <class T1>
struct odds<T1>
{
typedef std::tuple<T1> type;
static type value(T1&& t1)
{
return std::make_tuple(std::forward<T1>(t1));
}
};
template <class T1, class T2>
struct odds<T1, T2>
{
typedef std::tuple<T1> type;
static type value(T1&& t1, T2&&)
{
return std::make_tuple(std::forward<T1>(t1));
}
};
template <class T1, class T2, class... TTail>
struct odds<T1, T2, TTail...>
{
typedef decltype(std::tuple_cat(T1(), typename odds<TTail...>::type())) type; // L32
static type value(T1&& t1, T2&&, TTail&&... rest)
{
return std::tuple_cat(std::forward<T1>(t1), odds<TTail...>::value(std::forward<TTail>(rest)...)); // L35
}
};
, со следующим в качестве контрольного примера:
// assume <tuple>, <utility> are included at top of file
template <class... T>
auto foo(T... x) -> typename odds<T...>::type
{
return odds<T...>::value(x...);
//...
}
int main() {
auto bar = foo(5, true, 6, false); // L46
auto baz = odds<int, bool, int, bool>::value(5, true, 6, false); // L47
// bar, baz should be tuple<int,int> with value { 5, 6 }
}
Однако проблемы вывода шаблонов возникают как в clang-3.1, так и в gcc-4.7.2:
Clang выход:
test.cc:32:19: error: no matching function for call to 'tuple_cat'
typedef decltype(std::tuple_cat(T1(), typename odds<TTail...>::type())) type;
^~~~~~~~~~~~~~
test.cc:40:30: note: in instantiation of template class 'odds<int, bool, int, bool>' requested here
auto foo(T... x) -> typename odds<T...>::type
^
test.cc:40:6: note: while substituting deduced template arguments into function template 'foo' [with T = <int, bool, int, bool>]
auto foo(T... x) -> typename odds<T...>::type
^
/usr/include/c++/v1/tuple:1063:1: note: candidate template ignored: substitution failure [with _Tuple0 = int, _Tuples = <std::__1::tuple<int>>]
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
^
/usr/include/c++/v1/tuple:987:1: note: candidate function not viable: requires 0 arguments, but 2 were provided
tuple_cat()
^
test.cc:46:13: error: no matching function for call to 'foo'
auto bar = foo(5, true, 6, false);
^~~
test.cc:40:6: note: candidate template ignored: substitution failure [with T = <int, bool, int, bool>]
auto foo(T... x) -> typename odds<T...>::type
^
test.cc:35:10: error: no matching function for call to 'tuple_cat'
return std::tuple_cat(std::forward<T1>(t1), odds<TTail...>::value(std::forward<TTail>(rest)...));
^~~~~~~~~~~~~~
test.cc:47:41: note: in instantiation of member function 'odds<int, bool, int, bool>::value' requested here
auto baz = odds<int, bool, int, bool>::value(5,true,6,false);
^
/usr/include/c++/v1/tuple:1063:1: note: candidate template ignored: substitution failure [with _Tuple0 = int, _Tuples = <std::__1::tuple<int>>]
tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
^
/usr/include/c++/v1/tuple:987:1: note: candidate function not viable: requires 0 arguments, but 2 were provided
tuple_cat()
^
3 errors generated.
Выход Gcc:
test.cc: In instantiation of ‘struct odds<int, bool, int, bool>’:
test.cc:40:6: required by substitution of ‘template<class ... T> typename odds<T ...>::type foo(T ...) [with T = {int, bool, int, bool}]’
test.cc:46:34: required from here
test.cc:32:74: error: no matching function for call to ‘tuple_cat(int, odds<int, bool>::type)’
test.cc:32:74: note: candidate is:
In file included from test.cc:1:0:
/usr/lib/gcc/x86_64-pc-linux-gnu/4.7.2/include/g++-v4/tuple:1027:5: note: template<class ... _Tpls, class> constexpr typename std::__tuple_cat_result<_Tpls ...>::__type std::tuple_cat(_Tpls&& ...)
/usr/lib/gcc/x86_64-pc-linux-gnu/4.7.2/include/g++-v4/tuple:1027:5: note: template argument deduction/substitution failed:
/usr/lib/gcc/x86_64-pc-linux-gnu/4.7.2/include/g++-v4/tuple:1024:31: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’
test.cc: In function ‘int main()’:
test.cc:46:34: error: no matching function for call to ‘foo(int, bool, int, bool)’
test.cc:46:34: note: candidate is:
test.cc:40:6: note: template<class ... T> typename odds<T ...>::type foo(T ...)
test.cc:40:6: note: substitution of deduced template arguments resulted in errors seen above
test.cc:46:34: error: unable to deduce ‘auto’ from ‘<expression error>’
test.cc:47:13: error: ‘value’ is not a member of ‘odds<int, bool, int, bool>’
test.cc:47:61: error: unable to deduce ‘auto’ from ‘<expression error>’
Gcc немного более полезен, особенно с ошибкой
test.cc:32:74: error: no matching function for call to ‘tuple_cat(int, odds<int, bool>::type)’
Цель состоит в том, чтобы вызвать функцию, которая рекурсивно распаковывает аргументы, собирает выборки в кортеж сбора и возвращает его. Чтобы накопить это плоским способом, я использую std::tuple_cat() чтобы сплющить рекурсивный кортеж хвоста, добавьте голову и верните кортеж. Переадресация используется для того, чтобы не отбрасывать ссылочные квалификаторы во время рекурсии.
Позже в коде результирующий кортеж распаковывается для вызова другой функции с переменным числом, но это выходит за рамки этой ошибки.
Ясно, что где-то я пропустил некоторые тонкие, но важные детали, но я обнаружил значительные трудности в поиске основной проблемы.
Решение
Аргументы tuple_cat должны быть кортежами (или «подобными кортежу» вещами, которые поддерживают std::tuple_size а также std::tuple_element API, такой как 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, ...>
Это не «конкатенация». Я думаю, что правильный термин для этого — «выравнивание».
Я не совсем уверен, что вы пытаетесь, потому что вы не предоставили полный пример. Ты звонишь foo с аргументом вроде std::tuple<T1, std::tuple<T2, std::tuple<T3, ...>>>?
Это не сработает, потому что foo выведет T как std::tuple<T1, std::tuple<T2, std::tuple<T3, ...>>> и создать экземпляр odds<T1> специализация, которая просто оборачивает аргумент foo внутри другой кортеж!
Другие решения
Я не знаю, если это вам интересно, так как это альтернативная реализация, а не ответ на ваш вопрос. Я думаю, используя tuple_cat как будто это в конечном итоге будет делать много ходов / копий во время выполнения, хотя, возможно, компилятор может избежать этого для тривиальных типов. Во всяком случае, это казалось интересной проблемой TMP.
Это то, что я придумал (что, возможно, слишком многословно); он может определенно использовать некоторую очистку (и версия clang, которую я имею — транк несколько недель назад — утверждает при попытке ее компилировать).
Интересный рекурсивный бит находится в Skipгде он использует предыдущий кортеж в качестве шаблона (действительно, количество) для построения следующего; вы можете увидеть, как, в конце концов, 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