What is a safe way to join strings in C?

I need to construct a path to a file from two strings. I could use this (not tested, though):

/* DON'T USE THIS CODE! */
/* cmp means component */
char *path_cmp1 = "/Users/john/";
char *path_cmp2 = "foo/bar.txt";
unsigned len = strlen(path_cmp1);
char *path = path_cmp1;
for (int i = 0; i < strlen开发者_如何学C(path_cmp2); i++) {
  path[len + i] = path_cmp2[i];
}

but this could lead to memory corruption I guess. Is there a better way to do this, or is there a function for this in the standard library?

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

char *join(const char* s1, const char* s2)
{
    char* result = malloc(strlen(s1) + strlen(s2) + 1);

    if (result) // thanks @pmg
    {
        strcpy(result, s1);
        strcat(result, s2);
    }

    return result;
}

This is simple enough to be written in place, especially when you have multiple strings to concatenate.

Note that these functions return their destination argument, so you can write

char* result = malloc(strlen(s1) + strlen(s2) + 1);
assert(result);
strcat(strcpy(result, s1), s2);

but this is less readable.

#include <stdio.h> 

char *a = "hello ";
char *b = "goodbye";
char *joined;

asprintf(&joined, "%s%s", a, b)

There are several problems in this code: 1 - calling strlen on the for loop is a bad idea, it will calculate the string length every iteration, so it is better to call it once before the loop and keep the result in a variable.

2 - The same strlen problem applies to strlen(path_cmp1) inside the loop, call it before the loop and increments its size.

In the end, it is better to simple copy both strings and store those on a dynamic allocated string, like:

char *join_strings(const char* s1, const char* s2)
{
    size_t lens1 = strlen(s1);
    size_t lens2 = strlen(s2);

    //plus 1 for \0
    char *result = malloc(lens1 + lens2 + 1);

    if(result)
    {
        memcpy(result, s1, lens1);
        memcpy(result+lens1, s2, lens2+1);
    }

    //do not forget to call free when do not need it anymore
    return result;
}

There are strcat and strncat for that.

char *path_cmp1 = "/Users/john/";
char *path_cmp2 = "foo/bar.txt";

int firstLength = strlen(path_cmp1);
int secondLength = strlen(path_cmp2);
char *both = malloc(firstLength+secondLength+1);
memcpy(both, path_cmp1, firstLength);
memcpy(both+firstLength, path_cmp2, secondLength+1);
       // this +1 copyes the second string's null-terminator too.

create a new string with the length of both inputs and strcpy/strcat the inputs and don't forget the null terminator.

Use strcat. (You are right that your code will lead to memory corruption.)

How about strcat in string.h?

path is just a pointer to path_cmp1 and you are trying to access beyond the end of the array. Very occasionally this will work, but in the vast majority of cases you will cause memory corruption.

As others have pointed out use strcat to concatenate strings.