获取 UTF-8 编码的 std::string 的实际长度？

Question

我的 std::string 是 UTF-8 编码的，所以显然，str.length() 返回错误的结果。

我找到了此信息，但我不确定如何使用它来执行此操作：

以下字节序列是 用于表示一个字符。这 序列为 使用取决于字符的 UCS 代码编号：

<前><代码> 0x00000000 - 0x0000007F： 0xxxxxxx 0x00000080 - 0x000007FF： 110xxxxx 10xxxxxx 0x00000800 - 0x0000FFFF： 1110xxxx 10xxxxxx 10xxxxxx 0x00010000 - 0x001FFFFF： 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

How can I find theactual length of a UTF-8编码std::string?谢谢

Answer 1

计算所有第一个字节（不匹配 10xxxxxx 的字节）。

int len = 0;
while (*s) len += (*s++ & 0xc0) != 0x80;

Answer 2

C++ 对编码一无所知，所以你不能指望使用
标准函数来执行此操作。

标准库确实确实承认字符编码（以区域设置的形式）的存在。如果您的系统支持区域设置，则使用标准库来计算字符串的长度非常容易。在下面的示例代码中，我假设您的系统支持区域设置 en_US.utf8。如果我编译代码并将其执行为“./a.out ソuniーSony”，则输出有 13 个字符值和 7 个字符。并且所有这些都无需参考 UTF-8 字符代码的内部表示或必须使用第 3 方库。

#include <clocale>
#include <cstdlib>
#include <iostream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
  string str(argv[1]);
  unsigned int strLen = str.length();
  cout << "Length (char-values): " << strLen << '\n';
  setlocale(LC_ALL, "en_US.utf8");
  unsigned int u = 0;
  const char *c_str = str.c_str();
  unsigned int charCount = 0;
  while(u < strLen)
  {
    u += mblen(&c_str[u], strLen - u);
    charCount += 1;
  }
  cout << "Length (characters): " << charCount << endl; 
}

Answer 3

这是一个幼稚的实现，但了解它是如何完成的应该对您有所帮助：

std::size_t utf8_length(std::string const &s) {
  std::size_t len = 0;
  std::string::const_iterator begin = s.begin(), end = s.end();
  while (begin != end) {
    unsigned char c = *begin;
    int n;
    if      ((c & 0x80) == 0)    n = 1;
    else if ((c & 0xE0) == 0xC0) n = 2;
    else if ((c & 0xF0) == 0xE0) n = 3;
    else if ((c & 0xF8) == 0xF0) n = 4;
    else throw std::runtime_error("utf8_length: invalid UTF-8");

    if (end - begin < n) {
      throw std::runtime_error("utf8_length: string too short");
    }
    for (int i = 1; i < n; ++i) {
      if ((begin[i] & 0xC0) != 0x80) {
        throw std::runtime_error("utf8_length: expected continuation byte");
      }
    }
    len += n;
    begin += n;
  }
  return len;
}

Answer 4

您可能应该听取 Omry 的建议，并为此寻找专门的图书馆。也就是说，如果您只是想了解执行此操作的算法，我会将其发布在下面。

基本上，您可以将字符串转换为更宽的元素格式，例如 wchar_t。请注意，wchar_t 存在一些可移植性问题，因为 wchar_t 的大小取决于您的平台。在 Windows 上，wchar_t 为 2 个字节，因此非常适合表示 UTF-16。但在 UNIX/Linux 上，它是四个字节，因此用于表示 UTF-32。因此，对于 Windows，只有当您不包含任何高于 0xFFFF 的 Unicode 代码点时，这才有效。对于 Linux，您可以在 wchar_t 中包含整个代码点范围。 （幸运的是，这个问题将通过 C++0x Unicode 字符类型得到缓解。）

注意到这一点，您可以使用以下算法创建一个转换函数：

template <class OutputIterator>
inline OutputIterator convert(const unsigned char* it, const unsigned char* end, OutputIterator out) 
{
    while (it != end) 
    {
        if (*it < 192) *out++ = *it++; // single byte character
        else if (*it < 224 && it + 1 < end && *(it+1) > 127) { 
            // double byte character
            *out++ = ((*it & 0x1F) << 6) | (*(it+1) & 0x3F);
            it += 2;
        }
        else if (*it < 240 && it + 2 < end && *(it+1) > 127 && *(it+2) > 127) { 
            // triple byte character
            *out++ = ((*it & 0x0F) << 12) | ((*(it+1) & 0x3F) << 6) | (*(it+2) & 0x3F);
            it += 3;
        }
        else if (*it < 248 && it + 3 < end && *(it+1) > 127 && *(it+2) > 127 && *(it+3) > 127) { 
            // 4-byte character
            *out++ = ((*it & 0x07) << 18) | ((*(it+1) & 0x3F) << 12) |
                ((*(it+2) & 0x3F) << 6) | (*(it+3) & 0x3F);
            it += 4;
        }
        else ++it; // Invalid byte sequence (throw an exception here if you want)
    }

    return out;
}

