std::char_traits

From cppreference.com
< cpp‎ | string
Defined in header <string>
template <

class CharT

> class char_traits;

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 comparison_category as std::strong_ordering.

(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)
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)