Standard library header <cwchar>

From cppreference.net

Cet en-tête était à l'origine dans la bibliothèque standard C sous le nom de <wchar.h> .

Cet en-tête fait partie des bibliothèques de chaînes wide et multibyte à terminaison nulle. Il fournit également certaines fonctions C-style I/O et la conversion depuis C-style Date .

Table des matières

Macros

NULL	constante de pointeur nul définie par l'implémentation (constante macro)
WEOF	une valeur non-caractère de type `std::wint_t` utilisée pour indiquer des erreurs (constante macro)
WCHAR_MIN	la plus petite valeur valide de wchar_t (constante macro)
WCHAR_MAX	la plus grande valeur valide de wchar_t (constante macro)

Types

mbstate_t	informations d'état de conversion nécessaires pour itérer sur les chaînes de caractères multioctets (classe)
size_t	type entier non signé retourné par l'opérateur `sizeof` (typedef)
`wint_t`	type entier pouvant contenir n'importe quel caractère large valide et au moins une valeur supplémentaire
tm	type de temps calendaire (classe)

Fonctions

Manipulation de chaînes
wcscpy	copie une chaîne large vers une autre (fonction)
wcsncpy	copie une certaine quantité de caractères larges d'une chaîne à une autre (fonction)
wcscat	ajoute une copie d'une chaîne large à une autre (fonction)
wcsncat	ajoute un certain nombre de caractères larges d'une chaîne large à une autre (fonction)
wcsxfrm	transforme une chaîne large de sorte que `wcscmp` produirait le même résultat que `wcscoll` (fonction)
Examen des chaînes
wcslen	retourne la longueur d'une chaîne large (fonction)
wcscmp	compare deux chaînes larges (fonction)
wcsncmp	compare un certain nombre de caractères de deux chaînes larges (fonction)
wcscoll	compare deux chaînes larges conformément à la locale actuelle (fonction)
wcschr	trouve la première occurrence d'un caractère large dans une chaîne large (fonction)
wcsrchr	trouve la dernière occurrence d'un caractère large dans une chaîne large (fonction)
wcsspn	retourne la longueur du segment initial maximal qui consiste uniquement en caractères larges trouvés dans une autre chaîne large (fonction)
wcscspn	retourne la longueur du segment initial maximal qui consiste uniquement en caractères larges non trouvés dans une autre chaîne large (fonction)
wcspbrk	trouve la première occurrence de n'importe quel caractère large d'une chaîne large dans une autre chaîne large (fonction)
wcsstr	trouve la première occurrence d'une chaîne large dans une autre chaîne large (fonction)
wcstok	trouve le jeton suivant dans une chaîne large (fonction)
Manipulation de tableaux de caractères larges
wmemcpy	copie une certaine quantité de caractères larges entre deux tableaux non chevauchants (fonction)
wmemmove	copie une certaine quantité de caractères larges entre deux tableaux, potentiellement chevauchants (fonction)
wmemcmp	compare une certaine quantité de caractères larges de deux tableaux (fonction)
wmemchr	trouve la première occurrence d'un caractère large dans un tableau de caractères larges (fonction)
wmemset	copie le caractère large donné à chaque position d'un tableau de caractères larges (fonction)
Conversion de caractères multioctets/étendus
mbsinit	vérifie si l'objet std::mbstate_t représente l'état de shift initial (fonction)
btowc	élargit un caractère étroit d'un octet en caractère large, si possible (fonction)
wctob	rétrécit un caractère large en un caractère étroit d'un seul octet, si possible (fonction)
mbrlen	retourne le nombre d'octets dans le prochain caractère multioctet, en fonction de l'état (fonction)
mbrtowc	convertit le prochain caractère multi-octets en caractère large, en fonction de l'état (fonction)
wcrtomb	convertit un caractère large en sa représentation multioctet, en tenant compte de l'état (fonction)
mbsrtowcs	convertit une chaîne de caractères multioctets étroite en chaîne large, avec état donné (fonction)
wcsrtombs	convertit une chaîne large en chaîne de caractères multioctets étroite, avec état donné (fonction)
Entrée/Sortie
fgetwc getwc	obtient un caractère large depuis un flux de fichier (fonction)
fgetws	obtient une chaîne large depuis un flux de fichier (fonction)
fputwc putwc	écrit un caractère large dans un flux de fichier (fonction)
fputws	écrit une chaîne large dans un flux de fichier (fonction)
getwchar	lit un caractère large depuis stdin (fonction)
putwchar	écrit un caractère large vers stdout (fonction)
ungetwc	place un caractère large dans un flux de fichier (fonction)
fwide	bascule un flux de fichier entre les E/S de caractères larges et les E/S de caractères étroits (fonction)
wscanf fwscanf swscanf	lit une entrée de caractères larges formatée depuis stdin , un flux de fichier ou un tampon (fonction)
vwscanf vfwscanf vswscanf (C++11) (C++11) (C++11)	lit une entrée de caractères larges formatée depuis stdin , un flux de fichier ou un tampon en utilisant une liste d'arguments variables (fonction)
wprintf fwprintf swprintf	imprime une sortie formatée de caractères larges vers stdout , un flux de fichier ou un tampon (fonction)
vwprintf vfwprintf vswprintf	imprime une sortie formatée de caractères larges vers stdout , un flux de fichier ou un tampon en utilisant une liste d'arguments variables (fonction)
Conversions de chaînes
wcsftime	convertit un std::tm en une représentation textuelle personnalisée de chaîne large (fonction)
wcstol wcstoll	convertit une chaîne large en valeur entière (fonction)
wcstoul wcstoull	convertit une chaîne large en une valeur entière non signée (fonction)
wcstof wcstod wcstold	convertit une chaîne large en une valeur à virgule flottante (fonction)

