std:: wctomb

Convertit un caractère large wc en encodage multioctet et le stocke (y compris toute séquence de changement) dans le tableau de caractères dont le premier élément est pointé par s . Pas plus de MB_CUR_MAX caractères sont stockés. La conversion est affectée par la catégorie LC_CTYPE des paramètres régionaux actuels.

Si wc est le caractère nul, l'octet nul est écrit dans s , précédé de toute séquence de changement nécessaire pour restaurer l'état de changement initial.

Si s est un pointeur nul, réinitialise l'état de conversion global et détermine si les séquences de décalage sont utilisées.

Paramètres

Valeur de retour

Si s n'est pas un pointeur nul, retourne le nombre d'octets contenus dans la représentation multi-octets de wc ou - 1 si wc n'est pas un caractère valide.

Si s est un pointeur nul, réinitialise son état de conversion interne pour représenter l'état de décalage initial et retourne ​ 0 ​ si l'encodage multioctet actuel n'est pas dépendant de l'état (n'utilise pas de séquences de décalage) ou une valeur non nulle si l'encodage multioctet actuel est dépendant de l'état (utilise des séquences de décalage).

Notes

Chaque appel à wctomb met à jour l'état de conversion global interne (un objet statique de type std::mbstate_t , uniquement connu de cette fonction). Si l'encodage multioctet utilise des états de changement, cette fonction n'est pas réentrante. Dans tous les cas, plusieurs threads ne devraient pas appeler wctomb sans synchronisation : std::wcrtomb peut être utilisé à la place.

Exemple

#include <clocale>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <string>
void print_wide(const std::wstring& wstr)
{
    bool shifts = std::wctomb(nullptr, 0); // réinitialiser l'état de conversion
    std::cout << "les séquences de décalage sont " << (shifts ? "" : "non " )
              << "utilisées\n" << std::uppercase << std::setfill('0');
    for (const wchar_t wc : wstr)
    {
        std::string mb(MB_CUR_MAX, '\0');
        const int ret = std::wctomb(&mb[0], wc);
        const char* s = ret > 1 ? "s" : "";
        std::cout << "le caractère multi-octets '" << mb << "' fait " << ret
                  << " octet" << s << ": [" << std::hex;
        for (int i{0}; i != ret; ++i)
        {
            const int c = 0xFF & mb[i];
            std::cout << (i ? " " : "") << std::setw(2) << c;
        }
        std::cout << "]\n" << std::dec;
    }
}
int main()
{
    std::setlocale(LC_ALL, "en_US.utf8");
    // Encodage multi-octets étroit UTF-8
    std::wstring wstr = L"z\u00df\u6c34\U0001d10b"; // ou L"zß水𝄋"
    print_wide(wstr);
}

les séquences de décalage sont non utilisées
le caractère multi-octets 'z' fait 1 octet: [7A]
le caractère multi-octets 'ß' fait 2 octets: [C3 9F]
le caractère multi-octets '水' fait 3 octets: [E6 B0 B4]
le caractère multi-octets '𝄋' fait 4 octets: [F0 9D 84 8B]

Voir aussi