Discussion :

[NiamorH]

Bonjour,

j'ai l'impression, après avoir lu le très instructif article sur la métaprog, que la seule façon d'utiliser les expressions templates, c'est en ayant une approche basée sur les vecteurs et les itérateurs.

Quelle est la bonne approche lorsque les données d'un objet à additionner (ou autre opération) sont différentes ?

Pour une classe Point2D ayant comme membres m_x et m_y, il suffit de faire m_coord[2], mais que se passe-t-il lorsqu'on fait l'addition de deux objets qui ont un short et un std::string par exemple ?

[Luc Hermitte]

Tu utilises les expressions templates sur ce que tu veux.

C'est par exemple un des moyen d'écrire un concaténeur qui à partir de toutes les chaines reçues en argument (std::string, char*, ...) détermine sur une première passe la longueur requise pour le résultat et termine par véritablement concaténer toutes les chaines.

[NiamorH]

Ce n'est pas vraiment ce que j'ai voulu dire.

un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
class Inutile
{
  int m_x;
  std::string m_chaine;
 
  operator = (Inutile& i)
  {
    m_x += i.m_x;
    m_chaine += i.m_chaine;
  }
}

J'ai du mal a voir comment implémenter une expression template de cette classe qui doit additionner des types différents.

[koala01]

Salut,

Pour autant que l'opérateur + soit défini pour chacun des types passés en template, cela devrait ressembler à quelque chose du genre de:

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
 
template <typename T, typename U>
class Inutile
{
    private:
        T _first;
        U _second;
    public:
        Inutile(const T& t, const U& u):_first(t),_second(u){}
        ~Inutile(){}
        Inutile& operator+(Inutile& two)
        {
             _first+=two._first;
             _second+=two._second;
             return *this;
        }
        void Affiche()
        {
            std::cout<<_first<<" "<<_second;
        }
};

[koala01]

Pour te montrer que cela fonctionne, si tu commente les lignes qui ont trait à troisieme, quatrieme et res2, la compilation du code suivant

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
 
int main()
{
    Inutile<std::string, int> premier("salut ",2);
    Inutile<std::string, int> deuxieme("tout le monde",3);
    Inutile<std::string, int> res=premier+deuxieme;
    res.Affiche();
    /* les lignes qui suivent ne fonctionneront pas, étant donné que les 
     * types ne corresondent pas 
     */
    Inutile<int, std::string> troisieme(2,"salut ");
    Inutile<std::string, int> quatrieme("tout le monde",3);
    Inutile<std::string, int> res2=troisieme+quatrieme;
    res2.Affiche();
 
    return 0;
}

(pour autant que tu aies inclus <string> et <iostream> )
te fournira la sortie écran:

salut tout le monde 5

[NiamorH]

Merci pour ta réponse mais celà ne résoud toujours pas mon problème.

Je parle bien ici d'expressions templates en métaprogrammation!

Deux remarques à ta solution :
l'opérateur + ne devrait pas modifier this. C = A + B ne doit pas modifier A
Une implémentation correcte de l'operateur + renvoie un objet temporaire, créé pour l'occasion et de fait, n'est pas optimisée.

Les expressions templates en métaprogrammation permettent de conserver une écriture lisible ( D = A+B*C ) mais sont optimisées car elles ne passent pas par des objets intermédiaires, elles font les calculs sur les variables membres directement. Le compilateur et les templates sont les clefs du système.

Cela marche bien lorsqu'on a un tableau de type unique comme une classe Vecteur ou Point, Rectangle, car l'opérateur ++ d'incrémentation est utilisé. Mais lorsque les types sont différents, l'exemple donné dans le tutoriel semble atteindre ses limites et je n'ai pas assez d'expérience en métaprog pour trouver l'astuce.

Peut-être en plaçant la déclaration des variables de la classe de façon a ce qu'elle aient des adresses contigues et en faisant des réinterpret_cast ?