varadic template template parameter

[giuseppe500]

ciao ho una classe template template parameter cosi

template <typename E, template <typename, typename> class T, typename X, typename V>
class Bar<E,T<X,V> > {

e vorrei sapere se � possibile creare un varadic template che accetti n coppie di valori par par � cosi:

template<class T, class U>
class par {
public:
    par::par() {}
};

ma potrei usare anche una tuple, se � piu comodo e inserisco la coppia cosi:

Bar<cars, par<int, double> > ipp;

ma vorrei poter inserire n par cosi:

Bar<cars, par<int, double>, par<int, int> ,par<int, string>....ecc..> ipp;

mi interessa conoscere all interno del template tutti i tipi delle coppie se faccio l'espansione ma non so veramente come fare giuro che ho cercato su google ma non ho trovato tutto e ho visto che � vacile ad es espandere un pak di tuple mi consigliate di passare alle tuple?
ma nelle tuple come ottengo il tipo ad un indice, � possibile?
so che col get<index>(tuple) ottengo il valore volevo sapere se c'era una funzione che ritorna il tipo.
grazie.

[shodan]

Esiste l'operatore decltype che restituisce il tipo della variable passata come argomento, tuttavia la discriminazione la devi fare con typeid o con i type_traits a seconda di cosa ti torna comodo.

        auto t = make_tuple(10,"ciao"s);
        cout << typeid(decltype(get<0>(t))).name() << endl;
        cout << is_integral<std::remove_reference_t<decltype(get<0>(t))>>::value << endl;

Ti rimando alla relativa documentazione dei type_traits su cppreference per i dettagli.
Inoltre esiste anche tuple_element, ma li occorre eplicitare i tipi nella tupla.

[giuseppe500]

Esiste l'operatore decltype che restituisce il tipo della variable passata come argomento, tuttavia la discriminazione la devi fare con typeid o con i type_traits a seconda di cosa ti torna comodo.

        auto t = make_tuple(10,"ciao"s);
        cout << typeid(decltype(get<0>(t))).name() << endl;
        cout << is_integral<std::remove_reference_t<decltype(get<0>(t))>>::value << endl;

Ti rimando alla relativa documentazione dei type_traits su cppreference per i dettagli.
Inoltre esiste anche tuple_element, ma li occorre eplicitare i tipi nella tupla.

Ho visto.
Per quanto riguarda il varadic template mi hai lasciato intuire che vanno benissimo le tuple no?
Inoltre vorrei e non so se si puo passare le tuple con un tipo iniziale int in modo da settarle in una tuple contenitore con l int usato come indice ho visto su google che le tuple possono essere ordinate in base al contenuto con la funzione tile ma si puo espandere tutte le tutle di input e poi ordinarle?
Grazie

[giuseppe500]

Il problema che ho visto adesso � che le mie tuple hanno tutte un int iniziale ma poi hanno qualsiasi tipo come secondo tipo si puo ordinare una tuple contenitore di tuple non omogenee? Come? Grazia

[shodan]

A meno di esigenze particolari le tuple vanno bene. Tuttavia per poter ordinarle devono essere di tipo omogeneo, ossia non puoi confrontare std::tuple<int,string> con std::tuple<int, double>.
Sarebbe come cercare di confrontare mele e pere. Al massimo puoi confrontare lo std::get<0> delle due tuple, ma poi come scambi o assegni la tupla che risponde al criterio?

[giuseppe500]

Scusa shodan se rompo ma la mia idea � di creare una funzione template a cui passo un elemento di un enum , come se fosse un int e restituire la tuple che ha quell int dalla tuple contenitrice delle tuple espanse.
La serie di tuple che passo avranno un int( tratto dall enum) e il valore e tipo che mi interessa forse posso enumerare la tuple contenitrice prendere il value 0 ( l int) e ritornare il valore che combacia.
Posso farlo?
Mi piace poco dover definire con uno 0 o un 1 il get del valore vorrei usare gli elementi di un enum piu chiaro penso sia nell inserimento sia nell estrazione.
Scusa nel qual caso fosse una fesseria ma se non ci si scontra non si impara e spesso i casi reali hanno delle soluzioni imprevedibili rispetto al semplice studio.
Intanto grazie 1000 e ciao.

[shodan]

Credo che il massimo che si possa ottenere sia questo:

struct type_a {};
struct type_b {};
struct type_c {};
struct type_d {};
struct type_e {};


auto number (type_a x) {
    return make_tuple(10, "ss"s);
}

auto number( type_b x) {
    return make_tuple("dd"s, 10);
}

template <class T>
auto wrapper (T a) -> decltype(number(a)) {
    return number(a);
}

int main(int argc, char* argv[]) {

        auto t1 = wrapper(type_a{});
        auto t2 = wrapper(type_b{});

}

dove number è in overload. Ovviamente i tipi di t1 e t2 sono incompatibili tra loro. Se è questo quello che ti serve puoi sfruttare questo esempio, altrimenti quello che vorresti fare con la enum è impossibile.

[giuseppe500]

Credo che il massimo che si possa ottenere sia questo:

struct type_a {};
struct type_b {};
struct type_c {};
struct type_d {};
struct type_e {};


auto number (type_a x) {
    return make_tuple(10, "ss"s);
}

auto number( type_b x) {
    return make_tuple("dd"s, 10);
}

template <class T>
auto wrapper (T a) -> decltype(number(a)) {
    return number(a);
}

int main(int argc, char* argv[]) {

        auto t1 = wrapper(type_a{});
        auto t2 = wrapper(type_b{});

}

dove number � in overload. Ovviamente i tipi di t1 e t2 sono incompatibili tra loro. Se � questo quello che ti serve puoi sfruttare questo esempio, altrimenti quello che vorresti fare con la enum � impossibile.

grazieshodan

[giuseppe500]

grazie shodan