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 :

problème de généricité


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre régulier
    Profil pro
    Inscrit en
    Février 2010
    Messages
    6
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Février 2010
    Messages : 6
    Par défaut problème de généricité
    Bonjour,
    sujet : problème généricité

    faire un produit scalaire entre float et int est impossible y a t il une solution pr résoudre ce problème ?
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    template <class T> // ceci  marche si les type sont omogène 
    T operator *(const Vecteur<T> & v1 ,const Vecteur<T2> & v2) ;
    merci pr vos propositoin

  2. #2
    Membre Expert
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Par défaut
    Il suffit de te faire une petite classe de traits pour ça qui va caluler ton type de retour.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    template<class T1, class T2>
    struct dot_product_result
    {
      static T1& t1;
      static T2& t2;
      typedef typename BOOST_TYPEOF_TPL( t1*t2 )  type;
    };
     
    template<class T1, class T2>
    typename dot_product_result<T1,T2>::type
    operator *(const Vecteur<T> & v1 ,const Vecteur<T2> & v2);
    La vrai bonne solution, serait d'empaqueter le tout dans un Polymorphic Function Object et de l'appeler dans operator* en utilisant le protocole result_of pour calculer le type de retour.

  3. #3
    Membre Expert
    Avatar de Goten
    Profil pro
    Inscrit en
    Juillet 2008
    Messages
    1 580
    Détails du profil
    Informations personnelles :
    Âge : 34
    Localisation : France

    Informations forums :
    Inscription : Juillet 2008
    Messages : 1 580
    Par défaut
    Ha, l'éternel soucis =). Enfin, ça se résout bien comme l'a montré joel.
    Mais sinon avec la prochaine norme y'aura decltype pour justement palier à ce genre de problème.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
     
    template <typename T1, typename T2>
    auto operator+(const T1& lhs, const T2& rhs) -> decltype(lhs + rhs)
    { // ... }

  4. #4
    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,
    Citation Envoyé par Joel F Voir le message
    La vrai bonne solution, serait d'empaqueter le tout dans un Polymorphic Function Object et de l'appeler dans operator* en utilisant le protocole result_of pour calculer le type de retour.
    Tu peux préciser STP ? Je vois pas trop ce que tu veux dire.

  5. #5
    Membre Expert
    Avatar de Joel F
    Homme Profil pro
    Chercheur en informatique
    Inscrit en
    Septembre 2002
    Messages
    918
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 45
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Chercheur en informatique
    Secteur : Service public

    Informations forums :
    Inscription : Septembre 2002
    Messages : 918
    Par défaut
    L'idée est de faire un foncteur dont l'operator() est template et dont le type de retour dépend des types templates d'entrée, d'où le nom de Polymorphic Function Object.

    Pour arriver à gérer ça propre, on se base sur le protocole result_of et son implantation pre-C++11 si besoin.

    Ca donne ç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
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
    struct dot_product_
    {
       template<class Sig> struct result;
       template<class This,class T1,class T2>
       struct result< This( std::vector<T1>,std::vector<T2>) >
       {
           static T1& t1;
           static T2& t2;
           typedef typename BOOST_TYPEOF_TPL( t1*t2 )  type;
       };
     
       template<class T1,class T2> inline
       typename result<dot_product(T1,T2)>::type
       operator()( T1 const& a, T2 const& b) const
      {
         return ...;
      }
    };
     
    template<class T1,class T2> inline
    typename boost::result_of<dot_product_(T1,T2)>::type
    dot_product( T1 const& a, T2 const& b)
    {
       dot_product_ callee;
       return callee(a,b);
    }
    L'avantage est de localiser le calcul et le calcul du type de retour dans une seule entité. On peut aussi faire du Tag Dispatching pour gérer les différents cas de calcul tout en gardant un point d'entrée unique. Enfin, la structure contenant le result_of et le calcul est un parfait foncteur prêt à l'usage pour toute autre fonction ou méta-fonction nécessitant un Callable Object.

  6. #6
    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,
    Ok. Il s'agit donc de regrouper toute la spécialisation au même endroit (dot_product_) au lieu de l'éparpiller à 2 endroits (dot_product_result et operator*), si j'ai bien compris.
    Merci pour l'explication et pour ces liens très intéressants.

Discussions similaires

  1. Problème de généricité avec les templates
    Par sfarc dans le forum Débuter
    Réponses: 9
    Dernier message: 30/12/2013, 03h51
  2. [débutant] un problème avec la généricité
    Par julien.63 dans le forum Langage
    Réponses: 12
    Dernier message: 19/01/2008, 22h25
  3. Problème de généricité de type privé
    Par dr_octopus74 dans le forum Ada
    Réponses: 5
    Dernier message: 20/11/2007, 22h27
  4. problème généricité et clonage
    Par BigNic dans le forum C#
    Réponses: 11
    Dernier message: 16/11/2007, 17h40
  5. problème de généricité avec Eclipse
    Par kespy13 dans le forum Eclipse Java
    Réponses: 3
    Dernier message: 02/04/2007, 00h05

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