std:: char_traits

La classe char_traits est un modèle de classe de traits qui abstrait les opérations de base sur les caractères et les chaînes pour un type de caractère donné. L'ensemble d'opérations défini est tel que les algorithmes génériques peuvent presque toujours être implémentés en fonction de celui-ci. Il est ainsi possible d'utiliser de tels algorithmes avec presque n'importe quel type de caractère ou de chaîne, simplement en fournissant une classe char_traits personnalisée.

Le modèle de classe char_traits sert de base pour les instanciations explicites. L'utilisateur peut fournir une spécialisation pour tout type de caractère personnalisé. Plusieurs spécialisations explicites sont fournies pour les types de caractères standards (voir ci-dessous), les autres spécialisations ne sont pas tenues de satisfaire aux exigences de CharTraits .

Spécialisations

La bibliothèque standard fournit les spécialisations standard suivantes :

Toutes ces spécialisations satisfont aux exigences de CharTraits .

Types membres

Les spécialisations standards définissent les types membres suivants requis par CharTraits :

Fonctions membres

Les spécialisations standards définissent les fonctions membres statiques suivantes requises par CharTraits :

Notes

CharTraits n'exige pas de définir les types et fonctions listés ci-dessus comme membres directs, il exige seulement que des types comme X::type et des expressions comme X :: func ( args ) soient valides et possèdent la sémantique requise. Les traits de caractères définis par l'utilisateur peuvent être dérivés d'autres classes de traits de caractères et ne remplacer que certains de leurs membres, voir l'exemple ci-dessous.

Exemple

#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

Voir aussi