Je travaille en C, et je dois concaténer quelques éléments.
En ce moment, j'ai ceci :
message = strcat("TEXT ", var);
message2 = strcat(strcat("TEXT ", foo), strcat(" TEXT ", bar));
Si vous avez de l’expérience en C, je suis sûr que vous vous rendez compte que cela donne un défaut de segmentation lorsque vous essayez de l’exécuter. Alors comment puis-je contourner ce problème ?
En C, les "strings" ; ne sont que de simples tableaux de char
. Par conséquent, vous ne pouvez pas les concaténer directement avec d'autres "strings" ;.
Vous pouvez utiliser la fonction strcat
, qui ajoute la chaîne pointée par src
à la fin de la chaîne pointée par dest
:
char *strcat(char *dest, const char *src);
Voici un [exemple tiré de cplusplus.com][1] :
char str[80];
strcpy(str, "these ");
strcat(str, "strings ");
strcat(str, "are ");
strcat(str, "concatenated.");
[1] : http://www.cplusplus.com/reference/clibrary/cstring/strcat.html
Pour le premier paramètre, vous devez fournir le tampon de destination lui-même. Le tampon de destination doit être un tampon de type tableau de caractères. Par exemple char buffer[1024];
**Assurez-vous que le premier paramètre dispose de suffisamment d'espace pour stocker ce que vous essayez d'y copier. Si vous en avez la possibilité, il est plus sûr d'utiliser des fonctions comme : strcpy_s
et strcat_s
où vous devez explicitement spécifier la taille du tampon de destination.
Note : Un littéral de chaîne de caractères ne peut pas être utilisé comme un tampon, puisqu'il s'agit d'une constante. Ainsi, vous devez toujours allouer un tableau de caractères pour le tampon.
La valeur de retour de strcat
peut être simplement ignorée, elle retourne simplement le même pointeur que celui passé en premier argument. Elle est là par commodité, et vous permet d'enchaîner les appels en une seule ligne de code :
strcat(strcat(str, foo), bar);
Votre problème pourrait donc être résolu comme suit :
char *foo = "foo";
char *bar = "bar";
char str[80];
strcpy(str, "TEXT ");
strcat(str, foo);
strcat(str, bar);
C'est un comportement non défini que de tenter de modifier des chaînes de caractères, ce qui est le cas de quelque chose comme :
strcat ("Hello, ", name);
va tenter de le faire. Il essaiera d'ajouter la chaîne name
à la fin de la chaîne littérale "Hello, "
, qui n'est pas bien définie.
Essayez quelque chose comme ceci. Vous obtiendrez ce que vous semblez vouloir faire :
char message[1000];
strcpy (message, "TEXT ");
strcat (message, var);
Cela crée une zone tampon qui est autorisée à être modifiée, puis y copie la chaîne de caractères et d'autres textes. Faites juste attention aux débordements de tampon. Si vous contrôlez les données d'entrée (ou les vérifiez au préalable), vous pouvez utiliser des tampons de longueur fixe comme je l'ai fait.
Sinon, vous devez utiliser des stratégies d'atténuation telles que l'allocation d'une quantité suffisante de mémoire à partir du tas pour être sûr de pouvoir gérer le problème. 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.
Le premier argument de strcat() doit pouvoir contenir suffisamment d'espace pour la chaîne concaténée. Allouez donc un tampon avec suffisamment d'espace pour recevoir le résultat.
char bigEnough[64] = "";
strcat(bigEnough, "TEXT");
strcat(bigEnough, foo);
/* and so on */
strcat() va concaténer le second argument avec le premier argument, et stocker le résultat dans le premier argument, le char* retourné est simplement ce premier argument, et seulement pour votre commodité.
Vous n'obtenez pas une chaîne de caractères nouvellement allouée avec le premier et le second argument concaténés, ce que je suppose que vous attendiez d'après votre code.