Strlen

Dans la bibliothèque standard du C, le strlen est une fonction de corde de qui détermine la longueur d'une chaîne de caractères.

Utilisation d'exemple

inclure le
de

force d'international (vide) { carboniser *string = " ; Bonjour World" ; ; printf (" ; %d \ n" ; , strlen (la corde)); retour 0 ; } Ce programme imprimera la valeur 11, qui est la longueur du " de corde ; Bonjour World" ;. Des chaînes de caractères sont stockées dans un choix d'un type de données appelé le char. L'extrémité d'une corde est trouvée en recherchant le caractère nul du premier dans la rangée.

Exécution

Il y a beaucoup de réalisations possibles du strlen . Les fonctions naïves sont généralement rapides ; mais d'autres méthodes existent. La fonction est habituellement fournie à partir d'une bibliothèque . Deux choses valent de maintenir dans l'esprit cependant :
Les bons compilateurs de

optimiseront souvent des appels pour strlen () avec des arguments de cordes de constante, faisant le calcul à au moment de la compilation.

qu'aucune optimisation ne peut faire pour strlen () rapide pour les entrées sensiblement grandes, ainsi stockant la longueur du " ; " des C-cordes ; est généralement la difficulté recommandée.

Naïf

Une exécution possible du strlen pourrait être : lang=c> de inadmissible de/* * }

pour (s=str ; *s ; s++) ; s-streptocoque de retour ; } L'exécution ci-dessus lit la corde du commencement jusqu'à la fin pour rechercher un caractère de NUL. Elle s'arrête quand elle voit un caractère de NUL, et la différence entre les indicateurs de l'endroit du caractère de NUL et le commencement de la corde est retournée.

Approche de Multi-Byte

Cette approche emploie le tour de vérifier plus de bytes immédiatement. L'ancienne approche emploie juste une vérification de byte. La note, cette cette approche est expliquée sur des valeurs non signées. Noter que cette approche vérifie des groupes de bytes en les lisant dans une variable. Elle appartient au programmeur pour manipuler l'alignement de mémoire et la disponibilité appropriés de la taille de cette variable. Pourtant vous pouvez probablement lire de l'adresse de mémoire inadmissible sur le bout lu. Ainsi ce n'est pas sûr sans résoudre ces choses (les cordes assignées de alignement sur rechercher la fenêtre, qui est faite déjà par le malloc, et la longueur étant se multiplient de elle).

S'il y a une force à octet zéro être vérifié en comprenant comment des nombres sont représentés dans la binaire. Chaque caractère est allumé, laisse présumer 8 bits, byte. Certain nombre des bytes, laisse présumer 4, forment un mot. Et ce mot sera le groupe que nous examinons pour assurer des 0 ' bytes de Th.

Quelles propriétés ce byte a-t-il ? Tout le peu a placé à 0. D'autres ont une partie de peu réglé à 1. C'est juste qu'aucun nombre plus considérablement que 0 n'est byte de nul. Que voulons-nous réaliser ? Voir s'il y a à octet zéro, et s'il n'y en a aucun nous devons avoir la même réponse pour toutes les variations possibles d'autres bytes de non-nul. C'est juste que nous voulons une certaine manière de tracer ceux au même modèle ou le nombre, qui le cas échéant le byte est 0 sera cassé.

Si nous pouvions tracer tous les bytes non-0 à une valeur et 0 bytes à l'autre valeur elle serait résolue.

lang=c> de Ce code produit le >= 128 (0x80) de valeur pour des valeurs à partir de l'intervalle <1, 127> en le traçant à <1+127, 127+127>.

Et (et) l'opération est employée pour exclure le peu de la valeur 128, parce que elle cause le débordement numérique. Et cette valeur donc n'est pas manipulée jusqu'ici. Mais puisque nous avons exclu cette valeur nous devons faire quelque chose à son sujet. Nous l'ajoutons simplement, parce que c'est juste une autre valeur qui doit distingué de 0 valeurs. Et donc ce doit être traité la même manière.

lang=c> de

Maintenant nous avons fait toutes les valeurs qui sont > 0 valeurs de peu réglées 128.

lang=c> de De cette façon nous vérifions si la valeur était le >= 0. La solution de Multibyte devrait être évidente.

inclure

le size_t strlen (le *ptr de char) { IP d'uint32_t* ; char* s ;

NOTE de // : que ce contrôle est rarley fait dans des bibliothèques de C. si (PTR NUL de ==) ERROR_VALUE de retour ; //or 0

Alignement de poignée de // ici de façon ou d'autre sinon manipulé dans la corde. De la corde de // doit être alignée sur la frontière de nombre entier // ou quelques architectures pourrait se comporter inopinément ! NOTE de // : Ceci est également exigé de sorte que vous ne débordiez pas limites de // de la mémoire en regardant des bytes au delà de la fin de // la C-corde. IP = (uint32_t *) PTR ;

// multi-sautent (moins de temps autour de la boucle) tandis que (1) {contrôle de/* pour chacun des zéro * uint32_t X = *ip ; contrôle de/* pour non-tout zéro * si (((((x et 0x7f7f7f7f) + 0x7f7f7f7f7f) | x) et 0x80808080) ! = 0x80808080) coupure ; ++ip ; /* fait avancer 4 bytes immédiatement * }

compte de // tous bytes restants pour (s = (char*) IP ; 0 ! = *s ; ++s) /* ne font rien * ;

s de retour - PTR ; }

Ceci peut être trouvé dans Hackmem.

Assemblée

Parfois les dossiers d'en-tête pour une bibliothèque de C particulière émettent des versions intégrées rapides du strlen écrit dans le . Le compilateur peut également faire ceci ; ou les dossiers d'en-tête peuvent simplement appeler des versions de fonction intégrée de compilateur.

Le d'écriture strlen dans l'assemblée est principalement fait pour la vitesse. La complexité du code émise d'un compilateur est souvent plus haute que l'assemblée main-optimisée, même pour des fonctions très courtes. De plus, un appel de fonction exige installer une armature appropriée d'appel sur la plupart des réalisations ; ces opérations peuvent être supérieures à la taille des fonctions simples comme le strlen .

Random links: