Discussion :

[victor_gasgas]

Bonjour,

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

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
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.

[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 :

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

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 :

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

typedef Typelist<char, int, NullType> l;

[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

[victor_gasgas]

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 :

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

typedef Typelist<Type1, NullType>

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

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
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 :

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
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.

[gb_68]

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>

(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 :

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
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 )

Code :

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

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

Code :

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

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

[victor_gasgas]

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