'std :: wstring_convert' для максимально возможного преобразования (из блока чтения файла UTF8)

Question

Я извлекаю текст из текстового файла utf-8 и делаю его кусками для увеличения производительности.

std::ifstream.read(myChunkBuff_str, myChunkBuff_str.length())

Вот более подробный пример

Я получаю около 16 тысяч символов с каждого куска.Мой следующий шаг - преобразовать этот std::string во что-то, что может позволить мне поработать над этими «сложными персонажами» индивидуально, таким образом преобразовав std::string в std::wstring.

Я использую следующую функцию для преобразования, взято отсюда:

#include <string>
#include <codecvt>
#include <locale>

std::string narrow (const std::wstring& wide_string)
{
    std::wstring_convert <std::codecvt_utf8 <wchar_t>, wchar_t> convert;
    return convert.to_bytes (wide_string);
}

std::wstring widen (const std::string& utf8_string)
{
    std::wstring_convert <std::codecvt_utf8 <wchar_t>, wchar_t> convert;
    return convert.from_bytes (utf8_string);
}

Однако в конце фрагмента один из русских символов может быть обрезан-off, и преобразование не удастся, с std::range_error exception.

Например, в UTF-8 «привет» занимает 15 символов, а «приве» - 13 символов.Итак, если бы мой кусок был гипотетически 14, 'т' было бы частично пропущено, и преобразование вызвало бы исключение.

Вопрос:

Как обнаружить их частичнозагруженный персонаж?(в данном случае 'т') Это позволило бы мне выполнить конвертацию без него и, возможно, перенести следующий кусок чуть раньше, чем планировалось, чтобы включить этот проблемный 'т' в следующий раз?

Я не хочуtry или catch вокруг этих функций, так как try / catch может замедлить работу программы.Это также не говорит мне «сколько символов не хватало для успешного преобразования».

Я знаю о wstring_convert::converted(), но это не очень полезно, если моя программа падает до того, как я доберусь до нее

Answer 1

Вы можете сделать это, используя несколько функций.UTF-8 имеет способ обнаружить начало многобайтового символа и (с начала) размер многобайтового символа.

Итак, две функции:

// returns zero if this is the first byte of a UTF-8 char
// otherwise non-zero.
static unsigned is_continuation(char c)
{
    return (c & 0b10000000) && !(c & 0b01000000);
}

// if c is the *first* byte of a UTF-8 multibyte character, returns 
// the total number of bytes of the character.
static unsigned size(const unsigned char c)
{
    constexpr static const char u8char_size[] =
    {
          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
        , 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
        , 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2
        , 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
        , 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0, 0
    };
    return u8char_size[(unsigned char)c];
}

Вы можете отследитьс конца вашего буфера до is_continuation(c) это false .Затем проверьте, длиннее ли size(c) текущего UTF-8 символа конца буфера.

Отказ от ответственности - в прошлый раз, когда я смотрел, эти функции работали, но некоторое время не использовал их.

Редактировать: для добавления.

Если вам захочется все это сделать вручную, я также могу опубликовать код для преобразования многобайтового символа UTF-8 в многобайтовый UTF-16или UTF-32 char.

UTF-32 Легко:

// returns a UTF-32 char from a `UTF-8` multibyte
// character pointed to by cp
static char32_t char32(const char* cp)
{
    auto sz = size(*cp); // function above

    if(sz == 1)
        return *cp;

    char32_t c32 = (0b01111111 >> sz) & (*cp);

    for(unsigned i = 1; i < sz; ++i)
        c32 = (c32 << 6) | (cp[i] & 0b0011'1111);

    return c32;
}

UTF-16 Немного сложнее:

// UTF-16 characters can be 1 or 2 characters wide...
using char16_pair = std::array<char16_t, 2>;

// outputs a UTF-16 char in cp16 from a `UTF-8` multibyte
// character pointed to by cp
//
// returns the number of characters in this `UTF-16` character
// (1 or 2).
static unsigned char16(const char* cp, char16_pair& cp16)
{
    char32_t c32 = char32(cp);

    if(c32 < 0xD800 || (c32 > 0xDFFF && c32 < 0x10000))
    {
        cp16[0] = char16_t(c32);
        cp16[1] = 0;
        return 1;
    }

    c32 -= 0x010000;

    cp16[0] = ((0b1111'1111'1100'0000'0000 & c32) >> 10) + 0xD800;
    cp16[1] = ((0b0000'0000'0011'1111'1111 & c32) >> 00) + 0xDC00;

    return 2;
}