Comment concaténer const/literal chaînes de caractères en C?

Éviter d'utiliser strcat dans le code C. Le plus propre et, surtout, de la façon la plus sûre est d'utiliser snprintf:

char buf[256];
snprintf(buf, sizeof buf, "%s%s%s%s", str1, str2, str3, str4);

Certains intervenants ont soulevé une question que le nombre d'arguments peuvent ne pas correspondre à la chaîne de format et le code de la compilation, mais la plupart des compilateurs déjà émettre un avertissement si c'est le cas.

Aussi malloc et realloc sont utiles si vous ne savez pas à l'avance combien de chaînes sont concaténées.

#include <stdio.h>
#include <string.h>

void example(const char *header, const char **words, size_t num_words)
{
    size_t message_len = strlen(header) + 1; /* + 1 for terminating NULL */
    char *message = (char*) malloc(message_len);
    strncat(message, header, message_len);

    for(int i = 0; i < num_words; ++i)
    {
       message_len += 1 + strlen(words[i]); /* 1 + for separator ';' */
       message = (char*) realloc(message, message_len);
       strncat(strncat(message, ";", message_len), words[i], message_len);
    }

    puts(message);

    free(message);
}

Ne pas oublier d'initialiser la mémoire tampon de sortie. Le premier argument de strcat doit être une chaîne terminée par null avec suffisamment d'espace supplémentaire alloué pour la suite de la chaîne:

char out[1024] = ""; //must be initialized
strcat( out, null_terminated_string ); 
//null_terminated_string has less than 1023 chars

Que des personnes ont souligné la manipulation des chaînes de beaucoup d'améliorations. De sorte que vous pouvez apprendre comment utiliser le C++ de la bibliothèque string au lieu de C-style chaînes. Cependant voici une solution en pur C

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

void appendToHello(const char *s) {
    const char *const hello = "hello ";

    const size_t sLength     = strlen(s);
    const size_t helloLength = strlen(hello);
    const size_t totalLength = sLength + helloLength;

    char *const strBuf = malloc(totalLength + 1);
    if (strBuf == NULL) {
        fprintf(stderr, "malloc failed\n");
        exit(EXIT_FAILURE);
    }

    strcpy(strBuf, hello);
    strcpy(strBuf + helloLength, s);

    puts(strBuf);

    free(strBuf);

}

int main (void) {
    appendToHello("blah blah");
    return 0;
}

Je ne suis pas sûr de savoir si c'est correct/safe mais pour l'instant, je ne pouvais pas trouver une meilleure façon de le faire dans la norme ANSI C.

C'est un comportement indéterminé pour tenter de modifier les littéraux de chaîne, qui est ce que quelque chose comme:

strcat ("Hello, ", name);

va tenter de faire. Il va essayer de virer de bord sur le name chaîne à la fin de la chaîne littérale "Hello, ", ce qui n'est pas bien défini.

Essayer quelque chose de cela. Il réalise ce qui vous semble être d'essayer de faire:

char message[1000];
strcpy (message, "TEXT ");
strcat (message, var);

Cela crée une zone tampon qui est autorisé à être modifiée et puis d'exemplaires à la fois la chaîne de caractères littérale et d'autres du texte. Juste être prudent avec les débordements de tampon. Si vous contrôlez les données d'entrée (ou de la vérifier avant de la main), c'est bien d'utiliser fixe la longueur des tampons, comme je l'ai.

Sinon, vous devez utiliser des stratégies d'atténuation comme l'allocation de suffisamment de mémoire dans le tas pour vous assurer que vous pouvez le manipuler. En d'autres termes, quelque chose comme:

const static char TEXT[] = "TEXT ";

//Make *sure* you have enough space.

char *message = malloc (sizeof(TEXT) + strlen(var) + 1);
if (message == NULL)
     handleOutOfMemoryIntelligently();
strcpy (message, TEXT);
strcat (message, var);

//Need to free message at some point after you're done with it.

