How to unpack tuple of unknown length? - c++

Question

There are three potential directions I can see.
std::tie()
Structured bindings, i.e. auto (var1, var2, var3...) = t;
std::get<?>(t)
I have tuple size from this:
int tupleSize = tuple_size<decltype(t)>::value;
How can I use tupleSize to unpack the tuple?
In case it's not clear, I want to be able to copy and paste a tuple of any size in and be able to compile and run the code without changing anything else.

Answer 1

Comments under question
I'd like to do arithmetic on the numeric values, and concatenation on the strings and char*'s. –
Alex
...
The tuple contains various types, so I won't be able to add every element. I have a tuple of strings, ints, doubles, char*s, etc. I need to be able to add numeric values and concatenate string values depending on the type. –
Alex
I understand this this way:
template<typename T1, typename T2>
auto add_items(const T1& a, const T2& b)
{
return a + b;
}
auto add_items(const char* a, const char* b)
{
return std::string{a} + b;
}
template<typename ...Ts, size_t ...indexes>
auto add_tuples_hepler(const std::tuple<Ts...>& a, const std::tuple<Ts...>& b, std::index_sequence<indexes...>)
{
return std::make_tuple(add_items(std::get<indexes>(a), std::get<indexes>(b))...);
}
template<typename ...Ts>
auto add_tuples(const std::tuple<Ts...>& a, const std::tuple<Ts...>& b)
{
return add_tuples_hepler(a, b, std::make_index_sequence<sizeof...(Ts)>{});
}
https://godbolt.org/z/a1bdbKKhh
Still I'm not convinced since lots of details are missing in question and comments.

Answer 2

You can accomplish this indirectly by filtering for different type categories.
template <template <typename> typename Cond, typename... Ts> //
constexpr static auto extractTup(std::tuple<Ts...> const& tup) {
if constexpr (sizeof...(Ts) == 0) {
return tup;
} else {
auto const head = [](auto const& x0, auto const&...) {
return std::tuple{x0};
};
auto const tail = [](auto const&, auto const&... xs) {
return std::tuple{xs...};
};
using T0 = std::tuple_element<0, std::tuple<Ts...>>::type;
if constexpr (Cond<T0>::value) {
return std::tuple_cat(std::apply(head, tup),
extractTup<Cond>(std::apply(tail, tup)));
} else {
return extractTup<Cond>(std::apply(tail, tup));
}
}
}
Examples
For example you can extract all values that are integral and then add them up in an extra std::apply call:
std::tuple<int, std::string, float, unsigned, char const*> test = {
-1, std::string{"hello"}, 3.14, 42, " world"
};
auto const inttp = extractTup<std::is_integral>(test);
auto const intsum = std::apply([](auto const&... i) { return (i + ...); }, inttp);
// intsum == 41
Similarly you can extract all strings and concatenate them:
template <typename T> struct is_stringy : std::false_type {};
template <> struct is_stringy<std::string> : std::true_type {};
template <> struct is_stringy<char const*> : std::true_type {};
template <> struct is_stringy<char*> : std::true_type {};
template <std::size_t N> struct is_stringy<char const[N]> : std::true_type {};
template <std::size_t N> struct is_stringy<char[N]> : std::true_type {};
.
auto const strtp = extractTup<is_stringy>(test);
// -> {std::string{"hello"}, " world"}
live demo