21 KiB
[char.traits]
27 Strings library [strings]
27.2 Character traits [char.traits]
27.2.1 General [char.traits.general]
Subclause [char.traits] defines requirements on classes representingcharacter traits, and defines a class templatechar_traits, along with five specializations,char_traits,char_traits<char8_t>,char_traits<char16_t>,char_traits<char32_t>, andchar_traits<wchar_t>, that meet those requirements.
Most classes specified in [string.classes], [string.view], and [input.output] need a set of related types and functions to complete the definition of their semantics.
These types and functions are provided as a set of member typedef-names and functions in the template parameter traits used by each such template.
Subclause [char.traits] defines the semantics of these members.
To specialize those templates to generate a string, string view, or iostream class to handle a particular character container type ([defns.character.container])C, that and its related character traits classX are passed as a pair of parameters to the string, string view, or iostream template as parameterscharT andtraits.
IfX::char_type is not the same type asC, the program is ill-formed.
27.2.2 Character traits requirements [char.traits.require]
In Table 87,X denotes a traits class defining types and functions for the character container typeC;c andd denote values of typeC;p andq denote values of typeconst C*;s denotes a value of typeC*;n,i andj denote values of typesize_t;e andf denote values of typeX::int_type;pos denotes a value of typeX::pos_type; andr denotes an lvalue of typeC.
No expression which is part of the character traits requirements specified in [char.traits.require] shall exit via an exception.
Table 87 — Character traits requirements [tab:char.traits.req]
| ð Expression |
Return type | Assertion/note | Complexity |
|---|---|---|---|
| ð | pre-/post-condition | ||
| ð X::char_type |
C | ||
| ð X::int_type |
(described in [char.traits.typedefs]) | ||
| ð X::off_type |
(described in [iostreams.limits.pos] and [iostream.forward]) | ||
| ð X::pos_type |
(described in [iostreams.limits.pos] and [iostream.forward]) | ||
| ð X::state_type |
(described in [char.traits.typedefs]) | ||
| ð X::eq(c,d) |
bool | Returns: whether c is to be treated as equal to d. | constant |
| ð X::lt(c,d) |
bool | Returns: whether c is to be treated as less than d. | constant |
| ð X::compare(p,q,n) |
int | Returns: 0 if for each i in [0, n), X::eq(p[i],q[i]) is true; else, a negative value if, for some j in [0, n), X::lt(p[j],q[j]) is true and for each i in [0, j) X::eq(p[i],q[i]) is true; else a positive value. | linear |
| ð X::length(p) |
size_t | Returns: the smallest i such that X::eq(p[i],charT()) is true. | linear |
| ð X::find(p,n,c) |
const X::char_type* | Returns: the smallest q in [p, p+n) such that X::eq(*q,c) is true, nullptr otherwise. | linear |
| ð X::move(s,p,n) |
X::char_type* | for each i in [0, n), performs X::assign(s[i],p[i]). Copies correctly even where the ranges [p, p+n) and [s, s+n) overlap. Returns: s. |
linear |
| ð X::copy(s,p,n) |
X::char_type* | Preconditions: The ranges [p, p+n) and [s, s+n) do not overlap. Returns: s. for each i in [0, n), performs X::assign(s[i],p[i]). |
linear |
| ð X::assign(r,d) |
(not used) | assigns r=d. | constant |
| ð X::assign(s,n,c) |
X::char_type* | for each i in [0, n), performs X::assign(s[i],c). Returns: s. |
linear |
| ð X::not_eof(e) |
int_type | Returns: e if X::eq_int_type(e,X::eof()) is false, otherwise a value f such that X::eq_int_type(f,X::eof()) is false. | constant |
| ð X::to_char_type(e) |
X::char_type | Returns: if for some c, X::eq_int_type(e,X::to_int_type(c)) is true, c; else some unspecified value. | constant |
| ð X::to_int_type(c) |
X::int_type | Returns: some value e, constrained by the definitions of to_char_type and eq_int_type. | constant |
| ð X::eq_int_type(e,f) |
bool | Returns: for all c and d, X::eq(c,d) is equal to X::eq_int_type(X::to_int_type(c), X::to_int_type(d)); otherwise, yields true if e and f are both copies of X::eof(); otherwise, yields false if one of e and f is a copy of X::eof() and the other is not; otherwise the value is unspecified. | constant |
| ð X::eof() |
X::int_type | Returns: a value e such that X::eq_int_type(e,X::to_int_type(c)) is false for all values c. | constant |
The class template
template struct char_traits; is provided in the header as a basis for explicit specializations.
27.2.3 Traits typedefs [char.traits.typedefs]
using int_type = see below;
Preconditions: int_type shall be able to represent all of the valid characters converted from the correspondingchar_type values, as well as an end-of-file value,eof().210
using state_type = see below;
Preconditions: state_type meets theCpp17Destructible (Table 35),Cpp17CopyAssignable (Table 34),Cpp17CopyConstructible (Table 32), andCpp17DefaultConstructible (Table 30) requirements.
Ifeof() can be held inchar_type then some iostreams operations can give surprising results.
27.2.4 char_traits specializations [char.traits.specializations]
27.2.4.1 General [char.traits.specializations.general]
namespace std {template<> struct char_traits; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>;}
The header defines five specializations of the class templatechar_traits:char_traits<char>,char_traits<char8_t>,char_traits<char16_t>,char_traits<char32_t>, andchar_traits<wchar_t>.
27.2.4.2 struct char_traits [char.traits.specializations.char]
namespace std {template<> struct char_traits {using char_type = char; using int_type = int; using off_type = streamoff; using pos_type = streampos; using state_type = mbstate_t; using comparison_category = strong_ordering; static constexpr void assign(char_type& c1, const char_type& c2) noexcept; static constexpr bool eq(char_type c1, char_type c2) noexcept; static constexpr bool lt(char_type c1, char_type c2) noexcept; static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); static constexpr size_t length(const char_type* s); static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* assign(char_type* s, size_t n, char_type a); static constexpr int_type not_eof(int_type c) noexcept; static constexpr char_type to_char_type(int_type c) noexcept; static constexpr int_type to_int_type(char_type c) noexcept; static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; static constexpr int_type eof() noexcept; };}
The type mbstate_t is defined in and can represent any of the conversion states that can occur in animplementation-defined set of supported multibyte character encoding rules.
The two-argument member assign is defined identically to the built-in operator =.
The two-argument members eq and lt are defined identically to the built-in operators== and < for type unsigned char.
The membereof() returnsEOF.
27.2.4.3 struct char_traits<char8_t> [char.traits.specializations.char8.t]
namespace std {template<> struct char_traits<char8_t> {using char_type = char8_t; using int_type = unsigned int; using off_type = streamoff; using pos_type = u8streampos; using state_type = mbstate_t; using comparison_category = strong_ordering; static constexpr void assign(char_type& c1, const char_type& c2) noexcept; static constexpr bool eq(char_type c1, char_type c2) noexcept; static constexpr bool lt(char_type c1, char_type c2) noexcept; static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); static constexpr size_t length(const char_type* s); static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* assign(char_type* s, size_t n, char_type a); static constexpr int_type not_eof(int_type c) noexcept; static constexpr char_type to_char_type(int_type c) noexcept; static constexpr int_type to_int_type(char_type c) noexcept; static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; static constexpr int_type eof() noexcept; };}
The two-argument members assign, eq, and lt are defined identically to the built-in operators =, ==, and < respectively.
The member eof() returns animplementation-defined constant that cannot appear as a valid UTF-8 code unit.
27.2.4.4 struct char_traits<char16_t> [char.traits.specializations.char16.t]
namespace std {template<> struct char_traits<char16_t> {using char_type = char16_t; using int_type = uint_least16_t; using off_type = streamoff; using pos_type = u16streampos; using state_type = mbstate_t; using comparison_category = strong_ordering; static constexpr void assign(char_type& c1, const char_type& c2) noexcept; static constexpr bool eq(char_type c1, char_type c2) noexcept; static constexpr bool lt(char_type c1, char_type c2) noexcept; static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); static constexpr size_t length(const char_type* s); static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* assign(char_type* s, size_t n, char_type a); static constexpr int_type not_eof(int_type c) noexcept; static constexpr char_type to_char_type(int_type c) noexcept; static constexpr int_type to_int_type(char_type c) noexcept; static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; static constexpr int_type eof() noexcept; };}
The two-argument members assign,eq, and lt are defined identically to the built-in operators =, ==, and<, respectively.
The member eof() returns animplementation-defined constant that cannot appear as a valid UTF-16 code unit.
27.2.4.5 struct char_traits<char32_t> [char.traits.specializations.char32.t]
namespace std {template<> struct char_traits<char32_t> {using char_type = char32_t; using int_type = uint_least32_t; using off_type = streamoff; using pos_type = u32streampos; using state_type = mbstate_t; using comparison_category = strong_ordering; static constexpr void assign(char_type& c1, const char_type& c2) noexcept; static constexpr bool eq(char_type c1, char_type c2) noexcept; static constexpr bool lt(char_type c1, char_type c2) noexcept; static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); static constexpr size_t length(const char_type* s); static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* assign(char_type* s, size_t n, char_type a); static constexpr int_type not_eof(int_type c) noexcept; static constexpr char_type to_char_type(int_type c) noexcept; static constexpr int_type to_int_type(char_type c) noexcept; static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; static constexpr int_type eof() noexcept; };}
The two-argument members assign,eq, and lt are defined identically to the built-in operators =, ==, and<, respectively.
The member eof() returns animplementation-defined constant that cannot appear as a Unicode code point.
27.2.4.6 struct char_traits<wchar_t> [char.traits.specializations.wchar.t]
namespace std {template<> struct char_traits<wchar_t> {using char_type = wchar_t; using int_type = wint_t; using off_type = streamoff; using pos_type = wstreampos; using state_type = mbstate_t; using comparison_category = strong_ordering; static constexpr void assign(char_type& c1, const char_type& c2) noexcept; static constexpr bool eq(char_type c1, char_type c2) noexcept; static constexpr bool lt(char_type c1, char_type c2) noexcept; static constexpr int compare(const char_type* s1, const char_type* s2, size_t n); static constexpr size_t length(const char_type* s); static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a); static constexpr char_type* move(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* copy(char_type* s1, const char_type* s2, size_t n); static constexpr char_type* assign(char_type* s, size_t n, char_type a); static constexpr int_type not_eof(int_type c) noexcept; static constexpr char_type to_char_type(int_type c) noexcept; static constexpr int_type to_int_type(char_type c) noexcept; static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept; static constexpr int_type eof() noexcept; };}
The two-argument membersassign,eq, andlt are defined identically to the built-in operators=,==, and<, respectively.
The membereof() returnsWEOF.