[Boost.Tokenizer] Utiliser le caractère de séparation NULL

Version imprimable

Bonjour,

Durant mon projet, j'aurais besoin de séparer une multistring (tableau de char, instauré par Microsoft, représentant plusieurs chaînes de caractères séparées par un caractère NULL, selon : "String1\0String2\0String3\00" [deux caractères NULL finaux]) en plusieurs strings. J'ai donc pensé à boost::tokenizer, mais en faisant le test suivant :
Code:

1 2 3 4 5 6 7 //#define MAX_PATH 260 char temp[MAX_PATH] = "YOUHOU;\0SALUT\0TOP"; boost::tokenizer<boost::char_separator<char> > tok(std::string(temp), boost::char_separator<char>("\0")); for (boost::tokenizer<boost::char_separator<char> >::const_iterator i = tok.begin(); i != tok.end(); ++i ) MessageBox(hwnd, i->c_str(), "Test", MB_ICONINFORMATION);
Je n'ai que la première string, ce qui paraît logique du fait que le caractère NULL finit en principe les strings.

Seulement voilà, je dois faire cette séparation, et j'aimerais vraiment utiliser Boost.Tokenizer pour cela (j'aurais aussi l'alternative STL avec des istream_iterator<>, mais je risque d'avoir le même problème) ; par conséquent, sauriez-vous comment remédier à ce problème (une astuce quelconque) ?

Merci d'avance.

Salut,

Et pourquoi n'utiliserais tu, tout simplement, pas un simple vecteur de chaines tant que tu n'a pas réellement besoin du multistring :question:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 std::vector<std::string> tab; tab.push_back("chaine 1"); tab.push_back("chaine 2"); /*....*/ et une fonction qui irait bien avec: std::string AllInOne( const std::vector<std::string>& tab) { std::string ret="" for(size_t i=0;i<tab.size();i++) { ret+=tab[i]; /*éventuellement */ if(i!=tab.size()-1) ret+="caractere de separation"; } return ret; }
D'un autre coté, si le but est de séparer une chaine en plusieurs selon un séparateur donné, rien ne t'oblige à utiliser une multistring...

27/07/2007, 23h39
kidpaddle2

Citation:

rien ne t'oblige à utiliser une multistring...

Si, l'API Windows elle-même... GetOpenFileName() permet d'afficher une boîte de dialogue de sélection de fichiers à ouvrir, dont les chemins constituent au retour la multi-string.

Aucun moyen ?
29/07/2007, 16h52
kidpaddle2

Up

Mais, alors, et ce n'est finalement qu'une question (étant pour le moins allergique à l'API windows...), es-tu sur qu'il n'existe aucune méthode dans la multistring qui permette d'obtenir les chaines de manière séparées :question:

Il me semblerait quelque peu idiot, meme venant de microsoft, qu'ils n'aient pas prévu un moyen pour le faire...

Je ne sais pas, moi, peut etre, tout simplement l'opérateur [] :question:

Cela *pourrait* donner un truc du genre de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 /* considérons que ms soit une variable de type multistring ;) */ std::string s1=ms[0]; std::string s2=ms[1]; /*...*/ /* Voir, peut etre encore mieux: récupérer simplement les chaines dans un * tableau (en adaptant à la fonction qui permet de récupérer le nombre de * chaines dans la multistring (j'ai mis ici size(), mais c'est peut etre autre * chose ;) ) ) */ std::vector<std::string> tab; for(size_t i=0;i<ms.size();i++) { tab.push_back(ms[i]); }
La =>doc msdn<= semble parler d'une fonction qui devrait déjà te permettre d'avancer un peu: ToString ;)

A partir de là, tu devrais pouvoir envisager de travailler plus sereinement ;)

29/07/2007, 21h35
kidpaddle2

Ils fournissent le format, à nous de coder une fonction (ou alors je ne connais pas celle fournie) permettant d'extraire les chaines.

J'en ai une pareille, en C, mais j'aurais aimé simplifier au maxi le code source en introduisant le plus possible de concepts apportés par Boost (ou la STL, GLib etc.). Après, si ce n'est pas possible, tant pis, mais j'aurais aimé...

