petit exemple: fabriquer votre propre opérateur ternaire

petit exemple: fabriquer votre propre opérateur ternaire - C++ - Programmation

Marsh Posté le 25-07-2003 à 18:08:55    

/!\ topic sérieux /!\
déconseillé aux débutants. Tout le monde peut lire ce topic et tester le code, mais j'aimerais que l'on reste focalisé sur la technique et pas sur le C++ lui même. Si il y a des points dans le code que vous ne comprenez pas, c'est sans doute une lacune. N'hésitez pas à créer des topics spécifiques (j'aimerais eviter des questions déplacées sur les constructeurs() : truc(chose), les operateur AutreType(), les déclarations imbriquées etc)
 
pour ceux que ça interesse... ce topic à pour but de présenter une technique avancée du C++. Je ne suis pas un véritable expert, donc je peux très bien raconter des bêtises et faire n'importe quoi.
 
Le C++ est langage où l'on manipule les objets par valeur et non par « référence » comme dans des langages comme Java ou Python.
 
Si on analyse l'expression
 
a = b * c
 
cela implique généralement et selon la sémantique habituelle, la création d'un objet temporaire:
 
tmp ( b * c )
a = tmp
 
dans beaucoup d'application ce genre de sémantique ainsi que la création de nombreux objets temporaires ne posent absolument aucun problème: le coup de la création/copie/destruction étant négligeable. Maintenant, vous avez une application où ces opérations ne sont pas du tout négligeables comme dans le cas de calcul scientifique.
 
Le but de ce topic est de montrer une technique permettant de réduire le nombre d'objets temporaires créés. Avant de commencer à vous l'expliquer, je signale qu'il existe une autre technique courremment utilisée qui est basée sur le concept de poignée (handle), c'est à dire que différents objets sont en mesures de partager des membres, et l'intégrité est assurée par un mécanisme de copie sur écriture (copy on write). Pour cela, on utilise souvent des pointeurs intelligents comme les boost::shared_ptr.
 
L'autre technique consiste à jongler sur les mécanismes de surcharge et de résolution de fonction. Je prends ici l'exemple des opérateurs arithmétique + et * mais celà fonctionne avec toutes les fonctions et tous les opérateurs, pour toutes les fonctions n-aires (mais celaest beaucoup plus long)
 
Simplement pour en revenir à l'expression
 
a = (b * c) + d  
 
on va essayer transmettre à a des références aux objets b, c et d et éviter ainsi la création de 2 objets temporaires. Pour réaliser ce mécanisme, on va se servir d'objets porteurs qui vous nous servir à transporter les références jusqu'à a.
cette expression va alors se décomposer
 
a = porteur*(b, c) + d
a = porteur*+(b, c, d)
 
et tou ça n'implique la création d'aucun objet temporaire. a dispose de références à b, c et d et peut librement effectuer les opérations qu'il souhaite et l'affectation.
 
 
bon apres, je sais pas trop expliquer, j'ai essayer de faire un petit exemple, sans doute critiquable. (Notez bien au passage l'implémentation des opérateurs binaires comme fonction externes utilisant les fonctions membres autour de l'affectation, c'est là une tres bonne méthode d'implémentation)
 

Code :
  1. //  source-highlight -v -doc -n -scpp -fhtml operator3.cpp
  4. #include <iostream>
  6. using namespace std;
  8. class Foo
  9. {
  10. public: 
  12.   struct MultScript;
  13.   struct AddScript;
  14.   struct AddMultScript;
  16.   Foo()
  17.   {
  18.     cout << "Foo()\n";
  19.   }
  21.   Foo(const Foo &other)
  22.   {
  23.     cout << "Foo(Foo)\n";
  24.   }
  26.   ~Foo()
  27.   {
  28.     cout << "~Foo()\n";
  29.   }
  32.   Foo & operator=(const Foo &other)
  33.   {
  34.     cout << "operator=(Foo)\n";
  35.     return *this;
  36.   }
  38.   Foo &operator=(const AddScript &as)
  39.   {
  40.     cout << "operator=(AddScrip)\n";
  41.     return *this;
  42.   }
  44.   Foo &operator=(const MultScript &as)
  45.   {
  46.     cout << "operator=(MultScrip)\n";
  47.     return *this;
  48.   }
  50.   Foo &operator=(const AddMultScript &as)
  51.   {
  52.     cout << "operator=(AddMultScrip)\n";
  53.     return *this;
  54.   }
  56.   Foo &operator+=(const Foo &other)
  57.   {
  58.     cout << "operator+=(Foo)\n";
  59.     return *this;
  60.   }
  62.   Foo &operator*=(const Foo &other)
  63.   {
  64.     cout << "operator*=(Foo)\n";
  65.     return *this;
  66.   }
  68. };
  72. struct Foo::AddScript
  73. {
  74.   AddScript(const Foo &lhs, const Foo &rhs)
  75.     : m_lhs(lhs),
  76.       m_rhs(rhs)
  77.   {}
  79.   operator Foo() const
  80.   {
  81.     cout << "AddScript::Foo()\n";
  83.     Foo tmp(m_lhs);
  84.     tmp+=m_rhs;
  85.     return tmp;
  86.   }
  88.   const Foo &m_lhs;
  89.   const Foo &m_rhs;
  90. };
  93. struct Foo::MultScript
  94. {
  95.   MultScript(const Foo &lhs, const Foo &rhs)
  96.     : m_lhs(lhs),
  97.       m_rhs(rhs)
  98.   {}
  100.   operator Foo() const
  101.   {
  102.     cout << "MultScript::Foo()\n";
  104.     Foo tmp(m_lhs);
  105.     tmp*=m_rhs;
  106.     return tmp;
  107.   }
  109.   const Foo &m_lhs;
  110.   const Foo &m_rhs;
  111. };
  114. struct Foo::AddMultScript
  115. {
  116.   AddMultScript(const Foo &a, const Foo &b, const Foo &c)
  117.     : m_a(a),
  118.       m_b(b),
  119.       m_c(c)
  120.   {}
  122.   operator Foo() const
  123.   {
  124.     cout << "AddMultScript::Foo()\n";
  126.     Foo prod(m_b);
  127.     prod*=m_c;
  129.     Foo sum(m_a);
  130.     sum+=prod;
  131.    
  132.     return sum;
  133.   }
  135.   const Foo &m_a;
  136.   const Foo &m_b;
  137.   const Foo &m_c;
  138. };
  141. Foo::MultScript operator*(const Foo &rhs, const Foo &lhs)
  142. {
  143.   cout << "operator*(Foo, Foo)\n";
  144.   return Foo::MultScript(rhs, lhs);
  145. }
  147. Foo::AddScript operator+(const Foo &rhs, const Foo &lhs)
  148. {
  149.   cout << "operator+(Foo, Foo)\n";
  150.   return Foo::AddScript(rhs, lhs);
  151. }
  153. Foo::AddMultScript operator+(const Foo &a, const Foo::MultScript &ms)
  154. {
  155.   cout << "operator+*(Foo, Foo::MultScrip)\n";
  156.   return Foo::AddMultScript(a, ms.m_lhs, ms.m_rhs);
  157. }
  161. int main()
  162. {
  163.   Foo a, b, c, d;
  165.   cout << "\n\n";
  167.   cout << "a=b+c\n";
  168.   a=b+c;
  169.   cout << '\n';
  171.   cout << "a=c*d\n";
  172.   a=c*d;
  173.   cout << '\n';
  175.   cout << "a=b+c+d\n";
  176.   a=b+c+d;
  177.   cout << '\n';
  179.   cout << "a=b*c*d\n";
  180.   a=b*c*d;
  181.   cout << '\n';
  183.   cout << "a=a+b+c+d\n";
  184.   a=a+b+c+d;
  185.   cout << '\n';
  187.   cout << "a=a*b*c*d\n";
  188.   a=a*b*c*d;
  189.   cout << '\n';
  191.   cout << "a=b+c*d\n";
  192.   a=b+c*d;
  193.   cout << '\n';
  195. }


 
Enjoy  :hello:

Reply

Marsh Posté le 25-07-2003 à 18:08:55   

Reply

Marsh Posté le 25-07-2003 à 18:25:50    

Mouai, concepte intéressant...


---------------
Le Tyran
Reply

Marsh Posté le 25-07-2003 à 20:00:35    

Tres interressant, j'utilise une technique similaire pour générer duc ode utilisant des opérations ternaires en AltiVec à partir de l'écriture a*b+c.  Tres tres bon exposé :D

Reply

Marsh Posté le 25-07-2003 à 20:42:29    

Je flagge...pas le temps de lire de suite et certainement au-dessus de mon niveau, mais j'aime apprendre!:jap:

Reply

Marsh Posté le 25-07-2003 à 20:56:50    

pas facile a comprendre tout ca!
Est ce que tu pourrais expliquer ceci:

Code :
  1. Foo::AddScript operator+(const Foo &rhs, const Foo &lhs)
  2.   {
  3.       cout << "operator+(Foo, Foo)\n";
  4.       return Foo::AddScript(rhs, lhs);//que fait cette ligne exactement?
  5.   }


 
 
La sortie pour ceux qui ne peuvent pas executer :

Foo()
Foo()
Foo()
Foo()
 
 
a=b+c
operator+(Foo, Foo)
operator=(AddScrip)
 
a=c*d
operator*(Foo, Foo)
operator=(MultScrip)
 
a=b+c+d
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
Foo(Foo)
~Foo()
operator+(Foo, Foo)
operator=(AddScrip)
~Foo()
 
a=b*c*d
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
Foo(Foo)
~Foo()
operator*(Foo, Foo)
operator=(MultScrip)
~Foo()
 
a=a+b+c+d
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
Foo(Foo)
~Foo()
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
Foo(Foo)
~Foo()
operator+(Foo, Foo)
operator=(AddScrip)
~Foo()
~Foo()
 
a=a*b*c*d
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
Foo(Foo)
~Foo()
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
Foo(Foo)
~Foo()
operator*(Foo, Foo)
operator=(MultScrip)
~Foo()
~Foo()
 
a=b+c*d
operator*(Foo, Foo)
operator+*(Foo, Foo::MultScrip)
operator=(AddMultScrip)
 
~Foo()
~Foo()
~Foo()
~Foo()
Press any key to continue

Reply

Marsh Posté le 25-07-2003 à 21:06:22    

:heink: j'avais dit pas de question à la con.... je vois pas ce que tu comprends pas: a) il y a pas de constructeur par defaut pour les classes *Script b) on construit l'objet qu'on retourne (normal quoi)
 
 
edit : « Press any key to continue »
ho le windozien


Message édité par Taz le 25-07-2003 à 21:08:51
Reply

Marsh Posté le 25-07-2003 à 21:08:36    

++Taz a écrit :

:heink:
 
 
edit : « Press any key to continue »
ho le windozien  


ben ouais c'est pas sencé appeler Foo::AddScript(rhs, lhs)???
Or on y est dans addscript  :heink:  
 
Mais bon je connais plus le C que le c++
 
 
edit : j'ai deja assez de mal comme ca :o


Message édité par polo021 le 25-07-2003 à 21:09:52
Reply

Marsh Posté le 25-07-2003 à 21:09:41    

polo021 a écrit :


ben ouais c'est pas sencé appeler Foo::AddScript(rhs, lhs)???
Or on y est dans addscript  :heink:  
 
Mais bon je connais plus le C que le c++

:pfff: merci de ta participation, au revoir

Reply

Marsh Posté le 25-07-2003 à 21:10:32    

++Taz a écrit :

:pfff: merci de ta participation, au revoir


 :bounce: explique

Reply

Marsh Posté le 25-07-2003 à 21:12:46    

polo021 a écrit :


 :bounce: explique

:heink: que je sache, en C comme en C++, le prototype d'une fonction, c'est
 
<type de retour> nomDeLaFonction([<argument>])
 
je crois que tu ne sais pas ça. franchement je m'attendais pas à ça comme question, on est vendredi mais quand meme

Reply

Marsh Posté le 25-07-2003 à 21:12:46   

Reply

Marsh Posté le 25-07-2003 à 21:22:58    

disons plutot : a quoi sert ceci alors

Code :
  1. struct Foo::AddScript
  2.   {
  3.       AddScript(const Foo &lhs, const Foo &rhs)
  4.         : m_lhs(lhs),
  5.           m_rhs(rhs)
  6.       {}
  7.    
  8.       operator Foo() const
  9.       {
  10.           cout << "AddScript::Foo()\n";
  11.      
  12.           Foo tmp(m_lhs);
  13.           tmp+=m_rhs;
  14.           return tmp;
  15.       }
  16.    
  17.       const Foo &m_lhs;
  18.       const Foo &m_rhs;
  19.   };

c bien ca que tu appeles quand tu fais Foo::AddScript(rhs, lhs), n'est cce pas

Reply

Marsh Posté le 25-07-2003 à 21:26:56    

deux 2 choses l'une:
- tu n'a pas lu l'explication sur le role des classes Script
- « déconseillé aux débutants », pour moi c'est la première fois que tu vois une classe: on ne peut pas faire plus simple que les classes Script. si tu veux apprendre le C++, regarde les bibliolinks, si tu veux qu'on t'aide à créer ta première classe, on t'aidera, si tu veux un conseille de livre, je te donnerai des références. Mais là je peux rien pour toi. En tout cas pas dans ce topic.


Message édité par Taz le 25-07-2003 à 21:27:34
Reply

Marsh Posté le 25-07-2003 à 21:38:52    

restons en là alors [:spamafote]

Reply

Marsh Posté le 25-07-2003 à 21:42:49    

polo021 a écrit :

restons en là alors [:spamafote]

ben fais un autre topic / envoie moi un PM avec le code de AddScript et que te le commente ligne par ligne

Reply

Marsh Posté le 25-07-2003 à 23:18:17    

interressant je me suis dérouler le bordel dans la tête :D (ça fait mal mais ça passe)
=> technique notée dans un coin :D

Reply

Marsh Posté le 25-07-2003 à 23:34:12    

tiens moi j'ai pas la même trace que polo
 

Foo()
Foo()
Foo()
Foo()
 
 
a=b+c
operator+(Foo, Foo)
operator=(AddScrip)
 
a=c*d
operator*(Foo, Foo)
operator=(MultScrip)
 
a=b+c+d
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
operator+(Foo, Foo)
operator=(AddScrip)
~Foo()
 
a=b*c*d
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
operator*(Foo, Foo)
operator=(MultScrip)
~Foo()
 
a=a+b+c+d
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
operator+(Foo, Foo)
AddScript::Foo()
Foo(Foo)
operator+=(Foo)
operator+(Foo, Foo)
operator=(AddScrip)
~Foo()
~Foo()
 
a=a*b*c*d
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
operator*(Foo, Foo)
MultScript::Foo()
Foo(Foo)
operator*=(Foo)
operator*(Foo, Foo)
operator=(MultScrip)
~Foo()
~Foo()
 
a=b+c*d
operator*(Foo, Foo)
operator+*(Foo, Foo::MultScrip)
operator=(AddMultScrip)
 
~Foo()
~Foo()
~Foo()
~Foo()


 
polo à des
 
Foo(Foo)
~Foo()  
 
je crée un nouvo topic pour en parler et j'essaye de me renseigner

Reply

Marsh Posté le 26-07-2003 à 10:37:47    

polo021 a écrit :


ben ouais c'est pas sencé appeler Foo::AddScript(rhs, lhs)???
Or on y est dans addscript  :heink:  
 
Mais bon je connais plus le C que le c++
 
 
edit : j'ai deja assez de mal comme ca :o


 
AddScript est une classe : on est dans opérator+, qui appelle le constructeur de la classe.
-> AddScript n'est pas une fonction : achète des lunettes :)

Reply

Marsh Posté le 26-07-2003 à 10:41:54    

leneuf22 a écrit :


 
AddScript est une classe : on est dans opérator+, qui appelle le constructeur de la classe.
-> AddScript n'est pas une fonction : achète des lunettes :)

il a fait un topic exprès
http://forum.hardware.fr/forum2.ph [...] h=&subcat=

Reply

Marsh Posté le 26-07-2003 à 10:45:11    

leneuf22 a écrit :


 
AddScript est une classe : on est dans opérator+, qui appelle le constructeur de la classe.
-> AddScript n'est pas une fonction : achète des lunettes :)

:sol:  
Comprends mieux maintenant [:ddr555]

Reply

Marsh Posté le 26-07-2003 à 21:11:58    

si ce genre de petite mémo plait, j'en referais peut être. Non?

Reply

Marsh Posté le 27-07-2003 à 01:39:05    

Taz a écrit :

si ce genre de petite mémo plait, j'en referais peut être. Non?


 
[:calin]
 
http://membres.lycos.fr/cybear/Forum/topicR.gif
 
 
C'est bieng ce genre de wrappers, mais il faut bien en mesurer la portée.
Par exemple avec ce genre d'opérations:
 

Code :
  1. Foo a,b,c,d,e,r;
  2. r=a+b+c+e;


 
On n'économise qu'un objet temporaire Foo avec le wraper AddScript au lieu de la méthode classique (i.e friend Foo Foo::operator+(const Foo&, const Foo& )).


Message édité par schnapsmann le 27-07-2003 à 01:46:37

---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"
Reply

Marsh Posté le 27-07-2003 à 01:48:59    

ben c'est déjà pas mal, et puis si tu te réfères au titre du topic, ce n'est pas l'objet du topic. mais je considere que c'est déjà un petit plus non négligeable. pas possible de faire du quaternaire avec que des + avec la meme technique par ce que c'est la meme précédence, c'est donc évalué comme a+b+c+d = ((a+b)+c)+d)


Message édité par Taz le 27-07-2003 à 01:59:55
Reply

Marsh Posté le 27-07-2003 à 01:58:17    

Taz a écrit :

ben c'est déjà pas mal, et puis si tu te réfères au titre du topic, ce n'est pas l'objet du topic. mais je considere que c'est déjà un petit plus non négligeable. et puis la voix est ouverte pour faire un opérateur quaternaire (y a plus qu'a rajouté une classe AddAddscript tres simple et a surchargé + et c'est réglé)


 
Mais oui je n'ai pas prétendu le contraire  [:calin]  
 
Dommage qu'on ne puisse pas bidouiller les précédences et associativités des opérateurs selon leur type (comme en ocaml) ce qui permettrait des optimisations automatiques pour tous les opérateurs n-aires.


---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"
Reply

Marsh Posté le 27-07-2003 à 02:09:55    

j'ai edité, mais je complète: la seule bidouille qu'on peut ajouter permet de réduire la durée de vie des objets temporaires, on peut alors obtenir au lieu de ça  
 

a=a+b+c+d
operator+(Foo, Foo)
Add2Script::Foo()
Foo(Foo)
operator+=(Foo)
operator+(Foo, Foo)
Add2Script::Foo()
Foo(Foo)
operator+=(Foo)
operator+(Foo, Foo)
operator=(Add2Scrip)
~Foo()
~Foo()


 
ceci
 
 