int main()
{
    std::string s = "\u00EAtre";
    cout << s.length() << endl;

    std::wstring output;
    convert(reinterpret_cast<const unsigned char*> (s.c_str()), 
        reinterpret_cast<const unsigned char*>(s.c_str()) + s.length(), std::back_inserter(output));

    cout << output.length() << endl; // Actual length
}

该算法并不完全通用，因为 InputIterator 需要是一个unsigned char，因此您可以将每个字节解释为具有 0 到 0xFF 之间的值。 OutputIterator 是通用的（这样你就可以使用 std::back_inserter 而不必担心内存分配），但它作为通用参数的使用是有限的：基本上，它必须输出到一个足够大的元素数组来表示UTF-16 或 UTF-32 字符，例如 wchar_t、uint32_t 或 C++0x char32_t 类型。另外，我没有包含用于转换大于 4 字节的字符字节序列的代码，但您应该从发布的内容中了解该算法的工作原理。

另外，如果您只想计算字符数，而不是输出到新的宽字符缓冲区，则可以修改算法以包含计数器而不是 OutputIterator。或者更好的是，只需使用 Marcelo Cantos 'answer 计算第一个字节。

Answer 5

我建议您使用 UTF8-CPP。它是一个仅包含头文件的库，用于在 C++ 中使用 UTF-8。有了这个库，它看起来像这样：（

int LenghtOfUtf8String( const std::string &utf8_string ) 
{
    return utf8::distance( utf8_string.begin(), utf8_string.end() ); 
}

代码来自我的脑海。）

Answer 6

我的大部分个人 C 库代码仅用英语进行过真正的测试，但以下是我实现 utf-8 字符串长度函数的方法。我最初基于此 wiki 页表中描述的位模式。现在这不是最易读的代码，但我的目的是删除循环中的任何分支。也很抱歉，当要求 C++ 时，这是 C 代码，它应该很容易地转换为 C++ 中的 std::string，尽管需要进行一些细微的修改。以下函数是从我的网站复制的，如果您有兴趣。

size_t utf8len(const char* const str) {
    size_t len = 0;
    for (size_t i = 0; *str != 0; ++len) {
        int v0 = (*str & 0x80) >> 7;
        int v1 = (*str & 0x40) >> 6;
        int v2 = (*str & 0x20) >> 5;
        int v3 = (*str & 0x10) >> 4;
        str += 1 + v0 * v1 + v0 * v1 * v2 + v0 * v1 * v2 * v3;
    }
    return len;
}

请注意，这不会验证任何字节（与此处所有其他建议的答案非常相似）。就我个人而言，我会将字符串验证与字符串长度函数分开，因为这不是它的责任。如果我们要将字符串验证移至另一个函数，我们可以执行如下所示的验证。

bool utf8valid(const char* const str) {
    if (str == NULL)
        return false;
    const char* c = str;
    bool valid = true;
    for (size_t i = 0; c[0] != 0 && valid;) {
        valid = (c[0] & 0x80) == 0
            || ((c[0] & 0xE0) == 0xC0 && (c[1] & 0xC0) == 0x80)
            || ((c[0] & 0xF0) == 0xE0 && (c[1] & 0xC0) == 0x80 && (c[2] & 0xC0) == 0x80)
            || ((c[0] & 0xF8) == 0xF0 && (c[1] & 0xC0) == 0x80 && (c[2] & 0xC0) == 0x80 && (c[3] & 0xC0) == 0x80);
        int v0 = (c[0] & 0x80) >> 7;
        int v1 = (c[0] & 0x40) >> 6;
        int v2 = (c[0] & 0x20) >> 5;
        int v3 = (c[0] & 0x10) >> 4;
        i += 1 + v0 * v1 + v0 * v1 * v2 + v0 * v1 * v2 * v3;
        c = str + i;
    }
    return valid;
}

如果您追求可读性，我承认其他建议更具可读性。

更新：感谢 Max Brauer（留下评论）稍微简化了代码。经过他的简化，utf8len 将变成这样。

