Concepts

CharT requirements

If type BidiIterT is used as a template argument to basic_regex<>, then CharT is iterator_traits<BidiIterT>::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 1.14. 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.

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 1.15. Traits Requirements

Expression	Return type	Assertion / Note 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<CharT>` or `std::vector<CharT>`
`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`. [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`.

Acknowledgements

This section is adapted from the equivalent page in the Boost.Regex documentation and from the proposal to add regular expressions to the Standard Library.