std:: regex_search

From cppreference.net

Défini dans l'en-tête `<regex>`
template < class BidirIt, class Alloc, class CharT, class Traits > bool regex_search ( BidirIt first, BidirIt last, std:: match_results < BidirIt, Alloc > & m, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(1)	(depuis C++11)
template < class BidirIt, class CharT, class Traits > bool regex_search ( BidirIt first, BidirIt last, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(2)	(depuis C++11)
template < class CharT, class Alloc, class Traits > bool regex_search ( const CharT * str, std:: match_results < const CharT * , Alloc > & m, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(3)	(depuis C++11)
template < class CharT, class Traits > bool regex_search ( const CharT * str, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(4)	(depuis C++11)
template < class STraits, class SAlloc, class Alloc, class CharT, class Traits > bool regex_search ( const std:: basic_string < CharT, STraits, SAlloc > & s, std:: match_results < typename std:: basic_string < CharT, STraits, SAlloc > :: const_iterator , Alloc > & m, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(5)	(depuis C++11)
template < class STraits, class SAlloc, class CharT, class Traits > bool regex_search ( const std:: basic_string < CharT, STraits, SAlloc > & s, const std:: basic_regex < CharT, Traits > & e, std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) ;	(6)	(depuis C++11)
template < class STraits, class SAlloc, class Alloc, class CharT, class Traits > bool regex_search ( const std:: basic_string < CharT, STraits, SAlloc > && , std:: match_results < typename std:: basic_string < CharT, STraits, SAlloc > :: const_iterator , Alloc > & , const std:: basic_regex < CharT, Traits > & , std:: regex_constants :: match_flag_type flags = std:: regex_constants :: match_default ) = supprimé ;	(7)	(depuis C++11)

Détermine s'il y a une correspondance entre l'expression régulière e et une sous-séquence dans la séquence de caractères cible. Le résultat détaillé de la correspondance est stocké dans m (si présent).

1,2) La séquence de caractères cible est représentée par l'intervalle

first

last

Si `BidirIt` ne satisfait pas aux exigences de LegacyBidirectionalIterator , le comportement est indéfini.	(jusqu'à C++23)
Si `BidirIt` ne modélise pas `bidirectional_iterator` , le comportement est indéfini.	(depuis C++23)

3,4) La séquence de caractères cible est représentée par la plage

str

str + std:: char_traits < CharT > :: length ( str )

5,6) La séquence de caractères cible est représentée par la chaîne s .

7) La séquence de caractères cible ne peut pas être représentée par une std::string rvalue.

Si une correspondance n'existe pas, les expressions suivantes impliquant m (si elle existe) doivent produire les valeurs spécifiées :

Expression	Valeur
m. `ready` ( )	true
m. `size` ( )	0
m. `empty` ( )	true

S'il existe une correspondance, étant donné n'importe quel entier dans ( 0 , m. size ( ) ) comme n , les expressions suivantes impliquant m doivent produire les valeurs spécifiées pour chaque surcharge listée ci-dessous :

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` ` qui sont considérées comme équivalentes à `


         ` pour le code source. Tous les termes C++ (`match_results`, `suffix`, `matched`, `first`, `second`) et la syntaxe du code ont été conservés dans leur forme originale.

Expression	Valeur
Expression	Surcharge (1)	Surcharge (3)	Surcharge (5)
m. `ready` ( )	true
m. `size` ( )	1 + e. `mark_count` ( )
m. `empty` ( )	false
m. `prefix` ( ) . first	first	str	s. begin ( )
m. `prefix` ( ) . second	m [ 0 ] . first
m. `prefix` ( ) . matched	m. prefix ( ) . first ! = m. prefix ( ) . second
m. `suffix` ( ) . first	m [ 0 ] . second
m. `suffix` ( ) . second	dernier	std:: char_traits < CharT > :: length ( str ) + str	s. end ( )
m. `suffix` ( ) . matched	m. suffix ( ) . first ! = m. suffix ( ) . second
m `[0]` . first	le début de la séquence qui correspondait e
m `[0]` . second	la fin de la séquence qui correspondait e
m `[0]` . matched	true
m `[n]` . first	last si la sous-expression marquée n n'a pas participé à la correspondance le début de la séquence correspondant à la sous-expression n sinon
m `[n]` . second	last si la sous-expression marquée n n'a pas participé à la correspondance la fin de la séquence sinon correspondant à la sous-expression n sinon
m `[n]` . matched	false si la sous-expression marquée n n'a pas participé à la correspondance true sinon

Table des matières

Paramètres

first, last	-	la plage de caractères cible
str	-	la chaîne de style C cible terminée par un caractère nul
s	-	la std::basic_string cible
m	-	les résultats de correspondance
e	-	l'expression régulière
flags	-	indicateurs utilisés pour déterminer comment la correspondance sera effectuée

Valeur de retour

Retourne true si une correspondance existe, false sinon.

Notes

Afin d'examiner toutes les correspondances dans la séquence cible, std::regex_search peut être appelée dans une boucle, en redémarrant à chaque fois à partir de m [ 0 ] . second de l'appel précédent. std::regex_iterator offre une interface simple pour cette itération.

Exemple

Exécuter ce code

#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    std::string lines[] = {"Roses are #ff0000",
                           "violets are #0000ff",
                           "all of my base are belong to you"};
    std::regex color_regex("#([a-f0-9]{2})"
                            "([a-f0-9]{2})"
                            "([a-f0-9]{2})");
    // correspondance simple
    for (const auto& line : lines)
        std::cout << line << ": " << std::boolalpha
                  << std::regex_search(line, color_regex) << '\n';
    std::cout << '\n';
    // afficher le contenu des sous-expressions marquées dans chaque correspondance
    std::smatch color_match;
    for (const auto& line : lines)
        if (std::regex_search(line, color_match, color_regex))
        {
            std::cout << "correspondances pour '" << line << "'\n";
            std::cout << "Préfixe: '" << color_match.prefix() << "'\n";
            for (std::size_t i = 0; i < color_match.size(); ++i) 
                std::cout << i << ": " << color_match[i] << '\n';
            std::cout << "Suffixe: '" << color_match.suffix() << "\'\n\n";
        }
    // recherche répétée (voir aussi std::regex_iterator)
    std::string log(R"(
        Speed:	366
        Mass:	35
        Speed:	378
        Mass:	32
        Speed:	400
	Mass:	30)");
    std::regex r(R"(Speed:\t\d*)");
    for (std::smatch sm; regex_search(log, sm, r);)
    {
        std::cout << sm.str() << '\n';
        log = sm.suffix();
    }
    // démonstration avec chaîne de style C
    std::cmatch cm;
    if (std::regex_search("this is a test", cm, std::regex("test"))) 
        std::cout << "\nTrouvé " << cm[0] << " à la position "
                  << cm.prefix().length() << '\n';
}

