Hierarchie et variadic template

Version imprimable

Bonjour,

Grâce à votre aide j'ai pu avoir le code d'une typelist:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 template<class... Types> struct Typelist; template<> struct Typelist<>{}; template<class Head, class... Tail> struct Typelist<Head,Tail...> { typedef Head head_type; typedef Typelist<Tail...> tail_type; }; //Exemple typedef Typelist<char, int> l;
Maintenant j'aurais adapté la création de hiérarchie comme dans ce tuto de developpez.com

Mais avec les conditions d'arrêt je m'embrouille complétement n'ayant plus de NullType. Si vous pouvez me mettre sur la voie :)

Merci d'avance.

21/09/2010, 17h26
koala01
Salut,

Ce qu'il y a de bien avec les template, c'est que tu peux fournir autant de spécialisations partielles ou totales que tu peux le souhaiter.

Tu peux donc parfaitement rajouter une spécialisation proche de
Code:

1 2 3 4 5 6 template<class Head> struct Typelist<Head, NullType> { typedef Head head_type; typedef Typelist<> tail_type; };
et ton alias deviendrait alors

Code:

typedef Typelist<char, int, NullType> l;
21/09/2010, 17h52
victor_gasgas

Merci pour la réponse. Par contre le paramètre template NullType est-il possible de le mettre par défaut, c'est à dire qu'il soit transparent pour l'utilisateur? Surtout en utilisant les variadic template. Merci pour ton aide, sa s'éclaircie :)

Je re-poste pour montrer mon avancement :

Ma classe pour générée la hiérarchie ne fonctionne qu'avec une typelist de la forme suivante :

Code:

typedef Typelist<Type1, NullType>

Ci-dessous la classe pour généré :

Code:

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 TList, template <class> class Handler> class ScatteredHierarchy;
 
 
    template
    <
        class T1,
        class T2,
        template <class> class Handler
    >
 
    class ScatteredHierarchy<Typelist<T1, T2>, Handler> : public Handler<T1>, public ScatteredHierarchy<T2, Handler>
    {
 
    };
 
 
    template
    <
        class T,
        template <class> class Handler
    >
    class ScatteredHierarchy<Typelist<T, NullType>, Handler> : public Handler<T>
    {
 
    };
 
 
    template
    <
        template <class> class Handler
    >
    class ScatteredHierarchy<NullType, Handler>
    {
 
    };

Et enfin la classe de la type liste :

Code:

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
struct NullType {};
 
 
 
    template<class... Types>
    struct Typelist;
 
 
    template<>
    struct Typelist<>{};
 
 
    template<class Head>
    struct Typelist<Head, NullType>
    {
        typedef Head head_type;
 
        typedef Typelist<> tail_type;
    };
 
 
    template<class Head, class... Tail>
    struct Typelist<Head,Tail...>
    {
         typedef Head head_type;
 
         typedef Typelist<Tail...> tail_type;
 
    };

Si quelqu'un peut m'aider.

Le NullType t'est-il vraiment nécessaire pour la suite ?
Sinon tu peux t'en passer

le TypeList<T1, T2> correspond à : ma liste débute avec le type T1 et se poursuit avec T2 (qui correspond à la suite de la liste, sous forme de TypeList récursivement imbriqués)
avec les variadics cela devient TypeList<Head,Tail...> avec Head = T1, Tail... ~ T2 (ou plutôt TypeList<Tail...> ~ T2)

le TypeList<T, NullType> correspond à : ma liste ne contient que le type T (NullType étant un artifice de programmation pour marquer la fin de la récursivité)
avec les variadics cela devient TypeList<T> avec NullType = <rien> :P

(j'ai pas de compilateur c++x0 directement sous la main, je ne peux vérifier ce code, mais l'idée y est)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 template <class TList, template <class> class Handler> class CScatteredHierarchy; template < class Head , class... Tail , template <class> class Handler > class CScatteredHierarchy<TypeList<Head, Tail...>, Handler> : public Handler<Head>, public CScatteredHierarchy<TypeList<Tail...>, Handler> { }; template < class T , template <class> class Handler > class CScatteredHierarchy<TypeList<T>, Handler> : public Handler<T> { };
Si l'opérateur "unpack" est permis dans la partie déclaration des ancêtres (à vérifier, GCC m'a déjà fait des surprises :aie:)
Code:

1 2 3 4 5 6 7 8 9 10 template <class TList, template <class> class Handler> class CScatteredHierarchy; template < class... T , template <class> class Handler > class CScatteredHierarchy<TypeList<T...>, Handler> : public Handler<T>... { };
Voir même sans TypeList :mrgreen:
Code:

1 2 3 4 5 6 7 8 template < class... T , template <class> class Handler > class CScatteredHierarchy : public Handler<T>... { };

22/09/2010, 17h24
victor_gasgas

Merci pour vos réponses j'ai pu adapter mon code, et il est fonctionnel maintenant :D