CKTIS / C++
UTF-8 en C++ : unités de code, points de code et graphèmes
La longueur d’un texte UTF-8 dépend de ce que l’on compte : unités de code, points de code ou grappes de graphèmes. L’exemple compte et tronque du texte UTF-8 bien formé sans couper de point de code.
Version : ISO C++23; implementation support may vary
Syntaxe
// u8"text" has type const char8_t[5]; the bound includes the terminating zero code unit.
std::u8string_view text = u8"text"; // <string_view>
text.size(); // number of code units in the view
text.substr(0, n); // prefix of up to n code units; no Unicode boundary checkUne unité de code UTF-8 est un octet de 8 bits. Un point de code est une valeur numérique Unicode, comme U+0301. Chaque valeur scalaire Unicode (un point de code hors de la plage des substituts) occupe une à quatre unités dans un UTF-8 bien formé. Une grappe de graphèmes étendue regroupe un ou plusieurs points de code selon les règles de segmentation Unicode (UAX #29). Elle représente approximativement un caractère perçu par l’utilisateur, et non une largeur d’affichage.
Depuis C++20, un littéral u8"..." est de type const char8_t[N], où N inclut l’unité nulle finale. Contrairement à un littéral ordinaire "...", le pointeur issu du tableau ne se convertit pas implicitement en const char*. std::u8string_view, déclaré dans <string_view>, est une vue non propriétaire. size() compte les unités de la vue. Le constructeur à pointeur seul s’arrête au premier zéro ; pour inclure des zéros internes, passez un pointeur et la longueur d’une plage valide. Le littéral existe pendant toute l’exécution du programme ; toute autre zone de stockage doit rester valide tant que la vue est utilisée.
Dans un UTF-8 bien formé, chaque point de code commence par exactement une unité qui n’est pas une unité de continuation. Les unités de continuation suivent le motif binaire 10xxxxxx. On peut donc compter les débuts sans décoder les valeurs. substr(0, n) coupe par unités de code et peut scinder une séquence de plusieurs unités. Pour garder le plus long préfixe respectant une limite d’unités, reculez tant que la position de coupe désigne une unité de continuation, jusqu’à une frontière de point de code.
Le comptage et la troncature supposent un UTF-8 bien formé : ils ne valident pas l’encodage, ne normalisent pas le texte et ne repèrent pas les frontières de graphèmes. Validez d’abord les entrées non fiables, puis rejetez les données mal formées ou appliquez une règle de remplacement explicite. Pour tronquer selon les caractères perçus, utilisez une bibliothèque qui implémente la segmentation des graphèmes Unicode ; C++23 ne fournit pas d’API générique à cet effet.
Exemples
#include <cstddef>
#include <iostream>
#include <string_view>
constexpr bool is_continuation(char8_t unit) noexcept {
return (unit & 0xC0u) == 0x80u;
}
// Precondition: text is well-formed UTF-8.
constexpr std::size_t count_code_points(std::u8string_view text) noexcept {
std::size_t count = 0;
for (char8_t unit : text) {
if (!is_continuation(unit)) {
++count;
}
}
return count;
}
// Precondition: text is well-formed UTF-8.
constexpr std::u8string_view trim_to_unit_budget(
std::u8string_view text, std::size_t max_units) {
auto end = max_units < text.size() ? max_units : text.size();
while (end > 0 && end < text.size() && is_continuation(text[end])) {
--end;
}
return text.substr(0, end);
}
int main() {
constexpr std::u8string_view text = u8"e\u0301\U0001F642";
constexpr auto prefix = trim_to_unit_budget(text, 2);
static_assert(text.size() == 7);
static_assert(count_code_points(text) == 3);
static_assert(prefix == u8"e");
std::cout << "code_units: " << text.size() << '\n'
<< "code_points: " << count_code_points(text) << '\n'
<< "prefix_code_units: " << prefix.size() << '\n';
}Résultat
code_units: 7 code_points: 3 prefix_code_units: 1
`e`, U+0301 et l’emoji U+1F642 occupent respectivement 1, 2 et 4 unités : au total, 7 unités de code, 3 points de code et 2 grappes de graphèmes. Une limite de 2 couperait au milieu de l’encodage de U+0301 ; la fonction conserve donc seulement `e`. Le préfixe reste bien formé en UTF-8, mais perd l’accent. Le programme ne calcule pas le nombre de grappes.
Leçons associées
- C++ · Leçon 49 · Avancé · Version : 3
Sources
- String literals [lex.string]
- Character sets [lex.charset]
- Compatibility with ISO C++ 2017: lexical conventions [diff.cpp17.lex]
- Header <string_view> synopsis [string.view.synop]
- Construction and assignment [string.view.cons]
- Capacity [string.view.capacity]
- String operations [string.view.ops]
- Standard format specifiers [format.string.std]
- N4950 — Working Draft, Standard for Programming Language C++
- Unicode Standard Annex #29: Unicode Text Segmentation