size_t utf8len(const char* str) {
    size_t len = 0;
    for (size_t i = 0; *str != 0; ++len) {
        int v01 = ((*str & 0x80) >> 7) & ((*str & 0x40) >> 6);
        int v2 = (*str & 0x20) >> 5;
        int v3 = (*str & 0x10) >> 4;
        str += 1 + ((v01 << v2) | (v01 & v3));
    }
    return len;
}

Answer 7

尝试使用像 iconv 这样的编码库。
它可能有你想要的api。

另一种方法是实现您自己的 utf8strlen ，它确定每个代码点的长度并迭代代码点而不是字符。

Answer 8

一种稍微懒惰的方法是只计算前导字节，但访问每个字节。这节省了解码各种前导字节大小的复杂性，但显然您需要付费才能访问所有字节，尽管通常没有那么多（2x-3x）：

size_t utf8Len(std::string s)
{
  return std::count_if(s.begin(), s.end(),
    [](char c) { return (static_cast<unsigned char>(c) & 0xC0) != 0x80; } );
}

请注意，某些代码值作为前导字节是非法的，这些代码值代表例如，比扩展 unicode 所需的 20 位更大的值，但其他方法无论如何都不知道如何处理该代码。

Answer 9

UTF-8 CPP 库有一个函数可以做到这一点。您可以将该库包含到您的项目中（它很小），也可以只查看该函数。 http://utfcpp.sourceforge.net/

char* twochars = "\xe6\x97\xa5\xd1\x88";
size_t dist = utf8::distance(twochars, twochars + 5);
assert (dist == 2);

Answer 10

这段代码是我从 php-iconv 移植到 c++ 的，你需要先使用 iconv，希望有用：

// porting from PHP
// http://lxr.php.net/xref/PHP_5_4/ext/iconv/iconv.c#_php_iconv_strlen
#define GENERIC_SUPERSET_NBYTES 4
#define GENERIC_SUPERSET_NAME   "UCS-4LE"

UInt32 iconvStrlen(const char *str, size_t nbytes, const char* encode)
{
    UInt32 retVal = (unsigned int)-1;

    unsigned int cnt = 0;

    iconv_t cd = iconv_open(GENERIC_SUPERSET_NAME, encode);
    if (cd == (iconv_t)(-1))
        return retVal;

    const char* in;
    size_t  inLeft;

    char *out;
    size_t outLeft;

    char buf[GENERIC_SUPERSET_NBYTES * 2] = {0};

    for (in = str, inLeft = nbytes, cnt = 0; inLeft > 0; cnt += 2) 
    {
        size_t prev_in_left;
        out = buf;
        outLeft = sizeof(buf);

        prev_in_left = inLeft;

        if (iconv(cd, &in, &inLeft, (char **) &out, &outLeft) == (size_t)-1) {
            if (prev_in_left == inLeft) {
                break;
            }
        }
    }
    iconv_close(cd);

    if (outLeft > 0)
        cnt -= outLeft / GENERIC_SUPERSET_NBYTES;

    retVal = cnt;
    return retVal;
}

UInt32 utf8StrLen(const std::string& src)
{
    return iconvStrlen(src.c_str(), src.length(), "UTF-8");
}

Answer 11

只是另一个简单的实现来计算 UTF-8 字符串中的字符

int utf8_strlen(const string& str)
{
    int c,i,ix,q;
    for (q=0, i=0, ix=str.length(); i < ix; i++, q++)
    {
        c = (unsigned char) str[i];
        if      (c>=0   && c<=127) i+=0;
        else if ((c & 0xE0) == 0xC0) i+=1;
        else if ((c & 0xF0) == 0xE0) i+=2;
        else if ((c & 0xF8) == 0xF0) i+=3;
        //else if (($c & 0xFC) == 0xF8) i+=4; // 111110bb //byte 5, unnecessary in 4 byte UTF-8
        //else if (($c & 0xFE) == 0xFC) i+=5; // 1111110b //byte 6, unnecessary in 4 byte UTF-8
        else return 0;//invalid utf8
    }
    return q;
}

Answer 12

大多数（如果不是全部）其他答案只给出了 组合字符、表情符号或更复杂的脚本。例如，下面是 上面 user2781185 的解决方案在对 Godbolt 上的演示：

Length (char-values):  5, length (code points):  4. String: café

Length (char-values):  6, length (code points):  5. String: café

Length (char-values): 15, length (code points):  5. String: 가각

Length (char-values): 24, length (code points):  8. String: ဂ︀င︀⋚︀丸︀

Length (char-values): 47, length (code points): 13. String: