Discussion :

[econte]

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

[nowahn]

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 C++ :

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

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).

[koala01]

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

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

Code :

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

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

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 :

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

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;
}