std::char_traits
Defined in header <string>
|
||
template
<
class CharT |
||
The char_traits
char_traits
The char_traits
class template serves as a basis for explicit instantiations. The user can provide a specialization
CharTraits
Specializations
The standard library provides the following standard specializations:
Defined in header
<string> | |
std::char_traits<char> | the standard character traits of char |
std::char_traits<wchar_t> | the standard character traits of wchar_t |
std::char_traits<char8_t> (C++20) | the standard character traits of char8_t |
std::char_traits<char16_t> (C++11) | the standard character traits of char16_t |
std::char_traits<char32_t> (C++11) | the standard character traits of char32_t |
All these specializations satisfy the requirements of CharTraits.
Member types
The standard specializations define the following member types required by CharTraits
CharT
|
Member type | ||||
---|---|---|---|---|---|
char_type
|
int_type
|
off_type
|
pos_type
|
state_type
| |
char | char | int | std::streamoff | std::streampos | std::mbstate_t |
wchar_t | wchar_t | std::wint_t | std::wstreampos | ||
char8_t | char8_t | unsigned int | std::u8streampos | ||
char16_t | char16_t | std::uint_least16_t | std::u16streampos | ||
char32_t | char32_t | std::uint_least32_t | std::u32streampos |
On top of that, the standard specializations also define the member type |
(since C++20) |
Member functions
The standard specializations define the following static member functions required by CharTraits
[static]
|
assigns a character (public static member function) |
[static]
|
compares two characters (public static member function) |
[static]
|
moves one character sequence onto another (public static member function) |
[static]
|
copies a character sequence (public static member function) |
[static]
|
lexicographically compares two character sequences (public static member function) |
[static]
|
returns the length of a character sequence (public static member function) |
[static]
|
finds a character in a character sequence (public static member function) |
[static]
|
converts int_type to equivalent char_type (public static member function) |
[static]
|
converts char_type to equivalent int_type (public static member function) |
[static]
|
compares two int_type values (public static member function) |
[static]
|
returns an eof value (public static member function) |
[static]
|
checks whether a character is eof value (public static member function) |
Notes
CharTraits
does not require defining the types and functions listed above as direct members, it only requires types like X::type
and expressions like
X::func(args)
Example
User-defined character traits may be used to provide case-insensitive comparison:
#include <cctype> #include <iostream> #include <string> #include <string_view> struct ci_char_traits : public std::char_traits<char> { static char to_upper(char ch) { return std::toupper((unsigned char) ch); } static bool eq(char c1, char c2) { return to_upper(c1) == to_upper(c2); } static bool lt(char c1, char c2) { return to_upper(c1) < to_upper(c2); } static int compare(const char* s1, const char* s2, std::size_t n) { while (n-- != 0) { if (to_upper(*s1) < to_upper(*s2)) return -1; if (to_upper(*s1) > to_upper(*s2)) return 1; ++s1; ++s2; } return 0; } static const char* find(const char* s, std::size_t n, char a) { const auto ua{to_upper(a)}; while (n-- != 0) { if (to_upper(*s) == ua) return s; s++; } return nullptr; } }; template<class DstTraits, class CharT, class SrcTraits> constexpr std::basic_string_view<CharT, DstTraits> traits_cast(const std::basic_string_view<CharT, SrcTraits> src) noexcept { return {src.data(), src.size()}; } int main() { using namespace std::literals; constexpr auto s1 = "Hello"sv; constexpr auto s2 = "heLLo"sv; if (traits_cast<ci_char_traits>(s1) == traits_cast<ci_char_traits>(s2)) std::cout << s1 << " and " << s2 << " are equal\n"; }
Output:
Hello and heLLo are equal
See also
stores and manipulates sequences of characters (class template) |
|
(C++17)
|
read-only string view (class template) |
wraps a given abstract device (std::basic_streambuf) and provides high-level input interface (class template) |
|
wraps a given abstract device (std::basic_streambuf) and provides high-level output interface (class template) |
|
abstracts a raw device (class template) |