c32rtomb

Convertit un point de code unique de sa représentation en caractère large 32 bits à longueur variable (mais généralement, UTF-32) vers sa représentation en caractère multioctet étroit.

Si s n'est pas un pointeur nul, la fonction détermine le nombre d'octets nécessaires pour stocker la représentation du caractère multi-octets de c32 (en incluant toute séquence de changement, et en prenant en compte l'état actuel de conversion multi-octets * ps ), et stocke la représentation du caractère multi-octets dans le tableau de caractères dont le premier élément est pointé par s , en mettant à jour * ps si nécessaire. Au maximum MB_CUR_MAX octets peuvent être écrits par cette fonction.

Si s est un pointeur nul, l'appel est équivalent à c32rtomb ( buf, U ' \0 ' , ps ) pour un tampon interne buf .

Si c32 est le caractère large nul U ' \0 ' , un octet nul est stocké, précédé de toute séquence de changement nécessaire pour restaurer l'état de changement initial et le paramètre d'état de conversion * ps est mis à jour pour représenter l'état de changement initial.

Si la macro __STDC_UTF_32__ est définie, l'encodage 32 bits utilisé par cette fonction est UTF-32 ; sinon, il est défini par l'implémentation. La macro est toujours définie et l'encodage est toujours UTF-32. (depuis C23) Dans tous les cas, l'encodage des caractères multioctets utilisé par cette fonction est spécifié par les paramètres régionaux C actuellement actifs.

Paramètres

Valeur de retour

En cas de succès, retourne le nombre d'octets (y compris toute séquence de décalage) écrits dans le tableau de caractères dont le premier élément est pointé par s . Cette valeur peut être ​ 0 ​ , par exemple lors du traitement des unités char32_t initiales dans une séquence multi- char32_t -unit (ne se produit pas en UTF-32).

En cas d'échec (si c32 n'est pas un caractère large 32 bits valide), retourne - 1 , stocke EILSEQ dans errno , et laisse * ps dans un état non spécifié.

Exemple

#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <uchar.h>
int main(void)
{
    setlocale(LC_ALL, "en_US.utf8");
    const char32_t in[] = U"zß水🍌"; // or "z\u00df\u6c34\U0001F34C"
    size_t in_sz = sizeof in / sizeof *in;
    printf("Processing %zu UTF-32 code units: [", in_sz);
    for (size_t n = 0; n < in_sz; ++n)
        printf("%s%08X", n ? " " : "", in[n]);
    puts("]");
    char* out = malloc(MB_CUR_MAX * in_sz);
    char* p = out;
    mbstate_t state = {0};
    for (size_t n = 0; n < in_sz; ++n)
    {
        size_t rc = c32rtomb(p, in[n], &state);
        if(rc == (size_t)-1) break;
        p += rc;
    }
    size_t out_sz = p - out;
    printf("into %zu UTF-8 code units: [", out_sz);
    for (size_t x = 0; x < out_sz; ++x)
        printf("%s%02X", x ? " " : "", +(unsigned char)out[x]);
    puts("]");
    free(out);
}

Processing 5 UTF-32 code units: [0000007A 000000DF 00006C34 0001F34C 00000000]
into 11 UTF-8 code units: [7A C3 9F E6 B0 B4 F0 9F 8D 8C 00]

Références

Voir aussi