Come scambiare due parametri di un modello variadico al momento della compilazione?

Question

Sto cercando di scambiare due parametri di un modello variadic in fase di compilazione:

template<int...Numbers>struct sequence{}; 

template<size_t first,size_t second> 
struct Swap_Pair 
{ 
    const static size_t First = first; 
    const static size_t Second = second; 
}; 

template <int...Numbers,class swap_pair> 
struct Swap_Data 
{ 
    static std::array<int, sizeof...(Numbers)> data_;//How to swap Numbers base on the pair and store it in data_ ? 
}; 

Il caso d'uso dovrebbe essere:

sequence<1, 2, 3, 4, 5, 6> array; 
auto result = Swap_Data < array, Swap_Pair<2, 5> > ::data_; 
//result is now std::array which contains 1 2 6 4 5 3 

io non riesco a capire che cosa è il corretto modo di scrivere Swap_Data.

E come posso fare uno scambio ricorsivo per lo scambio di parametri variadici e la conversione in std :: array in fase di compilazione?

Answer 1

Il collegamento che ho postato sul commento è la mia implementazione di una metafunzione simile a std::bind() per metafunzioni.

Quello che ho fatto è trasformare i parametri di chiamata bind dal suo valore (un valore o un segnaposto) a un valore, o il valore rappresentato da quel segnaposto.

Nel tuo caso puoi provare un approccio simile: mappa la sequenza da segnaposto (i valori passati in scambio) ai valori corrispondenti della sequenza. Qualcosa di simile:

template<std::size_t I> 
struct placeholder{}; 

using _1 = placeholder<0>; 
... //More placeholder aliases 

template<typename SEQ , typename... PLACEHOLDERS> 
struct swap; 

template<std::size_t... Is , std::size_t... Ps> 
struct swap<sequence<Is...>,placeholder<Ps>...> 
{ 
    template<typename PLACEhOLDER> 
    struct transformation; 

    template<std::size_t I> 
    struct transformation<placeholder<I>> 
    { 
     static constexpr const std::size_t result = get<sequence<Is...>,I>::value; 
    }; 

    using result = map<transformation,sequence<Is...>>; 
}; 

Dove map è un metafunction simile a std::transform() (molto facile da scrivere), e get un metafunction che recupera l'elemento Ith di una sequenza (troppo facile).

Questo potrebbe essere utilizzato in questo modo:

using swapped = typename swap<sequence<1,2,3>,_3,_2,_1>::result; //swapped is sequence<3,2,1>