Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

UTF-8 en C++: unidades de código, puntos de código y grupos de grafemas

La longitud de un texto UTF-8 depende de si se cuentan unidades de código, puntos de código o grupos de grafemas. El ejemplo cuenta y recorta UTF-8 bien formado sin partir un punto de código.

Versión: ISO C++23; implementation support may vary

Sintaxis

// 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 check

Una unidad de código UTF-8 es un octeto de 8 bits. Un punto de código es un valor numérico de Unicode, como U+0301. Cada valor escalar de Unicode (un punto de código fuera del rango de sustitutos) ocupa de una a cuatro unidades en UTF-8 bien formado. Un grupo de grafemas extendido reúne uno o más puntos de código según las reglas de segmentación de Unicode (UAX #29). Se aproxima a un carácter percibido por el usuario, no al ancho que ocupa en pantalla.

Desde C++20, un literal u8"..." tiene tipo const char8_t[N], y N incluye la unidad cero final. A diferencia de lo que ocurre con un literal ordinario "...", el puntero obtenido del array no se convierte implícitamente a const char*. std::u8string_view, de <string_view>, es una vista que no posee los datos. size() cuenta sus unidades de código, y el constructor que solo recibe un puntero se detiene en el primer cero. Para incluir ceros internos, usa el constructor con puntero y longitud de un rango válido. Un literal existe durante toda la ejecución del programa; cualquier otro almacenamiento debe seguir siendo válido mientras se use la vista.

En UTF-8 bien formado, cada punto de código comienza con una única unidad que no es de continuación. Las unidades de continuación tienen el patrón 10xxxxxx. Por eso se pueden contar los inicios sin decodificar sus valores. substr(0, n) corta por unidades de código y puede partir una secuencia de varias unidades. Para conservar el prefijo más largo que quepa en el límite, retrocede mientras la posición de corte indique una unidad de continuación, hasta llegar a un límite entre puntos de código.

El recuento y el recorte presuponen UTF-8 bien formado: no validan la codificación, no normalizan el texto ni localizan los límites de los grafemas. Si la entrada no es de confianza, valídala primero y rechaza los datos mal formados o aplica una política de sustitución explícita. Para recortar por caracteres percibidos, usa una biblioteca que implemente la segmentación de grafemas de Unicode; C++23 no ofrece una API de propósito general para ello.

Ejemplos

#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';
}

Resultado

code_units: 7
code_points: 3
prefix_code_units: 1

`e`, U+0301 y el emoji U+1F642 ocupan 1, 2 y 4 unidades respectivamente: 7 unidades de código, 3 puntos de código y 2 grupos de grafemas en total. Un límite de 2 cortaría en medio de la codificación de U+0301, así que la función conserva solo `e`. El prefijo es UTF-8 bien formado, pero pierde el acento. El programa no calcula el número de grupos.

Lecciones relacionadas

  • C++ · Lección 49 · Avanzado · Versión: 3

Fuentes