En supposant que vous avez un char[fixed_size] plutôt qu'un char*, vous pouvez utiliser un seul, de création de macro pour le faire tout à la fois avec <<cout<<like de la commande ("plutôt %s disjoints %s\n", "que", "printf format de style"). Si vous travaillez avec des systèmes embarqués, cette méthode vous permettra également de laisser de côté les malloc et le grand *printf famille de fonctions comme snprintf() (Cela empêche dietlibc de se plaindre de *printf trop)

#include <unistd.h> //for the write example
//note: you should check if offset==sizeof(buf) after use
#define strcpyALL(buf, offset, ...) do{ \
    char *bp=(char*)(buf+offset); /*so we can add to the end of a string*/ \
    const char *s, \
    *a[] = { __VA_ARGS__,NULL}, \
    **ss=a; \
    while((s=*ss++)) \
         while((*s)&&(++offset<(int)sizeof(buf))) \
            *bp++=*s++; \
    if (offset!=sizeof(buf))*bp=0; \
}while(0)

char buf[256];
int len=0;

strcpyALL(buf,len,
    "The config file is in:\n\t",getenv("HOME"),"/.config/",argv[0],"/config.rc\n"
);
if (len<sizeof(buf))
    write(1,buf,len); //outputs our message to stdout
else
    write(2,"error\n",6);

//but we can keep adding on because we kept track of the length
//this allows printf-like buffering to minimize number of syscalls to write
//set len back to 0 if you don't want this behavior
strcpyALL(buf,len,"Thanks for using ",argv[0],"!\n");
if (len<sizeof(buf))
    write(1,buf,len); //outputs both messages
else
    write(2,"error\n",6);

• Note 1, vous généralement ne pas utiliser de argv[0] comme ça - juste un exemple
• Note 2, vous pouvez utiliser n'importe quelle fonction qui retourne un char*, y compris les non standard des fonctions comme itoa() pour convertir des entiers types de chaînes.
• Note 3, si vous êtes déjà à l'aide de printf n'importe où dans votre programme, il n'y a pas de raison de ne pas utiliser de snprintf(), puisque le code compilé est plus grand (mais inline et nettement plus rapide)

Vous essayez de copier une chaîne dans une adresse qui est allouée statiquement. Vous avez besoin d'un chat dans une mémoire tampon.

Spécifiquement:

...snip...

destination

Pointer to the destination array, which should contain a C string, and be large enough to contain the concatenated resulting string.

...snip...

http://www.cplusplus.com/reference/clibrary/cstring/strcat.html

Il y a un exemple ici.

C'était ma solution

#include <stdlib.h>
#include <stdarg.h>

char *strconcat(int num_args, ...) {
    int strsize = 0;
    va_list ap;
    va_start(ap, num_args);
    for (int i = 0; i < num_args; i++) 
        strsize += strlen(va_arg(ap, char*));

    char *res = malloc(strsize+1);
    strsize = 0;
    va_start(ap, num_args);
    for (int i = 0; i < num_args; i++) {
        char *s = va_arg(ap, char*);
        strcpy(res+strsize, s);
        strsize += strlen(s);
    }
    va_end(ap);
    res[strsize] = '
#include <stdlib.h>
#include <stdarg.h>
char *strconcat(int num_args, ...) {
int strsize = 0;
va_list ap;
va_start(ap, num_args);
for (int i = 0; i < num_args; i++) 
strsize += strlen(va_arg(ap, char*));
char *res = malloc(strsize+1);
strsize = 0;
va_start(ap, num_args);
for (int i = 0; i < num_args; i++) {
char *s = va_arg(ap, char*);
strcpy(res+strsize, s);
strsize += strlen(s);
}
va_end(ap);
res[strsize] = '\0';
return res;
}
';

    return res;
}

mais vous avez besoin de spécifier le nombre de chaînes que vous allez pour concaténer

char *str = strconcat(3, "testing ", "this ", "thing");