Introduction détaillée à l'utilisation des expressions régulières en C++

Cette fois, je vais vous apporter une introduction détaillée à l'utilisation des expressions régulières en C++. Quelles sont les précautions lors de l'utilisation des expressions régulières en C++. Voici des cas pratiques, jetons un coup d'oeil.

Expression régulièreRegex (expression régulière) est un outil puissant pour décrire des séquences de caractères. Les expressions régulières existent dans de nombreux langages. Les expressions régulières sont également incluses dans C++ 11 dans le cadre de la nouvelle norme. De plus, il prend également en charge 6 syntaxes d'expressions régulières différentes, à savoir : ECMASCRIPT, basic, extend, awk, grep et egrep. . ECMASCRIPT est la syntaxe par défaut Nous pouvons spécifier la syntaxe à utiliser lors de la construction de l'expression régulière.

L'expression régulière est un modèle de texte. Les expressions régulières sont des outils de traitement de texte puissants, pratiques et efficaces. Les expressions régulières elles-mêmes, associées à une notation de modèle générale comme un langage de programmation de poche, donnent aux utilisateurs la possibilité de décrire et d'analyser du texte. Avec une prise en charge supplémentaire fournie par des outils spécifiques, les expressions régulières peuvent ajouter, supprimer, séparer, superposer, insérer et découper divers types de texte et de données.

Une expression régulière complète se compose de deux types de caractères : les caractères spéciaux sont appelés "méta-caractères", et les autres sont des caractères de texte "littéraux" ou normaux, tels que des lettres, des chiffres, des caractères chinois et. souligne). Les métacaractères d'expression régulière offrent des capacités de description plus puissantes.

Comme les éditeurs de texte, la plupart des langages de programmation de haut niveau prennent en charge les expressions régulières, telles que Perl, Java, Python et C/C++. Ces langages ont leurs propres packages d'expressions régulières.

Une expression régulière n'est qu'une chaîne, elle n'a pas de limite de longueur. "Sous-expression" fait référence à une partie de l'expression régulière entière, généralement une expression entre parenthèses ou une branche à choix multiples séparée par "|".

Par défaut, les lettres des expressions sont sensibles à la casse.

Métacaractères couramment utilisés :

1. "." : Faites correspondre n'importe quel caractère sauf "n", si vous souhaitez faire correspondre "n", pour n'importe quel caractère, vous devez utiliser un modèle tel que "[sS]" ;

2. "^" : correspond au caractère d'entrée position de départ de la chaîne, ne correspond à aucun caractère, doit correspondre "^" lui-même, vous devez utiliser "^";

3. "$": correspond à la fin de la chaîne d'entrée, ne correspond à aucun caractère, pour correspondre au caractère "$" lui-même, vous vous devez utiliser "$" ;

4. « * » : correspond au caractère ou à la sous-expression précédent zéro ou plusieurs fois, « * » est équivalent à « {0,} », tel que « ^*b » peut correspondre à "b" ", "^b", "^^b", ...;

5. "+" : correspond au caractère ou à la sous-expression précédente une ou plusieurs fois, équivalent à "{1 ,}", Par exemple, "a+b" peut correspondre à "ab", "aab", "aaab", ...;

6. "?" : Correspond au caractère ou à la sous-expression précédent zéro ou une fois, ce qui équivaut à "{0,1}", comme "a[cd]?" peut correspondre à "a", "ac", "ad" lorsque ce caractère suit tout autre qualificatif "*", "+ ; ", "?" , "{n}", "{n,}", "{n,m}", le mode de correspondance est "non gourmand". Le modèle « non gourmand » correspond à la chaîne la plus courte possible recherchée, tandis que le modèle « gourmand » par défaut correspond à la chaîne la plus longue possible recherchée. Par exemple, dans la chaîne "oooo", "o+?" ne correspond qu'à un seul "o", tandis que "o+" correspond à tous les "o"

7. "|" : Logiquez les deux conditions de correspondance " ; Ou" (Ou) opération, telle que l'expression régulière "(lui|elle)" correspond à "cela lui appartient" et "cela lui appartient", mais ne peut pas correspondre à "cela leur appartient.";

