Utilisation de regex.h

Bonjour,

j'aimerai utiliser les regex en C et je me suis vite tourner vers la librairie regex.h. J'ai créé un petit code de test :

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

#include <stdio.h> #include <regex.h>   int regex_string_check(const char *string) { const char *pattern = "[:alnum:]"; regex_t regex; int ret;   ret = regcomp(&regex, pattern, 0); if(ret != 0) return 1;   ret = regexec(&regex, string, 0, NULL, 0); if(ret != 0) goto free_regex;   regfree(&regex);   return 0;   free_regex: regfree(&regex); return 2; }   int main(int argc, char **argv) { printf("Regex return : %d\n", regex_string_check("tot 14o")); printf("Regex return : %d\n", regex_string_check("tototata14")); printf("Regex return : %d\n", regex_string_check("toto @_-|yu")); }

---

J'ai ma fonction "regex_string_check" qui me renvoie :
* 0 si tout s'est passé,
* 1 s'il n'a pas réussi à initialiser la regex,
* 2 si la chaîne que je passe en paramètre ne correspond pas à ma regex.

La regex que j'utilise est assez simple : "[:alnum:]" => je veux seulement les caractères alpha-numériques [a-zA-Z0-9].
Logiquement il y a que la deuxième chaîne : "tototata14" qui devrait me renvoyer 0. La première contenant un espace et la deuxième des caractères non alpha-numérique.

Or, voici le résultat de l'exécution :

Code:

---

1 2 3 4

[root@bsd_dev ~/tests/c/regex]# ./regex Regex return : 2 Regex return : 0 Regex return : 0

---

Je dois avoir un souci quelque part mais je vois pas où ?
regcomp : regcomp returns 0 if it succeeds in compiling the regular expression; otherwise, it returns a nonzero error code (see the table below).
regexec : regexec returns 0 if the regular expression matches; otherwise, it returns a nonzero value.

Cordialement.

Bonjour,

• Il faut écrire « [[:alnum:]] ». La première paire de crochets est le conteneur de caractères proprement dit, et les noms de classes sont ensuite passés à l'intérieur de celui-ci entre « [: » et « :] ». Ça te permet de spécifier éventuellement plusieurs classes ;
• Garde à l'esprit que cette expression ne reconnaîtra que le premier caractère de la chaîne examinée et validant l'expression. Il faudra ajouter « * » ou « + » à ton expression si tu veux reconnaître un mot entier ;
• Il manque un « return 0 » à la fin de ta fonction main ;
• Prend l'habitude de ne jamais travailler en root sur ta machine. Crée un utilisateur propre auquel tu donneras des pouvoirs éventuellement.

Merci pour les informations :)

Voici mon nouveau code :

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

#include <stdio.h> #include <regex.h>   int regex_string_check(const char *string) { const char *pattern = "[^[:alnum:][:blank:]*$]"; regex_t regex; int ret;   ret = regcomp(&regex, pattern, 0); if(ret != 0) return 1;   ret = regexec(&regex, string, 0, 0, 0); if(ret != 0) goto free_regex;   regfree(&regex);   return 0;   free_regex: regfree(&regex); return 2; }   int main(int argc, char **argv) { printf("Regex return : %d\n", regex_string_check("tot 14o")); printf("Regex return : %d\n", regex_string_check("tototata14")); printf("Regex return : %d\n", regex_string_check("toto @_-|yu"));   return 0; }

---

Pour autoriser les espaces, j'ai trouvé [:space:] mais d'après ce que je peux voir dans la documentation ça autorise aussi les tabulations. Est ce que l'on peut autoriser uniquement les espaces ?
Voici le résultat de l'exécution (je suis toujours en root ^_^') :

Code:

---

1 2 3 4

[root@bsd_dev ~/tests/c/regex]# ./regex Regex return : 2 Regex return : 2 Regex return : 0

---

Le seul truc qui me perturbe c'est que les deux premières qui devraient fonctionner retournent 2 alors que la dernière qui ne devrait pas fonctionner retourne 0. C'est logique mais inversé O_o

Edit : j'ai essayé de check l'erreur pour avoir plus d'information voici le code :

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

int regex_string_check(const char *string) { const char *pattern = "[^[:alnum:][:blank:]*$]"; regex_t regex; int ret;   ret = regcomp(&regex, pattern, 0); if(ret != 0) return 1;   ret = regexec(&regex, string, 0, 0, 0); if(ret) { if(ret == REG_NOMATCH) printf("No match !\n"); else if(ret == REG_ESPACE) printf("Out of memory !\n"); else printf("Error ! \n"); goto free_regex; }   regfree(&regex);   return 0;   free_regex: regfree(&regex); return 2; }

---

Et dans la console il m'affiche "No match !" pour les deux premières expressions...

Citation:

---

Envoyé par Sango64

Pour autoriser les espaces, j'ai trouvé [:space:] mais d'après ce que je peux voir dans la documentation ça autorise aussi les tabulations. Est ce que l'on peut autoriser uniquement les espaces ?

---

Oui, il suffit de taper l'espace, comme un caractère ordinaire, plutôt qu'utiliser une classe de caractères.

Citation:

---

Le seul truc qui me perturbe c'est que les deux premières qui devraient fonctionner retournent 2 alors que la dernière qui ne devrait pas fonctionner retourne 0. C'est logique mais inversé O_o

---

C'est normal, tu as ajouté « ^ » au début de ton motif, ce qui correspond à un négateur : à présent, l'expression recherche les caractères qui ne sont pas dans la liste.

D'autre part, tu as ajouté « *$ » à la fin de ta liste mais à cet endroit, ils sont considérés comme des caractères ordinaires. Si ce sont les opérateurs dont on parlait plus haut, il faut les mettre en dehors des crochets.

Citation:

---

Et dans la console il m'affiche "No match !" pour les deux premières expressions...

---

« No match » signifie « pas de correspondance ».

Je suis vraiment un débutant en regex :aie:
Je sais maintenant que '^' possède deux significations différentes selon son placement !

Voici donc le fameux pattern qu'il me fallait : const char *pattern = "^[[:alnum:] ]*$";

Merci encore pour tes conseils ;)

Petite intervention au passage pour présenter un site très intéressant pour tester des regex : https://regex101.com/

Rappels des conventions utilisé pour les regex, et tests en temps réel d'un regex sur plusieurs chaîne de caractère différente.