Ce que je voulais dire, c'est que d'après la msdn, il y a une méthode ToString qui permet de transformer ta multistring en String...

Pour autant que la classe String soit compatible avec la std::string, voire, même plutôt avec la std::istringstream, tu pourrais envisager de travailler sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 std::istringstream iss(GetOpenFileName().ToString()); /* ne reste plus qu'à gérer cette chaine en utilisant le back slach comme * séparateur... Pour la facilité, autant les placer tous dans un tableau ;) */ std::vector<std::string> tab; std::string str; while (std::getline(iss,str,'\\')) tab.push_back(str); /* récupération du lecteur logique */ std::cout<<"le lecteur logique est "<<tab[0]<<std::endl; /* la liste des sous dossiers for(size_t i=1;i<tab.size()-1;i++) std::cout<<" sous dossier "<<i<<" :"<<tab[i]<<std::endl; std::cout<<" nom du fichier :"<<tab[tab.size()-1]<<std::endl;
Toute la difficulté étant d'être sur du fait que ToString renvoie quelque chose qui soit compatible avec la std::string, ou, au pire, avec la std::wstring :P

30/07/2007, 10h42
kidpaddle2

Le problème, c'est que je ne travaille pas en MFC (j'ai omis de le dire). J'ai donc juste la fonction BOOL GetOpenFileName(LPOPENFILENAME), et c'est tout. Donc à part si il y a effectivement une autre fonction pour récupérer les éléments d'une multistring, j'aimerais utiliser un tokenizer pour récupérer les éléments séparés par le caractère NULL, ce que je ne peux apparemment pas, puisque -je suppose- la conversion en std::string tronque d'ores et déjà la multistring en monostring...

correction d'une coquille dans le code

Reste peut être alors la méthode "bourine"...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
size_t i=0;
std::string str;
std::vector<std::string> tab;
while(ms[i]!='\0' && ms[i+1]!='\0')
{
    str+=ms[i];
    if (ms[i]='\0')
    {
        tab.push_back(str);
        str="";
    }
    ++i;
}

31/07/2007, 15h59
Matthieu Brucher

A part la méthod ebourrine, point de salut...
La raison est simple : tokenizer prend un string en paramètre. Or lors de la transformation char* vers string, la chaîne considérée s'arrête au premier '\0', car on considère qu'on transforme une chaîne C. Dans le cas contraire, il n'y a aucun moyen de savoir quand on doit s'arrêter.
31/07/2007, 16h08
koala01

C'est bien pour cela que, avant d'envisager une méthode "bourine", j'ai essayé de savoir s'il n'y avait pas moyen d'obtenir quelque chose qui soit compatible avec les chaînes de caractères (mais en avouant bien fort mon aversion pour l'API utilisée ;):D)

Et du coup, m$ redescend de nouveau d'un cran dans mon estime...
:dehors:
31/07/2007, 16h21
Matthieu Brucher

Dans une string, il est possible d'avoir des \o, mais une fois qu'on récupère un char* ou un const char*, la chaîne est supprosée s'arrêter au premier '\0' rencontré. Donc c'est dommage de ne pas retourner la chaîne à la place du char*.
31/07/2007, 16h38
kidpaddle2

Citation:

A part la méthod ebourrine, point de salut...
La raison est simple : tokenizer prend un string en paramètre. Or lors de la transformation char* vers string, la chaîne considérée s'arrête au premier '\0', car on considère qu'on transforme une chaîne C. Dans le cas contraire, il n'y a aucun moyen de savoir quand on doit s'arrêter.

A vrai dire, je m'en doutais, mais j'espérais une sorte de style ou autre, pour me permettre cette manipulation... enfin, puisqu'il n'y a pas de solution, je clos le topic.

Merci à vous.
31/07/2007, 16h46
koala01
Note que, réflection faite, n'y aurait-il pas moyen de le transtyper brutalement:question:

Je ne sais pas, quelque chose du genre de
Code:

1 2 3 4 std::string str=static_cast<std::string&> (ms); std::istringstream iss(str); /* "plus qu'à récupérer les chaines séparées :D */
(c'est la réflextion de miles concernant les \0 qui m'a mis sur la voie ;):D)
31/07/2007, 17h49
Matthieu Brucher