8 " : Marque le caractère suivant comme caractère spécial, texte, référence arrière ou caractère d'échappement octal. Par exemple, "n" correspond au caractère "n", "n" correspond au caractère de nouvelle ligne et la séquence "\" correspond à "". , "("correspondance"(";

9. « w » : faites correspondre des lettres, des chiffres ou des traits de soulignement, n'importe quelle lettre, chiffre ou trait de soulignement, c'est-à-dire l'un des A~Z, a~z, 0~9, _

10 ; . "W" : correspond à n'importe quel caractère qui n'est pas une lettre, un chiffre ou un trait de soulignement

11. "s" : correspond à n'importe quel caractère d'espacement, y compris l'un des caractères d'espacement tels que les espaces, les tabulations, les formulaires ; flux, etc., équivalent à "[fnrtv]";

12. "S": correspond à tout caractère qui n'est pas un espace, équivalent à "[^fnrtv]"

13. « d » : correspond à des nombres, n'importe quel nombre, de 0 à 9, équivalent à « [0-9] » ; "[^0-9]";

15. "b": Correspond à une limite de mot, c'est-à-dire la position entre le mot et l'espace, c'est-à-dire la position entre le mot et l'espace, ne correspond à aucun caractère, tel que , "erb" correspond à "er" dans "jamais", mais ne correspond pas à "er" dans "verb"

16. "B" : correspondance sans limite de mot ; , "erB" correspond à "verb" "er" dans "jamais" ;

17. "f" : correspond à un caractère de saut de page, équivalent à "x0c" et "cL" ; 18. "n" : correspond à un caractère de nouvelle ligne, équivalent à "x0a" et "cJ"

19. "r" : correspond à un caractère de retour chariot, équivalent à "x0d" et "cM" ; 🎜>

20. "t" : correspond à un caractère de tabulation, équivalent à "x09" et "cI" ;

21. "v" : correspond à un caractère de tabulation vertical, équivalent à "x0b" et "cK";

22. "cx": correspond au caractère de contrôle indiqué par "x", par exemple, cM correspond à Control-M ou au caractère de retour chariot, "x" La valeur doit être comprise entre "A-Z" ou "a-z". Sinon, on suppose que c est le caractère "c" lui-même

23. "{n}" : "n" est un entier non négatif, qui correspond exactement n fois ; , par exemple, "o{2}" ne correspond pas au "o" dans "Bob", mais correspond aux deux "o" dans "food"

24. "{n,} : "n" est un entier non négatif correspondant au moins n fois. Par exemple, "o{2,}" ne correspond pas au "o" de "Bob", mais correspond à tous les "o" de "foooood", " o{1" ,}" est équivalent à "o+", "o{0,}" est équivalent à "o*"

25. "{n,m}" : "n" et " ; m" sont des entiers non négatifs, où n<=m correspond au moins n fois et au plus m fois, par exemple, "o{1,3}" correspond aux trois premiers o de "foooooood", 'o{0 ,1}' est équivalent à 'o?', notez que des espaces ne peuvent pas être insérés entre des virgules et des nombres ; par exemple, "ba{1,3}" peut correspondre à "ba" ou "baa" ou "baaa" ; >

26. "x| y" : correspond à "x" ou "y", par exemple, "z|food" correspond à "z" ou "food" ; "(z|f)ood" correspond à "zood" ; ou "food" ;

27. "[xyz] : jeu de caractères, correspond à n'importe quel caractère contenu, par exemple, "[abc]" correspond à "a" dans "plain" ; 28. "[^xyz]" : jeu de caractères inversé, correspond à n'importe quel caractère non inclus, correspond à n'importe quel caractère sauf "xyz", par exemple, "[^abc]" correspond à "p" dans "plain" ; > 29. " [a-z]" :

plage de caractères

, correspond à n'importe quel caractère dans la plage spécifiée, par exemple, "[a-z]" correspond à n'importe quelle lettre minuscule dans la plage "a" à "z" < ; 🎜>

30. "[^a-z]" : caractère de plage inversé, correspond à tout caractère qui n'est pas dans la plage spécifiée, par exemple, "[^a-z]" correspond à tout caractère qui n'est pas dans la plage de "a " à "z";

31. "( )" : Définissez l'expression entre "(" et ")" comme un groupe "groupe", et enregistrez les caractères correspondant à cette expression dans une zone temporaire, un expression régulière Jusqu'à 9 peuvent être enregistrés et ils peuvent être référencés avec des symboles de "1" à "9"

32. "(motif)": Faites correspondre le modèle et capturez la sous-expression correspondante, vous pouvez utiliser $0... L'attribut $9 récupère les correspondances capturées de la collection "matches" résultante

 ;

33. “(?:pattern)”：匹配pattern但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配，这对于用”or”字符” (|)”组合模式部件的情况很有用, 如，”industr(?:y|ies)”是比”industry|industries”更简略的表达式；

34. “(?=pattern)”： 非获取匹配，正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。如，"Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始；

35. “(?!pattern)”： 非获取匹配，正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串，该匹配不需要获取供以后使用。如"Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"；

要匹配某些特殊字符，需在此特殊字符前面加上”\”，如要匹配字符”^”、”$”、”()”、”[]”、”{}”、”.”、”?”、”+”、”*”、”|”，需使用” \^”、” \$”、” \ (“、”\)”、” \ [“、”\]”、” \{“、”\}”、” \.”、” \?”、” \+”、” \*”、” \|”。

在C++/C++11中，GCC版本是4.9.0及以上，VS版本为VS2013及以上时，会有regex头文件，此头文件中会有regex_match、regex_search、regex_replace等函数可供调用，以下是测试代码：

#include "regex.hpp" 
#include  
#include  
#include  
#include  
int test_regex_match() 
{ 
 std::string pattern{ "\\d{3}-\\d{8}|\\d{4}-\\d{7}" }; // fixed telephone 
 std::regex re(pattern); 
 std::vector str{ "010-12345678", "0319-9876543", "021-123456789"}; 
 /* std::regex_match: 
  判断一个正则表达式(参数re)是否匹配整个字符序列str,它主要用于验证文本 
  注意，这个正则表达式必须匹配被分析串的全部，否则返回false;如果整个序列被成功匹配，返回true 
 */ 
 for (auto tmp : str) { 
  bool ret = std::regex_match(tmp, re); 
  if (ret) fprintf(stderr, "%s, can match\n", tmp.c_str()); 
  else fprintf(stderr, "%s, can not match\n", tmp.c_str()); 
 } 
 return 0; 
} 
int test_regex_search() 
{ 
 std::string pattern{ "http|hppts://\\w*$" }; // url 
 std::regex re(pattern); 
 std::vector str{ "http://blog.csdn.net/fengbingchun", "https://github.com/fengbingchun", 
  "abcd://124.456", "abcd https://github.com/fengbingchun 123" }; 
 /* std::regex_search: 
  类似于regex_match,但它不要求整个字符序列完全匹配 
  可以用regex_search来查找输入中的一个子序列，该子序列匹配正则表达式re 
 */ 
 for (auto tmp : str) { 
  bool ret = std::regex_search(tmp, re); 
  if (ret) fprintf(stderr, "%s, can search\n", tmp.c_str()); 
  else fprintf(stderr, "%s, can not search\n", tmp.c_str()); 
 } 
 return 0; 
} 
int test_regex_search2() 
{ 
 std::string pattern{ "[a-zA-z]+://[^\\s]*" }; // url 
 std::regex re(pattern); 
 std::string str{ "my csdn blog addr is: http://blog.csdn.net/fengbingchun , my github addr is: https://github.com/fengbingchun " }; 
 std::smatch results; 
 while (std::regex_search(str, results, re)) { 
  for (auto x : results) 
   std::cout << x << " "; 
  std::cout << std::endl; 
  str = results.suffix().str(); 
 } 
 return 0; 
} 
int test_regex_replace() 
{ 
 std::string pattern{ "\\d{18}|\\d{17}X" }; // id card 
 std::regex re(pattern); 
 std::vector str{ "123456789012345678", "abcd123456789012345678efgh", 
  "abcdefbg", "12345678901234567X" }; 
 std::string fmt{ "********" }; 
 /* std::regex_replace: 
  在整个字符序列中查找正则表达式re的所有匹配 
  这个算法每次成功匹配后，就根据参数fmt对匹配字符串进行替换 
 */ 
 for (auto tmp : str) { 
  std::string ret = std::regex_replace(tmp, re, fmt); 
  fprintf(stderr, "src: %s, dst: %s\n", tmp.c_str(), ret.c_str()); 
 } 
 return 0; 
} 
int test_regex_replace2() 
{ 
 // reference: http://www.cplusplus.com/reference/regex/regex_replace/ 
 std::string s("there is a subsequence in the string\n"); 
 std::regex e("\\b(sub)([^ ]*)"); // matches words beginning by "sub" 
 // using string/c-string (3) version: 
 std::cout << std::regex_replace(s, e, "sub-$2"); 
 // using range/c-string (6) version: 
 std::string result; 
 std::regex_replace(std::back_inserter(result), s.begin(), s.end(), e, "$2"); 
 std::cout << result; 
 // with flags: 
 std::cout << std::regex_replace(s, e, "$1 and $2", std::regex_constants::format_no_copy); 
 std::cout << std::endl; 
 return 0; 
}
相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！
推荐阅读：
使用正则表达式提取字符串详解（附代码）
容易产生错误的js手机号码验证
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!