a=a+b+c+d
operator+(Foo, Foo)
operator+(Foo::Add2Script, Foo)
Add2Script::Foo()
Foo(Foo)
operator+=(Foo)
~Foo()
operator+(Foo::Add2Script, Foo)
Add2Script::Foo()
Foo(Foo)
operator+=(Foo)
~Foo()
operator=(Add2Script)

 
 
c'est peut etre pas mal de changer la précédence/priorité, mais je sais pas si c'est vraiment source de confusion à ce moment là... et au niveaux des conversion, y a pas de problème?

Reply

Marsh Posté le 27-07-2003 à 02:10:56    

cela dit ça doit etre difficile de définir une relation pyramidale pour la resolution d'une expression, ça va contre le principe d'évaluation de gauche à droite..., donc je saisis pas trop comment le changement de priorité change quelque chose: tu ne peux pas dire: l'addition de ces 2 types est prioritaire à l'addition de ces 2 types... si? et ça marche comment si ton opérateur n'est pas symétrique? je peux comprendre l'interet mais je suis pas sur que ça soit une bonne chose. et le C++ est ce qu'il est. on surcharge, on ne définit pas, donc ce n'est pas possible de changer la priorité. enfin, là n'est pas la question, on est pas vraiment là pour faire des comparaisons...


