stl algo replace

Version imprimable

04/01/2008, 21h25
dj.motte

stl algo replace
Salut,

Je ne comprends pas bien.
Code:

1 2 3 int a [5] = { 2,2,7,9,0} ; replace( a, a+5, 2, -1) ; // bon ?
Mais
Code:

1 2 3 string z( "Un chat qui mange un chat") ; replace( z.begin(), z.end(), "chat", "chien") ; // là pas bon
Pourtant il me semble bien que l'opérateur == existe bien pour les std::string ?

Je sais qu'il existe une méthode "replace" pour les "string", mais je pensais que l'algo "replace" pouvait en faire autant.

D'où vient l'erreur ?
04/01/2008, 21h42
yan
Citation:
Envoyé par dj.motte

Code:

1 2 3 string z( "Un chat qui mange un chat") ; replace( z.begin(), z.end(), "chat", "chien") ; // là pas bon
Cela ne doit pas compiler non?
ici tu parcoure les caractères pas les mots. Donc cela ne marchera pas

Citation:

Envoyé par dj.motte

Je sais qu'il existe une méthode "replace" pour les "string", mais je pensais que l'algo "replace" pouvait en faire autant.

Je ne connait pas mais si il y as ce que tu veut tu n'as pas trop le choix. Peut etre avec boost.tokenizer
tu peut faire cel
04/01/2008, 23h21
dj.motte

stl algo replace

salut,

Citation:

Je ne connait pas mais si il y as ce que tu veut tu n'as pas trop le choix. Peut etre avec boost.tokenizer
tu peut faire cel

Bon on ne va pas ressortir "boost" dès la moindre question ?

En l'occurrence je ne vois pas bien la réponse.
Il y a un truc qui cloche comme sous mon nez, mais je ne vois pas ...
04/01/2008, 23h36
JolyLoic
Une string est un conteneur de char. std::replace un élément d'un conteneur par un autre. Donc ce qui pourrait marcher pour une string serait :
Code:

1 2 string z( "Un chat qui mange un chat") ; replace( z.begin(), z.end(), 'c', 'C') ;
Autrement, au sujet de boost, il y a justement plein d'algorithmes adaptés aux chaînes, dans boost::string_algo :ccool:.
04/01/2008, 23h39
koala01

Salut,

