[section Concepts] [h2 CharT requirements] If type `BidiIterT` is used as a template argument to _basic_regex_, then `CharT` is `iterator_traits::value_type`. Type `CharT` must have a trivial default constructor, copy constructor, assignment operator, and destructor. In addition the following requirements must be met for objects; `c` of type `CharT`, `c1` and `c2` of type `CharT const`, and `i` of type `int`: [table CharT Requirements [ [[*Expression]] [[*Return type]] [[*Assertion / Note / Pre- / Post-condition]] ] [ [`CharT c`] [`CharT`] [Default constructor (must be trivial).] ] [ [`CharT c(c1)`] [`CharT`] [Copy constructor (must be trivial).] ] [ [`c1 = c2`] [`CharT`] [Assignment operator (must be trivial).] ] [ [`c1 == c2`] [`bool`] [`true` if `c1` has the same value as `c2`.] ] [ [`c1 != c2`] [`bool`] [`true` if `c1` and `c2` are not equal.] ] [ [`c1 < c2`] [`bool`] [`true` if the value of `c1` is less than `c2`.] ] [ [`c1 > c2`] [`bool`] [`true` if the value of `c1` is greater than `c2`.] ] [ [`c1 <= c2`] [`bool`] [`true` if `c1` is less than or equal to `c2`.] ] [ [`c1 >= c2`] [`bool`] [`true` if `c1` is greater than or equal to `c2`.] ] [ [`intmax_t i = c1`] [`int`] [ `CharT` must be convertible to an integral type. ] ] [ [`CharT c(i);`] [`CharT`] [`CharT` must be constructable from an integral type.] ] ] [h2 Traits Requirements] In the following table `X` denotes a traits class defining types and functions for the character container type `CharT`; `u` is an object of type `X`; `v` is an object of type `const X`; `p` is a value of type `const CharT*`; `I1` and `I2` are `Input Iterators`; `c` is a value of type `const CharT`; `s` is an object of type `X::string_type`; `cs` is an object of type `const X::string_type`; `b` is a value of type `bool`; `i` is a value of type `int`; `F1` and `F2` are values of type `const CharT*`; `loc` is an object of type `X::locale_type`; and `ch` is an object of `const char`. [table Traits Requirements [ [ [*Expression] ] [ [*Return type] ] [ [*Assertion / Note\n Pre / Post condition] ] ] [ [ `X::char_type` ] [ `CharT` ] [ The character container type used in the implementation of class template _basic_regex_. ] ] [ [ `X::string_type` ] [ `std::basic_string` or `std::vector` ] [ ] ] [ [ `X::locale_type` ] [ ['Implementation defined] ] [ A copy constructible type that represents the locale used by the traits class. ] ] [ [ `X::char_class_type` ] [ ['Implementation defined] ] [ A bitmask type representing a particular character classification. Multiple values of this type can be bitwise-or'ed together to obtain a new valid value. ] ] [ [ `X::hash(c)` ] [ `unsigned char` ] [ Yields a value between `0` and `UCHAR_MAX` inclusive. ] ] [ [ `v.widen(ch)` ] [ `CharT` ] [ Widens the specified `char` and returns the resulting `CharT`. ] ] [ [ `v.in_range(r1, r2, c)` ] [ `bool` ] [ For any characters `r1` and `r2`, returns `true` if `r1 <= c && c <= r2`. Requires that `r1 <= r2`. ] ] [ [ `v.in_range_nocase(r1, r2, c)` ] [ `bool` ] [ For characters `r1` and `r2`, returns `true` if there is some character `d` for which `v.translate_nocase(d) == v.translate_nocase(c)` and `r1 <= d && d <= r2`. Requires that `r1 <= r2`. ] ] [ [ `v.translate(c)` ] [ `X::char_type` ] [ Returns a character such that for any character `d` that is to be considered equivalent to `c` then `v.translate(c) == v.translate(d)`. ] ] [ [ `v.translate_nocase(c)` ] [ `X::char_type` ] [ For all characters `C` that are to be considered equivalent to `c` when comparisons are to be performed without regard to case, then `v.translate_nocase(c) == v.translate_nocase(C)`. ] ] [ [ `v.transform(F1, F2)` ] [ `X::string_type` ] [ Returns a sort key for the character sequence designated by the iterator range `[F1, F2)` such that if the character sequence `[G1, G2)` sorts before the character sequence `[H1, H2)` then `v.transform(G1, G2) < v.transform(H1, H2)`. ] ] [ [ `v.transform_primary(F1, F2)` ] [ `X::string_type` ] [ Returns a sort key for the character sequence designated by the iterator range `[F1, F2)` such that if the character sequence `[G1, G2)` sorts before the character sequence `[H1, H2)` when character case is not considered then `v.transform_primary(G1, G2) < v.transform_primary(H1, H2)`. ] ] [ [ `v.lookup_classname(F1, F2)` ] [ `X::char_class_type` ] [ Converts the character sequence designated by the iterator range `[F1,F2)` into a bitmask type that can subsequently be passed to `isctype`. Values returned from `lookup_classname` can be safely bitwise or'ed together. Returns `0` if the character sequence is not the name of a character class recognized by `X`. The value returned shall be independent of the case of the characters in the sequence. ] ] [ [ `v.lookup_collatename(F1, F2)` ] [ `X::string_type` ] [ Returns a sequence of characters that represents the collating element consisting of the character sequence designated by the iterator range `[F1, F2)`. Returns an empty string if the character sequence is not a valid collating element. ] ] [ [ `v.isctype(c, v.lookup_classname(F1, F2))` ] [ `bool` ] [ Returns `true` if character `c` is a member of the character class designated by the iterator range `[F1, F2)`, `false` otherwise. ] ] [ [ `v.value(c, i)` ] [ `int` ] [ Returns the value represented by the digit `c` in base `i` if the character `c` is a valid digit in base `i`; otherwise returns `-1`.\n \[Note: the value of `i` will only be `8`, `10`, or `16`. -end note\] ] ] [ [ `u.imbue(loc)` ] [ `X::locale_type` ] [ Imbues `u` with the locale `loc`, returns the previous locale used by `u`. ] ] [ [ `v.getloc()` ] [ `X::locale_type` ] [ Returns the current locale used by `v`. ] ] ] [h2 Acknowledgements] This section is adapted from the equivalent page in the _regexpp_ documentation and from the _proposal_ to add regular expressions to the Standard Library. [endsect]