Discussion :

[dj.motte]

Bonsoir,

Pour revenir à la traduction maj min d' un chaîne .

Vu que char_lower ne fait a priori rien d'autre qu'appeler tolower, pourquoi ne pas écrire plus simplement :
Code:
transform( z.begin(), z.end(), z.begin(), tolower ) ;

cette syntaxe de transform ne fonctionne pas sur mon ordinateur. Ca ne tourne que si j' enveloppe tolower dans une
autre fonction

Code :

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

1
2
3
4
5
6
7
 
 
int char_lower( int c )
{ 
  return tolower(c)  ;
}
transform( z.begin(), z.end(), z.begin(), char_lower ) ;

Dans ce second cas c'est ok.
Pourquoi l' utilisation directe de "tolower" provoque une erreur à la complilation alors que son prototype est identique à "char_lower" ?

Cordialement.

[Laurent Gomila]

Quelle erreur obtiens-tu ?

[dj.motte]

Boujour

Le messge d' erreur est

no matching function for call to `transform(__gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, <unknown type>)'

il semble que "tolower" soit "<unknown type>" ?

Et si "tolower" "toupper" étaient des macros pas des fonctions ? Cela m' étonnerait .

Cordialement.

[Luc Hermitte]

Peut-être (je pose la question sans connaitre la réponse) parce qu'il existe plusieurs fonctions de ce nom, et que donc il ne sait laquelle choisir ? Ceci dit, je me serait plutôt attendu à un autre message d'erreur.

[dj.motte]

Bonsoir,

Ancien code

Code :

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

1
2
 
transform( z.begin(), z.end(), z.begin(),  tolower ) ;  raté

Nouveau code

Code :

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

1
2
 
transform( z.begin(), z.end(), z.begin(),  ::tolower ) ;  ok

Par contre il y a problème lors de l' appel d' une fonction membre dans une classe, pour faire la conversion maj min .

Cordialement.

[dj.motte]

Bonsoir

( Linux )

Soit la classe :

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
 
class Doc 
{ private :
  protected :
  public :
  Doc( param etc... ) ;
  void  Nx() {  placebo }
  void str_upper( char&  c )
  { c =  toupper(c) ; }
 
  int upr_str( int c )
  { return toupper(c) ; }
 
  template < class T >
  class str_upr : public unary_function<char, void>
  { public :
    void operator() (char& x) { x = ::toupper(x)  ; }
  };
 
  void strupper( string & s )
  {
    //for( size_t i = 0 ; i < s.length() ; i++ )
    //s[i] = toupper( s[i] ) ;  ok forme naïve
 
    //transform( s.begin(), s.end(), s.begin(), ::toupper ) ; ok
    //transform( s.begin(), s.end(), s.begin(), upr_str ) ;  ok
 
    void (Doc::*F)(int&)  ;
    F = &Doc::str_upper ; ok
    for_each( s.begin(), s.end(), F ) ;  raté
 
    //for_each( s.begin(), s.end(), str_upr<char>() ) ; ok
  }
};

cette forme ne compile pas

for_each( s.begin(), s.end(), F ) ;

Parce que c' est un pointeur sur la fonction membre de "Doc".
Alors que l' on attend une fonction non pointée.

Comment appeler une fonction membre de classe pour un itérateur tel que "for_each" ?

Cordialement.

[Laurent Gomila]

Ce serait quelque chose de ce goût là :

Code :

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

for_each( s.begin(), s.end(), bind1st(mem_fun1(&Doc::str_upper), this)) ;

Mais ça ne compile pas à cause du paramètre de str_upper qui est une référence. A mon avis seul transform est utilisable dans ce cas. Peut-être que aussi regarder du côté de boost::bind ?

[dj.motte]

Bonjour,

Ce serait quelque chose de ce goût là :

for_each( s.begin(), s.end(), bind1st(mem_fun1(&Doc::str_upper), this)) ;

Ca ne veut toujours pas compiler.
Au passge ce serait pas plutôt mem_fun à la place de mem_fun1.

Cordialement

[Laurent Gomila]

Oui, j'avais prévenu que ça ne compilait pas (problème de référence sur référence).

C'est bien mem_fun1 pour les fonctions membres à un argument, mem_fun c'est la même chose mais sans paramètre.

[philippe V]

moi je ferait simplement

Code :

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

1
2
3
4
5
 
std::string str="bonjour  a tous  mes  amis";
int i;
for(i=0;str[i];i++)
    str[i]=toupper(str[i]);

[Luc Hermitte]

Marchera pas.
Le 0 terminal n'est pas garanti dans les std::string.

[Laurent Gomila]

Et std::transform est là pour t'éviter ce genre de boucle.

[philippe V]

bient enfait tout depend de la string que tu passe et que tu retourne

Code :

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

1
2
 
std::string str="boujour a tout mes amie"

ici std string sais tres bien comment gerer la string il ajoutera tout seul le \0 a la fin

prenom la fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
std::string strToUpper(std::string str)
{
         std::string sss;
         sss.resize(str.length());
         int i;
         for(i=0;str[i];i++)
              sss[i]=toupper(str[i]);
 
        return sss;
}

il y a effectivement un danger

parcontre

Code :

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

1
2
3
4
5
6
 
void strToUpper(std::string str)
{
         int i;
         for(i=0;str[i] && str[i]!=' ';i++)
	str[i]=toupper(str[i]);

ici les caracteres avant le 1er espace seront mis en majuscule et l'integraliter de la string ne sera pas compromie

[Laurent Gomila]

std::string connait sa taille, elle n'a donc pas besoin d'un \0 final. La norme est explicite à ce sujet : seul string::c_str() garantit d'avoir une chaîne terminée par un \0.

[philippe V]

std::string connait sa taille, elle n'a donc pas besoin d'un \0 final.

merci pour la presision

[dj.motte]

Bonsoir

Je crois que je vais renoncer au

Code :

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

1
2
 
for_each( s.begin(), s.end(), ... )

Cordialement.