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 :

Optimisation template variadic


Sujet :

Langage C++

  1. #1
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2011
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2011
    Messages : 274
    Points : 176
    Points
    176
    Par défaut Optimisation template variadic
    Bonjour, c'est encore moi ^^

    Cette fois plus de problèmes de compilation ou autre, mais juste une tentative d'amélioration de ce que je viens de faire. Voilà le code que je viens de finir (c'est un début donc c'est en vrac, à vrai dire c'était pour voir si ça marchait )

    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
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    #include <iostream>
     
    template <typename T, typename ... Args>
    class Mecanism
    {
        public:
            Mecanism() {};
            virtual ~Mecanism() = 0;
     
            virtual T getValue(Args ... args) = 0;
    };
     
    template <typename T, typename ... Args>
    Mecanism<T,Args...>::~Mecanism()
    {}
     
    template <typename T, typename U>
    class CarreXMecanism : public Mecanism<T,U>
    {
        public:
            CarreXMecanism() {};
            ~CarreXMecanism() {};
     
            T getValue(U arg1)
            {
                return (T)(arg1*arg1);
            }
    };
     
    template <typename T, typename U>
    class Plus100Mecanism : public Mecanism<T,U>
    {
        public:
            Plus100Mecanism() {};
            ~Plus100Mecanism() {};
     
            T getValue(U arg1)
            {
                return (T)(arg1+100);
            }
    };
     
    template <typename T, typename U, typename V>
    class CarreXYMecanism : public Mecanism<T,U,V>
    {
        public:
            CarreXYMecanism() {};
            ~CarreXYMecanism() {};
     
            T getValue(U arg1, V arg2)
            {
                return (T)(arg1*arg1+arg2*arg2);
            }
    };
     
     
     
    template <typename T, typename ... Args>
    class function
    {
        public:
            function(Mecanism<T,Args...> &mec) : m_mec(mec) {}
            ~function() {};
     
            T getValue(Args ... args) {return m_mec.getValue(args...);}
     
        private:
            Mecanism<T,Args...> &m_mec;
    };
     
     
     
    template <unsigned int S, typename ... Args>
    class Composee;
     
    template <>
    class Composee<0>{};
     
    template <unsigned int S, typename T, typename U, typename ... Args>
    class Composee<S, T, U, Args ...> : public Composee<0>
    {
        public:
            Composee(Composee<S-1,U,Args...> &XFunction, Mecanism<T,U> &mec) : m_mec(mec), m_func(XFunction) {}
            ~Composee() {};
     
            template <typename ... Args2>
            T getValue(Args2 ... args2) {return m_mec.getValue(m_func.getValue(args2...));}
     
        private:
            Mecanism<T,U> &m_mec;
            Composee<S-1,U,Args...> &m_func;
    };
     
    template <typename T, typename U, typename ... Args>
    class Composee<0, T, U, Args ...> : public Composee<0>
    {
        public:
            Composee(function<U,Args...> &XFunction, Mecanism<T,U> &mec) : m_mec(mec), m_func(XFunction) {}
            ~Composee() {};
     
            T getValue(Args ... args) {return m_mec.getValue(m_func.getValue(args...));}
     
        private:
            Mecanism<T,U> &m_mec;
            function<U,Args...> &m_func;
    };
     
     
    using namespace std;
     
    int main()
    {
        CarreXYMecanism<int, double, char> m1;
        function<int, double, char> f1(m1);
        std::cout<<f1.getValue(10,'.')<<" premiere valeur. "<<std::endl; //affiche 10*10+la valeur ascii du point au carré
     
        Plus100Mecanism<double, int> m2;
        Composee<0, double, int, double, char> c1(f1,m2);
        std::cout<<c1.getValue(8.596,'A')<<" seconde valeur. "<<std::endl; //affiche (char)(8.596*8.596+65*65)+100
     
        CarreXMecanism<long, double> m3;
        Composee<1, long, double, int, double, char> c2(c1,m3);
        std::cout<<c2.getValue(8.596,'A')<<" troisieme valeur. "<<std::endl; //affiche ((char)(8.596*8.596+65*65)+100)²
     
        return 0;
    }
    Comme vous le voyez, cela fonctionne et permet de réaliser plusieurs composition d'affilée : par exemple ici :
    -1 : function => mecanism x²+y²
    -2 : composee (niveau 0) => mecanism x+100
    -3 : composee (niveau 1 ou supérieur) => mecanism x²
    =>> on obtient au final la composition (x²+y²+100)²

    Je voulais simplement connaître vos avis et vos propositions pour améliorer ce code, afin que je parte sur de bonnes bases pour la suite

  2. #2
    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
    Bonjour,

    J'ai pas encore trop regardé le code, mais c'est quoi le but ? Comme ça ça ressemble vaguement à un début de bibliothèque de lambda polymorphique, et dans ce cas je te conseillerais de regarder comment fonctionne boost::phoenix et de lire la doc de boost::proto qui a un exemple que va dans ce sens de mémoire.

  3. #3
    Membre habitué
    Homme Profil pro
    Étudiant
    Inscrit en
    Avril 2011
    Messages
    274
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Meurthe et Moselle (Lorraine)

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2011
    Messages : 274
    Points : 176
    Points
    176
    Par défaut
    En fait c'est pour recréer facilement des courbes dans le but pour l'instant de créer des sons en modélisant leur signal et leur courbe d'enveloppe de manière intuitive.

    De plus cela pourrait également servir à établir des trajectoires d'objet en fonction du temps dans n'importe quel type d'environnement.

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

Discussions similaires

  1. imbrication template variadic
    Par Lintel-oo dans le forum Langage
    Réponses: 0
    Dernier message: 30/10/2012, 12h31
  2. Réponses: 3
    Dernier message: 10/08/2012, 14h44
  3. Réponses: 2
    Dernier message: 10/01/2009, 14h38
  4. Optimisation Listechainé avec template et operateur surchargé.
    Par Alain Defrance dans le forum Langage
    Réponses: 8
    Dernier message: 29/12/2007, 19h25

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