Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Littéral de chaîne u8 : unités de code, points de code et grappes de graphèmes

Le préfixe `u8` sélectionne l’encodage UTF-8 du littéral. La longueur en unités de code, le nombre de points de code et le nombre de grappes de graphèmes sont des mesures distinctes.

Version : ISO C++23; implementation support may vary

Syntaxe

u8"text"
u8R"tag(raw text)tag"

// C++23: a view over the UTF-8 code units of a literal
#include <string_view>
constexpr std::u8string_view text = u8"e\u0301";

u8"texte" est un littéral de chaîne dont l’encodage est UTF-8. Depuis C++20, c’est un tableau non modifiable de type const char8_t[N] à durée de stockage statique ; de C++11 à C++17, son type était const char[N]. N comprend l’unité nulle ajoutée à la fin. Un littéral sans préfixe utilise l’encodage des littéraux ordinaires, qui n’est pas nécessairement UTF-8. Dans la forme brute u8R"tag(...)tag", les barres obliques inverses n’introduisent pas de séquences d’échappement.

Lorsque le tableau est converti en pointeur, on obtient un const char8_t*, pas un const char*. C++23 autorise l’initialisation directe de tableaux de char ou de unsigned char avec un littéral u8, sans introduire de conversion implicite entre ces types de pointeurs. La prise en charge de cette correction peut varier selon l’implémentation. std::cout << u8"x" sélectionne une surcharge supprimée. Avant de passer du texte à une interface qui prend un const char*, vérifiez l’encodage qu’elle attend.

std::u8string_view, déclaré dans <string_view>, ne possède pas ses données. Une vue sur un littéral peut référencer son stockage pendant toute l’exécution du programme. size() compte les unités de code de la vue. Le constructeur qui prend seulement un pointeur s’arrête avant le premier zéro ; fournissez un pointeur et une longueur pour conserver les zéros internes.

Une unité de code UTF-8 fait huit bits. Un point de code est une valeur numérique dans l’espace de codes Unicode ; UTF-8 encode chaque valeur scalaire (un point de code autre qu’un substitut) sur une à quatre unités. Une grappe de graphèmes étendue regroupe un ou plusieurs points de code selon les règles de segmentation Unicode et correspond approximativement à un caractère perçu. e suivi de l’accent aigu combinant U+0301 forme trois unités de code, deux points de code et une seule grappe de ce type.

Uniquement si l’UTF-8 est valide, on peut compter les points de code en comptant les unités qui ne sont pas des unités de continuation (10xxxxxx). Pour conserver les k premiers points, terminez le préfixe au début du point suivant ou à la fin des données s’il n’y en a pas. Une coupe à un indice d’unité quelconque peut scinder une séquence UTF-8 ; même une coupe entre deux points de code peut scinder une grappe. Ni ce comptage ni cette troncature ne valident l’UTF-8, ne normalisent le texte ou ne repèrent les frontières des grappes. Même u8"\xFF" contient une unité non valide en UTF-8. Validez les entrées non fiables avant d’utiliser ce raccourci et segmentez le texte séparément pour tronquer par grappes.

Exemples

#include <cstddef>
#include <iostream>
#include <string_view>

int main() {
    constexpr auto& literal = u8"e\u0301";
    constexpr std::u8string_view text{literal};
    static_assert(sizeof(literal) == 4 && text.size() == 3);

    std::size_t points = 0;
    std::size_t first_end = text.size();
    for (std::size_t i = 0; i < text.size(); ++i) {
        if ((static_cast<unsigned>(text[i]) & 0xC0u) != 0x80u) {
            ++points;
            if (points == 2) {
                first_end = i;
            }
        }
    }

    const auto prefix = text.substr(0, first_end);
    std::cout << "Code units: " << text.size() << '\n'
              << "Code points: " << points << '\n'
              << "First code point, code units: " << prefix.size() << '\n';
}

Résultat

Code units: 3
Code points: 2
First code point, code units: 1

Le programme affiche des nombres : le résultat ne dépend pas de la capacité du terminal à afficher l’accent. Le préfixe ne contient que `e` : il reste valide en UTF-8, mais perd l’accent de la grappe d’origine. Le programme ne compte pas les grappes.

Leçons associées

  • C++ · Leçon 49 · Avancé · Version : 3

Sources