Standardbibliothek-Header <cwchar>

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Header der Standardbibliothek

Sprachunterstützung <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)    <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Konzepte <concepts> (C++20) Diagnose <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Speicherverwaltung <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogrammierung <type_traits> (C++11) <ratio> (C++11)

Allgemeine Hilfsmittel <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Container <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)    <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteratoren <iterator> Bereiche (Ranges) <generator> (C++23) <ranges> (C++20)

Algorithmen <algorithm> <numeric> Strings <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Textverarbeitung <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)    Numerik <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <valarray> Zeit <chrono> (C++11) <ctime> C Kompatibilität <ccomplex> (C++11/17/20*) <ciso646> (bis C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Ein-/Ausgabe <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Nebenläufigkeitsunterstützung <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Ausführungshilfe <execution> (C++17)

 

Dieser Header war ursprünglich Teil der C-Standardbibliothek als <wchar.h>.

Dieser Header ist Teil der Bibliotheken für nullterminierte weite und Mehrbyte-Zeichen-Strings. Er stellt auch einige C-Style I/O-Funktionen und Konvertierungen von C-Style Datum bereit.

Makros

NULL	implementierungsdefinierte Nullzeigerkonstante (macro constant)
WEOF	ein Nicht-Zeichenwert vom Typ std::wint_t, der zur Anzeige von Fehlern verwendet wird (Makro-Konstante)
WCHAR_MIN	der kleinste gültige Wert von wchar_t (Makro-Konstante)
WCHAR_MAX	der größte gültige Wert von wchar_t (Makro-Konstante)

Typen

mbstate_t	Konvertierungsinformationen, die zum Iterieren über Multibyte-Zeichenstrings benötigt werden (Klasse)
size_t	nicht vorzeichenbehafteter Ganzzahltyp, der vom sizeof-Operator zurückgegeben wird (typedef)
wint_t	Ganzzahliger Typ, der jedes gültige breite Zeichen und mindestens einen weiteren Wert speichern kann
tm	Typ für Kalenderzeit (Klasse)

Funktionen

Stringmanipulation
wcscpy	kopiert eine breite Zeichenkette in eine andere (Funktion)
wcsncpy	kopiert eine bestimmte Anzahl breiter Zeichen von einer Zeichenkette in eine andere (Funktion)
wcscat	hängt eine Kopie einer breiten Zeichenkette an eine andere an (Funktion)
wcsncat	hängt eine bestimmte Anzahl breiter Zeichen von einer breiten Zeichenkette an eine andere an (Funktion)
wcsxfrm	transformiert eine breite Zeichenkette so, dass wcscmp dasselbe Ergebnis wie wcscoll liefert (Funktion)
Stringuntersuchung
wcslen	gibt die Länge einer breiten Zeichenkette zurück (Funktion)
wcscmp	vergleicht zwei breite Zeichenketten (Funktion)
wcsncmp	vergleicht eine bestimmte Anzahl von Zeichen aus zwei breiten Zeichenketten (Funktion)
wcscoll	vergleicht zwei breite Zeichenketten gemäß der aktuellen Locale (Funktion)
wcschr	findet das erste Vorkommen eines breiten Zeichens in einer breiten Zeichenkette (Funktion)
wcsrchr	findet das letzte Vorkommen eines breiten Zeichens in einer breiten Zeichenkette (Funktion)
wcsspn	gibt die Länge des maximalen Anfangssegments zurück, das nur von den breiten Zeichen, die in einer anderen breiten Zeichenkette gefunden wurden (Funktion)
wcscspn	gibt die Länge des maximalen Anfangssegments zurück, das nur von den breiten Zeichen, die nicht in einer anderen breiten Zeichenkette gefunden wurden (Funktion)
wcspbrk	findet die erste Stelle irgendeines breiten Zeichens aus einer breiten Zeichenkette in einer anderen breiten Zeichenkette (Funktion)
wcsstr	findet das erste Vorkommen einer breiten Zeichenkette innerhalb einer anderen breiten Zeichenkette (Funktion)
wcstok	findet das nächste Token in einer breiten Zeichenkette (Funktion)
Manipulation von breiten Zeichen-Arrays
wmemcpy	kopiert eine bestimmte Anzahl breiter Zeichen zwischen zwei nicht überlappenden Arrays (Funktion)
wmemmove	kopiert eine bestimmte Anzahl breiter Zeichen zwischen zwei, möglicherweise überlappenden, Arrays (Funktion)
wmemcmp	vergleicht eine bestimmte Anzahl breiter Zeichen aus zwei Arrays (Funktion)
wmemchr	findet das erste Vorkommen eines breiten Zeichens in einem breiten Zeichen-Array (Funktion)
wmemset	kopiert das gegebene breite Zeichen in jede Position eines breiten Zeichen-Arrays (Funktion)
Konvertierung von Mehrbyte-/weiten Zeichen
mbsinit	prüft, ob das std::mbstate_t-Objekt den anfänglichen Shift-Zustand repräsentiert (Funktion)
btowc	erweitert ein ein Byte breites schmales Zeichen zu einem Wide-Zeichen, falls möglich (Funktion)
wctob	verengt ein Wide-Zeichen zu einem ein Byte breiten schmalen Zeichen, falls möglich (Funktion)
mbrlen	gibt die Anzahl der Bytes im nächsten Multibyte-Zeichen zurück, gegeben den Zustand (Funktion)
mbrtowc	konvertiert das nächste Multibyte-Zeichen in ein Wide-Zeichen, gegeben den Zustand (Funktion)
wcrtomb	konvertiert ein Wide-Zeichen in seine Multibyte-Darstellung, gegeben den Zustand (Funktion)
mbsrtowcs	konvertiert einen schmalen Multibyte-Zeichenstring in einen Wide-String, gegeben den Zustand (Funktion)
wcsrtombs	konvertiert einen Wide-String in einen schmalen Multibyte-Zeichenstring, gegeben den Zustand (Funktion)
Ein-/Ausgabe
fgetwcgetwc	liest ein Weitzeichen aus einem Dateistream (Funktion)
fgetws	liest einen Weitzeichenstring aus einem Dateistream (Funktion)
fputwcputwc	schreibt ein Weitzeichen in einen Dateistream (Funktion)
fputws	schreibt einen Weitzeichenstring in einen Dateistream (Funktion)
getwchar	liest ein breites Zeichen von stdin (Funktion)
putwchar	schreibt ein breites Zeichen nach stdout (Funktion)
ungetwc	gibt ein Weitzeichen zurück in einen Dateistream (Funktion)
fwide	wechselt einen Dateistream zwischen Weitzeichen-E/A und Schmalzeichen-E/A (Funktion)
wscanffwscanfswscanf	liest formatierte breite Zeichen-Eingabe von stdin, einem Dateistream oder einem Puffer (Funktion)
vwscanfvfwscanfvswscanf (C++11)(C++11)(C++11)	liest formatierte breite Zeichen-Eingabe von stdin, einem Dateistream oder einem Puffer mit variabler Argumentenliste (Funktion)
wprintffwprintfswprintf	druckt formatierte breite Zeichen-Ausgabe nach stdout, einem Dateistream oder einem Puffer (Funktion)
vwprintfvfwprintfvswprintf	druckt formatierte breite Zeichen-Ausgabe nach stdout, einem Dateistream oder einem Puffer mit variabler Argumentenliste (Funktion)
String-Konvertierungen
wcsftime	konvertiert ein std::tm-Objekt in eine benutzerdefinierte Textdarstellung als breites Zeichen-String (Funktion)
wcstolwcstoll	wandelt eine breite Zeichenkette in einen ganzzahligen Wert um (Funktion)
wcstoulwcstoull	wandelt eine breite Zeichenkette in einen vorzeichenlosen ganzzahligen Wert um (Funktion)
wcstofwcstodwcstold	wandelt eine breite Zeichenkette in einen Fließkommawert um (Funktion)

Hinweise

• NULL ist auch in den folgenden Headern definiert
  • <cstddef>
  • <cstring>
  • <ctime>
  • <clocale>
  • <cstdio>
• std::size_t ist auch in den folgenden Headern definiert
  • <cstddef>
  • <ctime>
  • <cstdio>
• std::wint_t ist auch in den folgenden Headern definiert
  • <cwctype>
• std::tm ist auch in den folgenden Headern definiert
  • <ctime>

Synopsis

namespace std {
  using size_t =    /* see description */; // freestanding
  using mbstate_t = /* see description */; // freestanding
  using wint_t =    /* see description */; // freestanding
 
  struct tm;
 
  int fwprintf(FILE* stream, const wchar_t* format, ...);
  int fwscanf(FILE* stream, const wchar_t* format, ...);
  int swprintf(wchar_t* s, size_t n, const wchar_t* format, ...);
  int swscanf(const wchar_t* s, const wchar_t* format, ...);
  int vfwprintf(FILE* stream, const wchar_t* format, va_list arg);
  int vfwscanf(FILE* stream, const wchar_t* format, va_list arg);
  int vswprintf(wchar_t* s, size_t n, const wchar_t* format, va_list arg);
  int vswscanf(const wchar_t* s, const wchar_t* format, va_list arg);
  int vwprintf(const wchar_t* format, va_list arg);
  int vwscanf(const wchar_t* format, va_list arg);
  int wprintf(const wchar_t* format, ...);
  int wscanf(const wchar_t* format, ...);
  wint_t fgetwc(FILE* stream);
  wchar_t* fgetws(wchar_t* s, int n, FILE* stream);
  wint_t fputwc(wchar_t c, FILE* stream);
  int fputws(const wchar_t* s, FILE* stream);
  int fwide(FILE* stream, int mode);
  wint_t getwc(FILE* stream);
  wint_t getwchar();
  wint_t putwc(wchar_t c, FILE* stream);
  wint_t putwchar(wchar_t c);
  wint_t ungetwc(wint_t c, FILE* stream);
  double wcstod(const wchar_t* nptr, wchar_t** endptr);
  float wcstof(const wchar_t* nptr, wchar_t** endptr);
  long double wcstold(const wchar_t* nptr, wchar_t** endptr);
  long int wcstol(const wchar_t* nptr, wchar_t** endptr, int base);
  long long int wcstoll(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long int wcstoul(const wchar_t* nptr, wchar_t** endptr, int base);
  unsigned long long int wcstoull(const wchar_t* nptr, wchar_t** endptr, int base);
  wchar_t* wcscpy(wchar_t* s1, const wchar_t* s2);                // freestanding
  wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);     // freestanding
  wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n);     // freestanding
  wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);    // freestanding
  wchar_t* wcscat(wchar_t* s1, const wchar_t* s2);                // freestanding
  wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n);     // freestanding
  int wcscmp(const wchar_t* s1, const wchar_t* s2);               // freestanding
  int wcscoll(const wchar_t* s1, const wchar_t* s2);
  int wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n);    // freestanding
  size_t wcsxfrm(wchar_t* s1, const wchar_t* s2, size_t n);
  int wmemcmp(const wchar_t* s1, const wchar_t* s2, size_t n);    // freestanding
  const wchar_t* wcschr(const wchar_t* s, wchar_t c);             // freestanding
  wchar_t* wcschr(wchar_t* s, wchar_t c);                         // freestanding
  size_t wcscspn(const wchar_t* s1, const wchar_t* s2);           // freestanding
  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);   // freestanding
  wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2);               // freestanding
  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);            // freestanding
  wchar_t* wcsrchr(wchar_t* s, wchar_t c);                        // freestanding
  size_t wcsspn(const wchar_t* s1, const wchar_t* s2);            // freestanding
  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);    // freestanding
  wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2);                // freestanding
  wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr); // freestanding
  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);  // freestanding
  wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n);              // freestanding
  size_t wcslen(const wchar_t* s);                                // freestanding
  wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);              // freestanding
  size_t wcsftime(wchar_t* s, size_t maxsize, const wchar_t* format, const tm* timeptr);
  wint_t btowc(int c);
  int wctob(wint_t c);
 
  // multibyte / wide string and character conversion functions
  int mbsinit(const mbstate_t* ps);
  size_t mbrlen(const char* s, size_t n, mbstate_t* ps);
  size_t mbrtowc(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps);
  size_t wcrtomb(char* s, wchar_t wc, mbstate_t* ps);
  size_t mbsrtowcs(wchar_t* dst, const char** src, size_t len, mbstate_t* ps);
  size_t wcsrtombs(char* dst, const wchar_t** src, size_t len, mbstate_t* ps);
}
 
#define NULL      /* see description */ // freestanding
#define WCHAR_MAX /* see description */ // freestanding
#define WCHAR_MIN /* see description */ // freestanding
#define WEOF      /* see description */ // freestanding

Defect Reports

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 345	C++98	std::tm wurde in <cwchar> nicht bereitgestellt	bereitgestellt