Comment calculer le nombre de caractères dans une chaîne unicode en C

Vous ne pouvez compter que les personnages qui ont les deux premiers bits sont pas mis à 10 (c'est à dire, tout moins que 0x80 ou supérieure à 0xbf).

C'est parce que tous les personnages, avec les deux premiers bits mis à 10 UTF-8 poursuite octets.

Voir ici pour une description de l'encodage et de la façon dont strlen pouvez travailler sur une chaîne UTF-8.

Pour trancher et découper des chaînes UTF-8, vous avez essentiellement de suivre les mêmes règles. N'importe quel octet de départ avec un 0 bits ou un 11 de la séquence de le début de l'UTF-8 code point, tous les autres sont des caractères de continuité.

Votre meilleur pari, si vous ne voulez pas utiliser une bibliothèque tierce, est tout simplement de fournir des fonctions le long des lignes de:

utf8left (char *destbuff, char *srcbuff, size_t sz);
utf8mid  (char *destbuff, char *srcbuff, size_t pos, size_t sz);
utf8rest (char *destbuff, char *srcbuff, size_t pos;

pour obtenir, respectivement:

• la gauche sz UTF-8 octets d'une chaîne.
• la sz UTF-8 octets d'une chaîne, en commençant à pos.
• le reste de l'UTF-8 octets d'une chaîne, en commençant à pos.

Ce sera un bon bloc de construction pour être capable de manipuler les chaînes de caractères suffisamment à vos fins.

Essayez ceci pour la taille:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
//returns the number of utf8 code points in the buffer at s
size_t utf8len(char *s)
{
size_t len = 0;
for (; *s; ++s) if ((*s & 0xC0) != 0x80) ++len;
return len;
}
//returns a pointer to the beginning of the pos'th utf8 codepoint
//in the buffer at s
char *utf8index(char *s, size_t pos)
{    
++pos;
for (; *s; ++s) {
if ((*s & 0xC0) != 0x80) --pos;
if (pos == 0) return s;
}
return NULL;
}
//converts codepoint indexes start and end to byte offsets in the buffer at s
void utf8slice(char *s, ssize_t *start, ssize_t *end)
{
char *p = utf8index(s, *start);
*start = p ? p - s : -1;
p = utf8index(s, *end);
*end = p ? p - s : -1;
}
//appends the utf8 string at src to dest
char *utf8cat(char *dest, char *src)
{
return strcat(dest, src);
}
//test program
int main(int argc, char **argv)
{
//slurp all of stdin to p, with length len
char *p = malloc(0);
size_t len = 0;
while (true) {
p = realloc(p, len + 0x10000);
ssize_t cnt = read(STDIN_FILENO, p + len, 0x10000);
if (cnt == -1) {
perror("read");
abort();
} else if (cnt == 0) {
break;
} else {
len += cnt;
}
}
//do some demo operations
printf("utf8len=%zu\n", utf8len(p));
ssize_t start = 2, end = 3;
utf8slice(p, &start, &end);
printf("utf8slice[2:3]=%.*s\n", end - start, p + start);
start = 3; end = 4;
utf8slice(p, &start, &end);
printf("utf8slice[3:4]=%.*s\n", end - start, p + start);
return 0;
}

Exemple d'exécution:

matt@stanley:~/Desktop$ echo -n 你们好āa | ./utf8ops 
utf8len=5
utf8slice[2:3]=好
utf8slice[3:4]=ā

Noter que votre exemple est un arrêt par une erreur. theString[2] == "好"

Dans le monde réel, theString[3]=foo; n'est pas une véritable opération. Pourquoi jamais vous voulez remplacer un caractère à une position particulière dans la chaîne de caractères avec un caractère différent? Il n'y a certainement pas de langage naturel-traitement de texte de la tâche pour laquelle cette opération est significative.

Comptage de caractères est également peu susceptible d'être utile. Combien de caractères (pour votre idée de "caractère") sont là, dans le "á"? Comment à propos de "á"? Maintenant, comment au sujet de "གི"? Si vous avez besoin de cette information pour mettre en œuvre une sorte d'édition de texte, vous allez avoir à faire face à ces questions difficiles, ou tout simplement utiliser une bibliothèque existante/gui toolkit. Je recommanderais ce dernier, sauf si vous êtes un expert sur le monde des scripts et des langues et pensez que vous pouvez faire mieux.

Pour toutes autres fins, strlen vous dit exactement l'information qui est réellement utile: combien d'espace de stockage d'une chaîne de caractères. C'est ce qui est nécessaire pour la combinaison et la séparation des chaînes. Si tout ce que vous voulez faire est de combiner les chaînes ou les séparer à un délimiteur particulier, snprintf (ou strcat si vous insistez...) et strstr tout ce dont vous avez besoin.

Si vous souhaitez effectuer de plus haut niveau en langage naturel-texte opérations, comme la capitalisation, de la ligne de rupture, etc. ou même de niveau supérieur, des opérations comme la pluralisation, le temps des changements, etc. ensuite, vous aurez besoin soit d'une bibliothèque comme unité de soins intensifs ou respectivement quelque chose de beaucoup plus haut niveau et linguistiquement capable (et spécifiques de la langue(s) vous travaillez).

Encore une fois, la plupart des programmes n'ont pas de toute utilisation de ce genre de chose, il suffit d'assembler et d'analyser le texte sans aucune considération pour le langage naturel.

En général, nous devrions utiliser un autre type de données de caractères unicode.

Par exemple, vous pouvez utiliser l'échelle de type de données char

wchar_t theString[] = L"你们好āa";

Note du modificateur L qui indique que la chaîne est composée de larges caractères.

La longueur de la chaîne peut être calculée à l'aide de la wcslen fonction, qui se comporte comme strlen.

Je n'ai de mise en œuvre similaire années en arrière. Mais je n'ai pas le code avec moi.

Pour chacun des caractères unicode, le premier octet indique le nombre d'octets de la suivre pour la construction d'un caractère unicode. Basé sur le premier octet, vous pouvez déterminer la longueur de chaque caractère unicode.

Je pense que c'est une bonne UTF8 bibliothèque.
entrez description du lien ici