Comment calculer la longueur d'une chaîne de caractères en C de manière efficace?

Comment calculer la longueur d'une chaîne de caractères en C efficacement (dans le temps)?

Droit maintenant, je suis en train de faire:

int calculate_length(char *string) {
    int length = 0;
    while (string[length] != 'int calculate_length(char *string) {
int length = 0;
while (string[length] != '\0') {
length++;
}
return length;
}
') {
        length++;
    }
    return length;
}

Mais c'est très lent par rapport à strlen() par exemple, est-il un autre moyen de le faire?

Grâce.

EDIT: je travaille dans un autoportant de l'environnement, je ne suis pas autorisés à utiliser de lib externe, y compris "de la chaîne.h".

Pourquoi ne pas utiliser strlen alors? Ou est-ce un exercice?
Ce n'est pas un exercice, l'environnement dans lequel je travaille ne m'autorise pas à inclure d'autres "libs", y compris "de la chaîne.h" donc, je dois mettre en œuvre et vous voudriez qu'il soit aussi efficace que possible tout en étant maintainble.
Vous souhaitez peut-être modifier votre message original de mentionner que vous êtes dans un autoportant de l'environnement.
Prendre en compte le fait que le std bibliothèque peut aussi être compilé avec les optimisations du compilateur activé et que votre code n'est pas.
Il y a d'excellentes réponses ici, mais gardez à l'esprit que c'est de la micro-optimisation, et non tous les programmeurs à comprendre l'utilisation et l'importance de la macro-optimisation. Voici un exemple de 40x speedup parfaitement OK-la recherche de code: stackoverflow.com/questions/926266/...

InformationsquelleAutor Carla Álvarez | 2010-01-15

c performance string

41

De la Code source de FreeBSD:
```
size_t
strlen(const char *str)
{
    const char *s;
    for (s = str; *s; ++s);
    return(s - str);
}
```
Par rapport à ton code, c'est probablement ce cartes très bien pour une instruction assembleur, ce qui peut expliquer une grosse différence de performances.
- Le compilateur doit être en mesure d'optimiser cette assez efficacement, ce qui signifie que le code est encore lisible, et devrait encore fonctionner assez rapidement.
InformationsquelleAutor Andomar
9

strlen(). Les chances sont, si quelqu'un avait trouvé une meilleure, plus rapide méthode générique, strlen aurait été remplacé par l'.

InformationsquelleAutor aib
9

Prendre un coup d'oeil au code source de strlen () de la libc standard. Fonctions dans les bibliothèques standards sont généralement hautement optimisé. Check it out ici (codé en assembleur) - c'est à partir de la GNU libc.
```
size_t
DEFUN(strlen, (str), CONST char *str)
{
  int cnt;

  asm("cld\n"                   /* Search forward.  */
      /* Some old versions of gas need `repne' instead of `repnz'.  */
      "repnz\n"                 /* Look for a zero byte.  */
      "scasb" /* %0, %1, %3 */ :
      "=c" (cnt) : "D" (str), "0" (-1), "a" (0));

  return -2 - cnt;
}
```
- Une version de l'assembly peut être plus rapide, mais vous auriez besoin de quelques chiffres pour appuyer cette revendication. Voir leaf.dragonflybsd.org/mailarchive/commits/2011-11/msg00195.html
InformationsquelleAutor Sudhanshu
6

Prendre un coup d'oeil à GNU C library strlen() source.

Il utilise un certain nombre de non-évident astuces pour gagner de la vitesse sans le déposer à l'assemblée, y compris:
- arriver à un personnage qui est correctement aligné
- la lecture de ces alignés parties de la chaîne dans un int (ou certaines grandes datatype) de lire plusieurs caractères à la fois
- à l'aide de bits se tourner les astuces pour vérifier si l'un des caractères incorporés dans ce bloc de caractères est de zéro
etc.
- Actuel FreeBSD on utilise quelque chose de similaire, pourrait venir sous la main: freebsd.org/cgi/cvsweb.cgi/src/lib/libc/string/...
- Que voulez-vous dire "sans le déposer à l'assemblée"? Sur i386, il utilise de l'assemblée (voir Sudhanshu de répondre).
- Sudhanshu est différente de celle que j'liés. Il est certainement possible que, lors de la glibc est construit pour un x86 Sudhanshu est utilisé (je suis honnêtement pas sûr); toutefois, l'exemple que j'ai souligné est directement du code C qui peut être utilisé comme un exemple de quelques optimisations possibles.
InformationsquelleAutor Michael Burr
3

Le plus simple est d'appeler strlen(). Sérieusement. C'est déjà optimisé par le compilateur et/ou de la bibliothèque vendeurs pour être aussi rapide que possible pour votre architecture.

Une commune de l'optimisation est de supprimer la nécessité d'augmenter un compteur, et de calculer la longueur du pointeur:
```
size_t my_strlen(const char *s)
{
  const char *anchor = s;

  while(*s)
   s++;

  return s - anchor;
}
```
InformationsquelleAutor unwind
3

C les chaînes sont intrinsèquement inefficace, il y a deux raisons pour l'utilisation de la ASCIZ convention:
- La bibliothèque standard C utilise
- Le compilateur utilise pour littérales constantes de chaîne
La première de ces académique dans ce cas, puisque vous n'êtes pas à l'aide de la bibliothèque standard, la seconde est facilement vaincu par la création de fonctions ou macros qui fournissent des conversions de chaînes C plus efficace de la convention tels que Pascal cordes. Le point est que vous ne devez pas être un esclave de la convention C si vous n'êtes pas à l'aide de la bibliothèque C.
- ++ Vous avez raison, mais parfois nous cherchons des cycles dans tous les mauvais endroits. Je n'ai pas vu de code réel où la vitesse de strlen était encore sur le radar, compte tenu de la multitude de macro-façons qui font en général des logiciels lent.
- Ne pouvais pas être plus d'accord. Susceptibles d'être prématuré de l'optimisation, mais l'article que j'ai lié donne quelques exemples dans le monde réel où il a été critique. Un strlen() la fonction pour une chaîne pascal est à la fois rapide et déterministe.
InformationsquelleAutor Clifford
2

Encore une autre façon d'accélérer char de comptage est d'utiliser la vectorisation!

Voici un exemple de comment le faire avec le respect de l'UTF8-chaînes codées:

Encore plus rapide de caractères UTF-8 de comptage,

http://www.daemonology.net/blog/2008-06-05-faster-utf8-strlen.html

InformationsquelleAutor qbitty
0

Sur les processeurs de type i386, libc souvent l'utilisation d'un ultra-version optimisée de strlen, souvent écrit en langage d'assemblage. Le papier "La Longueur De La Chaîne" explique comment ils fonctionnent.

Ici est une version optimisée pour les OpenBSD. (Ils ont aussi un version portable.) Voici la la version de la GNU libc.

InformationsquelleAutor bortzmeyer
0

Certaines des réponses ci-dessus sont très bons, et c'est mon point de vue.
Il y a un mot-clé connu comme "le registre"
```
#include <stdio.h>
size_t strlenNew(char *s);

int main(int argc, char* argv[])
{
    printf("Size of \"Hello World\" is ::\t%d",strlenNew("Hello World"));
    return 0;
}

