Comment concaténer deux chaînes de caractères en C?

Comment ajouter deux chaînes?

J'ai essayé name = "derp" + "herp";, mais j'ai une erreur:

L'Expression doit avoir un type intégral ou enum

102
demandé sur Peter Mortensen 2011-12-11 19:11:35

10 réponses

C n'a pas le support pour les chaînes que d'autres langues ont. Une chaîne en C est juste un pointeur vers un tableau de char qui est terminé par le premier caractère null. 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 inquiéter à ce sujet maintenant. Notez que la fonction renvoie un bloc de mémoire allouée au tas appelant et transmet la propriété de cette mémoire. Il est de la responsabilité de l'appelant à free la mémoire quand il n'est plus nécessaire.

Appelez la fonction comme ceci:

char* s = concat("derp", "herp");
// do things with s
free(s); // deallocate the string

Si vous étiez dérangé par les performances, vous voudriez éviter d'analyser à plusieurs reprises les tampons d'entrée à la recherche du terminateur null.

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 prévoyez de faire beaucoup de travail avec des chaînes, il est peut-être préférable d'utiliser une langue différente qui a un support de première classe pour chaîne.

123
répondu David Heffernan 2018-06-22 09:00:06
#include <stdio.h>

int main(){
    char name[] =  "derp" "herp";
    printf("\"%s\"\n", name);//"derpherp"
    return 0;
}
15
répondu BLUEPIXY 2011-12-11 17:12:53

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);
11
répondu mmdemirbas 2017-05-23 12:18:23

Vous devez utiliser strcat, ou mieux, strncat. Google (le mot clé est "concaténation").

8
répondu orlp 2011-12-11 15:12:52

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.

5
répondu Mahesh 2011-12-11 15:14:07

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.

5
répondu 2016-01-20 01:00:50

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.

3
répondu Peter Mortensen 2017-05-22 18:34:40
#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);
}
2
répondu user2870383 2015-12-02 04:04:12

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;
}
2
répondu Paurav Shah 2018-08-05 15:27:15

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".

0
répondu Lindydancer 2011-12-11 15:20:36