Notes

NULL est également défini dans les en-têtes suivants :
std::size_t est également défini dans les en-têtes suivants :
std::wint_t est également défini dans les en-têtes suivants :
- <cwctype>
std::tm est également défini dans les en-têtes suivants :
- <ctime>

Synopsis

namespace std {
  using size_t =    /* voir description */; // autonome
  using mbstate_t = /* voir description */; // autonome
  using wint_t =    /* voir description */; // autonome
  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);                // autonome
  wchar_t* wcsncpy(wchar_t* s1, const wchar_t* s2, size_t n);     // autonome
  wchar_t* wmemcpy(wchar_t* s1, const wchar_t* s2, size_t n);     // autonome
  wchar_t* wmemmove(wchar_t* s1, const wchar_t* s2, size_t n);    // autonome
  wchar_t* wcscat(wchar_t* s1, const wchar_t* s2);                // autonome
  wchar_t* wcsncat(wchar_t* s1, const wchar_t* s2, size_t n);     // autonome
  int wcscmp(const wchar_t* s1, const wchar_t* s2);               // autonome
  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);    // autonome
  const wchar_t* wcschr(const wchar_t* s, wchar_t c);             // autonome
  wchar_t* wcschr(wchar_t* s, wchar_t c);                         // autonome
  size_t wcscspn(const wchar_t* s1, const wchar_t* s2);           // autonome
  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);   // autonome
  wchar_t* wcspbrk(wchar_t* s1, const wchar_t* s2);               // freestanding
  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);            // autonome
  wchar_t* wcsrchr(wchar_t* s, wchar_t c);                        // autonome
  size_t wcsspn(const wchar_t* s1, const wchar_t* s2);            // autonome
  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);    // autonome
  wchar_t* wcsstr(wchar_t* s1, const wchar_t* s2);                // autonome
  wchar_t* wcstok(wchar_t* s1, const wchar_t* s2, wchar_t** ptr); // autonome
  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);  // autonome
  wchar_t* wmemchr(wchar_t* s, wchar_t c, size_t n);              // autonome
  size_t wcslen(const wchar_t* s);                                // autonome
  wchar_t* wmemset(wchar_t* s, wchar_t c, size_t n);              // autonome
  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);
  // fonctions de conversion de chaînes et caractères multioctets / larges
  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      /* voir description */ // freestanding
#define WCHAR_MAX /* voir description */ // freestanding
#define WCHAR_MIN /* voir description */ // freestanding
#define WEOF      /* voir description */ // freestanding

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Applicable à	Comportement publié	Comportement corrigé
LWG 345	C++98	std::tm n'était pas fourni dans `<cwchar>`	fourni

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <cwchar>

Table des matières

Macros

Types

Fonctions

Manipulation de chaînes

Examen des chaînes

Manipulation de tableaux de caractères larges

Conversion de caractères multioctets/étendus

Entrée/Sortie

Conversions de chaînes

Notes

Synopsis

Rapports de défauts