Discussion :

[Invité]

Salut, en fait j'essaye de récupérer un élément d'un tuple via une variable de type int. (et non pas une constexpr)

Cependant je ne trouve pas comment faire :
J'ai essayé ceci :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
template <typename T, int i, bool>
    struct S {
             static typename std::tuple_element<i, decltype(T::typelist)>::type actualType = std::tuple_element<i, decltype(T::typelist)>();
    };
    template<>
    template<typename T, int i>
    struct S<T, i, false>
    {
        static void get(int n, T& result)
        {
            //assert(false);
        }
    };
    template <typename T, int i>
    struct S<T, i, true> {
        static void get(int n, T& result) {
            switch(n) {
                case 0 : {
                    actualType = std::get<i>(T::typelist);
                    break;
                }
                    default : {
                    constexpr bool isGreater = (std::tuple_size<decltype(T::typelist)>::value > i + 1);
                    return S<T, i+1, isGreater>::get(n-1, result);
                    break;
                }
            }
        }
        static typename std::tuple_element<i, decltype(T::typelist)>::type actualType;
    };

Le problème c'est que si la variable statique n'est pas initialisée le compilateur râle, alors je ne sais pas comment je pourrais initializer cette variable statique et si y'a pas moyen je ne vois pas comment récupérer l'élément dans le tuple. :/
J'ai cherché partout sur internet mais je n'ai rien trouvé, quelqu'un a t'il une solution ?

Merci.

[Invité]

Haaaaaa voilà je pense que j'ai trouvé ce que je cherchais!

http://en.cppreference.com/w/cpp/uti.../tuple_element

[ternel]

toujours pas, regarde bien, l'index est encore un parametre template, donc une constexpr.

Mais tu peux t'en sortir avec un switch, si ton nombre d'élément est connu.

Suppose que tu travaille avec un using my_tuple = tuple<int, int, double, int, double>.
Dans ce cadre, tu peux créer les deux fonctions suivantes.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
int get_int(my_tuple const& t, int i) {
    switch(i) {
        case 0: return get<0>(t);
        case 1: return get<1>(t);
        case 3: return get<3>(t);
        default: throw ...;
    }
}
 
double get_double(my_tuple const& t, int i) {
    switch(i) {
        case 2: return get<2>(t);
        case 4: return get<4>(t);
        default: throw ...;
    }
}

Qu'en penses-tu?

[Invité]

Mon nombre d'éléments n'est pas connu. :/

Bref j'ai laissé tombé std::tuple qui ne répond pas à mes besoins.

Et ici j'essaye de créer un tuple plus dynamique on va dire.

Mais j'ai un autre problème, je ne sais pas comment passer un template à une classe template qui hérite d'une autre classe template :

J'ai essayé ceci mais ça ne compile pas. :/

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
template <size_t I, typename L, typename T>
struct Element {
    T type;
};
 
 
template <size_t I, typename L, template <std::size_t I, typename L, typename T> class E>
struct TypelistElement : public Element<I, L,class = allocator<T>> {
 
};

Le truc c'est que je voudrais accéder au type de l'élément de la typelist sans connaître T. (Car je connais T au départ quand je l'ajoute mais plus après quand je le récupère.

C'est ça le problème. :/

[Ehonn]

Et ici j'essaye de créer un tuple plus dynamique on va dire.

Comme std::vector<boost::any> ? C'est du type erasure que tu veux ?

[Invité]

Non, c'est plus compliqué que ça parce que avec boost::any tu es obligé de faire un cast pour le récupérer le type de la variable.

Ce que je voudrais faire c'est un truc comme ceci :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
Any any(3);
auto T = any.get();