你应该使用 strcat，或者更好，strncat。谷歌它(关键字是“连接”)。

您不能像在 C 中那样添加字符串字面值。您必须创建一个大小为 字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串字符串的缓冲区，并将相应的文字复制到该缓冲区，同时确保它以空结束。或者可以使用类似 strcat的库函数。

C 不像其他语言那样支持字符串。C 中的字符串只是一个指向 char数组的指针，该数组以第一个空字符结束。C 语言中没有字符串串联运算符。

使用 strcat连接两个字符串:

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

这不是最快的方法，但你现在不应该担心这个。请注意，该函数将分配给调用方的堆内存块返回给调用方，并将该内存的所有权传递给调用方。当内存不再需要时，调用者对 free内存负责。

这样调用函数:

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

如果您碰巧被性能问题所困扰，那么您应该避免重复扫描输入缓冲区以寻找 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;
}

如果您计划使用字符串进行大量工作，那么您最好使用另一种具有对字符串的一流支持的语言。

在 c 语言中，你没有字符串作为一般的第一类物件。必须将它们作为字符数组进行管理，这意味着必须确定如何管理数组。一种方法是普通变量，例如放在堆栈上。另一种方法是使用 malloc动态分配它们。

排序后，可以将一个数组的内容复制到另一个数组，以使用 strcpy或 strcat连接两个字符串。

话虽如此，但 C 确实有“字符串文字”的概念，这是在编译时已知的字符串。使用时，它们将是一个放置在只读内存中的字符数组。但是，可以通过将两个字符串文字相邻写入来连接它们，如 "foo" "bar"，它将创建字符串文字“ foobar”。

没有 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;
}

或者使用 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;
}

详情请参阅 Malloc、 自由和 (咒语)。

#include <stdio.h>


int main(){
char name[] =  "derp" "herp";
printf("\"%s\"\n", name);//"derpherp"
return 0;
}

大卫赫弗南 解释的问题在他的答案，我写了改进的代码。见下文。

泛型函数

我们可以编写一个有用的 可变参数函数来连接任意数量的字符串:

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

用法

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

产出:

  // Empty line
a
ab
abc

清理现场

请注意，当不需要分配的内存时，应该释放它，以避免内存泄漏:

char *str = concat(2,"a","b");
println(str);
free(str);

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

我会假设你需要它来做一次性的事情。我会假设你是一个 PC 开发者。

使用堆栈，卢克。到处使用它。不要使用 malloc/free 为小分配，永远不会。

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

如果每个字符串10KB 还不够，那么就在大小上添加一个零，不用麻烦了,-不管怎样，他们会在作用域结束时释放堆栈内存。

连接字符串

在 C 语言中连接任意两个字符串至少有三种方法:-

1)将字符串2复制到字符串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)将字符串1和字符串2复制到字符串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)使用 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;
}

使用 memcpy

char *str1="hello";
char *str2=" world";
char *str3;


str3=(char *) malloc (11 *sizeof(char));
memcpy(str3,str1,5);
memcpy(str3+strlen(str1),str2,6);


printf("%s + %s = %s",str1,str2,str3);
free(str3);

我在这里使用 asprintf

示例代码:

char* fileTypeToStr(mode_t mode) {
char * fileStrBuf = NULL;
asprintf(&fileStrBuf, "%s", "");


bool isFifo = (bool)S_ISFIFO(mode);
if (isFifo){
asprintf(&fileStrBuf, "%s %s,", fileStrBuf, "FIFO");
}


...


bool isSocket = (bool)S_ISSOCK(mode);
if (isSocket){
asprintf(&fileStrBuf, "%s %s,", fileStrBuf, "Socket");
}


return fileStrBuf;
}