#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

On peut écrire une fonction variadique utile pour concaténer n'importe quel nombre 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;
}

Utilisation

#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

Nettoyage

Notez que vous devez libérer la mémoire allouée lorsqu'elle 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 (le mot clé est "concaténation").

Vous ne pouvez pas ajouter des littéraux de chaîne comme ça dans C. Vous devez créer un tampon de taille chaîne littérale un + chaîne littérale deux + un octet pour le caractère de terminaison null et copier les littéraux correspondants dans ce tampon et assurez-vous également qu'il est terminé par null. Ou vous pouvez utiliser des fonctions de bibliothèque comme strcat.

Je suppose que vous en avez besoin pour des choses ponctuelles. Je suppose que vous êtes un développeur de PC.

Utilise la pile, Luke. Utilisez-le partout. N'utilisez pas malloc / free pour les petites allocations, jamais .

#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 embêtez pas, - ils vont libérer leur mémoire de pile à la fin des étendues de toute façon.

Sans 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;
}

Voir malloc, libre et asprintf pour plus de détails.

#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);
}

Concaténer Des Chaînes

Concaténer deux chaînes quelconques en C peut se faire d'au moins 3 façons : -

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 la chaîne 1 et la chaîne 2 dans 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;
}

En C, vous n'avez pas vraiment de chaînes, en tant qu'objet générique de première classe. Vous avez à 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 façon est de variables normales, par exemple placées sur la pile. Une autre façon est de les allouer dynamiquement en utilisant malloc.

Une fois que vous l'avez trié, vous pouvez copier le contenu d'un tableau dans un autre, pour concaténer deux chaînes en utilisant strcpy ou strcat.

Cela dit, C ont le concept de "littéraux de chaîne", qui sont des chaînes connues au moment de la compilation. Lorsqu'ils sont utilisés, ils seront un tableau de caractères placé dans la mémoire en lecture seule. Il est cependant possible de concaténer deux littéraux de chaîne en les écrivant l'un à côté de l'autre, comme dans "foo" "bar", ce qui créera le littéral de chaîne "foobar".