Exclure les n premiers arguments du pack de paramètres

Question

J'ai une fonction foo qui appelle une fonction bar avec un sous-ensemble de types transmis au modèle variadique foo. Par exemple:

template <typename... T> 
void foo() { 
    // ... 
    template <size_t start_idx, typename... T> 
    using param_pack = /*Parameter pack with T[start_idx]...T[N]*/ 
    auto b = bar<param_pack<2, T...>>(); 
    // ... 
} 

Existe-t-il un moyen d'extraire un "pack de sous-paramètres". Dans le cas ci-dessus si T = [int float char double] puis param_pack<2, T...> = [char double]

[EDIT]

Mon objectif est d'être en mesure d'utiliser quelque chose comme ça pour correspondre à des gestionnaires d'événements. Par exemple

struct ev {}; 

template <typename... T> 
struct event : ev { 
    std::tuple<T...> data_; 

    event(T&&... d) : data_(std::make_tuple(std::forward<T>(d)...)) {} 
}; 

template <typename... Functor> 
struct handler { 
    std::tuple<Functor...> funcs_; 

    handler(Functor&&... f) : funcs_(std::make_tuple(std::forward<Functor>(f)...)) {} 

    void handle_message(ev* e) { 
    auto ptrs = std::make_tuple(
     dynamic_cast<event<param_pack<1, typename function_traits<F>::args>>*>(e)... 
    ); 

    match(ptrs); 
    } 
}; 

Ici function_traits::args obtenir un pack de paramètres pour les arguments de la fonction et itère match sur le tuple funcs_ vérifier si le dynamic_cast a réussi et l'exécution de la première fonction avec succès. Je les ai déjà implémentés.

Les gestionnaires sont quelque chose comme

[] (handler* self, <ARGS>) -> void { 
    // ... 
} 

Je suis essentiellement en train de se débarrasser de l'argument self.

Answer 1

Mettez de côté le fait qu'il n'a pas de contrôle sur l'indice N pour la simplicité, voici une solution basée sur une déclaration de fonction (pas de définition nécessaire) et un en utilisant la déclaration:

template<std::size_t N, typename... T, std::size_t... I> 
std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...> 
sub(std::index_sequence<I...>); 

template<std::size_t N, typename... T> 
using subpack = decltype(sub<N, T...>(std::make_index_sequence<sizeof...(T) - N>{})); 

La bonne partie de cette approche est que vous avez de ne pas introduire un nouveau type conçu autour d'un tuple, se spécialisent alors il itérativement en quelque sorte.

---

Il suit un minimum, par exemple de travail qui utilise le code ci-dessus:

#include<functional> 
#include<tuple> 
#include<cstddef> 
#include<type_traits> 

template<std::size_t N, typename... T, std::size_t... I> 
std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...> 
sub(std::index_sequence<I...>); 

template<std::size_t N, typename... T> 
using subpack = decltype(sub<N, T...>(std::make_index_sequence<sizeof...(T) - N>{})); 

int main() { 
    static_assert(std::is_same<subpack<2, int, float, char, double>, std::tuple<char, double>>::value, "!"); 
} 

Voir un exemple complet et en cours d'exécution sur wandbox.

---

La version étendue qui comprend un contrôle sur l'indice N ressemblerait à ceci:

template<std::size_t N, typename... T, std::size_t... I> 
std::enable_if_t<(N < sizeof...(T)), std::tuple<std::tuple_element_t<N+I, std::tuple<T...>>...>> 
sub(std::index_sequence<I...>); 

C'est le type que vous pouvez voir dans le premier exemple une fois enveloppé dans une std::enable_if_t, rien de plus. Encore une fois, la déclaration est suffisante, aucune définition requise.

---

EDIT

Si vous voulez utiliser votre propre modèle de classe au lieu d'un std::tuple, vous pouvez facilement modifier le code pour le faire:

#include<functional> 
#include<tuple> 
#include<cstddef> 
#include<type_traits> 

template<typename...> 
struct bar {}; 

template<template<typename...> class C, std::size_t N, typename... T, std::size_t... I> 
std::enable_if_t<(N < sizeof...(T)), C<std::tuple_element_t<N+I, std::tuple<T...>>...>> 
sub(std::index_sequence<I...>); 

template<template<typename...> class C, std::size_t N, typename... T> 
using subpack = decltype(sub<C, N, T...>(std::make_index_sequence<sizeof...(T) - N>{})); 

int main() { 
    static_assert(std::is_same<subpack<bar, 2, int, float, char, double>, bar<char, double>>::value, "!"); 
} 

---

EDIT

Selon le code ajouté à la question, la solution ci-dessus est toujours valable. Vous devez simplement définir votre classe event comme suit:

struct ev {}; 

template <typename> 
struct event; 

template <typename... T> 
struct event<std::tuple<T...>>: ev { 
    // ... 
}; 

De cette façon, quand vous faites ceci:

event<param_pack<1, typename function_traits<F>::args>> 

Vous obtenez toujours un tuple de param_pack (qui est le subpack en utilisant la déclaration dans mon exemple), mais il correspond à la spécialisation partielle du modèle event et le pack de paramètres est à votre disposition en tant que T....

C'est le meilleur que vous pouvez faire, car vous ne pouvez pas mettre un paquet de paramètres dans une déclaration d'utilisation. Quoi qu'il en soit, cela fonctionne, donc probablement, il peut résoudre votre problème.

Answer 2

Vous pouvez faire quelque chose comme:

template <std::size_t N, typename ... Ts> struct drop; 

template <typename ... Ts> 
struct drop<0, Ts...> 
{ 
    using type = std::tuple<Ts...>; 
}; 

template <std::size_t N, typename T, typename ... Ts> 
struct drop<N, T, Ts...> 
{ 
    using type = typename drop<N - 1, Ts...>; 
}; 

// Specialization to avoid the ambiguity 
template <typename T, typename... Ts> 
struct drop<0, T, Ts...> 
{ 
    using type = std::tuple<T, Ts...>; 
}; 

Answer 3

Voici une solution rapide mais pas particulièrement réutilisable.

template <typename Pack, std::size_t N, std::size_t... Is> 
void invoke_bar_impl(std::index_sequence<Is...>) { 
    bar<std::tuple_element_t<N + Is, Pack>...>(); 
} 

template <std::size_t N, typename... Ts> 
void invoke_bar() { 
    auto indices = std::make_index_sequence<sizeof...(Ts) - N>(); 
    invoke_bar_impl<std::tuple<Ts...>, N>(indices); 
}