std:: char_traits

Die char_traits -Klasse ist eine Traits-Klassenvorlage, die grundlegende Zeichen- und Zeichenkettenoperationen für einen gegebenen Zeichentyp abstrahiert. Der definierte Operationensatz ist so gestaltet, dass generische Algorithmen fast immer darauf aufbauend implementiert werden können. Es ist somit möglich, solche Algorithmen mit nahezu jedem beliebigen Zeichen- oder Zeichenkettentyp zu verwenden, indem man einfach eine angepasste char_traits -Klasse bereitstellt.

Die char_traits -Klassenvorlage dient als Basis für explizite Instanziierungen. Der Benutzer kann eine Spezialisierung bereitstellen für beliebige benutzerdefinierte Zeichentypen. Mehrere explizite Spezialisierungen sind für die Standard-Zeichentypen vorhanden (siehe unten), andere Spezialisierungen müssen nicht die Anforderungen von CharTraits erfüllen.

Spezialisierungen

Die Standardbibliothek bietet die folgenden Standardspezialisierungen:

Alle diese Spezialisierungen erfüllen die Anforderungen von CharTraits .

Mitgliedertypen

Die Standardspezialisierungen definieren die folgenden Membertypen, die von CharTraits benötigt werden:

Memberfunktionen

Die standardmäßigen Spezialisierungen definieren die folgenden statischen Elementfunktionen, die von CharTraits benötigt werden:

Hinweise

CharTraits erfordert nicht, dass die oben aufgeführten Typen und Funktionen als direkte Member definiert werden, es werden lediglich Typen wie X::type und Ausdrücke wie X :: func ( args ) gültig sind und die erforderliche Semantik haben. Benutzerdefinierte Zeicheneigenschaften können von anderen Zeicheneigenschaftenklassen abgeleitet werden und nur einige ihrer Member überschreiben, siehe das folgende Beispiel.

Beispiel

#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

Siehe auch