basic_regex Class
encapsule une expression régulière.
template<class Elem,
class RXtraits = regex_traits<Elem>,
class basic_regex {
public:
basic_regex();
explicit basic_regex(const Elem *ptr,
flag_type flags = ECMAScript);
basic_regex(const Elem *ptr, size_type len,
flag_type flags = ECMAScript);
basic_regex(const basic_regex& right);
template<class STtraits, class STalloc>
explicit basic_regex(const basic_string<Elem, STtraits, STalloc>& str,
flag_type flags = ECMAScript);
template<class InIt>
explicit basic_regex(InIt first, InIt last,
flag_type flags = ECMAScript);
basic_regex& operator=(const basic_regex& right);
basic_regex& operator=(const Elem *ptr);
template<class STtraits, class STalloc>
basic_regex& operator=(const basic_string<Elem, STtraits, STalloc>& str);
basic_regex& assign(const basic_regex& right);
basic_regex& assign(const Elem *ptr,
flag_type flags = ECMAScript);
basic_regex& assign(const Elem *ptr, size_type len,
flag_type flags = ECMAScript);
template<class STtraits, class STalloc>
basic_regex& assign(const basic_string<Elem, STtraits, STalloc>& str,
flag_type flags = ECMAScript);
template<class InIt>
basic_regex& assign(InIt first, InIt last,
flag_type flags = ECMAScript);
locale_type imbue(locale_type loc);
locale_type getloc() const;
void swap(basic_regex& other) throw();
unsigned mark_count() const;
flag_type flags() const;
typedef Elem value_type;
typedef regex_constants::syntax_option_type flag_type;
typedef typename RXtraits::locale_type locale_type;
static const flag_type icase = regex_constants::icase;
static const flag_type nosubs = regex_constants::nosubs;
static const flag_type optimize = regex_constants::optimize;
static const flag_type collate = regex_constants::collate;
static const flag_type ECMAScript = regex_constants::ECMAScript;
static const flag_type basic = regex_constants::basic;
static const flag_type extended = regex_constants::extended;
static const flag_type awk = regex_constants::awk;
static const flag_type grep = regex_constants::grep;
static const flag_type egrep = regex_constants::egrep;
private:
RXtraits traits; // exposition only
};
Paramètres
Elem
Le type d'éléments à rechercher.RXtraits
Classe Ctraits pour les éléments.
Notes
La classe de modèle décrit un objet qui contient une expression régulière.Les objets de cette classe de modèle peuvent être passés aux fonctions de modèle regex_match Function, regex_search Function, et regex_replace Function, ainsi que les arguments appropriés de chaîne de texte, pour rechercher du texte qui correspond à l'expression régulière.La bibliothèque TR1 fournit deux spécialisations de cette classe de modèle, avec les définitions de type regex Typedef pour les éléments de type char, et wregex Typedef pour les éléments de type wchar_t.
L'argument template RXtraits décrit différentes propriétés importantes de la syntaxe des expressions régulières que la classe de modèle prend en charge.une classe qui spécifie ces caractéristiques d'expression régulière doit avoir la même interface externe comme objet de classe de modèle regex_traits Class.
Certaines fonctions prennent une séquence d'opérande qui définit une expression régulière.Vous pouvez spécifier une telle séquence d'opérande plusieurs façons :
ptr -- un début se terminant par null de séquence (telle que la chaîne c, pour Elem de type char) à l'adresse ptr (qui ne doit pas être un pointeur null), où l'élément en cours est la valeur value_type() il ne fait pas partie de la séquence d'opérande
ptr, count -- une séquence d'éléments d' count en commençant à l'adresse ptr (qui ne doit pas être un pointeur null)
str -- la séquence est spécifiée par l'objet strd' basic_string
first, last -- une séquence d'éléments délimités par les itérateurs first et last, dans la plage [first, last)
right -- l'objet rightd' basic_regex
Ces fonctions membres prennent également un argument flags qui définit différentes options pour la conversion en l'expression régulière en plus de celles décrites par le type d' RXtraits .
Configuration requise
en-tête : <regex>
l'espace de noms : type