Message édité par Taz le 27-07-2003 à 02:26:10
Reply

Marsh Posté le 27-07-2003 à 02:23:02    

Taz a écrit :

cela dit ça doit etre difficile de définir une relation pyramidale pour la resolution d'une expression, ça va contre le principe d'évaluation de gauche à droite..., donc je saisis pas trop comment le changement de priorité change quelque chose: tu ne peux pas dire: l'addition de ces 2 types est prioritaire à l'addition de ces 2 types... si?


 
au temps pour moi, il s'agit plutot de privilégier l'opérateur de plus grande arité sur les autres. C'est faisable avec un parser LALR1.


---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"
Reply

Marsh Posté le 27-07-2003 à 02:27:01    

SchnapsMann a écrit :


 
au temps pour moi, il s'agit plutot de privilégier l'opérateur de plus grande arité sur les autres. C'est faisable avec un parser LALR1.

:heink: en infixé, c'est faisable? tu fais une rapide explication/exemple ? j'ai du mal avec les opérateurs b-aires n>2 en infixé. je réfléchis, et c'est possible qu'en pas infixé il me semble


Message édité par Taz le 27-07-2003 à 02:33:30
Reply

Marsh Posté le 27-07-2003 à 02:56:17    

Taz a écrit :

:heink: en infixé, c'est faisable? tu fais une rapide explication/exemple ? j'ai du mal avec les opérateurs b-aires n>2 en infixé


 
rapide non  :o  
 