Il y a de fortes chances pour que dans le comportement replace de la std::string (s'il existe, mais je te fais confiance ;) :D), le remplacement soit fait sur base des fonctions C de gestion de chaines, telles que strcmp et autres joyeusetés du genre.

Il ne faut pas oublier le fait que la std::string englobe toute une gestion de "tableau de caractères", et que c'est peut etre là que le bât blesse ;)

L'algorithme std::replace quant à lui a de grandes chances d'être prévu pour permettre le remplacement... d'objets ;)

Si donc tu as un comportement replace() pour la std::string, il est fortement préférable de l'utiliser de préférence à tout autre si tu en as besoin ;)
04/01/2008, 23h54
dj.motte

stl algo replace

Salut,

Citation:

Une string est un conteneur de char. std::replace un élément d'un conteneur par un autre. Donc ce qui pourrait marcher pour une string serait :

Code :

string z( "Un chat qui mange un chat") ;
replace( z.begin(), z.end(), 'c', 'C') ;

Ben oui, cela ne fonctionne que pour un caractère et non pas pour une chaîne de caractères.

Merci à tous ...
05/01/2008, 11h07
yan

Citation:

Envoyé par dj.motte

Bon on ne va pas ressortir "boost" dès la moindre question ?

lol
C'est le problème, il y as des choses que l'on trouve dans les autre langage et non dans le C++. BOOST en comble une bonne partie :mouarf:.

Vu que tu n'aime pas boost voici une solution avec la STL :

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
 
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <iterator>
 
 
struct chatchien
    {
    std::string operator() (const std::string & ss) {return ss == "chat" ? "chien" :ss;};
    } ;
 
int main(int argc,char ** argv)
    {
 
   std::istringstream is ("Un chat qui mange un chat");
   std::stringstream ios ;
 
    //parcoure le flux mot à mot et applique le foncteur chatchien. Stocke le resultat dans un autre flux en ajoutant un espace aprés chaque mot
    std::transform(std::istream_iterator<std::string>(is) ,std::istream_iterator<std::string>()
        ,std::ostream_iterator<std::string>(ios," "),chatchien() );
 
    std::string result;
 
    //récupère la phrase dans le flux il y aura un espace en trop la fin.
    std::getline(ios,result);
    std::cout<<result<<std::endl;
 
    return 0;
}

Salut,

Merçi Mongaulois pour la solution sans boost ... Bof un peu compliqué. Ce n'est pas que je n'aime pas boost, mais j'évite d'y avoir recours pour un oui ou un non.

J'avais trouvé une solution sans doute pas assez compliquée...

Code:

1
2
3
4
5
6
7
8
 
void replace_words( string& z, const string& ow, const string& nw )
{   size_t p = 0 ;
    while( string::npos != (p = z.find(ow,p)) )
    {
       z.replace(p,ow.length(), nw ) ;
    }
}

Par contre j'ai du faire un code affreux pour que cette fonction soit sensible à la casse, une sorte de C++ bidouillé :

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
 
size_t  case_find( size_t pos , const string&  z , const string& sub, bool exact  )
{
      typedef int (*fcmp)( const char *, const char *, size_t ) ;
      fcmp C = ( exact  ==  true  ) ?  ::strncmp :   ::strncasecmp ;
 
     if( sub.length()  < z.length()  &&   pos <  z.length() - sub.length()  )  ;
     {
          while( z[ pos ] )
         {
             if( ! C( &z[ pos ], &sub[0], sub.length()  ) ) return pos ;
             pos++ ;
         }
     }
     return string::npos  ;
}
 
void replace_words( string& z, const string& ow, const string& nw, bool ex )
{   size_t p = 0 ;
    while( string::npos != (p = case_find( p , z,  ow, ex )) )
    {
       z.replace(p,ow.length(), nw ) ;
    }
}

Pas terrible, mais je ne vois pas comment faire autrement... Mais si avec boost !

Citation:

Envoyé par dj.motte

Merçi Mongaulois pour la solution sans boost ... Bof un peu compliqué. Ce n'est pas que je n'aime pas boost, mais j'évite d'y avoir recours pour un oui ou un non.

C'est une solution parmi d'autre. Mais cela ne doit pas etre la meilleur..
Par conntre pour ne pas etre sensible a la case je fait un truc comme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 struct upperchar { char operator() (const char & c) { return toupper(c);} } struct chatchien { std::string operator() (const std::string & ss) { std::string tmp; std::tranform(ss.begin(),ss.end(),std::back_inserter(tmp),upperchar()) return tmp == "CHAT" ? "chien" : ss; }; } ;
Citation:

Envoyé par dj.motte

Pas terrible, mais je ne vois pas comment faire autrement... Mais si avec boost !

lol y as des chance :king:

05/01/2008, 21h05
dj.motte

Salut,

Non c'est le contraire je voulais que la fonction soit sensible à la casse et bien entendu extensible à d'autres choses que chat et chien ...
05/01/2008, 21h24
yan

Citation:

Envoyé par dj.motte

Salut,

Non c'est le contraire je voulais que la fonction soit sensible à la casse et bien entendu extensible à d'autres choses que chat et chien ...

j'avais pas compris dsl. Compliqué ton code alors, en effet.
une comparaison de string est sensible a la case,non???

En tous cas, dans le code que j'ai fait, si tu met une majuscule a chat ca ne change pas ce mot. C'est donc bien sensible a la casse

Si tu veut comprendre mon code regarde ce tuto
http://r0d.developpez.com/articles/algos-stl/
et demande ce que tu ne comprend pas ;)
05/01/2008, 21h54
dj.motte

Salut,

En Anglais "case sensitive" en Français sensible à la casse veut dire que l'on tient compte de la différence entre majuscules et minuscules. Au cas où on ne veut pas fait cette distinction on dit insensible à la casse.

Où alors il faut j'aille voir un psychiatre !
05/01/2008, 22h08
yan

Citation:

Envoyé par dj.motte

Salut,

En Anglais "case sensitive" en Français sensible à la casse veut dire que l'on tient compte de la différence entre majuscules et minuscules. Au cas où on ne veut pas fait cette distinction on dit insensible à la casse.

Où alors il faut j'aille voir un psychiatre !

euh...
alors là,
soit j'ai rien compris a ce que tu veut soit t'as pas compris ce que j'ai fait.

Le premier code est case sensitive (différence entre majuscules et minuscules) et le second ou je compare avec le mot en majuscule ne l'est plus.
La comparaison de std::string est case sensitive.
Et toi tu veut faire du "case sensitive" donc ce que j'avais fait
06/01/2008, 18h23
dj.motte
Salut,

Désolé j'ai fait une erreur. Dans ma deuxième solution je voulais dire une méthode qui tient compte non pas de la casse ou pas, mais du choix de la casse.
Code:

1 2 void replace_words( string& z, const string& oldw, const string& neww, bool exact ) ;
Ainsi quand "bool exact" ( choix de la casse) est à "true" on tient compte de la casse, pas dans le cas contraire "false".
06/01/2008, 20h23
yan

ok ok