std:: regex_search

From cppreference.net

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur und Formatierung bleiben unverändert.)

Definiert in Header `<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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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)	(seit 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 ) = delete ;	(7)	(seit C++11)

Bestimmt, ob eine Übereinstimmung zwischen dem regulären Ausdruck e und einer Teilsequenz in der Zielzeichensequenz besteht. Das detaillierte Übereinstimmungsergebnis wird in m gespeichert (falls vorhanden).

1,2) Die Zielzeichenfolge wird durch den Bereich

first

last

dargestellt.

Falls `BidirIt` nicht die Anforderungen von LegacyBidirectionalIterator erfüllt, ist das Verhalten undefiniert.	(bis C++23)
Falls `BidirIt` nicht `bidirectional_iterator` modelliert, ist das Verhalten undefiniert.	(seit C++23)

3,4) Die Zielzeichenfolge wird durch den Bereich

str

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

dargestellt.

5,6) Die Zielzeichenfolge wird durch die Zeichenkette s dargestellt.

7) Die Zielzeichenfolge kann nicht durch einen std::string R-Wert dargestellt werden.

Wenn keine Übereinstimmung existiert, sollten die folgenden Ausdrücke, die m (falls vorhanden) enthalten, die angegebenen Werte ergeben:

Ausdruck	Wert
m. `ready` ( )	true
m. `size` ( )	0
m. `empty` ( )	true

Wenn eine Übereinstimmung existiert, ergibt für jede ganze Zahl in ( 0 , m. size ( ) ) als n , die folgenden Ausdrücke mit m die unten für jede Überladung angegebenen Werte:

Ausdruck	Wert
Ausdruck	Überladung (1)	Überladung (3)	Überladung (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	letzte	std:: char_traits < CharT > :: length ( str ) + str	s. end ( )
m. `suffix` ( ) . matched	m. suffix ( ) . first ! = m. suffix ( ) . second
m `[0]` . first	der Beginn der Sequenz, die übereinstimmte e
m `[0]` . second	das Ende der Sequenz, die übereinstimmte e
m `[0]` . matched	true
m `[n]` . first	last falls markierter Teilausdruck n nicht an der Übereinstimmung teilgenommen hat der Start der Sequenz, die andernfalls Teilausdruck n entspricht, andernfalls
m `[n]` . second	last falls markierter Teilausdruck n nicht an der Übereinstimmung teilgenommen hat das Ende der Sequenz andernfalls passender Teilausdruck n andernfalls
m `[n]` . matched	false falls markierter Teilausdruck n nicht an der Übereinstimmung teilgenommen hat true andernfalls

Inhaltsverzeichnis

Parameter

first, last	-	der Zielzeichenbereich
str	-	die nullterminierte C-Zeichenkette als Ziel
s	-	die std::basic_string als Ziel
m	-	die Übereinstimmungsergebnisse
e	-	der reguläre Ausdruck
flags	-	Flags zur Steuerung der Übereinstimmungsausführung

Rückgabewert

Gibt true zurück, wenn eine Übereinstimmung existiert, false andernfalls.

Hinweise

Um alle Übereinstimmungen innerhalb der Zielsequenz zu untersuchen, std::regex_search kann in einer Schleife aufgerufen werden, wobei jedes Mal neu gestartet wird von m [ 0 ] . second des vorherigen Aufrufs. std::regex_iterator bietet eine einfache Schnittstelle für diese Iteration.

Beispiel

Diesen Code ausführen

#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})");
    // einfache Übereinstimmung
    for (const auto& line : lines)
        std::cout << line << ": " << std::boolalpha
                  << std::regex_search(line, color_regex) << '\n';
    std::cout << '\n';
    // Inhalt markierter Teilausdrücke in jeder Übereinstimmung anzeigen
    std::smatch color_match;
    for (const auto& line : lines)
        if (std::regex_search(line, color_match, color_regex))
        {
            std::cout << "Übereinstimmungen für '" << line << "'\n";
            std::cout << "Präfix: '" << color_match.prefix() << "'\n";
            for (std::size_t i = 0; i < color_match.size(); ++i) 
                std::cout << i << ": " << color_match[i] << '\n';
            std::cout << "Suffix: '" << color_match.suffix() << "\'\n\n";
        }
    // wiederholte Suche (siehe auch 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();
    }
    // C-String-Demo
    std::cmatch cm;
    if (std::regex_search("this is a test", cm, std::regex("test"))) 
        std::cout << "\nGefunden " << cm[0] << " an Position "
                  << cm.prefix().length() << '\n';
}

Ausgabe:

Roses are #ff0000: true
violets are #0000ff: true
all of my base are belong to you: false
Übereinstimmungen für 'Roses are #ff0000'
Präfix: 'Roses are '
0: #ff0000
1: ff
2: 00
3: 00
Suffix: ''
Übereinstimmungen für 'violets are #0000ff'
Präfix: 'violets are '
0: #0000ff
1: 00
2: 00
3: ff
Suffix: ''
Speed:	366
Speed:	378
Speed:	400
Gefunden test an Position 10

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	Angewendet auf	Verhalten wie veröffentlicht	Korrektes Verhalten
LWG 2205	C++11	n konnte in der Nachbedingung null sein	kann nur positiv sein
LWG 2329	C++11	Überladung (5) akzeptierte `basic_string` -Rvalues, was zu hängenden Iteratoren führen konnte	abgelehnt durch gelöschte Überladung (7)

Siehe auch

basic_regex (C++11)	Regulärer Ausdruck-Objekt (Klassen-Template)
match_results (C++11)	identifiziert einen regulären Ausdruck-Treffer, einschließlich aller Unterausdruck-Treffer (Klassen-Template)
regex_match (C++11)	versucht, einen regulären Ausdruck mit einer gesamten Zeichensequenz abzugleichen (Funktions-Template)

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