IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage C++ Discussion :

Implémentation boost :: tuple ?


Sujet :

Langage C++

  1. #1
    Membre éprouvé
    Profil pro
    Inscrit en
    Mars 2010
    Messages
    118
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mars 2010
    Messages : 118
    Par défaut Implémentation boost :: tuple ?
    Bonjour,

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

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  2. #2
    Rédacteur
    Avatar de 3DArchi
    Profil pro
    Inscrit en
    Juin 2008
    Messages
    7 634
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Juin 2008
    Messages : 7 634
    Par défaut
    Salut,
    Première réponse : ouvre tuple.hpp et regarde

    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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

  3. #3
    Expert confirmé
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Décembre 2003
    Messages
    3 549
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Décembre 2003
    Messages : 3 549
    Par défaut
    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.

  4. #4
    Membre Expert

    Homme Profil pro
    Développeur informatique
    Inscrit en
    Septembre 2007
    Messages
    1 895
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Opérateur de télécommunications

    Informations forums :
    Inscription : Septembre 2007
    Messages : 1 895
    Par défaut
    Citation Envoyé par loufoque Voir le message
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.
    [FAQ des forums][FAQ Développement 2D, 3D et Jeux][Si vous ne savez pas ou vous en êtes...]
    Essayez d'écrire clairement (c'est à dire avec des mots français complets). SMS est votre ennemi.
    Evitez les arguments inutiles - DirectMachin vs. OpenTruc ou G++ vs. Café. C'est dépassé tout ça.
    Et si vous êtes sages, vous aurez peut être vous aussi la chance de passer à la télé. Ou pas.

    Ce site contient un forum d'entraide gratuit. Il ne s'use que si l'on ne s'en sert pas.

  5. #5
    Expert confirmé
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Décembre 2003
    Messages
    3 549
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Décembre 2003
    Messages : 3 549
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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...

Discussions similaires

  1. Implémentation d'un tuple dynamique.
    Par Invité dans le forum Langage
    Réponses: 50
    Dernier message: 07/08/2014, 11h29
  2. Réponses: 2
    Dernier message: 16/02/2013, 23h41
  3. Boost::tuples, Templates, Nombre de paramètre
    Par NoIdea dans le forum Débuter
    Réponses: 16
    Dernier message: 31/07/2010, 21h32
  4. Implémentation des fonctions mathématiques
    Par mat.M dans le forum Mathématiques
    Réponses: 9
    Dernier message: 17/06/2002, 16h19

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo