C: Quel est le meilleur et le plus rapide pour concaténer des chaînes

Joel Spolsky, dans son Retour à la base article décrit le problème de l'inefficacité de concaténation de chaîne avec strcat comme le Shlemiel l'algorithme du peintre (lire l'article, c'est très bon). Comme un exemple de l'inefficacité de code, il donne cet exemple, qui s'exécute en O(n²) temps:

char bigString[1000];     /* I never know how much to allocate... */
bigString[0] = '
char bigString[1000];     /* I never know how much to allocate... */
bigString[0] = '\0';
strcat(bigString,"John, ");
strcat(bigString,"Paul, ");
strcat(bigString,"George, ");
strcat(bigString,"Joel ");
';
strcat(bigString,"John, ");
strcat(bigString,"Paul, ");
strcat(bigString,"George, ");
strcat(bigString,"Joel ");

Ce n'est pas vraiment un problème pour marcher sur la première chaîne de la première fois; puisque nous avons déjà eu à marcher sur la deuxième chaîne, le moteur d'exécution de un strcat est linéaire en la longueur de la suite. Plusieurs strcats est cependant problématique, car nous marchons précédemment concaténées résultats, encore et encore. Il fournit à cette alternative:

Comment pouvons-nous résoudre ce problème? Un peu de smart C programmeurs de mettre en œuvre leurs propres
mystrcat comme suit:

char* mystrcat( char* dest, char* src )
{
     while (*dest) dest++;
     while (*dest++ = *src++);
     return --dest;
}

Qu'avons-nous fait ici? À peu de frais, nous sommes de retour d'un
pointeur à la fin de la nouvelle, la plus longue chaîne. De cette façon, le code que
les appels de cette fonction peut décider d'ajouter d'autres sans rescanner
la chaîne:

char bigString[1000];     /* I never know how much to allocate... */
char *p = bigString;
bigString[0] = '
char bigString[1000];     /* I never know how much to allocate... */
char *p = bigString;
bigString[0] = '\0';
p = mystrcat(p,"John, ");
p = mystrcat(p,"Paul, ");
p = mystrcat(p,"George, ");
p = mystrcat(p,"Joel ");
';
p = mystrcat(p,"John, ");
p = mystrcat(p,"Paul, ");
p = mystrcat(p,"George, ");
p = mystrcat(p,"Joel ");

C'est, bien sûr, linéaire de la performance, pas de n au carré, de sorte qu'il
de ne pas subir de dégradation lorsque vous avez beaucoup de choses à
concaténer.

Bien sûr, c'est ce que vous pouvez faire si vous souhaitez utiliser la norme C des chaînes de caractères. L'alternative que vous décrivez de mise en cache de la longueur de la chaîne et à l'aide d'une concaténation de la fonction (par exemple, l'appel de strcat légèrement différents arguments) est une sorte de variation sur Pascal chaînes, qui Joel également mentionné:

Les concepteurs de Pascal étaient au courant de ce problème et "fixe" par
le stockage d'un nombre d'octets dans le premier octet de la chaîne. Ceux-ci sont appelés
Pascal Cordes. Ils peuvent contenir des zéros et ne sont pas null.
Parce qu'un octet ne peut stocker des nombres entre 0 et 255, Pascal
les chaînes sont limitées à 255 octets de longueur, mais parce qu'ils ne sont pas
null ils occupent la même quantité de mémoire que ASCIZ
les chaînes de caractères. La grande chose à propos de Pascal chaînes, c'est que vous n'avez jamais
pour avoir une boucle juste pour déterminer la longueur de votre chaîne. Trouver
la longueur d'une chaîne en Pascal est l'une des instructions de montage à la place
de l'ensemble de la boucle. Il est rapidement plus rapidement.

...

Pour une longue période, si vous souhaitez placer une chaîne Pascal littérale dans votre
Le code en C, on devait écrire:

char* str = "
char* str = "\006Hello!";
6Hello!";

Oui, vous avez dû compter les octets à la main, vous-même, et de coder en dur
dans le premier octet de votre chaîne. Paresseux les programmeurs ce faire,
et lents programmes:

char* str = "*Hello!";
str[0] = strlen(str) - 1;

Pour concaténer plusieurs chaînes de caractères, le code peut utiliser strlen() et memcpy() qui sont à la fois souvent bien optimisé fonctions.

Avec cette approche, facile d'ajouter un peu de size limite.

Compte tenu de la réelle possibilité que le tampon de destination peut déborder sinon, une limite de taille est essentielle.

Moment de l'exécution proportionnelle à la somme des longueurs de chaîne: O(len(S[0]) + len(S[1]) + len(S[2]) + ...)

char *strsncat(char *dest, size_t size, char * strs[], size_t n) {
  assert(size > 0);
  size--;
  char *p = dest;
  while (n-- > 0) {
    size_t len = strlen(*strs);
    if (len >= size) {
      len = size;
    }
    size -= len;
    memcpy(p, *strs, len);
    strs++;
    p += len;
  }
  *p = '
char *strsncat(char *dest, size_t size, char * strs[], size_t n) {
assert(size > 0);
size--;
char *p = dest;
while (n-- > 0) {
size_t len = strlen(*strs);
if (len >= size) {
len = size;
}
size -= len;
memcpy(p, *strs, len);
strs++;
p += len;
}
*p = '\0';
return dest;
}
void cat_test(void) {
char dest[10];
char *strs[]  = { "Red", "Green", "Blue" };
printf("'%s'\n",strsncat(dest, sizeof dest, strs, sizeof strs/sizeof strs[0]));
//'RedGreenB'
}
';
  return dest;
}

void cat_test(void) {
  char dest[10];
  char *strs[]  = { "Red", "Green", "Blue" };
  printf("'%s'\n",strsncat(dest, sizeof dest, strs, sizeof strs/sizeof strs[0]));
  //'RedGreenB'
}

Supposons que vous disposez de deux chaînes de caractères: s1 et s2 avec une longueur l1 et l2 Concaténation signifie que vous devez générer une nouvelle chaîne s3 avec une longueur l1+l2. Le temps de la complexité de cette opération est O(l1+l2). De ce point de vue, strcat() semble être le meilleur choix.

Cependant, si vous souhaitez indiquer l'état que les deux chaînes sont concaténés, alors vous n'avez qu'à enregistrer leurs conseils, ce qui est O(1). Un exemple simple serait comme ceci:

typedef struct ConcatStr {
    char* str1;
    char* str2;
} ConcatStr;
ConcatStr myStrcat( char* str1, char* str2 )
{
    ConcatStr cstr;
    cstr.str1 = str1;
    cstr.str2 = str2;
}

Cochez cette

https://john.nachtimwald.com/2017/02/26/efficient-c-string-builder/

Il m'a aidé à Copier un char** dans le presse-papiers en un clin d'œil

    str_builder_t *sb;
     sb = str_builder_create();

                        int colcnt=0;
                        for (int i=0;i<nrF;i++)  //nrF = number of Fileds 
                    {
                            //strcat(DATA,sqlite_array[i]);
                     str_builder_add_str(sb, sqlite_array[i], 0); 
                            if (colcnt<nrofcolumns)  //my list view 
                                {
                            str_builder_add_str(sb, "\t", 0); 
                                colcnt++;

                            }
                                if (colcnt==nrofcolumns) 
                            {

                            str_builder_add_str(sb, "\n", 0); 
                                    colcnt=0;
                            }

                    }

    HANDLE  glob =GlobalAlloc(GMEM_FIXED,str_builder_len(sb)+1);
    memcpy(glob,str_builder_peek(sb),str_builder_len(sb)+1);
    OpenClipboard(NULL);
    EmptyClipboard();
    SetClipboardData(CF_TEXT,glob);
    CloseClipboard();