#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

int main() {
   char *s1 = "abc";
   char *s2 = "def";
   int i;

   for (i=1; i<=10; i++) {
     char *sum = (char*)malloc(255);
     sum[0] = '\0';
     strcat(sum, s1);
     strcat(sum, s2);
     printf("%s\n", sum);
     free(sum);
   }
}

#include <string.h>

DAS>#include <string.h>
DAS>#include <stdlib.h>
DAS>#include <stdio.h>
DAS>#include <unistd.h>

DAS>int main() {
DAS>   char *s1 = "abc";
DAS>   char *s2 = "def";
DAS>   int i;

DAS>   for (i=1; i<=10; i++) {
DAS>     char *sum = (char*)malloc(255);
DAS>     sum[0] = '\0';
DAS>     strcat(sum, s1);
DAS>     strcat(sum, s2);
DAS>     printf("%s\n", sum);
DAS>     free(sum);
DAS>   }
DAS>}

DAS>

char *s1 = "abc";
char *s2 = "def";
char *s3 = (char*)malloc(strlen(s1) + strlen(s2) + 1);
sprintf(s3, "%s%s", s1, s2);
free(s3);

char * concat(const char * s1, const char * s2)
{
    size_t l1 = strlen(s1);
    size_t l2 = strlen(s2);
    size_t len = l1 + l2 + 1;

    char * dst = (char *)malloc(len);

    memcpy(dst, s1, l1);
    memcpy(dst + l1, s2, l2);
    dst[len - 1] = 0;

    return dst;
}

...

char * str = concat("abc", "def");


printf(str);

free(str);

DAS>     sum[0] = '\0';
DAS>     strcat(sum, s1);
DAS>     strcat(sum, s2);

     strcat(strcpy(sum, s1), s2);

char * concat(char * dst, const char * s1, const char * s2)
{
    size_t l1 = strlen(s1);
    size_t l2 = strlen(s2);
    size_t len = l1 + l2 + 1;

    memcpy(dst, s1, l1);
    memcpy(dst + l1, s2, l2);
    dst[len - 1] = 0;

    return dst;
}

...

    char * s1 = "abc";
    char * s2 = "def";

    // сами вычисляем размер, сами выделяем память
    char * str = (char *)malloc(strlen(s1) + strlen(s2) + 1);
    str = concat(str, s1, s2);

    printf(str);

    free(str);

    char buffer[255];

    // можно использовать стек
    str = concat(buffer, s1, s2);
    printf(str);

B>sprintf(s3, "%s%s", s1, s2);

sprintf("%s%s", s1, s2, s3);

char * concat(char * dst, const char * s1, const char * s2)
{
    *dst = 0;

    strcat(dst, s1);
    strcat(dst, s2);

    return dst;
}

for (i=1; i<=10; i++) {
     char *sum = (char*)malloc(255);
     concat(sum, s1, s2);
     printf("%s\n", sum);
     free(sum);
   }

I>     strcat(strcpy(sum, s1), s2);
I>

    char *sum = strcat(strcpy(malloc(strlen(s1)+strlen(s2)+1), s1), s2);
    printf(sum);
    free(sum);

SE>char * concat(char * dst, const char * s1, const char * s2)
SE>{
SE>    *dst = 0;

SE>    strcat(dst, s1);
SE>    strcat(dst, s2);

SE>    return dst;
SE>}

SE>char * concat(char * dst, const char * s1, const char * s2)
SE>{
SE>    size_t l1 = strlen(s1);
SE>    size_t l2 = strlen(s2);
SE>    size_t len = l1 + l2 + 1;

SE>    memcpy(dst, s1, l1);
SE>    memcpy(dst + l1, s2, l2);
SE>    dst[len - 1] = 0;

SE>    return dst;
SE>}

SE>...

SE>    char * s1 = "abc";
SE>    char * s2 = "def";

SE>    // сами вычисляем размер, сами выделяем память
SE>    char * str = (char *)malloc(strlen(s1) + strlen(s2) + 1);
SE>    str = concat(str, s1, s2);

SE>    printf(str);

SE>    free(str);

SE>    char buffer[255];

SE>    // можно использовать стек
SE>    str = concat(buffer, s1, s2);
SE>    printf(str);

SE>

char * concat(char * dst, const char * s1, const char * s2, size_t l1, size_t l2, size_t len)
{
    memcpy(dst, s1, l1);
    memcpy(dst + l1, s2, l2);
    dst[len - 1] = 0;

    return dst;
}

...

    char * s1 = "abc";
    char * s2 = "def";
        
    size_t l1, l2, len;
        
    l1 = strlen(s1);
    l2 = strlen(s2);
    len = l1+l2+1;
    // сами вычисляем размер, сами выделяем память
    char * str = (char *)malloc(1en);
    str = concat(str, s1, s2, l1, l2, len);

    printf(str);

    free(str);

    printf(strcat(strcpy(malloc(strlen(s1)+strlen(s2)+1),s1),s2));

#include <stdio.h>

void f(char *s1, char *s2, char *s3)
{
    sprintf("%s%s", s1, s2, s3);
}

4.2 Array-to-pointer conversion
. . .
2 A string literal (2.13.4) that is not a wide string literal can be converted to an rvalue of type “pointer to
char”; a wide string literal can be converted to an rvalue of type “pointer to wchar_t”. In either case,
the result is a pointer to the first element of the array. This conversion is considered only when there is an
explicit appropriate pointer target type, and not when there is a general need to convert from an lvalue to an
rvalue. [Note: this conversion is deprecated. See Annex D. ] For the purpose of ranking in overload resolution
(13.3.3.1.1), this conversion is considered an array-to-pointer conversion followed by a qualification
conversion (4.4). [Example: "abc" is converted to “pointer to const char” as an array-to-pointer conversion,
and then to “pointer to char” as a qualification conversion. ]

char const* translate(char const* fmt) __attribute__((format_arg(1)));
int main()
{
    printf(translate("%s"), 1);
}

B>char *s1 = "abc";
B>char *s2 = "def";
B>char *s3 = (char*)malloc(strlen(s1) + strlen(s2) + 1);
B>sprintf(s3, "%s%s", s1, s2);
B>free(s3);
B>

char *s1 = "abc";
char *s2 = "def";
char *result;

asprintf(&result, "%s%s", s1, s2);
/* используем result */
free(result);

CONFORMING TO
These functions are GNU extensions, not in C or POSIX. They are also
available under *BSD. The FreeBSD implementation sets strp to NULL on
error.