Assignement conditionel

Assignement conditionel - C++ - Programmation

Marsh Posté le 30-04-2005 à 18:09:44    

Je savais pas trop comment poser ma question, mais j'aimerai faire un truc comme ça:
 

Code :
  1. class truc
  2. {
  3. float a,b;
  4. int i,j;
  5. public:
  6.    InitFromXml( const XmlElement &Xml );
  7. }
  9. truc::InitFromXml( const XmlElement &Xml )
  10. {
  11.    a=10.5;
  12.    b=20.3;
  13.    i=5;
  14.    j=6;
  16.    a = Xml[ "param_a" ];
  17.    b = Xml[ "param_b" ];
  18.    i = Xml[ "param_i" ];
  19. }


 
bref, faire un ' a = Xml[ "param_a" ] ' qui marche c'est pas le prob, le prob c'est que j'aimerai que si l'attribut Xml (en l'occurance) n'est pas trouvé, a ne soit pas assigné.
 
parce qu'avec un truc style:
 
GetXml( "param_a", a );
 
utilisant un GetXml( const std::string &, float & );
par exemple OK, là je peux ne pas modifier 'a' si j'ai en envie, mais dans le cas d'un assignement, ou cast en passant par une structure intermédiaire, je vois pas comment ruser le lapin vert.


Message édité par bjone le 30-04-2005 à 18:10:21
Reply

Marsh Posté le 30-04-2005 à 18:09:44   

Reply

Marsh Posté le 30-04-2005 à 18:29:29    

Moi je me satisferais entièrement d'un GetXml("param_a", a);
 
Parce que bon, les implications d'un "a=b;" qui est exécuté parfois, ça doit pas être joli à voir...

Reply

Marsh Posté le 30-04-2005 à 21:19:02    

uifgy

Reply

Marsh Posté le 30-04-2005 à 21:23:57    

t'as qu'à faire en sorte que a ne soit plus un int et se bien surcharger constructeurs et operator= et tu peux avoir quelque chose comme tu veux. Mais ça nuit à la lisibilité puisque lors de la surcharge d'opérateurs, on chercher à conserver la sémantique originale.


Message édité par Taz le 30-04-2005 à 21:24:25
Reply

Marsh Posté le 01-05-2005 à 00:06:52    

oué, maos ça me tentais bien d'avoir un truc le plus court possible à lire/écrire.

Reply

Marsh Posté le 01-05-2005 à 16:39:05    

ouep, finalement je vais faire un << pour ça, ça sera moins ambigu.

Reply

Marsh Posté le 02-05-2005 à 23:51:25    

Bon j'ai testé une approche qui permet d'écrire comme ça:
ça me plait pas trop mal.
 
avec un fichier xmeul pas compliant style:

Code :
  1. <Yop A="84" B="95.776505" Test="20" wesh="7139.703064" zorg="true" />
  2. <Youpi rg="24" />
  3. <Yop A="90" Test="20" wesh="-9577.649780" B="-119.720622" zorg="false" />
  4. <Youpa rg="644" />
  5. <Yop B="-167.608908" zorg="false" Test="20" wesh="-14018.199585" A="94" />
  6. <zz a="98" />


 

Code :
  1. #include <iostream>
  2. #include "XmlElement.h"
  4. using namespace std;
  6. int main()
  7. {
  8. TiXmlDocument Doc;
  10. if( Doc.LoadFile("test.xml" ) )
  11. {
  12.  XmlElement Xml=Doc.FirstChildElement("Yop" );
  14.  while( Xml )
  15.  {
  16.   int A=12;
  17.   float B=-20;
  18.   bool zorg=false;
  20.   Xml["A"]>>A;
  21.   Xml["B"]>>B;
  22.   Xml["zorg"]>>zorg;
  24.   cout<<A<<" "<<B<<" : "<<zorg<<"\n";
  26.   Xml["A"]<<A+2;
  27.   Xml["B"]<<B*1.1;
  28.   Xml["wesh"]<<A*B;
  30.   Xml["zorg"]<<(B>A);
  32.   ++Xml;
  33.  }
  35.  Doc.SaveFile();
  36. }
  37. }


 
bon c'est une surcouche à TinyXml, en mode cracra const char * et pas STL, demain je fais la variante STL et je m'y colle, sinon coté code ça donne ça:
 
XmlElement.h

Code :
  1. #pragma once
  3. #include <tinyxml.h>
  5. struct XmlElementAttribute
  6. {
  7. TiXmlElement *Element;
  8. const char *Attribute;
  10. XmlElementAttribute( TiXmlElement *Elem, const char *Attr ) : Element(Elem), Attribute(Attr) {};
  12. const char *GetValue() const
  13. {
  14.  if( !Element || !Attribute )
  15.   return NULL;
  17.  return Element->Attribute(Attribute);
  18. }
  20. operator const char*() const
  21. {
  22.  return GetValue();
  23. }
  24. };
  27. class XmlElement
  28. {
  29. public:
  30. TiXmlElement *Element;
  32. XmlElement( TiXmlElement *Elem=NULL ) : Element(Elem) {};
  34. XmlElement &operator = (TiXmlElement *Elem )
  35. {
  36.  Element=Elem;
  37.  return *this;
  38. }
  40. operator TiXmlElement * () const
  41. {
  42.  return Element;
  43. }
  45. TiXmlElement * operator -> () const
  46. {
  47.  return Element;
  48. }
  50. XmlElement &operator ++ ();
  52. const XmlElementAttribute operator [] ( const char *AttributeName ) const
  53. {
  54.  return XmlElementAttribute( Element, AttributeName );
  55. }
  57. };
  59. int operator >> ( const XmlElementAttribute &ElemAttr, int &Value );
  60. float operator >> ( const XmlElementAttribute &ElemAttr, float &Value );
  61. double operator >> ( const XmlElementAttribute &ElemAttr, double &Value );
  62. bool operator >> ( const XmlElementAttribute &ElemAttr, bool &Value );
  64. const char * operator << ( const XmlElementAttribute &ElemAttr, const char *Value  );
  65. int operator << ( const XmlElementAttribute &ElemAttr, int Value  );
  66. double operator << ( const XmlElementAttribute &ElemAttr, double Value  );
  67. bool operator << ( const XmlElementAttribute &ElemAttr, bool Value  );


 
XmlElement.cpp

Code :
  1. include <assert.h>
  2. #include "XmlElement.h"
  3. #include "Size.h"
  5. XmlElement &XmlElement::operator ++ ()
  6. {
  7. if( Element )
  8. {
  9.  const char *Name=Element->Value();
  11.  if( Name )
  12.   Element=Element->NextSiblingElement(Name);
  13.  else
  14.   Element=NULL;
  15. }
  17. return *this;
  18. }
  20. //////////////////////////////////////////////////////////////////////////////
  21. //////////////////////////////////////////////////////////////////////////////
  23. bool ExtractInt( const char *Str, int &Value )
  24. {
  25. assert(Str);
  27. if( sscanf(Str,"%d",&Value) == 1 || sscanf( Str,"%x",&Value) == 1 )
  28.  return true;
  30. return false;
  31. }
  33. bool ExtractFloat( const char *Str, float &Value )
  34. {
  35. assert(Str);
  37. if( sscanf(Str,"%f",&Value) == 1 )
  38.  return true;
  39. else
  40. {
  41.  int iValue;
  42.  if( ExtractInt( Str, iValue ) )
  43.  {
  44.   Value=(float)iValue;
  45.   return true;
  46.  }
  47. }
  49. return false;
  50. }
  52. bool ExtractDouble( const char *Str, double &Value )
  53. {
  54. assert(Str);
  56. if( sscanf(Str,"%lf",&Value) == 1 )
  57.  return true;
  58. else
  59. {
  60.  float fValue;
  61.  if( ExtractFloat( Str, fValue) )
  62.  {
  63.   Value=fValue;
  64.   return true;
  65.  }
  66. }
  68. return false;
  69. }
  71. int operator >> ( const XmlElementAttribute &ElemAttr, int &Value )
  72. {
  73. if( const char *Attribute=ElemAttr.GetValue() )
  74.  ExtractInt( Attribute, Value );
  76. return Value;
  77. }
  79. float operator >> ( const XmlElementAttribute &ElemAttr,  float &Value )
  80. {
  81. if( const char *Attribute=ElemAttr.GetValue() )
  82.  ExtractFloat( Attribute, Value );
  84. return Value;
  85. }
  87. double operator >> ( const XmlElementAttribute &ElemAttr, double &Value )
  88. {
  89. if( const char *Attribute=ElemAttr.GetValue() )
  90.  ExtractDouble( Attribute, Value );
  92. return Value;
  93. }
  95. bool operator >> ( const XmlElementAttribute &ElemAttr, bool &Value )
  96. {
  97. const char *TrueStrings[]={ "true", "valid", "enable", "enabled" };
  98. const char *FalseStrings[]={ "false", "invalid", "disable", "disabled" };
  100. if( const char *Attribute=ElemAttr.GetValue() )
  101. {
  102.  for( size_t i=0 ; i < size(TrueStrings) ; ++i )
  103.   if( !stricmp(TrueStrings[i],Attribute) )
  104.    return Value=true;
  106.  for( size_t i=0 ; i < size(FalseStrings) ; ++i )
  107.   if( !strcmpi(FalseStrings[i],Attribute) )
  108.    return Value=false;
  110.  int iValue;
  111.  if( ExtractInt( Attribute, iValue ) )
  112.   return Value=(iValue!=0);
  113. }
  115. return Value;
  116. }
  118. //////////////////////////////////////////////////////////////////////////////
  119. //////////////////////////////////////////////////////////////////////////////
  121. const char * operator << ( const XmlElementAttribute &ElemAttr, const char *Value  )
  122. {
  123. if( ElemAttr.Element )
  124.  ElemAttr.Element->SetAttribute(ElemAttr.Attribute,Value);
  126. return Value;
  127. }
  129. int operator << ( const XmlElementAttribute &ElemAttr, int Value  )
  130. {
  131. if( ElemAttr.Element )
  132.  ElemAttr.Element->SetAttribute( ElemAttr.Attribute, Value );
  134. return Value;
  135. }
  137. double operator << ( const XmlElementAttribute &ElemAttr, double Value  )
  138. {
  139. if( ElemAttr.Element )
  140.  ElemAttr.Element->SetDoubleAttribute( ElemAttr.Attribute, Value );
  142. return Value;
  143. }
  145. bool operator << ( const XmlElementAttribute &ElemAttr, bool Value  )
  146. {
  147. if( ElemAttr.Element )
  148.  ElemAttr.Element->SetAttribute( ElemAttr.Attribute, Value ? "true" : "false" );
  150. return Value;
  151. }


 
bon oki, const char*, strcmpi, sscanf, const char * blog[] ça pue du bec, mais c'était un essai.
des remarques ?
y'a moyen de simplifier ?
c'est de la mairde ça sert à rien ?
j'ai que du temps à perdre ?
sapu c pas libre ? (en fait si)


Message édité par bjone le 02-05-2005 à 23:52:15
Reply

Marsh Posté le 03-05-2005 à 11:02:58    

diantre c'est si pourri que ça ?

Reply

Sujets relatifs:

Leave a Replay

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