définition d'une classe de Trait & problème de "stringstream"

Version imprimable

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:

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:

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

Bonjour,

Je ne suis pas sûr que le char_traits intervienne dans la sortie d’un nombre (je vois pas à quoi pourraient servir les fonctions qu’il y a dans un char_traits pour ça, mais peut-être que je me trompe).

Pour préciser le problème, quel est l’état d’erreur du flux avant et après la sortie du nombre :
Code:

1 2 3 4 5 6 xstringstream str; str << "Coucou - pi = "; std::cout << std::boolalpha << "before : " << str.fail() << '\n'; str << 3.14; std::cout << "after : " << str.fail() << '\n' << std::noboolalpha; std::cout << str.str() << std::endl;
Il serait tout à fait normal que la sortie du nombre échoue si le flux est en erreur avant (je vois pas pourquoi ça serait le cas, mais ça coûte rien de vérifier).

Salut,

JCout n'est jamais qu'une variable globale de type... basic_ostream<CharT, Traits> spécialisée pour... charT = char (et donc Traits = char_traits<char>, alors que cin est une variable globale de ... basic_istream, selon la même spécialisation...

Il en va de même pour wcout (respectivement wcin), mais avec une spécialisation basée sur wchar_t.

En y mettant toutes les précautions dues à mon incertitude, tu devrais donc envisager de... créer une variable qui utilise ton char_traits particulier, tant pour la sortie que pour l'entrée :aie:

Comme il s'agit d'une variable, et non d'un type, tu devrais donc rajouter à tes typedefs:

Code:

1 2 std::basic_ostream <char, xstring_traits<char> > xcout; std::basic_istream <char, xstring_traits<char> > xcin;

et donc utiliser xcout (respectivement xcin) à la place de cout (respectivement cin) pour tes entrées/sorties standards :P

Je testerai dés que j'aurai un peu le temps, mais je suis quasiment sur de mon fait ;)

EDIT : vérification faite, il "suffit" de déclarer explictement la spécialisation du basic_ostream (respectivement basic_istream):
Code:

1 2 3 4 5 6 7 8 9 10 11 extern template class std::basic_ostream<char,xstring_traits<char> >; extern template class std::basic_istream<char,xstring_traits<char> >; int main() { xstring str("Coucou"); float pi=3.1415; std::cout<<str<<pi<<std::boolalpha<<(str=="coucou")<<std::endl; std::cout<<"veuillez introduire \"coucou\" EN MINUSCULE pour le test :"; std::cin>>str; std::cout<<std::boolalpha<<(str=="COUCOU")<<std::endl; }