Bonjour,

Suite à un exemple trouvé sur le web, j'ai défini un nouveau type de variable appelé 'xstring' qui est identique aux 'std::strings' à l'exception d'être insensible à la casse. Dans ce but, j'ai hérité une classe 'xstring_trait' de la classe 'std::char_traits'. Voilà le code correspondant au fichier header de la classe 'xstring'.


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
 
template <class T>
   class xstring_traits
      : public std::char_traits<T>
   {
   public:
 
   typedef T char_type;
 
      static int compare (const char_type *Str1, const char_type *Str2, 
                          size_t Num)
      {
         for (size_t i = 0; i < Num; ++i)
            if (!eq (*(Str1 + i), *(Str2 + i)))
               return lt (*(Str1 + i), *(Str2 + i))? -1 : 1;
         return 0;
      }
      static bool eq(const char_type &Ch1, const char_type &Ch2)
      {
         const std::locale & loc = std::locale ("");
         return std::toupper (Ch1, loc) == std::toupper (Ch2, loc);
      }
 
      static bool ne(const char_type &Ch1, const char_type &Ch2)
      {
         const std::locale & loc = std::locale ("");
         return std::toupper (Ch1, loc) != std::toupper (Ch2, loc);
      }
 
      static bool lt(const char_type &Ch1, const char_type &Ch2)
      {
         const std::locale & loc = std::locale ("");
         return std::toupper (Ch1, loc) < std::toupper (Ch2, loc);
      }
   };
 
 
template <class T>
   std::basic_ostream<T> & operator << (std::basic_ostream<T> &os, const std::basic_string <T, xstring_traits<T> > &s)
   {
      return os << std::basic_string<T> (s.begin (), s.end ());
   }
 
template <class T>
   std::basic_istream<T> & operator >> (std::basic_istream<T> &is, std::basic_string <T, xstring_traits<T> > &s)
   {
      std::basic_string<T> _s;
      is >> _s;
      s = std::basic_string <T, xstring_traits<T> > (_s.begin (), _s.end ());
      return is;
   }
 
template <class T>
std::basic_istream<T> & getline (std::basic_istream<T> &is, std::basic_string <T, xstring_traits<T> > &s)
   {
      std::basic_string<T> _s;
      std::getline (is, _s);
      s = std::basic_string <T, xstring_traits<T> > (_s.begin (), _s.end ());
      return is;
   }
 
template <class T>
std::basic_istream<T> & getline (std::basic_istream<T> &is, std::basic_string <T, xstring_traits<T> > &s, char delim)
   {
      std::basic_string<T> _s;
      std::getline (is, _s, delim);
      s = std::basic_string <T, xstring_traits<T> > (_s.begin (), _s.end ());
      return is;
   }
 
 
typedef std::basic_string        <char, xstring_traits<char> > xstring;
typedef std::basic_stringstream  <char, xstring_traits<char> > xstringstream;
typedef std::basic_istringstream <char, xstring_traits<char> > xistringstream;
typedef std::basic_ostringstream <char, xstring_traits<char> > xostringstream;
Les 'xstring' semblent marcher correctement. En revanche, j'ai aussi besoin d'une variable de type std::stringstream pour faire des conversions double, int, ... en 'xstring'. Le stringstream utilisant la nouvelle classe de Traits est baptisé 'xstringstream'. Et là, les conversions ne semblent pas marcher :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
 
xstringstream str;
str << "Coucou - pi = " << 3.14;
std::cout << str.str() << std::endl;
Il m'affiche "Coucou" mais rien pour la valeur de pi.
Auriez vous des idées me permettant d'avancer sur le problème ?

Merci d'avance