Discussion :

[Daïmanu]

Bonjour.

J'écris un petit convertisseur en ligne de commandes qui prend comme paramètre une concaténation de nombre et d'unités, du genre "3.1415㎭" ou "88mph" (sans espaces, sinon ce serait 2 arguments et non un seul).
J'aimerai les séparer en 2 variables (de type double et std::string).

Tous les codes sur le nets demandent un séparateur, mais il n'y en a pas ici.

Voila ce que j'ai écrit, mais qui me m'affiche 2 tokens quand je lui demande de me donner l'unité (un vide, et l'autre correct).

Code :

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

1
2
3
4
5
6
7
8
 
boost::regex number("\\d+[\\.,]?\\d*");
std::string arg( argv[1] );
boost::sregex_token_iterator tokens(arg.begin(), arg.end(), number, -1);
    //0 devrait séléctionner le nombre, et -1 l'unité
boost::sregex_token_iterator regend;
    for (; tokens != regend; ++tokens)
        std::cout << *tokens << std::endl;

Comment arriver à les séparer correctement et sans séparateur ?
Merci d'avance.

[Arzar]

Bonjour,

Dès fois, je me demande si l'utilisation de regex ne complique pas plus le sujet qu'autre chose , mais bref

En fait, il y a une petite incompréhension sur la manière dont les submatch (0, -1 ...) influe sur le résultat de sregex_token_iterator.

Par défaut, si l'on ne passe pas pas de submatch, c'est comme si l'on passait 0, dans ce cas, le regex_token_iterator va tenter de trouver dans la chaine toutes les portions matchant entièrement la regex.

Code :

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

1
2
3
4
5
6
7
8
 
std::regex number("\\d+[\\.,]?\\d*");
std::string arg = "88 56.4 45";
 
std::sregex_token_iterator tokens(arg.begin(), arg.end(), number);
std::sregex_token_iterator regend;
for (; tokens != regend; ++tokens)
    std::cout << *tokens << std::endl;

Affiche :
88
56.4
54

Par contre si l'on passe -1 alors le std::sregex_token_iterator se comporte comme si la regex indiquait le *séparateur* à matcher :

Code :

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

1
2
3
4
5
6
7
8
9
 
std::regex whitespace("\\s+");
std::string arg = "88 56.4 45";
 
std::sregex_token_iterator tokens(arg.begin(), arg.end(), whitespace, -1 );
std::sregex_token_iterator regend;
 
for (; tokens != regend; ++tokens)
  std::cout << *tokens << std::endl;

Affiche :
88
56.4
54

Aucune des deux solutions n'est satisfaisante ici, car en fait on souhaite faire comme si l'on avait deux regex différentes une pour les valeurs (3.1415) et une pour les unités (rad). La solution est d'utiliser les submatchs : Un submatch est délimité par des parenthèses et permet dans une même regex de matcher les morceaux qui nous intéressent, par exemple ici on pourrait utiliser les submatch suivant :

(\\d+[\\.,]?\\d*) -> la valeur
(\\w+) -> l'unité

Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
std::regex numberunit("(\\d+[\\.,]?\\d*)(\\w+)");
std::string arg = "3.1415rad 88mph";
 
std::sregex_token_iterator tokens(arg.begin(), arg.end(), numberunit, 1 ); // on choisit de ne garder que le submatch n°1
std::sregex_token_iterator regend;
 
for (; tokens != regend; ++tokens)
    std::cout << *tokens << std::endl;

Affiche :
3.1415
88

Mais ici on souhaite conserver les deux submatch, il faut alors passer au constructeur de sregex_token_iterator un tableau contenant l'index des submatch que l'on souhaite garder, c'est à dire 1 (la valeur) et 2 (l'unité)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
std::regex numberunit("(\\d+[\\.,]?\\d*)(\\w+)");
std::string arg = "3.1415rad 88mph";
 
int submatches[] = { 1, 2 };
std::sregex_token_iterator tokens(arg.begin(), arg.end(), numberunit, submatches );
std::sregex_token_iterator regend;
 
for (; tokens != regend; ++tokens)
   std::cout << *tokens << std::endl;

Affiche :
3.1415
rad
88
mph

Et voilà

Une remarque pour finir, on n'est pas obligé ici d'utiliser un sregex_token_iterator, on peut aussi utiliser directement la fonction regex_match, qui va remplir en une seule passe une structure smatch avec le résultat du match et des submatchs, au contraire de sregex_token_iterator qui découvre progressivement les matchs et submatchs à chaque incrémentation de l'itérateur.
C'est peut être un plus plus pratique ici :

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
 
std::regex numberunit("(\\d+[\\.,]?\\d*)(\\w+)");
std::string arg = "3.1415rad";
double valeur;
std::string unite;
 
std::smatch  res;
if(regex_match(arg, res,  numberunit) == true)
{
  if(res.size() == 3) // un match complet + deux submatch
  {
     valeur = stod(res[1]);
     unite = res[2];
  }
}

Note : res[0] contient 3.1415rad (le match complet)

[Daïmanu]

Merci pour ta réponse claire et précise.

Tiens je connaissais pas les submatch, décidément les regex sont des drôles de petits bonhommes

Tout marche nickel (à part pour la conversion de stod non reconnu par mon compilo, mais c'est un autre problème).

PS : smatch est dans boost:: et stod dans std::

[Jean-Marc.Bourguet]

Ca fait quand meme usine a gaz. J'utiliserais strtod avec son second argument non nul, meme si une expression reguliere valide un peu plus le format. Les espaces dans les arguments sont rares.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
string unit;
char* end;
// errno = 0; // necessaire si on veut savoir s'il y a un overflow ou un underflow
double v = strtod(argv[1], &end);
if (v == 0 && end == argv[1]) {
   // ne commence pas par un nombre
} else {
   // on peut s'amuser a trouver s'il y a un overflow ou un underflow, mais la valeur de v
   // est raisonnable (0 ou plus ou moins infini en pratique).
   unit = end;
}

Edit: En passant, stod est du C++11 et a un second parametre qui permet de faire la meme chose. Son probleme est qu'il leve une exception en case d'underflow ou d'overflow; je me demande si ignorer ces conditions n'est pas souvent plus adequat.

[Daïmanu]

C'est vrai que ta solution a l'air plus simple pour mon problème, même si c'est du C-style.
Par contre, la solution d'Arzar sera plus adéquate à des problèmes plus complexe, grâce au système de submatch.