L'obtention de la longueur réelle d'une codé en UTF-8 std::string?

Compter tous les premiers octets (ceux qui ne correspondent pas 10xxxxxx).

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

Vous devriez probablement prendre l'avis d'Omry et regardez-la dans une bibliothèque spécialisée pour cela. Cela dit, si vous voulez juste de comprendre l'algorithme pour ce faire, je vais le poster ci-dessous.

Fondamentalement, vous pouvez convertir une chaîne en un plus large-format de l'élément, comme wchar_t. Notez que wchar_t a quelques problèmes de portabilité, car wchar_t est de taille variable en fonction de votre plate-forme. Sur Windows, wchar_t est de 2 octets, et donc idéal pour la représentation UTF-16. Mais sur UNIX/Linux, il est de quatre octets, et est donc utilisé pour représenter l'UTF-32. Par conséquent, pour Windows, cela ne fonctionnera que si vous n'incluez pas l'Unicode codepoints au-dessus de 0xFFFF. Pour Linux, vous pouvez inclure l'ensemble de la gamme de codepoints dans un wchar_t. (Heureusement, ce problème sera atténué avec le C++0x Unicode types de caractères.)

Avec cet avertissement noté, vous pouvez créer une fonction de conversion à l'aide de l'algorithme suivant:

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
}

L'algorithme n'est pas totalement générique, parce que le InputIterator doit être un unsigned char, de sorte que vous pouvez interpréter chaque octet comme ayant une valeur comprise entre 0 et 0xFF. Le OutputIterator est générique, (si vous pouvez utiliser un std::back_inserter et ne pas s'inquiéter de l'allocation de mémoire), mais son utilisation comme un paramètre générique est limitée: en gros, c'est à la sortie d'un tableau d'éléments suffisamment grand pour représenter un UTF-16 ou UTF-32 caractères, tels que wchar_t, uint32_t ou le C++0x char32_t types. Aussi, je ne comprend pas le code pour convertir des caractères les séquences d'octets de plus de 4 octets, mais vous devriez obtenir le point de fonctionnement de l'algorithme à partir de ce qui est posté.

Aussi, si vous voulez juste compter le nombre de caractères, plutôt que de la sortie d'un nouveau grand personnage de la mémoire tampon, vous pouvez modifier l'algorithme afin d'inclure un compteur, plutôt que sur une OutputIterator. Ou, mieux encore, il suffit d'utiliser Marcelo Cantos de réponse à compter de la première-octets.

Je vous recommande d'utiliser UTF8-RPC. C'est un en-tête de la seule bibliothèque pour travailler avec de l'UTF-8 en C++. Avec cette lib, il ressemblerait à quelque chose comme ceci:

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

(Le Code est le sommet de ma tête.)

UTF-8 CPP bibliothèque a une fonction qui ne fait que cela. Vous pouvez inclure la librairie dans votre projet (il est petit) ou tout simplement regarder la fonction. http://utfcpp.sourceforge.net/

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

Juste une autre implémentation naïve de compter les caractères dans la chaîne 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;
}