Il faut se placer dans le cadre d'un compilo LR1 en fé :o
Ce qui permet de changer les règles de décalage/réduction suivant le type de token en haut de la pile. NB: c'est tjrs de l'infixe mais c'est faisable... c'est justement une limitation des compilos LALR1 qui se contentent de "simples" tables de shift/reduce pour effectuer le parsing.
 
Ensuite l'idée c'est de raffiner la règle de réécriture d'un opérateur pour le type dont tu veux optimiser l'opérateur n-aire, en changeant son associativité à droite (comme pour le '=' classiquement).


Message édité par schnapsmann le 27-07-2003 à 02:58:14

---------------
From now on, you will speak only when spoken to, and the first and last words out of your filthy sewers will be "Sir!"
Reply

Marsh Posté le 27-07-2003 à 02:59:50    

ok, j'avais po vu ça comme ça

Reply

Marsh Posté le 28-07-2003 à 13:37:26    

Retour au topic.
Taz il me semble que ton exemple ne marche pas si bien que ca ...
 
En effet, les operateurs Foo() appellent une à deux fois le constructeur de Foo ... (pour sum et prod non ?)  
DONC : il a bien construction d'objet temporaire ??
Ou alors les opérateurs de transtypage entre classes ont un comportement spécial qui m'est inconnu ?? (et donc éclaircissement stp)
 