Ca ne marche pas comme ça, cil y a pleins d'autres infos dans un string qui ne sont pas dans un char*. Quand on transforme un char* en string, il s'arrête au premier '\0', il n'y a rien qu'on puisse faire pour l'en empêcher. Et un cast brutal tel que celui-ci va faire soit une erreur de compilation soit un seg fault (plutôt une erreur de compilation).
31/07/2007, 20h07
kidpaddle2

Oui, c'est ça que j'aimerais faire : es-tu sûr que le cast (ou similaire) n'est pas envisageable ?

Au pire, je peux toujours (à l'aide d'une bête fonction de recherche perso, pour passer outre les caractères NULL) transformer les caractères NULL en ';' (par exemple), et les deux NULL finaux en un pour ensuite effectuer mon découpage tranquillement...
31/07/2007, 20h16
Matthieu Brucher

Citation:

Envoyé par kidpaddle2

Oui, c'est ça que j'aimerais faire : es-tu sûr que le cast (ou similaire) n'est pas envisageable ?

Certain.
31/07/2007, 22h47
kidpaddle2

Bon, je déclare donc ce topic Résolu.

Merci à vous.
27/02/2008, 15h57
k1000
Dans la classe std::basic_string (dont std::string est un typedef) on a le constructeur :

Code:

basic_string(const basic_string& __str, size_type __pos, size_type __n = npos);
- __str : chaîne
- __pos : index du premier caractère
- __n : nombre de caractères
Normalement, il supporte les multi-string. Pour récupérer la valeur, on utilise std::string::data() à la place de c_str() (c_str() donne une chaîne C terminée par '\0').
Donc on a : std::string multi_string('ma\0multi\0string\00', 0, 17);
Ensuite, on utilise boost::tokenizer avec cette string.
06/03/2008, 12h21
corrector

Citation:

Envoyé par kidpaddle2

les caractères NULL

Petite correction : les caractères NUL, par opposition aux "null pointers" = pointeurs nuls, et à la macro NULL.
06/03/2008, 12h22
corrector

Citation:

Envoyé par k1000

std::string multi_string('ma\0multi\0string\00', 0, 17);

Cette syntaxe n'a aucun sens.
06/03/2008, 12h31
corrector
Citation:

Envoyé par koala01

Code:

std::string str=static_cast<std::string&> (ms);

Un tel cast suppose que ms est
- soit d'un type dérivant de std::string
- soit d'un type définissant une conversion implicite vers std::string&, c'est à dire : operator std::string& ()
auxquels cas on peut faire directement :

Code:

std::string str = ms;

Insérer des casts au hasard n'est jamais une solution!
20/03/2008, 21h09
k1000

Citation:

Envoyé par corrector

Cette syntaxe n'a aucun sens.

Je pensais par là à une déclaration utilisant le contructeur, c-à-d :
std::string multi_string = std::string('ma\0multi\0string\0\0', 0, 17);
21/03/2008, 15h40
corrector
Citation:

Envoyé par k1000

Je pensais par là à une déclaration utilisant le contructeur, c-à-d :
std::string multi_string = std::string('ma\0multi\0string\0\0', 0, 17);

Je vois que tu as corrigé un oubli : as ajouté un \.

Il reste qu'en C++ le simple quote indique un littéral caractère (ou littéral multi-caractères) et le double quote une chaine littérale.

Enfin, écrire explicitement le nombre 17 n'est pas génial : il suppose qu'on sache compter, hors il arrive que les programmeurs se trompent en comptant (ça arrive même très souvent : "buffer overflow"). On préfère donc laisser le compilateur compter :
Code:

1 2 static const char init_string[ /*au compilateur de compter*/ ] = "ma\0multi\0string\0"; std::string multi_string (init_string, 0, sizeof init_string); // initialisation directe, pas de copie