Sortie :

Roses are #ff0000: true
violets are #0000ff: true
all of my base are belong to you: false
matches for 'Roses are #ff0000'
Prefix: 'Roses are '
0: #ff0000
1: ff
2: 00
3: 00
Suffix: ''
matches for 'violets are #0000ff'
Prefix: 'violets are '
0: #0000ff
1: 00
2: 00
3: ff
Suffix: ''
Speed:	366
Speed:	378
Speed:	400
Found test at position 10

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement publié	Comportement corrigé
LWG 2205	C++11	n pouvait être zéro dans la postcondition	ne peut être que positif
LWG 2329	C++11	la surcharge (5) acceptait les rvalues de `basic_string` , ce qui pouvait entraîner des itérateurs pendants	rejetée via la surcharge supprimée (7)

Voir aussi

basic_regex (C++11)	objet d'expression régulière (modèle de classe)
match_results (C++11)	identifie une correspondance d'expression régulière, y compris toutes les sous-expressions correspondantes (modèle de classe)
regex_match (C++11)	tente de faire correspondre une expression régulière à une séquence de caractères entière (modèle de fonction)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

Classes
basic_regex (C++11)
sub_match (C++11)
match_results (C++11)
Algorithms
regex_match (C++11)
regex_search (C++11)
regex_replace (C++11)
Iterators
regex_iterator (C++11)
regex_token_iterator (C++11)
Exceptions
regex_error (C++11)
Traits
regex_traits (C++11)
Constants
syntax_option_type (C++11)
match_flag_type (C++11)
error_type (C++11)
Regex Grammar
Modified ECMAScript-262 (C++11)

cppreference.net

Namespaces

Variants