De plus, si on veut ajouter une donnée dans Foo (style un double) il faut modifier lourdement le code :
 

Code :
  1. class Foo {
  2.   public:
  4.   struct AddScript
  5.   {
  6.       AddScript(const Foo & lhs, const Foo & rhs)
  7.   :m_lhs(lhs), m_rhs(rhs) {}
  8.    
  9.       const Foo & m_lhs;
  10.       const Foo & m_rhs;
  11.   };
  14.   struct MultScript
  15.   {
  16.       MultScript(const Foo & lhs, const Foo & rhs)
  17. :m_lhs(lhs), m_rhs(rhs) {}
  18.  
  19.       const Foo & m_lhs;
  20.       const Foo & m_rhs;
  21.   };
  23.   struct AddMultScript
  24.   {
  25.       AddMultScript(const Foo& a, const Foo& b, const Foo& c)
  26. :m_a(a), m_b(b), m_c(c) {}
  28.       const Foo & m_a;
  29.       const Foo & m_b;
  30.       const Foo & m_c;
  31.    };
  33.     Foo(double in):d(in) {
  34. cout << "Foo()\n";
  35.     }
  36.    
  37.     Foo(const Foo & other):d(other.d) {
  38. cout << "Foo(Foo)\n";
  39.     }
  40.    
  41.     ~Foo() {
  42. cout << "~Foo()\n";
  43.     }
  45.     Foo & operator=(const Foo & other) {
  46. cout << "operator=(Foo)\n";
  47. d = other.d;
  48. return *this;
  49.     }
  51.     Foo & operator=(const AddScript & as) {
  52. cout << "operator=(AddScrip)\n";
  53. d = as.m_lhs.d+as.m_rhs.d;
  54. return *this;
  55.     }
  57.     Foo & operator=(const MultScript & as) {
  58. cout << "operator=(MultScrip)\n";
  59. d = as.m_lhs.d*as.m_rhs.d;
  60. return *this;
  61.     }
  63.     Foo & operator=(const AddMultScript & as) {
  64. cout << "operator=(AddMultScrip)\n";
  65. d = as.m_a.d*as.m_b.d+as.m_c.d;
  66. return *this;
  67.     }
  69.     Foo & operator+=(const Foo & other) {
  70. cout << "operator+=(Foo)\n";
  71. d+=other.d;
  72. return *this;
  73.     }   
  75.     Foo & operator*=(const Foo & other) {
  76. cout << "operator*=(Foo)\n";
  77. d*=other.d;
  78. return *this;
  79.     }
  81.     double d;
  82. };
  85. Foo::MultScript operator*(const Foo & rhs, const Foo & lhs)
  86. {
  87.     cout << "operator*(Foo, Foo)\n";
  88.     return Foo::MultScript(rhs, lhs);
  89. }
  91. Foo::AddScript operator+(const Foo & rhs, const Foo & lhs)
  92. {
  93.     cout << "operator+(Foo, Foo)\n";
  94.     return Foo::AddScript(rhs, lhs);
  95. }
  97. Foo::AddMultScript operator+(const Foo & a, const Foo::MultScript & ms)
  98. {
  99.     cout << "operator+*(Foo, Foo::MultScrip)\n";
  100.     return Foo::AddMultScript(a, ms.m_lhs, ms.m_rhs);
  101. }
  103. int main()
  104. {
  105.     Foo a(1), b(2), c(3), d(4);
  107.     cout << "\n\n";
  109.     cout << "a=b+c\n";
  110.     a = b + c;
  111.     cout << "a=" << a.d << endl;
  112.     cout << '\n';
  114.     cout << "a=c*d\n";
  115.     a = c * d;
  116.     cout << '\n';
  118.     cout << "a=b+c*d\n";
  119.     a = b + c * d;
  120.     cout << '\n';
  121. }

 
 
