Início / coding / Perguntas / 77709693
Accepted
alfC
Asked: 2023-12-24 12:37:22 +0800 CST

Como imprimo um intervalo de caracteres Unicode em C++?

  • 772

Quero imprimir o intervalo de caracteres Unicode, de 00B2 a 00B5 (e muitos outros intervalos). Como posso imprimi-los programaticamente?

Obviamente, não sei como definir um caractere Unicode variável e depois fazer aritmética (incremento) para eles.

Estou procurando o loop equivalente a este abaixo.

Como posso imprimir programaticamente um intervalo arbitrário de caracteres Unicode?

#include <iostream>

int main() {

    std::cout << "\u00B2" << std::endl;
    std::cout << "\u00B3" << std::endl;
    std::cout << "\u00B4" << std::endl;
    std::cout << "\u00B5" << std::endl;

}

saída (caracteres unicode)

²
³
´
µ
c++

2 respostas

  1. Best Answer

    Não tenho certeza se entendi sua pergunta corretamente. No entanto, você pode conseguir isso programaticamente usando um loop e incrementando os pontos de código Unicode. Aqui está um exemplo em C++:

    #include <iostream>
#include <locale>

int main() {
   
    std::locale::global(std::locale(""));

    wchar_t start = 0x00B2;  // Unicode code point for '²'
    wchar_t end = 0x00B5;    // Unicode code point for 'µ'

    for (wchar_t codePoint = start; codePoint <= end; ++codePoint) {
        std::wcout << codePoint << std::endl;
    }

    return 0;
}

    O código acima usa wchar_t para caracteres largos e std::wcout para saída de caracteres largos. A linha std::locale::global(std::locale("")) define a localidade global para o padrão do usuário, o que é necessário para exibir corretamente os caracteres Unicode com base no ambiente do usuário.

    • 2

  2. Você pode codificar/decodificar de utf-8:

    void append_utf8 (::std::string& s, ::std::uint32_t unicode)
{
    if (unicode < 0x80)
    {
        s.push_back (unicode & 0x7F);
    }
    else if (unicode < 0x08'00)
    {
        s.push_back (((unicode >> 6) & 0x1F) | 0xC0);
        s.push_back ((unicode & 0x3F) | 0x80);
    }
    else if (unicode < 0x00'01'00'00)
    {
        s.push_back (((unicode >> 12) & 0x0F) | 0xE0);
        s.push_back (((unicode >> 6) & 0x3F) | 0x80);
        s.push_back ((unicode & 0x3F) | 0x80);
    }
    else
    {
        s.push_back (((unicode >> 18) & 0x07) | 0xF0);
        s.push_back (((unicode >> 12) & 0x3F) | 0x80);
        s.push_back (((unicode >> 6) & 0x3F) | 0x80);
        s.push_back ((unicode & 0x3F) | 0x80);
    }
}

::std::string to_utf8 (::std::uint32_t unicode)
{
    ::std::string res;
    append_utf8 (res, unicode);
    return res;
}

//--------------------------------------------------------------------------
constexpr ::std::uint32_t decodeUtf8 (const ::std::string_view& text, ::std::size_t& pos)
{
    if (text.size() <= pos)
    {
        throw ::std::out_of_range ("invalid position for decodeUtf8");
    }
    const ::std::uint32_t c0 = static_cast<unsigned char> (text[pos]);
    const auto is_extra_char = [] (char c) { return (c & 0b1100'0000) == 0b1000'0000; };
    const auto check_extra_size = [&] (int size) {
        if (text.size() <= pos + size || !std::all_of (&text[pos + 1], &text.data()[pos + 1 + size], is_extra_char))
        {
            throw ::std::out_of_range ("invalid position for decodeUtf8");
        }
    };
    if ((c0 & 0b1111'1000) == 0b1111'0000)
    {
        check_extra_size (3);
        const unsigned char c1 = text[pos + 1] & 0b0011'1111;
        const unsigned char c2 = text[pos + 2] & 0b0011'1111;
        const unsigned char c3 = text[pos + 3] & 0b0011'1111;

        pos += 4;
        return ((c0 & 0b000'0111) << 18) | (c1 << 12) | (c2 << 6) | c3;
    }
    else if ((c0 & 0b1111'0000) == 0b1110'0000)
    {
        check_extra_size (2);
        const unsigned char c1 = text[pos + 1] & 0b0011'1111;
        const unsigned char c2 = text[pos + 2] & 0b0011'1111;

        pos += 3;
        return ((c0 & 0b0000'1111) << 12) | (c1 << 6) | c2;
    }
    else if ((c0 & 0b1110'0000) == 0b1100'0000)
    {
        check_extra_size (1);
        const unsigned char c1 = text[pos + 1] & 0b0011'1111;

        pos += 2;
        return ((c0 & 0b0001'1111) << 6) | c1;
    }
    else
    {
        if ((c0 & 0b1000'0000) != 0)
        {
            throw ::std::runtime_error ("Invalid utf8 character for decodeUtf8");
        }
        pos += 1;
        return (c0 & 0b0111'1111);
    }
}

constexpr ::std::uint32_t decodeUtf8 (const ::std::string_view& text)
{
    std::size_t pos = 0;
    return decodeUtf8 (text, pos);
}

    E então

    for (auto c = decodeUtf8 ("\u00B2"); c != decodeUtf8 ("\u00B6"); ++c) {
    std::cout << to_utf8 (c) << std::endl;
}

    ou

    for (auto c = 0x00B2; c != 0x00B6; ++c) {
    std::cout << to_utf8 (c) << std::endl;
}

    Demonstração

    • 0

relate perguntas