size_t strlenNew(char *s)
{
    register int i=0;
    while(s[i]!='#include <stdio.h>
size_t strlenNew(char *s);
int main(int argc, char* argv[])
{
printf("Size of \"Hello World\" is ::\t%d",strlenNew("Hello World"));
return 0;
}
size_t strlenNew(char *s)
{
register int i=0;
while(s[i]!='\0') i++;
return i;
}
') i++;
    return i;
}
```
Lire ici: http://gustedt.wordpress.com/2010/08/17/a-common-misconsception-the-register-keyword/ et http://msdn.microsoft.com/en-us/library/482s4fy9(v=vs. 80).aspx

À partir du premier lien:

Cela peut être particulièrement utile pour les variables de tableau. Une variable tableau
est facilement confondu avec un pointeur de variable. Sauf s'il est suivi par
un [expr] ou avec un sizeof il renvoie l'adresse de la première
de l'élément. Si vous déclarez le tableau d'enregistrer tous ces usages sont
interdit; nous avons seulement accès à des éléments individuels ou d'en demander le total
taille. Un tel registre-tableau peut alors être beaucoup plus facile utilisé comme si c'
n'étaient tout simplement un ensemble de variables par l'optimiseur. Pas d'aliasing (l'accès à l'
la même variable à travers les différents pointeurs) peut se produire.

Ainsi, parfois, il peut y avoir des fluctuations de la performance. Personnellement, c'est un de mes fav implémentations, mais Sudhanshu et Andomar également fournir une bonne mise en œuvre 🙂

InformationsquelleAutor Binayaka Chakraborty

J'ai eu le même problème, et je l'ai résolu. La clé est la condition 2 de la boucle for:

int longitud(char cad[]){

    int i, cont;

    cont = 0;

    for(i = 0; i < 30 && cad[i] != 'int longitud(char cad[]){
int i, cont;
cont = 0;
for(i = 0; i < 30 && cad[i] != '\0'; i++){
if(cad[i] != '\0'){
if(cad[i] != ' '){
cont++;
}
}
}
cont--;
return cont;
}
'; i++){
        if(cad[i] != 'int longitud(char cad[]){
int i, cont;
cont = 0;
for(i = 0; i < 30 && cad[i] != '\0'; i++){
if(cad[i] != '\0'){
if(cad[i] != ' '){
cont++;
}
}
}
cont--;
return cont;
}
'){
            if(cad[i] != ' '){
                cont++;
            }
        }
    }
    cont--;
    return cont;
}

InformationsquelleAutor Victor26567

Je n'ai pas trouvé mieux :

inline
size_t mystrlen(char *_)

  { return ((_ == NULL) ? (_[0] != '  { return ((_ == NULL) ? (_[0] != '\0')) ? 0 : (1 + mystrlen(_ + 1)); }
')) ? 0 : (1 + mystrlen(_ + 1)); }

InformationsquelleAutor blueperfect

De base programme en C pour calculer la longueur de la chaîne.

#include <stdio.h>

/**
* Method to calculate string length.
* Returns -1 in case of null pointer, else return string length.
**/
int length(char *str) {

    int i = -1;
    //Check for NULL pointer, then return i = -1;
    if(str == NULL) return i;

    //Iterate till the empty character.
    while (str[++i] != '#include <stdio.h>
/**
* Method to calculate string length.
* Returns -1 in case of null pointer, else return string length.
**/
int length(char *str) {
int i = -1;
//Check for NULL pointer, then return i = -1;
if(str == NULL) return i;
//Iterate till the empty character.
while (str[++i] != '\0');
return i;  //Return string length.
}
int main (int argc, char **argv) {
int len = 0;
char abc[] = "hello";
len = length(abc);
printf("%d", len);  
return 0;
}
');
    return i;  //Return string length.
}

int main (int argc, char **argv) {

    int len = 0;
    char abc[] = "hello";
    len = length(abc);
    printf("%d", len);  
    return 0;
}

REMARQUE: Pour une meilleure façon, on doit toujours passer la taille du tableau à la fonction pour éviter le cas de fuite de mémoire. Par exemple, le **prototype de la méthode*:*

/**
* @desc calculate the length of str.
* @param1 *str pointer to base address of char array.
* @param2 size = capacity of str to hold characters.
* @return int -1 in case of NULL, else return string length.
**/
int length (char *str, int size);

InformationsquelleAutor Rahul Raina

-1

Je ne suis pas tout à fait sûr de ce que vous voulez faire.

Vous voulez ré-écrire strlen afin de rendre votre code compatible avec la norme c-Bibliothèque, ou vous souhaitez gérer les chaînes de caractères.

Dans le premier cas, je pense que tu ferais mieux d'utiliser directement les bibliothèques standard.

L'autre cas est intéressant : vous devriez jeter un oeil à la chaîne c++ de la classe, qui ont une mise en œuvre des traits de la stratégie permettant de créer rapidement des manipulations de très grandes chaînes de caractères).
- La question est assez précise de ce qu'il voulait dire, et déclare qu'il ne peut pas utiliser la norme comprend qu'il est libre et de l'environnement.
InformationsquelleAutor blueperfect
-5
```
int max;
max = sizeof(str);
return (--max);
```
- Cela ne fonctionne que pour char tableaux et C-littéraux de chaîne. Cela ne fonctionne pas pour les pointeurs vers des chaînes de caractères.
- ce ne fonctionne PAS string variables
InformationsquelleAutor nel

Vous devez vous connecter pour publier un commentaire.