La ca marche, la valeur de d est modifié corretement ET aucun objet temporaire n'est crée. Evidemment, il est nécessaire de surcharger + et * pour qu'ils gérent les cas :
 
Foo + xxScript
xxScript + Foo
xxScript + xxScript
 
Foo * xxScript
xxScript * Foo
xxScript * xxScript
 
Voila ... qu'en penses-tu ??

Reply

Marsh Posté le 28-07-2003 à 13:41:12    

Joel F a écrit :

Retour au topic.
Taz il me semble que ton exemple ne marche pas si bien que ca ...
 
En effet, les operateurs Foo() appellent une à deux fois le constructeur de Foo ... (pour sum et prod non ?)  
DONC : il a bien construction d'objet temporaire ??
Ou alors les opérateurs de transtypage entre classes ont un comportement spécial qui m'est inconnu ?? (et donc éclaircissement stp)
 
 


 
 :jap:  
Sauf optimisation du compilo y a bien ndouble appel du constructeur de recopie.


Message édité par LetoII le 28-07-2003 à 13:41:32

---------------
Le Tyran
Reply

Marsh Posté le 28-07-2003 à 13:49:52    

je vois pas trop de quel cas tu parle? pour a+b, a*b et a*b+c, je ne vois d'objet temporaire?

Reply

Marsh Posté le 28-07-2003 à 13:51:44    

Taz a écrit :

