Как Microsoft обрабатывает тот факт, что UTF-16 является кодировкой переменной длины в их реализации стандартной библиотеки C++

Вот как реализация Microsoft STL обрабатывает кодировку переменной длины:

basic_string<wchar_t>::operator[])( может возвращать низкий или высокий суррогат по отдельности.

basic_string<wchar_t>::size() возвращает количество wchar_t объектов. Суррогатная пара (один символ Unicode) использует два wchar_t и, следовательно, добавляет два к размеру.

basic_string<wchar_t>::resize() может обрезать строку в середине суррогатной пары.

basic_string<wchar_t>::insert() можно вставить в середину суррогатной пары.

basic_string<wchar_t>::erase() может стереть любую половину суррогатной пары.

В общем, шаблон должен быть ясен: STL не предполагает, что std::wstring находится в UTF-16, и не требует, чтобы он оставался UTF-16.

STL работает со строками просто как с оболочкой для массива символов, поэтому size() или length() в строке STL сообщит вам, сколько элементов char или wchar_t она содержит, и не обязательно количество печатных символов, которые она будет содержать в строке. .

Предполагая, что вы говорите о типе wstring, не будет никакой обработки кодировки - он просто имеет дело с элементами wchar_t, ничего не зная о кодировке. Это просто последовательность wchar_t. Вам нужно будет решить проблемы с кодировкой, используя функциональность других функций.

Две вещи:

1. Не существует «реализации Microsoft STL». Стандартная библиотека C++, поставляемая с Visual C++, предоставляется по лицензии Dinkumware.
2. Текущий стандарт C++ ничего не знает о Unicode и его формах кодирования. std::wstring — это просто контейнер для модулей wchar_t, которые в Windows являются 16-битными. На практике, если вы хотите сохранить строку в кодировке UTF-16 в wstring, просто примите во внимание, что вы действительно сохраняете кодовые единицы, а не кодовые точки.

MSVC хранит wchar_t в wstringс. Их можно интерпретировать как 16-битные слова Unicode или что-то еще.

Если вы хотите получить доступ к символам или глифам Юникода, вам придется обработать указанную необработанную строку по стандарту Юникода. Вы, вероятно, также хотите обрабатывать распространенные угловые случаи без нарушения.

Вот набросок такой библиотеки. Это примерно наполовину меньше памяти, чем могло бы быть, но дает вам доступ на месте к глифам Unicode в файле std::string. Это зависит от наличия приличного класса array_view, но вы все равно хотите написать один из них:

struct unicode_char : array_view<wchar_t const> {
  using array_view<wchar_t const>::array_view<wchar_t const>;

  uint32_t value() const {
    if (size()==1)
      return front();
    Assert(size()==2);
    if (size()==2)
    {
      wchar_t high = front()-0xD800;
      wchar_T low = back()-0xDC00;
      return (uint32_t(high)<<10) + uint32_t(low);
    }
    return 0; // error
  }
  static bool is_high_surrogate( wchar_t c ) {
    return (c >= 0xD800 && c <= 0xDBFF);
  }
  static bool is_low_surrogate( wchar_t c ) {
    return (c >= 0xDC00 && c <= 0xDFFF);
  }
  static unicode_char extract( array_view<wchar_t const> raw )
  {
    if (raw.empty())
      return {};
    if (raw.size()==1)
      return raw;
    if (is_high_surrogate(raw.front()) && is_low_surrogate(*std::next(raw.begin())))
      return {raw.begin(), raw.begin()+2);
    return {raw.begin(), std::next(raw.begin())};
  }
};
static std::vector<unicode_char> as_unicode_chars( array_view<wchar_t> raw )
{
  std::vector<unicode_char> retval;
  retval.reserve( raw.size() ); // usually 1:1
  while(!raw.empty())
  {
    retval.push_back( unicode_char::extract(raw) );
    Assert( retval.back().size() <= raw.size() );
    raw = {raw.begin() + retval.back().size(), raw.end()};
  }
  return retval;
}
struct unicode_glyph {
  std::array< unicode_char, 3 > buff;
  std::size_t count=0;
  unicode_char const* begin() const {
    return buff.begin();
  }
  unicode_char const* end() const {
    return buff.begin()+count;
  }
  std::size_t size() const { return count; }
  bool empty() { return size()==0; }
  unicode_char const& front() const { return *begin(); }
  unicode_char const& back() const { return *std::prev(end()); }
  array_view< unicode_char const > chars() const { return {begin(), end()}; }
  array_view< wchar_t const > wchars() const {
    if (empty()) return {};
    return { front().begin(), back().end() };
  }

  void append( unicode_char next ) {
    Assert(count<3);
    buff[count++] = next;
  }
  unicode_glyph() {}

  static bool is_diacrit(unicode_char c) const {
    auto v = c.value();
    return is_diacrit(v);
  }
  static bool is_diacrit(uint32_t v) const {
    return
      ((v >= 0x0300) && (v <= 0x0360))
    || ((v >= 0x1AB0) && (v <= 0x1AFF))
    || ((v >= 0x1DC0) && (v <= 0x1DFF))
    || ((v >= 0x20D0) && (v <= 0x20FF))
    || ((v >= 0xFE20) && (v <= 0xFE2F));
  }
  static size_t diacrit_count(unicode_char c) const {
    auto v = c.value();
    if (is_diacrit(v))
      return 1 + ((v >= 0x035C)&&(v<=0x0362));
    else
      return 0;
  }
  static unicode_glyph extract( array_view<const unicode_char> raw ) {
    unicode_glyph retval;
    if (raw.empty())
      return retval;
    if (raw.size()==1)
    {
      retval.append(raw.front());
      return retval;
    }
    retval.count = diacrit_count( *std::next(raw.begin()) )+1;
    std::copy( raw.begin(), raw.begin()+retval.count, retval.buff.begin() );
    return retval;
  }
};
static std::vector<unicode_glyph> as_unicode_glyphs( array_view<unicode_char> raw )
{
  std::vector<unicode_glyph> retval;
  retval.reserve( raw.size() ); // usually 1:1
  while(!raw.empty())
  {
    retval.push_back( unicode_glyph::extract(raw) );
    Assert( retval.back().size() <= raw.size() );
    raw = {raw.begin() + retval.back().size(), raw.end()};
  }
  return retval;
}
static std::vector<unicode_glyph> as_unicode_glyphs( array_view<wchar_t> raw )
{
  return as_unicode_glyphs( as_unicode_chars( raw ) );
}

более умный фрагмент кода будет генерировать unicode_chars и unicode_glyphs на лету с помощью какого-либо фабричного итератора. Более компактная реализация будет отслеживать тот факт, что конечный указатель предыдущего и начальный указатель следующего всегда идентичны, и объединять их вместе. Другой оптимизацией может быть использование оптимизации небольших объектов для глифа, основанное на предположении, что большинство глифов представляют собой один символ, и использование динамического распределения, если их два.

Обратите внимание, что я рассматриваю CGJ как стандартный диакрит, а двойные диакриты — как набор из 3 символов, которые образуют один (юникод), но полудиакриты не объединяют вещи в один глиф. Это все сомнительные варианты.

Это было написано в приступе бессонницы. Надеюсь, это хоть немного сработает.