C++ 变换 std::pair <std::pair<std::pair<a, b> , C&gt;, D&gt; 到 std::tuple <a, b, c, d></a,></std::pair<std::pair<a,>

Question

I have such kind of code:

const auto temp = std::make_pair(std::make_pair(std::make_pair('Q', 1.2),
    std::string("POWER")), 1);
std::cout << std::format("({}, {}, {}, {})\n", temp.first.first.first, 
    temp.first.first.second, temp.first.second, temp.second);

that obviously prints:

(Q, 1.2, POWER, 1)

I want to make it more readable and intuitive by converting "pair of pair and smth" to std::tuple :

const auto temp = std::make_pair(std::make_pair(std::make_pair('Q', 1.2),
    std::string("POWER")), 1);
const auto tuple = PairsToTuple(temp);

std::cout << std::format("({}, {}, {}, {})\n", std::get<0>(tuple),
    std::get<1>(tuple), std::get<2>(tuple), std::get<3>(tuple));

How can I do that?

Answer 1

You can recursively std::tuple_cat

template<typename First, typename Second>
auto flatten(std::pair<First, Second> pair) {
    return std::tuple_cat(flatten(pair.first), flatten(pair.second));
}

template<typename... Types>
auto flatten(std::tuple<Types...> tup) {
    return std::apply([](auto... args) { return std::tuple_cat(flatten(args)...);}, tup);
}

template<typename T>
auto flatten(T t) {
    return std::tuple{ t };
}

See it on coliru

If you have C++20, we can generalise this to anything tuple-like with a concept :

template<typename T>
auto flatten(T&& t) {
    if constexpr (tuple<std::remove_cvref_t<T>>) {
        return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
            return std::tuple_cat(flatten(get<Is>(std::forward<T>(t)))...);
        }(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<T>>>{});
    } else {
        return std::tuple{ std::forward<T>(t) };
    }
}

See it on coliru