je vois pas trop de quel cas tu parle? pour a+b, a*b et a*b+c, je ne vois d'objet temporaire?


 
C dans les operateurs de transtypage vers foo, même s'ils servent pas pour les calculs, y a un petit pb dedans.


---------------
Le Tyran
Reply

Marsh Posté le 28-07-2003 à 13:55:19    

Moi je ne vois pas de problème. c'est réalisé de manière la plus atomique possible. je vois meme pas la difference avec ton code, si ce n'est qu'il se passe vraiment quelque chose dedans

Reply

Marsh Posté le 28-07-2003 à 14:01:25    

Rien que là, il y a un truc qui me gêne un peu :
 

Code :
  1. struct Foo::AddMultScript
  2. {
  3. AddMultScript(const Foo &a, const Foo &b, const Foo &c)
  4.    : m_a(a),
  5.      m_b(b),
  6.      m_c(c)
  7. {}
  9. operator Foo() const
  10. {
  11.    cout << "AddMultScript::Foo()\n";
  13.    // et de un objet temporaire
  14.    Foo prod(m_b);
  15.    prod*=m_c;
  17.    // et de deux
  18.    Foo sum(m_a);
  19.    sum+=prod; 
  20.      
  21.     return sum;
  22. }
  24. const Foo &m_a;
  25. const Foo &m_b;
  26. const Foo &m_c;
  27. };

 
 
La création des objets temporaires n'apparaît pas dans les logs parce que j'ai l'impression qu'à aucun moment tu ne fais réellement l'opération arithmétique (pas d'appel au transtypage par l'opérateur Foo(), comme disait Leto2).
Ou alors j'ai rien compris, évidemment...

Reply

Marsh Posté le 28-07-2003 à 14:03:25    

Taz a écrit :

Moi je ne vois pas de problème. c'est réalisé de manière la plus atomique possible. je vois meme pas la difference avec ton code, si ce n'est qu'il se passe vraiment quelque chose dedans


 
La différence c qu'il a virré les operateurs de transtypage... J'ai pas regardé en détail mais oui apparement c la même chose que ce que tu as fait  [:ddr555]


Message édité par LetoII le 28-07-2003 à 14:03:46

---------------
Le Tyran
Reply

Marsh Posté le 28-07-2003 à 14:05:55    

umag a écrit :

Rien que là, il y a La création des objets temporaires n'apparaît pas dans les logs parce que j'ai l'impression qu'à aucun moment tu ne fais réellement l'opération arithmétique (pas d'appel au transtypage par l'opérateur Foo(), comme disait Leto2).
Ou alors j'ai rien compris, évidemment...


 
Ben c fait exprès qu'on passe pas par le transtypage, justement pour pas créer d'objet intermédiaire.


---------------
Le Tyran
Reply

Marsh Posté le 28-07-2003 à 14:09:07    

en fait y a besoin des opérateurs de transtypage, à moins fournir des constructeurs, sinon voif F(Foo) ne peut fonctionner avec F(a+b)
 
après ça m'a parru plus élégant et passe partout. c'est vrai que pour a+b+c, on peut encore spécialiser avec une classe Add3Script. mais le pincipal avantage que je vois, c'est qu'avec les opérateurs de conversion, on peut tres bien envisager ce genre de technique avec n'importe quelle classe sans avoir besoin de la modifier.

Reply

Marsh Posté le 28-07-2003 à 14:13:40    

LetoII a écrit :


 
Ben c fait exprès qu'on passe pas par le transtypage, justement pour pas créer d'objet intermédiaire.


 
Ben oui, c'est le principe... ;)
 
Mais il faut quand même faire l'opération quelque part, non ?
 
Donc l'opération, on la fait par exemple là pour le *+ avec un double :

Code :
  1. Foo & operator=(const AddMultScript & as)
  2. {
  3.    cout << "operator=(AddMultScrip)\n";
  4.    d = as.m_a.d*as.m_b.d+as.m_c.d; 
  5.    return *this;
  6. }

 
Et dans ce cas il n'y a effectivement pas d'objet temporaire créé...
Mais il fallait le dire, c'est tout.

Reply

Marsh Posté le 28-07-2003 à 14:14:44    

c'était un peu le but du topic non  :pt1cable:

Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed