Namensräume
Varianten
Aktionen

std::regex_constants::error_type

Von cppreference.com
< cpp‎ | regex
 
C++
 
Textverarbeitungsbibliothek
 
Bibliothek für reguläre Ausdrücke
Klassen
(C++11)
(C++11)
(C++11)
Algorithmen
(C++11)
(C++11)
(C++11)
Iteratoren
(C++11)
(C++11)
Ausnahmen
(C++11)
Traits
(C++11)
Konstanten
(C++11)
(C++11)
error_type
(C++11)
Reguläre Ausdrucksgrammatiken
(C++11)
 
Definiert in Header <regex>
using error_type = /* implementierungsdefiniert */;
 (1) (seit C++11)
constexpr error_type error_collate =    /* nicht spezifiziert */;

constexpr error_type error_ctype =      /* nicht spezifiziert */;
constexpr error_type error_escape =     /* nicht spezifiziert */;
constexpr error_type error_backref =    /* nicht spezifiziert */;
constexpr error_type error_brack =      /* nicht spezifiziert */;
constexpr error_type error_paren =      /* nicht spezifiziert */;
constexpr error_type error_brace =      /* nicht spezifiziert */;
constexpr error_type error_badbrace =   /* nicht spezifiziert */;
constexpr error_type error_range =      /* nicht spezifiziert */;
constexpr error_type error_space =      /* nicht spezifiziert */;
constexpr error_type error_badrepeat =  /* nicht spezifiziert */;
constexpr error_type error_complexity = /* nicht spezifiziert */;

constexpr error_type error_stack =      /* nicht spezifiziert */;
 (2) (seit C++11)
(inline seit C++17)
1) Der error_type ist ein Typ, der Fehler beschreibt, die beim Parsen regulärer Ausdrücke auftreten können.

Inhalt

[bearbeiten] Konstanten

Name Erklärung
error_collate Der Ausdruck enthält einen ungültigen KollektionsElementName
error_ctype Der Ausdruck enthält einen ungültigen Klassennamen
error_escape Der Ausdruck enthält ein ungültiges maskiertes Zeichen oder eine nachgestellte Maskierung
error_backref Der Ausdruck enthält eine ungültige Rückreferenz
error_brack Der Ausdruck enthält nicht übereinstimmende eckige Klammern ('[' und ']')
error_paren Der Ausdruck enthält nicht übereinstimmende runde Klammern ('(' und ')')
error_brace Der Ausdruck enthält nicht übereinstimmende geschweifte Klammern ('{' und '}')
error_badbrace Der Ausdruck enthält einen ungültigen Bereich in einem {}-Ausdruck
error_range Der Ausdruck enthält einen ungültigen Zeichenbereich (z. B. [b-a])
error_space Es war nicht genug Speicher vorhanden, um den Ausdruck in eine endliche Zustandsmaschine zu konvertieren
error_badrepeat '*', '?', '+' oder '{' wurde keinem gültigen regulären Ausdruck vorangestellt
error_complexity Die Komplexität eines versuchten Abgleichs überschritt ein vordefiniertes Niveau
error_stack Es war nicht genug Speicher vorhanden, um einen Abgleich durchzuführen

[bearbeiten] Beispiel

Implementiert einen Prüfer für reguläre Ausdrücke

Führen Sie diesen Code aus
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <regex>
#include <sstream>
#include <string>
 
void regular_expression_checker(const std::string& text,
                                const std::string& regex,
                                const std::regex::flag_type flags)
{
    std::cout << "Text: " << std::quoted(text) << '\n'
              << "Regex: " << std::quoted(regex) << '\n';
 
    try
    {
        const std::regex re{regex, flags};
        const bool matched = std::regex_match(text, re);
 
        std::stringstream out;
        out << (matched ? "MATCH!\n" : "DOES NOT MATCH!\n");
 
        std::smatch m;
        if (std::regex_search(text, m, re); !m.empty())
        {
            out << "prefix = [" << m.prefix().str().data() << "]\n";
 
            for (std::size_t i{}; i != m.size(); ++i)
                out << "  m[" << i << "] = [" << m[i].str().data() << "]\n";
 
            out << "suffix = [" << m.suffix().str().data() << "]\n";
        }
        std::cout << out.str() << '\n';
    }
    catch (std::regex_error& e)
    {
        std::cout << "Error: " << e.what() << ".\n\n";
    }
}
 
int main()
{
    constexpr std::regex::flag_type your_flags
        = std::regex::flag_type{0}
    // Choose one of the supported grammars:
        | std::regex::ECMAScript
    //  | std::regex::basic
    //  | std::regex::extended
    //  | std::regex::awk
    //  | std::regex::grep
    //  | std::regex::egrep
    // Choose any of the next options:
    //  | std::regex::icase
    //  | std::regex::nosubs
    //  | std::regex::optimize
    //  | std::regex::collate
    //  | std::regex::multiline
        ;
 
    const std::string your_text = "Hello regular expressions.";
    const std::string your_regex = R"(([a-zA-Z]+) ([a-z]+) ([a-z]+)\.)";
    regular_expression_checker(your_text, your_regex, your_flags);
 
    regular_expression_checker("Invalid!", R"(((.)(.))", your_flags);
    regular_expression_checker("Invalid!", R"([.)", your_flags);
    regular_expression_checker("Invalid!", R"([.]{})", your_flags);
    regular_expression_checker("Invalid!", R"([1-0])", your_flags);
}

Mögliche Ausgabe

Text: "Hello regular expressions."
Regex: "([a-zA-Z]+) ([a-z]+) ([a-z]+)\\."
MATCH!
prefix = []
  m[0] = [Hello regular expressions.]
  m[1] = [Hello]
  m[2] = [regular]
  m[3] = [expressions]
suffix = []
 
Text: "Invalid!"
Regex: "((.)(.)"
Error: Mismatched '(' and ')' in regular expression.
 
Text: "Invalid!"
Regex: "[."
Error: Unexpected character within '[...]' in regular expression.
 
Text: "Invalid!"
Regex: "[.]{}"
Error: Invalid range in '{}' in regular expression.
 
Text: "Invalid!"
Regex: "[1-0]"
Error: Invalid range in bracket expression..

[bearbeiten] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2053 C++11 Die Konstanten waren als static deklariert Das static-Schlüsselwort wurde entfernt

[bearbeiten] Siehe auch

(C++11)
 meldet Fehler, die von der Bibliothek für reguläre Ausdrücke generiert wurden
(Klasse) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/regex/error_type&oldid=173770"