Discussion :

[Invité]

Bonjour, j'essaye d'implémenter un tuple dynamique mais je rencontre un problème, en fait, je n'arrive pas à affecter le bon type pour l'élément du tuple dynamique :

Comme pour les tuples statique je crée une structure Element mais à part que là je n'ai pas de queue étant donné que je ne connais pas le nombre d'éléments à l'avance du tuple, je ne peux pas créer les élément avec un template variadique car ce sont des tuples à un élément, l'index 0 pointe vers le tuple lui même (tuple vide), l'index 1 point vers le 1er élément du tuple, etc..., tout comme std::tuple à part que là comme la taille est variable je défini l'index pour chaque élément du tuple et la taille à la compilation, comme ceci :

Bref voici ma structure Element :

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
 
/**Define an index to a type of an element.*/
template <std::size_t I, class... T> class Element;
/**Define the index to the first tuple instance
*The type of the tuple and the type of the first element of the tuple are stored.
*/
template<typename H, std::size_t>
class DynamicTuple;
template <class H> class Element <0, DynamicTuple<H, 0>> {
    public :
    typedef H& Type;
    typedef DynamicTuple<H, 0> VType;
};
 
template <std::size_t I, class H>
class Element<I, DynamicTuple<H, I>>
  : public Element<I - 1, DynamicTuple<H, I-1> >
{
};

Et voici ma structure dynamic tuple :

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
 
template <class T, size_t i=0>
struct DynamicTuple {
public :
    template <typename A>
    static void add_element(A element) {
        typedef typename Element<size+1, DynamicTuple<T, size+1>>::Type A;
    }
    static constexpr int getSize() {
        return size;
    }
private :
    static constexpr int size = i;
};

Le template est juste un type qui sert à identifier le tuple dynamique. (En général c'est la classe qui contient le tuple dynamique)

Le problème est que je lorsque je veux récupérer le type d'un élément, il me renvoie toujours le type de la classe contenant le tuple dynamique et je ne comprend pas pourquoi :

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
 
template <typename L, int I=0, bool B=true>
struct get_type {
};
template <typename L, int I>
struct get_type <L, I, true> {
    static typename Element<I, L>::Type element (L list, int n) {
        if (n == 0)
            return Element<I, L>::Type;
        constexpr bool isGreater = ((int) (I+1) > DynamicTuple<L, I+1>::getSize());
        return get_type<L, I+1, isGreater>::get_type(list, n);
    }
};
template <typename L, int I>
struct get_type <L, I, false> {
    static typename Element<I, L>::type element (L list, int n) {
        //assert(false);
    }
};

Voilà alors j'aimerais savoir comment lui spécifier que Element<1, DynamicTuple<MaClasse>>::Type est de type A et non pas de type MaClasse.
Et aussi si possible comment instancier cet élément.
Quand j'essaye, j'ai une erreur en compilation. (Vu que type est pas le bon)

[Invité]

J'ai essayé ça :

Code cpp :

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

1
2
3
4
5
6
 
template <typename A>
    static void add_element(A type) {
        typedef typename Element<size+1, DynamicTuple<T, size+1>>::Type Type;
        Type newType = (Type) type;
    }

Mais ça ne marche pas mieux. :/

[Invité]

Bon je pense que j'ai compris, en fait il faut que je trouve un moyen de référencer l'élément suivant à partir de l'élément actuel un peut comme le principe des listes chaîné et que je parcours chaque élément.

Mais je ne vois pas du tout comment faire ça avec des classes templates.

Donc si quelqu'un à une solution je suis preneur.

[Invité]

Bonsoir.

Je suis finalement parvenu à trouvé une solution mais j'ai un dernier problème :

C'est un problème d'ambiguité, en fait j'ai deux spécialisation pour la classe DynamicTuple comme 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
32
33
34
35
 
template <class H>
struct DynamicTuple <H, 0> {
public :
    DynamicTuple() {
        typedef typename Element<size, DynamicTuple<H, size>>::Type Type1;
        typedef typename Element<size, DynamicTuple<H, size>>::VType Type2;
        Type2 newtype2 = *this;
    }
 
    template <typename A>
    static void add_element(A* element) {
        DynamicTuple<A,size+1> *dt = new DynamicTuple<A, size+1>();
        typedef typename Element<size+1, DynamicTuple<A, size+1>>::Type Type1;
        typedef typename Element<size+1, DynamicTuple<A, size+1>>::VType Type2;
        Type1 newtype1 = *element;
        Type2 newtype2 = *dt;
    }
    static constexpr size_t getSize() {
        return size;
    }
private :
    static constexpr size_t size = 0;
};
template <class H, size_t I>
struct DynamicTuple<DynamicTuple<H, I>, I> : public DynamicTuple<H, I-1> {
    template <class = typename std::enable_if<(I > 0)>::type>
    DynamicTuple() {
    }
    template <class = typename std::enable_if<(I > 0)>::type>
    static constexpr size_t getSize() {
        return size;
    }
    static constexpr size_t size = I;
};

Et j'ai un typedef sur un DynamicTuple dans une autre structure, le problème survient quand je veux utiliser la fonction statique getSize() sur le typedef, il me renvoie une erreur d'ambiguité :

Code cpp :

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

1
2
3
4
 
typedef typename Element<I+1, DynamicTuple<L, I+1>>::VType NextType;
        constexpr bool isGreater = ((int) (I+1) > NextType::getSize());
        return typelist<NextType, T, I+1, isGreater>::exists(list, type);

Comment résoudre se problème ?
J'ai entendu parlé de SFINAE mais je ne vois pas trop bien comment l'utiliser ici.

[jo_link_noir]

Un code reproductible et l'erreur serai un plus

Par contre, je ne vois pas l’intérêt du constructeur.

[Invité]

Salut,

J'ai résolu le problème d'ambiguité en rajoutant un 4ème paramètre template mais j'ai du arrêté car plantage du compilateur...

Bref pour réussir à faire ce que je veux faire il faudrait arriver à passer à une classe (par exemple la classe template I+1), le type de l'élément de la classe I et arriver à le récupérer sans que la classe I+1 aie un paramètre template de du type de l'élement I.

Bref je pense pas que ça soit possible.