std::char_traits
| Definiert in Header <string> |
||
| template< class CharT |
||
Die char_traits-Klasse ist eine Traits-Klassenvorlage, die grundlegende Zeichen- und Zeichenkettenoperationen für einen gegebenen Zeichentyp abstrahiert. Die definierten Operationen sind so gestaltet, dass generische Algorithmen fast immer auf ihrer Grundlage implementiert werden können. Es ist somit möglich, solche Algorithmen mit fast jedem möglichen Zeichen- oder Zeichentyp zu verwenden, indem einfach eine angepasste char_traits-Klasse bereitgestellt wird.
Die char_traits-Klassenvorlage dient als Basis für explizite Instanziierungen. Der Benutzer kann eine Spezialisierung für beliebige benutzerdefinierte Zeichentypen bereitstellen. Mehrere explizite Spezialisierungen sind für die Standardzeichentypen vorgesehen (siehe unten), andere Spezialisierungen sind nicht erforderlich, um die Anforderungen von CharTraits zu erfüllen.
Inhalt |
[bearbeiten] Spezialisierungen
Die Standardbibliothek bietet die folgenden Standard-Spezialisierungen
| Definiert in Header
<string> | |
| std::char_traits<char> | die Standard-Zeichen-Traits für char |
| std::char_traits<wchar_t> | die Standard-Zeichen-Traits für wchar_t |
| std::char_traits<char8_t> (C++20) | die Standard-Zeichen-Traits für char8_t |
| std::char_traits<char16_t> (C++11) | die Standard-Zeichen-Traits für char16_t |
| std::char_traits<char32_t> (C++11) | die Standard-Zeichen-Traits für char32_t |
Alle diese Spezialisierungen erfüllen die Anforderungen von CharTraits.
[bearbeiten] Member-Typen
Die Standard-Spezialisierungen definieren die folgenden Member-Typen, die von CharTraits gefordert werden:
CharT
|
Mitgliedertyp | ||||
|---|---|---|---|---|---|
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 | ||
|
Darüber hinaus definieren die Standard-Spezialisierungen auch den Member-Typ |
(seit C++20) |
[bearbeiten] Member-Funktionen
Die Standard-Spezialisierungen definieren die folgenden statischen Member-Funktionen, die von CharTraits gefordert werden:
| [static] |
weist ein Zeichen zu (public static member function) |
| [static] |
vergleicht zwei Zeichen (public static member function) |
| [static] |
verschiebt eine Zeichensequenz auf eine andere (public static member function) |
| [static] |
kopiert eine Zeichensequenz (public static member function) |
| [static] |
vergleicht zwei Zeichensequenzen lexikographisch (public static member function) |
| [static] |
gibt die Länge einer Zeichensequenz zurück (public static member function) |
| [static] |
sucht ein Zeichen in einer Zeichensequenz (public static member function) |
| [static] |
konvertiert int_type in den äquivalenten char_type(public static member function) |
| [static] |
konvertiert char_type in den äquivalenten int_type(public static member function) |
| [static] |
vergleicht zwei int_type-Werte(public static member function) |
| [static] |
gibt einen eof-Wert zurück (public static member function) |
| [static] |
prüft, ob ein Zeichen ein eof-Wert ist (public static member function) |
[bearbeiten] Hinweise
CharTraits erfordert nicht, dass die oben aufgeführten Typen und Funktionen als direkte Member definiert werden, sondern nur, dass Typen wie X::type und Ausdrücke wie X::func(args) gültig sind und die erforderliche Semantik aufweisen. Benutzerdefinierte Zeichen-Traits können von anderen Zeichen-Trait-Klassen abgeleitet werden und nur einige ihrer Member überschreiben, siehe das Beispiel unten.
[bearbeiten] Beispiel
Benutzerdefinierte Zeichen-Traits können verwendet werden, um Groß-/Kleinschreibungs-unabhängigen Vergleich zu ermöglichen.
#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"; }
Ausgabe
Hello and heLLo are equal
[bearbeiten] Siehe auch
| speichert und manipuliert Zeichenfolgen (Klassenvorlage) | |
| (C++17) |
schreibgeschützte String-Ansicht (class template) |
| kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Eingabeschnittstelle bereit (class template) | |
| kapselt ein gegebenes abstraktes Gerät (std::basic_streambuf) und stellt eine High-Level-Ausgabeschnittstelle bereit (class template) | |
| abstrahiert ein Rohgerät (class template) |
