std:: char_traits

La clase char_traits es una plantilla de clase de rasgos que abstrae las operaciones básicas de caracteres y cadenas para un tipo de carácter dado. El conjunto de operaciones definido es tal que los algoritmos genéricos casi siempre pueden implementarse en términos de ella. Por lo tanto, es posible utilizar dichos algoritmos con casi cualquier tipo de carácter o cadena posible, simplemente proporcionando una clase char_traits personalizada.

La plantilla de clase char_traits sirve como base para instanciaciones explícitas. El usuario puede proporcionar una especialización para cualquier tipo de carácter personalizado. Se proporcionan varias especializaciones explícitas para los tipos de carácter estándar (ver más abajo), otras especializaciones no están obligadas a satisfacer los requisitos de CharTraits .

Especializaciones

La biblioteca estándar proporciona las siguientes especializaciones estándar:

Todas estas especializaciones satisfacen los requisitos de CharTraits .

Tipos de miembros

Las especializaciones estándar definen los siguientes tipos de miembros requeridos por CharTraits :

Funciones miembro

Las especializaciones estándar definen las siguientes funciones miembro estáticas requeridas por CharTraits :

Notas

CharTraits no requiere definir los tipos y funciones listados anteriormente como miembros directos, solo requiere que tipos como X::type y expresiones como X :: func ( args ) sean válidas y tengan la semántica requerida. Los rasgos de caracteres definidos por el usuario pueden derivarse de otras clases de rasgos de caracteres y solo sobrescribir algunos de sus miembros, consulte el ejemplo a continuación.

Ejemplo

#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";
}

Hello and heLLo are equal

Véase también