Implémentation boost :: tuple ?

Bonjour,

Après l'utilisation de la syntaxe suivante pour déclarer un boost :: tuple :

Code:

---

boost :: tuple< type1 , type2 , ... , typeN > t1 ( v1 , v2 , ... , vN );

---

Je me demande maintenant comment est ce qu'une classe à nombre de paramètres template variables est implémenté (actuellement) sachant qu'une liste variable de paramètre template ne sera intégrer qu'à partir de la norme C++1X pour la déclaration des classes?

Faut il utiliser le préprocesseur massivement (ça me semble être possible mais honnêtement je ne vois pas comment est ce que ça peut être codé)?

Ou encore faut il écrire un préprocesseur maison type moc du framework Qt ?

Avez vous des exemples succints ou des pistes de recherche pour l'implémentation d'une telle classe?

Merci d'avance.

[EDIT] je ne suis pas atteint du NIH, je suis juste curieux:D.

Salut,
Première réponse : ouvre tuple.hpp et regarde :lol:

Je ne connais pas les arcanes de boost, mais j'ai cru voir différents éléments selon les composants :
=> utilisation massive de Boost.Preprocessor ,
=> utilisation d'un type 'void/null' :

Code:

---

1 2 3 4 5 6

template < class T0 = null_type, class T1 = null_type, class T2 = null_type, class T3 = null_type, class T4 = null_type, class T5 = null_type, class T6 = null_type, class T7 = null_type, class T8 = null_type, class T9 = null_type> class tuple;

---

Je n'ai pas regardé en détail mais j'imagine qu'après ce sont des petits jeux amusants à coup de type list qu'on parcours et triture dans tous les sens

Pour faire une structure template variadique en C++03, c'est très simple.

Tu fais une première déclaration avec N paramètres templates, tous ayant des valeurs par défaut.

Puis tu fais des spécialisations partielles avec 0, 1, 2, 3, 4, ..., N paramètres.

Généralement on génère le tout à coup de macros.

Citation:

---

Envoyé par loufoque

Pour faire une structure template variadique en C++03, c'est très simple.

Tu fais une première déclaration avec N paramètres templates, tous ayant des valeurs par défaut.

Puis tu fais des spécialisations partielles avec 0, 1, 2, 3, 4, ..., N paramètres.

Généralement on génère le tout à coup de macros.

---

Je dirais même plus : on laisse le pré-compilateur faire la majorité du travail, ce qui rends le temps de compilation complètement dément lorsque N augmente.

L'idée principale est d'avoir deux fichiers headers construits ainsi :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

// fichier 1 forward déclarations des classes   définition des macros pour N=0 #include fichier 2   definition des macros pour N=1 #include fichier 2   etc...

---

Code:

---

1 2 3 4 5

// fichier 2   définition de la classe en utilisant les macros définies undef des macros

---

On voit tout de suite que le précompilateur est mis à rude épreuve, et la quantité de code générée peut être absolument énorme (N=12 est souvent largement suffisant, mais il me semble que boost va bien plus loin pour son tuple).

A noter que tu trouveras une implémentation similaire dans le <tr1/tuple> de gcc.

C'est une explication a priori trompeuse de comment on fait en pratique.

Il y a deux méthodes pour faire de la répétition avec le préprocesseur :
- une qui nécessite la définition d'une macro (mais seulement une, pas une par arité) et l'invocation d'une autre macro avec celle-ci en argument. Il s'agit de la répétition horizontale, la plus facile à mettre en place et la moins intrusive.

- et une qui ne nécessite pas de définition de macro et qui inclue le même fichier N fois en changeant la valeur de la macro N. Il s'agit de la répétition verticale, un peu plus ennuyeuse à utiliser puisqu'elle nécessite de découper le code en plusieurs fichiers (il est aussi possible de réutiliser le même fichier en jouant bien sur les ifdef). Elle est néanmoins plus rapide et génère de meilleurs messages erreurs.

La méthode décrite ci-dessus semble être une mauvaise description de la répétition horizontale.

C'est plutôt

Code:

---

1 2 3 4 5 6 7 8 9

#define N 0 #include "fichier2"   #undef N #define N 1 #include "fichier2" #undef N   etc.

---

et encore, on écrirait plutôt

Code:

---

1 2 3

#define BOOST_PP_ITERATION_LIMITS (0, 42) #define BOOST_PP_FILENAME_1 "fichier2" #include BOOST_PP_ITERATE()

---

Après, des gens moins malins déroulent la moitié du code à la main ce qui rend le code verbeux et "immaintenable".

La solution pour aller plus vite, c'est de préprocesser le tout, pas d'écrire la répétition à la main...