Namespaces
Variants

std::basic_regex<CharT,Traits>:: basic_regex

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
(C++11)
(C++11)
(C++11)
Iterators
(C++11)
(C++11)
Exceptions
(C++11)
Traits
(C++11)
Constants
(C++11)
(C++11)
(C++11)
Regex Grammar
(C++11)
std::basic_regex
basic_regex ( ) ;
(1) (depuis C++11)
explicit basic_regex ( const CharT * s,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(2) (depuis C++11)
basic_regex ( const CharT * s, std:: size_t count,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(3) (depuis C++11)
basic_regex ( const basic_regex & other ) ;
(4) (depuis C++11)
basic_regex ( basic_regex && other ) noexcept ;
(5) (depuis C++11)
template < class ST, class SA >

explicit basic_regex ( const std:: basic_string < CharT,ST,SA > & str,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(6) (depuis C++11)
template < class ForwardIt >

basic_regex ( ForwardIt first, ForwardIt last,

flag_type f = std:: regex_constants :: ECMAScript ) ;
(7) (depuis C++11)
basic_regex ( std:: initializer_list < CharT > init,
flag_type f = std:: regex_constants :: ECMAScript ) ;
(8) (depuis C++11)

Construit une nouvelle expression régulière à partir d'une séquence de caractères interprétés selon les indicateurs f .

1) Constructeur par défaut. Construit une expression régulière vide qui ne correspondra à rien.
2) Construit une expression rationnelle à partir d'une chaîne de caractères terminée par un caractère nul s .
3) Construit une expression rationnelle à partir d'une séquence de count caractères, pointée par s .
4) Constructeur de copie. Construit une expression régulière en copiant other .
5) Constructeur de déplacement. Construit une expression rationnelle avec le contenu de other en utilisant la sémantique de déplacement.
6) Construit une expression rationnelle à partir d'une chaîne str .
7) Constructeur de plage. Construit la chaîne avec le contenu de la plage [ first , last ) .
8) Constructeur de liste d'initialisation. Construit la chaîne avec le contenu de la liste d'initialisation init .

Paramètres

s - pointeur vers une chaîne terminée par un caractère nul
count - longueur d'une séquence de caractères utilisée pour initialiser l'expression régulière
first, last - plage d'une séquence de caractères utilisée pour initialiser l'expression régulière
str - une basic_string utilisée comme source pour initialiser l'expression régulière
other - une autre expression régulière utilisée comme source pour initialiser l'expression régulière
init - liste d'initialisation utilisée pour initialiser l'expression régulière
f - indicateurs utilisés pour guider l'interprétation de la séquence de caractères comme expression régulière
Exigences de type
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .

Exceptions

1) Peut lever des exceptions définies par l'implémentation.
2,3) std::regex_error si l'expression régulière fournie n'est pas valide.
4) Peut lever des exceptions définies par l'implémentation.
6-8) std::regex_error si l'expression régulière fournie n'est pas valide.

Exemple

Exécuter ce code 
#include <iomanip>
#include <iostream>
#include <regex>
#include <string>
void match_and_print(const std::string& text, const std::regex& pattern)
{
    std::sregex_iterator it(text.begin(), text.end(), pattern), it_end;
    int count = 0;
    for (; it != it_end; ++it)
    {
        const std::smatch& match = *it;
        std::cout << ++count << ". " << std::quoted(match.str()) << '\n';
    }
    std::cout << (count ? "\n" : "aucune correspondance trouvée\n\n");
}
int main()
{
    const std::string text = "Hello, World! 12345";
    // Correspond à un ou plusieurs chiffres
    std::string pattern_text = "\\d+";
    std::cout << "chiffres (" << pattern_text << "):\n";
    auto pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Correspond à un ou plusieurs caractères séparés par des espaces
    pattern_text = "[^\\s]+";
    std::cout << "mots (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Correspond à un ou plusieurs caractères séparés par des espaces
    pattern_text = "[a-zA-Z]+";
    std::cout << "mots sans symboles ni chiffres (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Correspond à un caractère non numérique, non alphabétique
    pattern_text = "[^0-9A-Za-z]";
    std::cout << "symbole (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Correspond à une ou plusieurs minuscules
    pattern_text = "[a-z]+";
    std::cout << "minuscules (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text);
    match_and_print(text, pattern);
    // Correspond à une ou plusieurs minuscules avec le drapeau std::regex::icase
    pattern_text = "[a-z]+";
    std::cout << "minuscules avec drapeau d'ignorer la casse (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::icase);
    match_and_print(text, pattern);
    // Correspond à une expression régulière POSIX de base
    pattern_text = "[[:digit:]]+";
    std::cout << "regex POSIX de base (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::basic);
    match_and_print(text, pattern);
    // Correspond à une expression régulière POSIX étendue
    pattern_text = "[[:digit:]]+";
    std::cout << "regex POSIX étendue (" << pattern_text << "):\n";
    pattern = std::regex(pattern_text, std::regex::extended);
    match_and_print(text, pattern);
}

Sortie : 

chiffres (\d+):
1. "12345"
mots ([^\s]+):
1. "Hello,"
2. "World!"
3. "12345"
mots sans symboles ni chiffres ([a-zA-Z]+):
1. "Hello"
2. "World"
symbole ([^0-9A-Za-z]):
1. ","
2. " "
3. "!"
4. " "
minuscules ([a-z]+):
1. "ello"
2. "orld"
minuscules avec indicateur d'ignorer la casse ([a-z]+):
1. "Hello"
2. "World"
regex POSIX basique ([[:digit:]]+):
aucune correspondance trouvée
regex POSIX étendue ([[:digit:]]+):
1. "12345"