Decomposer une chaine de caractere

Version imprimable

22/01/2009, 14h35
cortex59

Decomposer une chaine de caractere

bonjour,

j'ai une variable valeur qui contient : ON/OFF/DEF

et je voudrais le code qui me permet de recuperer
ON dans val1
OFF dans val2
DEF dans val3

merci
22/01/2009, 15h02
Biosox

Hello,

ça m'étonnerai que quelqu'un te donne le code tout fait...
je vais donc plutot t'orienter vers une solution

D'abord, de quel type est ta variable valeur?

si c'est un std::string, alors je te propose de regarder la fonction find pour trouver les indices des /.
Ensuite, la fonction substr pourra t'aider

si c'est un char*, tu devrai plutot poser la question dans le forum C

bon courage!
22/01/2009, 15h06
3DArchi

Boost.Tokenizer?
22/01/2009, 15h26
cortex59

Bon pas de chance c'es un char*

le tokenizer : j'ai rien compris
le find je trouve pas ce que je dois mettre en parametres

il n'y a pas un truc avec des strcpy, ou right....?

merci

Citation:

Envoyé par cortex59

Bon pas de chance c'es un char*

le tokenizer : j'ai rien compris

Pourtant, c'est tout écrit (tu peux aussi voir ici) :

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
 
#include <boost/tokenizer.hpp>
#include <string>
 
void split( const std::string & Msg, const std::string & Separators )
{
    // typedef pour alléger l'écriture
    typedef boost::tokenizer<boost::char_separator<char> > my_tok;
 
    // séparateur personnalisé
    boost::char_separator<char> sep( Separators.c_str() );
 
    // construire le tokenizer personnalisé
    my_tok tok( Msg, sep );
 
    // itérer la séquence de tokens
    for ( my_tok::const_iterator i = tok.begin();
          i != tok.end();
          ++i )
    {
        // afficher chaque token extrait
        std::cout << *i << '\n';
    }
}
// puis quelque part : 
  split("ON/OFF/DEF","/");

Citation:

Envoyé par cortex59

il n'y a pas un truc avec des strcpy, ou right....?

merci

Tutoriels?

22/01/2009, 16h05
Biosox

tu peux aussi convertir ton char* en string... ensuite:

en gros, le find il te permet de trouver l'indice du caractère que tu cherches
si tu as:
string maString = "bonjour";
alors:
maString.find('b') retourne 0 (b est à la position 0 dans "bonjour")
maString.find('o') retourne 1
maString.find('n') retourne 2

mais si tu cherches le 2eme 'o'... alors tu peux faire:
maString.find('o',3) (il va chercher un 'o' a partir du 3eme caractère... donc il ne vas pas tomber sur le premier)

et substr c'est simple:
string maSub = maString.substr(2,3); //maSub = "njo"... je te laisse deviner pourquoi

la tu devrais t'en sortir...
22/01/2009, 16h50
cortex59

le probleme c que je ne sais pas combien de "/" a dans ma chaine
et que je veu mettre les champs dans des variables differentes

merci

J'insiste avec mon boost :mrgreen:

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
 
template<class TConteneur>
void split( const std::string & Msg, const std::string & Separators, TConteneur&Conteneur )
{
    // typedef pour alléger l'écriture
    typedef boost::tokenizer<boost::char_separator<char> > my_tok;
 
    // séparateur personnalisé
    boost::char_separator<char> sep( Separators.c_str() );
 
    // construire le tokenizer personnalisé
    my_tok tok( Msg, sep );
 
    // inserter : 
    std::back_insert_iterator<TConteneur> it_insertion(Conteneur);
 
    // itérer la séquence de tokens
    for ( my_tok::const_iterator i = tok.begin();
          i != tok.end();
          ++i )
    {
        // afficher chaque token extrait
       *it_insertion = *i;
       ++it_insertion;
    }
}
 int main()
{
// puis quelque part : 
   std::vector<std::string> vect_str;
  split("ON/OFF/DEF/1/2/3","/",vect_str);
 
  std::copy(
     vect_str.begin(),
     vect_str.end(),
     std::ostream_iterator<std::string>(std::cout,"\n")
     );
 
    return 0;
}

Oui, enfin plus de quinze lignes de code pour une opération aussi basique que la tokenization d'une chaine avec des choses comme boost::tokenizer<boost::char_separator<char> >, std::back_insert_iterator<TConteneur> + boucles d'itérateurs... ça ne coule pas de source quand même.

Heureusement boost::split et boost::split_regex est bien plus simple d'emploi.
Code:

1 2 3 4 5 6 7 8 std::vector<std::string> result; std::string s = "ON/OFF/DEL"; boost::split(s, result, is_any_of("/")); std::vector<std::string> result2; std::string s2 = "ON////OFF//DEL"; boost::split_regex(s2, result2, boost::regex("/+"));
Edit : En c++ standard, il faut se palucher la tokenization à la main à base de string::find + string::substr.

Citation:

Envoyé par cortex59

Bon pas de chance c'es un char*

le tokenizer : j'ai rien compris
le find je trouve pas ce que je dois mettre en parametres

il n'y a pas un truc avec des strcpy, ou right....?

merci

Comma ça, très vite
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 void foo(char *text) { std::vector<char *> pf; char *p1=text; char *pend=p1+strlen(text); while (p1<=pend) { pf.push_back(p1); //find next tab while (*p1!='/' && *p1!='\0') ++p1; *p1='\0'; //move beyond next tab ++p1; } //utiliser pf }
A toi de parfaire pour que se soit plus "propre" et en utilisant des std::string.

Ou alors tu fais comme les autres te le proposent, tu utilises un canon pour tuer une mouche... ;)

soit avec substr, mais personne n'a parlé de getline avant de sortir boost?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#include <string>
#include <sstream>
#include <iostream>
 
int main()
{
    std::string v = "a/b/c";
    std::istringstream iss( v );
 
    std::string v1;
    std::getline( iss, v1, '/' );
 
    std::string v2;
    std::getline( iss, v2, '/' );
 
    std::string v3;
    std::getline( iss, v3, '/' );
 
    std::cout << v1 << " " << v2 << " " << v3 << std::endl;
 
    return 0;
}

A mon tour d'insister. :D
Sans boost, la solution la plus élégante passe par string::find et string::substr
Code:

1 2 3 4 5 6 7 8 9 10 11 void foo(const std::string& s, char token, std::vector<std::string>& result) { std::string::size_type first = 0, last; while (first != std::string::npos) { last = s.find_first_of(token, first); result.push_back(s.substr(first, last - first)); first = s.find_first_not_of(token, last); } }
Camboui, ton code m'a l'air un peu violent non ? La chaine de départ est complètement bousillée en sortant de la fonction. :mrgreen:

23/01/2009, 21h14
camboui

C'était pas précisé dans le cahier des charges, alors j'ose :yaisse2:
Et puis je savais bien que tous les autres répondants allaient proposer un code banal, quelconque, académique. Alors j'ai proposé un code qui n'est pas une solution toute faite, mais qui demande réflexion :king: