Namespaces
Variants

std:: regex_match

From cppreference.net
C++
Text processing library
Regular expressions library
Classes
(C++11)
(C++11)
(C++11)
Algorithms
regex_match
(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)
(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_match ( 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_match ( 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_match ( 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_match ( 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_match
( 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_match ( 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_match
( 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 ) = gelöscht ;
(7) (seit C++11)

Bestimmt, ob der reguläre Ausdruck e die gesamte Zielzeichenfolge abgleicht. Das detaillierte Abgleichresultat 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 Rvalue dargestellt werden.

Wenn die Übereinstimmung nicht 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 die Ü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
Ü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. prefix ( ) . matched false [1]
m. suffix ( ) . first last std:: char_traits < CharT > ::
length ( str ) + str 		s. end ( )
m. suffix ( ) . second
m. suffix ( ) . matched false [2]
m [0] . first first str s. begin ( )
m [0] . second last std:: char_traits < CharT > ::
length ( str ) + str 		s. end ( )
m [0] . matched true [3]
m [n] . first
  • last falls markierter Teilausdruck n nicht an der Übereinstimmung teilgenommen hat
  • der Start der Sequenz, die andernfalls Teilausdruck n entspricht
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
  1. ↑ Das Match-Präfix ist leer.
  2. ↑ Das Match-Suffix ist leer.
  3. ↑ Die gesamte Sequenz wird gematcht.

Inhaltsverzeichnis

Parameter

first, last - der Zielzeichenbereich
str - die Ziel-nullterminierte C-Zeichenkette
s - die Ziel- std::basic_string
m - die Übereinstimmungsergebnisse
e - der reguläre Ausdruck
flags - Flags zur Bestimmung, wie die Übereinstimmung durchgeführt wird

Rückgabewert

Gibt true zurück, wenn die gesamte Zielsequenz mit e übereinstimmt, false andernfalls.

Hinweise

Da regex_match nur vollständige Übereinstimmungen berücksichtigt, kann derselbe reguläre Ausdruck unterschiedliche Ergebnisse zwischen regex_match und std::regex_search liefern: 

std::regex re("Get|GetValue");
std::cmatch m;
std::regex_search("GetValue", m, re);  // gibt true zurück, und m[0] enthält "Get"
std::regex_match ("GetValue", m, re);  // gibt true zurück, und m[0] enthält "GetValue"
std::regex_search("GetValues", m, re); // gibt true zurück, und m[0] enthält "Get"
std::regex_match ("GetValues", m, re); // gibt false zurück

Beispiel

Diesen Code ausführen 
#include <cstddef>
#include <iostream>
#include <regex>
#include <string>
int main()
{
    // Einfache reguläre Ausdrucksübereinstimmung
    const std::string fnames[] = {"foo.txt", "bar.txt", "baz.dat", "zoidberg"};
    const std::regex txt_regex("[a-z]+\\.txt");
    for (const auto& fname : fnames)
        std::cout << fname << ": " << std::regex_match(fname, txt_regex) << '\n';
    // Extraktion eines Teilübereinstimmung
    const std::regex base_regex("([a-z]+)\\.txt");
    std::smatch base_match;
    for (const auto& fname : fnames)
        if (std::regex_match(fname, base_match, base_regex))
            // Die erste Teilübereinstimmung ist die gesamte Zeichenkette; die nächste
            // Teilübereinstimmung ist der erste geklammerte Ausdruck.
            if (base_match.size() == 2)
            {
                std::ssub_match base_sub_match = base_match[1];
                std::string base = base_sub_match.str();
                std::cout << fname << " hat eine Basis von " << base << '\n';
            }
    // Extraktion mehrerer Teilübereinstimmungen
    const std::regex pieces_regex("([a-z]+)\\.([a-z]+)");
    std::smatch pieces_match;
    for (const auto& fname : fnames)
        if (std::regex_match(fname, pieces_match, pieces_regex))
        {
            std::cout << fname << '\n';
            for (std::size_t i = 0; i < pieces_match.size(); ++i)
            {
                std::ssub_match sub_match = pieces_match[i];
                std::string piece = sub_match.str();
                std::cout << "  Teilübereinstimmung " << i << ": " << piece << '\n';
            }
        }
}

Ausgabe: 

foo.txt: 1
bar.txt: 1
baz.dat: 0
zoidberg: 0
foo.txt hat eine Basis von foo
bar.txt hat eine Basis von bar
foo.txt
  Teilübereinstimmung 0: foo.txt
  Teilübereinstimmung 1: foo
  Teilübereinstimmung 2: txt
bar.txt
  Teilübereinstimmung 0: bar.txt
  Teilübereinstimmung 1: bar
  Teilübereinstimmung 2: txt
baz.dat
  Teilübereinstimmung 0: baz.dat
  Teilübereinstimmung 1: baz
  Teilübereinstimmung 2: dat

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 2273 C++11 es war unklar, ob Teilübereinstimmungen berücksichtigt werden berücksichtigt nur vollständige Übereinstimmungen
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

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