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

C++ Discussion :

Meta-programation, template et cast implicite


Sujet :

C++

  1. #1
    Membre régulier
    Inscrit en
    Septembre 2010
    Messages
    73
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 73
    Points : 90
    Points
    90
    Par défaut Meta-programation, template et cast implicite
    Bonjour,
    Mon problème est à priori simple, si tant est qu'il ait une solution.
    L'exemple qui suit n'est pas mon problème mais c'est le même raisonnement.

    A partir de ces deux fonctions :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
     
    template <class T> inline float Sin(T a) { return sinf(a); } //fonction 1 renvoyant un float
    template <class T> inline double Sin(T a) { return sin(a); } //fonction 2 renvoyant un double
    Je veux trouver ces appelles à la compilation :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
     
    float fa = Math::Sin((double)1.0); //Utilisation de la fonction 1
    float fb = Math::Sin((float)1.0); //Utilisation de la fonction 1
    double da = Math::Sin((double)1.0); //Utilisation de la fonction 2
    double db = Math::Sin((float)1.0); //Utilisation de la fonction 2
    Mais l'ennuie c'est que le compilateur trouve une ambiguïté du à "l'autocasting" (coercition ?) float -> double, double -> float.

    Il n'y aurait pas une solution simple et propre de clarifier ça pour le compilateur ? Merci.

  2. #2
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Bonjour,


    essaye une syntaxe comme
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    float fa = Math::Sin<double>((double)1.0); //Utilisation de la fonction 1
    float fb = Math::Sin<float>((float)1.0); //Utilisation de la fonction 1
    double da = Math::Sin<double>((double)1.0); //Utilisation de la fonction 2
    double db = Math::Sin<float>((float)1.0); //Utilisation de la fonction 2
    qui devrait éviter toute embrouille du compilateur.

    edit: voir ci-dessous
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  3. #3
    Membre éclairé
    Avatar de Ekleog
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    448
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 448
    Points : 879
    Points
    879
    Par défaut
    AMHA le problème vient de la définition de Sin.
    En effet, la seule différence entre les deux définitions est le type de retour, qui n'entre pas en compte dans le choix d'une fonction.

    Donc il faudrait remplacer par :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    float Sin(float f) { return sinf(f); }
    double Sin(double d) { return sin(d); }
    Ou bien, si le but est d'apprendre la métaprog' :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    template <typename T> T Sin(T t) { return sin(t); }
    template <> float Sin<float>(float f) { return sinf(t); }

  4. #4
    Membre régulier
    Inscrit en
    Septembre 2010
    Messages
    73
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 73
    Points : 90
    Points
    90
    Par défaut
    D'abord merci à tous les deux.

    Ensuite, j'affine mon problème (vous ne pensiez pas vous en sortir si facilement ?!). Je voudrais utiliser ça (à peu près pareil qu'au dessus).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    float fa = Math::Sin((double)1.0); //Utilisation de la fonction 1
    float fb = Math::Sin((float)1.0); //Utilisation de la fonction 1
    double da = Math::Sin((double)1.0); //Utilisation de la fonction 2
    double db = Math::Sin((float)1.0); //Utilisation de la fonction 2
    float fc = Math::Sin((int)1.0); //Utilisation de la fonction 1
    double dc = Math::Sin((int)1.0); //Utilisation de la fonction 2
    Sans que j'aurais a définir la valeur du paramètre et la valeur de retour, manuellement. Ce que je voudrais éviter d'écrire, c'est ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    Fonction : Math::Sin</*type paramètre*/,/*type retour*/>
     
    float fa = Math::Sin<double,float>((double)1.0);
    float fb = Math::Sin<float,float>((float)1.0);
    double da = Math::Sin<double,double>((double)1.0);
    double db = Math::Sin<double,float>((float)1.0);
    float fc = Math::Sin<int,float>((int)1.0)
    double dc = Math::Sin<int,double>((int)1.0);
    Une idée ? Ou il faut que je revois ma fainéantise à la baisse ?

  5. #5
    Rédacteur/Modérateur


    Homme Profil pro
    Network game programmer
    Inscrit en
    Juin 2010
    Messages
    7 113
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 36
    Localisation : Canada

    Informations professionnelles :
    Activité : Network game programmer

    Informations forums :
    Inscription : Juin 2010
    Messages : 7 113
    Points : 32 958
    Points
    32 958
    Billets dans le blog
    4
    Par défaut
    Est-ce que ceci compilerait :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    template< typename R, typename P> R Sin(P val) { return sin(val); }
    Je n'ai pas de quoi tester.

    Sinon, parce qu'il est pas dit que l'ambiguité ne resurgisse pas ( 2 fonctions ne peuvent pas différer par leur unique type de retour)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    template< typename R, typename P> void Sin(P val, R& ret) { ret = sin(val); }
    Pensez à consulter la FAQ ou les cours et tutoriels de la section C++.
    Un peu de programmation réseau ?
    Aucune aide via MP ne sera dispensée. Merci d'utiliser les forums prévus à cet effet.

  6. #6
    En attente de confirmation mail

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Doubs (Franche Comté)

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

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Points : 3 311
    Points
    3 311
    Par défaut
    Je vois pas la Meta-Prog dans ton code ...

    La détermination automatique des paramètres template ne sert pas à grand chose ici. Si ton objectif est de créer des fonctions utilisant des algo plus ou moins performant selon la situation, il faut nécessairement que tu dises explictement quel précision tu veux.

    Si ce n'est pas pour ca que tu as plusieurs version, quel est la raison ?

    @Ekleog: Préfères la surcharge à la spécialisation des fonctions templates.

  7. #7
    Membre régulier
    Inscrit en
    Septembre 2010
    Messages
    73
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 73
    Points : 90
    Points
    90
    Par défaut
    Merci pour toutes ces réponses.

    Si ce n'est pas pour ca que tu as plusieurs version, quel est la raison ?
    Dans l'exemple que j'ai donné c'était simplement pour utilisé la double précision quand c'est nécessaire (qu'avec un double donc) et une simple précision pour tous les autres types. Tout ça en étant transparent, avec la même écriture.
    N'étant pas encore à fond dans la meta-programmation je voulais savoir si c'était aussi puissant que ça. Apparemment pas puisque le type de retour ne semble pas être pris en compte dans le cas présent (float et double) où la conversion se fait automatiquement.

    Je vois pas la Meta-Prog dans ton code ...
    La meta-programmation n'englobe pas tout ce qui concerne l'écriture de classe/fonction que se "définisse" à la compilation ?

    Merci encore pour vos réponses, ça m'a beaucoup aidé.

  8. #8
    En attente de confirmation mail

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Août 2004
    Messages
    1 391
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 33
    Localisation : France, Doubs (Franche Comté)

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

    Informations forums :
    Inscription : Août 2004
    Messages : 1 391
    Points : 3 311
    Points
    3 311
    Par défaut
    Si la méta-prog est très puissante, mais ce n'est en aucun cas ce que tu fais, ni ce que tu as besoin. Des classes de traits (plus proche de la programmation générique que de la méta-prog) devraient te suffir.

    Mais comment veux-tu que le compilateur sache avec quel précison calculé si tu ne lui dit pas.

    Par contre si ta précision dépend de la précision du paramètre tu peux faire quelque chose comme :
    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
     
    template<class T>
    struct ReturnTrait;
     
    template<class T>
    typename ReturnTrait<T>::type sin(const T& t)
    { /*blabla*/ }
     
    //Pour un paramètre simple précision :
    template<>
    struct ReturnTrait<float>
    { typedef float type; };
     
    //Pour un paramètre double précision :
    template<>
    struct ReturnTrait<double>
    { typedef double type; };
    En réalité dans ce cas on peut simplifer par :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    template<class T>
    struct ReturnTrait
    { typedef T type; };
    Edit: Non, la génération de fonctions/classes à la compilation c'est de la programmation générique. La méta-prog c'est l'utilisation de ces techniques de programmation générique pour effectuer des "calcul" à la compilation : les fonctions se transforment en classes templates, les objets en types, ect.

  9. #9
    Membre éclairé
    Avatar de Ekleog
    Homme Profil pro
    Étudiant
    Inscrit en
    Janvier 2012
    Messages
    448
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Janvier 2012
    Messages : 448
    Points : 879
    Points
    879
    Par défaut
    Citation Envoyé par Awakening Voir le message
    D'abord merci à tous les deux.

    Ensuite, j'affine mon problème (vous ne pensiez pas vous en sortir si facilement ?!). Je voudrais utiliser ça (à peu près pareil qu'au dessus).
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    float fa = Math::Sin((double)1.0); //Utilisation de la fonction 1
    float fb = Math::Sin((float)1.0); //Utilisation de la fonction 1
    double da = Math::Sin((double)1.0); //Utilisation de la fonction 2
    double db = Math::Sin((float)1.0); //Utilisation de la fonction 2
    float fc = Math::Sin((int)1.0); //Utilisation de la fonction 1
    double dc = Math::Sin((int)1.0); //Utilisation de la fonction 2
    [...]
    Il est impossible de choisir la fonction en fonction de son type de retour.
    Donc non.

    Citation Envoyé par Flob90 Voir le message
    [...]
    @Ekleog: Préfères la surcharge à la spécialisation des fonctions templates.
    D'où mon "Ou bien, si le but est d'apprendre la métaprog' :".
    (D'ailleurs, j'ai fait le même abus de langage que Awakening ...)

  10. #10
    Membre expert
    Avatar de Klaim
    Homme Profil pro
    Développeur de jeux vidéo
    Inscrit en
    Août 2004
    Messages
    1 717
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur de jeux vidéo
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 1 717
    Points : 3 344
    Points
    3 344
    Par défaut
    Au passage,

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    auto i = 1; // i est un int
    auto j = 1.0; // j est un double
    auto k = 1.0f; // k est un float
    Ca simplifiera un peu ton écriture si tu es au courant des types des valeures litérales....

  11. #11
    Membre régulier
    Inscrit en
    Septembre 2010
    Messages
    73
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 73
    Points : 90
    Points
    90
    Par défaut
    J'aime ce forum !

    On en apprend toujours plus que prévu.

    Du coup la finalité pourrait se traduire par ça :
    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 T>
    struct ReturnTrait { typedef float type; }; //Simple précision par défaut
    template<>
    struct ReturnTrait<double> { typedef double type; }; //Double précision qu'avec les doubles.
     
    template<class T>
    inline typename ReturnTrait<T>::type Sin(const T& a) //Fonction 1
    {
        return sinf(a);
    }
     
    template<>
    inline ReturnTrait<double>::type Sin(const double& a) //Fonction 2
    {
        return sin(a);
    }
    La fonction Sin, avec en paramètre, un float, un int ou un short.. renverra le résultat avec une précision simple (pas besoin de plus) et une double précision si c'est nécessaire.

  12. #12
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Décembre 2010
    Messages
    734
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Décembre 2010
    Messages : 734
    Points : 1 475
    Points
    1 475
    Par défaut
    C'est pas un peu violent pour ce qu'une simple surcharge ferait?

  13. #13
    Rédacteur

    Avatar de Matthieu Brucher
    Profil pro
    Développeur HPC
    Inscrit en
    Juillet 2005
    Messages
    9 810
    Détails du profil
    Informations personnelles :
    Âge : 42
    Localisation : France, Pyrénées Atlantiques (Aquitaine)

    Informations professionnelles :
    Activité : Développeur HPC
    Secteur : Industrie

    Informations forums :
    Inscription : Juillet 2005
    Messages : 9 810
    Points : 20 970
    Points
    20 970
    Par défaut
    Si, je pense. J'aurais écrit ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    template <class T> inline T Sin(T a) { return sinf(a); }
    inline double Sin(double a) {return sin(a);}
    puisque le compilateur va d'abord chercher dans les fonctions surchargées avant de regarder les templates.

  14. #14
    Membre régulier
    Inscrit en
    Septembre 2010
    Messages
    73
    Détails du profil
    Informations forums :
    Inscription : Septembre 2010
    Messages : 73
    Points : 90
    Points
    90
    Par défaut
    C'est pas un peu violent pour ce qu'une simple surcharge ferait?
    Ben c'est ce que je pensais au début, mais le résultat n'est pas le même qu'une simple surcharge en fait.

    @Matthieu Brucher : c'est ce que j'avais fait la toute première fois, mais le deuxième cas des tests suivant ne me plait pas :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    template <class T> inline T Sin(T a) { return sinf(a); }
    inline double Sin(double a) {return sin(a);}
     
    //Tests
    int a = Sin((int)1.000); // 0
    float fa = Sin((int)1.000); // 0 => perte de la précison du à la conversion int => float. Un int en argument retourne malheureusement une valeur en int
    float fb = Sin((float)1.000); // 0.841471
    double da = Sin((double)1.000); // 0.841471

  15. #15
    Membre expérimenté
    Homme Profil pro
    Inscrit en
    Décembre 2010
    Messages
    734
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Décembre 2010
    Messages : 734
    Points : 1 475
    Points
    1 475
    Par défaut
    Pourquoi pas:

    template<class T>
    inline float sin(T a){return fsin(a);}
    double sin(double a){return sin(a);}

    ?

  16. #16
    Rédacteur/Modérateur
    Avatar de JolyLoic
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2004
    Messages
    5 463
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Août 2004
    Messages : 5 463
    Points : 16 213
    Points
    16 213
    Par défaut
    Tu veux faire quoi au juste ? Es-tu certain qu'il n'est pas mieux de faire le calcul en double, tout le temps, puis de convertir en float à la fin dans les cas où l'espace de stockage importe ?

    As-tu lu : http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf (en particulier la section qui commence page 30) ?
    Ma session aux Microsoft TechDays 2013 : Développer en natif avec C++11.
    Celle des Microsoft TechDays 2014 : Bonnes pratiques pour apprivoiser le C++11 avec Visual C++
    Et celle des Microsoft TechDays 2015 : Visual C++ 2015 : voyage à la découverte d'un nouveau monde
    Je donne des formations au C++ en entreprise, n'hésitez pas à me contacter.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 5
    Dernier message: 24/07/2009, 16h40
  2. template et conversion implicite
    Par bolhrak dans le forum Langage
    Réponses: 3
    Dernier message: 10/11/2007, 14h17
  3. template et cast
    Par suckthewindow dans le forum Langage
    Réponses: 5
    Dernier message: 21/06/2007, 19h05
  4. Meta programation : Fonction templates
    Par Zenol dans le forum C++
    Réponses: 16
    Dernier message: 28/01/2007, 09h40
  5. [C#] Cast implicite inexistant ?
    Par ekinox17 dans le forum Windows Forms
    Réponses: 2
    Dernier message: 24/04/2006, 12h07

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