Comment concaténer deux chaînes en C?
Comment puis-je ajouter deux chaînes?
J'ai essayé name = "derp" + "herp";, mais j'ai eu une erreur:
L'expression doit être de type intégral ou enum
C ne prend pas en charge les chaînes de certaines autres langues. Une chaîne en C est juste un pointeur sur un tableau de char qui se termine par le premier caractère nul. Il n'y a pas d'opérateur de concaténation de chaîne dans C.
Utilisez strcat pour concaténer deux chaînes. Vous pouvez utiliser la fonction suivante pour le faire:
#include <stdlib.h>
#include <string.h>
char* concat(const char *s1, const char *s2)
{
char *result = malloc(strlen(s1) + strlen(s2) + 1); // +1 for the null-terminator
// in real code you would check for errors in malloc here
strcpy(result, s1);
strcat(result, s2);
return result;
}
Ce n’est pas le moyen le plus rapide de le faire, mais vous ne devriez pas vous en inquiéter pour le moment. Notez que la fonction renvoie un bloc de mémoire allouée au segment de mémoire et en transmet la propriété. Il est de la responsabilité de l'appelant de free la mémoire lorsqu'elle n'est plus utilisée.
Appelez la fonction comme ceci:
char* s = concat("derp", "herp");
// do things with s
free(s); // deallocate the string
Si les performances vous gênent, évitez d'analyser de manière répétée les tampons d'entrée à la recherche du terminateur nul.
char* concat(const char *s1, const char *s2)
{
const size_t len1 = strlen(s1);
const size_t len2 = strlen(s2);
char *result = malloc(len1 + len2 + 1); // +1 for the null-terminator
// in real code you would check for errors in malloc here
memcpy(result, s1, len1);
memcpy(result + len1, s2, len2 + 1); // +1 to copy the null-terminator
return result;
}
Si vous envisagez de travailler beaucoup avec des chaînes, il est peut-être préférable d'utiliser un autre langage prenant en charge les chaînes de première classe.
#include <stdio.h>
int main(){
char name[] = "derp" "herp";
printf("\"%s\"\n", name);//"derpherp"
return 0;
}
David Heffernan a expliqué le problème dans sa réponse et j'ai écrit le code amélioré. Voir ci-dessous.
Une fonction générique
Nous pouvons écrire un utile fonction variadique pour concaténer un nombre quelconque de chaînes:
#include <stdlib.h> // calloc
#include <stdarg.h> // va_*
#include <string.h> // strlen, strcpy
char* concat(int count, ...)
{
va_list ap;
int i;
// Find required length to store merged string
int len = 1; // room for NULL
va_start(ap, count);
for(i=0 ; i<count ; i++)
len += strlen(va_arg(ap, char*));
va_end(ap);
// Allocate memory to concat strings
char *merged = calloc(sizeof(char),len);
int null_pos = 0;
// Actually concatenate strings
va_start(ap, count);
for(i=0 ; i<count ; i++)
{
char *s = va_arg(ap, char*);
strcpy(merged+null_pos, s);
null_pos += strlen(s);
}
va_end(ap);
return merged;
}
Usage
#include <stdio.h> // printf
void println(char *line)
{
printf("%s\n", line);
}
int main(int argc, char* argv[])
{
char *str;
str = concat(0); println(str); free(str);
str = concat(1,"a"); println(str); free(str);
str = concat(2,"a","b"); println(str); free(str);
str = concat(3,"a","b","c"); println(str); free(str);
return 0;
}
Sortie:
// Empty line
a
ab
abc
Nettoyer
Notez que vous devriez libérer la mémoire allouée lorsque cela devient inutile pour éviter les fuites de mémoire:
char *str = concat(2,"a","b");
println(str);
free(str);
Vous devez utiliser strcat ou mieux strncat. Google il (le mot clé est "concaténer").
Je suppose que vous en avez besoin pour des choses uniques. Je suppose que vous êtes un développeur PC.
Utilise la pile, Luke. Utilisez-le partout. N'utilisez pas malloc/free pour les petites allocations, ever.
#include <string.h>
#include <stdio.h>
#define STR_SIZE 10000
int main()
{
char s1[] = "oppa";
char s2[] = "gangnam";
char s3[] = "style";
{
char result[STR_SIZE] = {0};
snprintf(result, sizeof(result), "%s %s %s", s1, s2, s3);
printf("%s\n", result);
}
}
Si 10 Ko par chaîne ne suffisent pas, ajoutez un zéro à la taille et ne vous dérangez pas: ils libéreront leur mémoire de pile à la fin des étendues.
Vous ne pouvez pas ajouter de littéraux de chaîne comme ceux de C. Vous devez créer un tampon de taille littéral de chaîne un + littéral de chaîne deux + un octet pour le caractère de fin null et copier les littéraux correspondants dans ce tampon ainsi que assurez-vous qu'il est null terminé. Vous pouvez également utiliser des fonctions de bibliothèque telles que strcat.
Sans l'extension GNU:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
const char str1[] = "First";
const char str2[] = "Second";
char *res;
res = malloc(strlen(str1) + strlen(str2) + 1);
if (!res) {
fprintf(stderr, "malloc() failed: insufficient memory!\n");
return EXIT_FAILURE;
}
strcpy(res, str1);
strcat(res, str2);
printf("Result: '%s'\n", res);
free(res);
return EXIT_SUCCESS;
}
Alternativement avec l'extension GNU:
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
const char str1[] = "First";
const char str2[] = "Second";
char *res;
if (-1 == asprintf(&res, "%s%s", str1, str2)) {
fprintf(stderr, "asprintf() failed: insufficient memory!\n");
return EXIT_FAILURE;
}
printf("Result: '%s'\n", res);
free(res);
return EXIT_SUCCESS;
}
Concaténer des cordes
La concaténation de deux chaînes en C peut être effectuée de trois manières au moins: -
1) En copiant la chaîne 2 à la fin de la chaîne 1
#include <stdio.h>
#include <string.h>
#define MAX 100
int main()
{
char str1[MAX],str2[MAX];
int i,j=0;
printf("Input string 1: ");
gets(str1);
printf("\nInput string 2: ");
gets(str2);
for(i=strlen(str1);str2[j]!='\0';i++) //Copying string 2 to the end of string 1
{
str1[i]=str2[j];
j++;
}
str1[i]='\0';
printf("\nConcatenated string: ");
puts(str1);
return 0;
}
2) En copiant les chaînes 1 et 2 sur la chaîne 3
#include <stdio.h>
#include <string.h>
#define MAX 100
int main()
{
char str1[MAX],str2[MAX],str3[MAX];
int i,j=0,count=0;
printf("Input string 1: ");
gets(str1);
printf("\nInput string 2: ");
gets(str2);
for(i=0;str1[i]!='\0';i++) //Copying string 1 to string 3
{
str3[i]=str1[i];
count++;
}
for(i=count;str2[j]!='\0';i++) //Copying string 2 to the end of string 3
{
str3[i]=str2[j];
j++;
}
str3[i]='\0';
printf("\nConcatenated string : ");
puts(str3);
return 0;
}
3) En utilisant la fonction strcat ()
#include <stdio.h>
#include <string.h>
#define MAX 100
int main()
{
char str1[MAX],str2[MAX];
printf("Input string 1: ");
gets(str1);
printf("\nInput string 2: ");
gets(str2);
strcat(str1,str2); //strcat() function
printf("\nConcatenated string : ");
puts(str1);
return 0;
}
#include <string.h>
#include <stdio.h>
int main()
{
int a,l;
char str[50],str1[50],str3[100];
printf("\nEnter a string: ");
scanf("%s",str);
str3[0]='\0';
printf("\nEnter the string which you want to concat with string one: ");
scanf("%s",str1);
strcat(str3,str);
strcat(str3,str1);
printf("\nThe string is %s\n",str3);
}
En C, vous n'avez pas vraiment de chaînes, en tant qu'objet générique de première classe. Vous devez les gérer comme des tableaux de caractères, ce qui signifie que vous devez déterminer comment vous souhaitez gérer vos tableaux. Une solution consiste à utiliser des variables normales, par exemple placé sur la pile. Une autre méthode consiste à les allouer dynamiquement à l'aide de malloc.
Une fois que vous avez trié cela, vous pouvez copier le contenu d'un tableau dans un autre, pour concaténer deux chaînes à l'aide de strcpy ou strcat.
Cela dit, C a le concept de "littéraux de chaîne", qui sont des chaînes connues au moment de la compilation. Une fois utilisés, ils constitueront un tableau de caractères placé dans une mémoire en lecture seule. Il est toutefois possible de concaténer deux littéraux de chaîne en les écrivant l'un à côté de l'autre, comme dans "foo" "bar", qui créera le littéral de chaîne "foobar".