C++17, Template Parameter-Pack Subset?

[cppbert3 (Gast)]

Hallo C++17 Gurus,

ich versuche gerade aus einem Parameter-Pack mit Typen
eine minimale Tree-Struktur zu erzeugen (ist für einen hierarchischen 
Daten-Filter)

In jeder Ebene wird aus dem uebergebenem Parameter-Pack der 1. Typ raus 
genommen und der Rest and die darunter liegende Ebene geschoben

das mit dem 1. Typ raustrennen funktioniert aber
an der Beschneidung des Parameter-Packs scheitere ich - meine
skip_first erzeugt ein tuple - aber ich weiss nicht wie
ich den tuple als Parameter-Pack uebergeben kann

jemand einen Tip?

gcc-godbolt: https://gcc.godbolt.org/z/EP637d

#include <tuple>
#include <vector>
#include <type_traits>

template<typename... Types>
using get_first = typename std::tuple_element<0,std::tuple<Types...>>::type;

template <typename T>
struct skip_first{};

template <typename First, typename... Rest>
struct skip_first<std::tuple<First, Rest...>>
{
  using type = std::tuple<Rest...>;
};

template <typename Container, typename FirstType, typename... RestTypes>
struct Sub
{
    const Container m_c;
    Sub(const Container& c):m_c(c){}
    using first_type = FirstType;

    using sub_first_type = get_first<RestTypes...>;
    using sub = Sub<Container, sub_first_type, RestTypes.../*[1...]*/>;
    sub get_sub() { return Sub(m_c); }
};

template <typename Container, typename... Types>
struct Top
{
    using sub_first_type = get_first<Types...>;
    using sub = Sub<Container, sub_first_type, Types.../*[1...]*/>;
};

using container = std::vector<int>;
using top = Top<container, int, short, long>;

static_assert(std::is_same<top::sub::first_type, int>::value, "wrong");
// die Test gehen nicht weil ich immer das volle Parameter-Pack weiter reichen
#if 0
static_assert(std::is_same<top::sub, Sub<container, int, short, long>>::value, "wrong");

static_assert(std::is_same<top::sub::sub::first_type, short>::value, "wrong");
static_assert(std::is_same<top::sub::sub, Sub<container, short, long>>::value, "wrong");

static_assert(std::is_same<top::sub::sub::sub::first_type, long>::value, "wrong");
static_assert(std::is_same<top::sub::sub::sub, Sub<container, long>>::value, "wrong");
#endif

// sollte eher gar nicht gehen
using sinnfrei = top::sub::sub::sub::sub::sub::sub;

[Urlaubär (Gast)]

Siehe auch: 
https://old.reddit.com/r/cpp_questions/comments/knttmz/c17_how_to_skip_first_type_of_parameter_pack_and/

[cppbert3 (Gast)]

Urlaubär schrieb:
> Siehe auch:
> 
https://old.reddit.com/r/cpp_questions/comments/knttmz/c17_how_to_skip_first_type_of_parameter_pack_and/

Ich wollte Antwort die über reddit gekommen ist hier auch noch posten, 
du warst schneller :)

[Wilhelm M. (wimalopaan)]

Das std::tuple brauchst Du gar nicht.

Ein Typ-Container ist einfach

template<typename... I>
struct list{};

Darauf aufbauend kann man sich Meta-Funktionen definieren, wie size<> 
oder etwa auch front<>:

#include <type_traits>
#include <cstddef>

template<typename... I>
struct list{};

namespace detail {
    template<typename> struct size_impl;
    template<typename... II>
    struct size_impl<list<II...>> {
        using type = std::integral_constant<size_t, sizeof...(II)>;
    };

    template<typename> struct front_impl;

    template<typename F, typename... II>
    struct front_impl<list<F, II...>> {
        using type = F;
    };
}

template<typename List>
using size = typename detail::size_impl<List>::type;

template<typename List>
inline static constexpr auto size_v = size<List>::value;

template<typename List>
using front = typename detail::front_impl<List>::type;

Damit geht dann:

using l1 = list<int, double>;

using f1 = front<l1>;

static_assert(std::is_same_v<f1, int>);

[Wilhelm M. (wimalopaan)]

Man kann natürlich für die Meta-Programmierung auch Boost-Hana nehmen - 
je nach Geschmack. Seit constexpr-lambdas geht ja vieles einfacher.

[Wilhelm M. (wimalopaan)]

BTW: es gibt ja keine syntaktisch vorgegebene Form von Meta-Funktionen 
in C++, aber für Funktionen F: type -> type hat sich seit Jahren obige 
Form eingebürgert.

Metafunktionen F: value -> value erledigt man heute eher mit constexpr / 
consteval Funktionen / closures.

Metafunktionen F: type -> value oder F: value -> type eher wieder nach 
obigem Muster.