Appending two strings - c

Question

I'm trying to write code to append two strings without the function strcat, but it doesn't work. It only works when the inputs are a single char.
Here's the code:
#include <stdio.h>
#include <string.h>
/*
Return the result of appending the characters in s2 to s1.
Assumption: enough space has been allocated for s1 to store the extra
characters.
*/
char* append (char s1[], char s2[]) {
int s1len = strlen (s1);
int s2len = strlen (s2);
int k;
for (k=0; k<s2len; k++) {
s1[k+s1len] = s2[k];
}
return s1;
}
int main ( ) {
char str1[10];
char str2[10];
while (1) {
printf ("str1 = ");
if (!gets(str1)) {
return 0;
};
printf ("str2 = ");
if (!gets(str2)) {
return 0;
};
printf ("The result of appending str2 to str1 is %s.\n",
append (str1, str2));
}
return 0;
}
How can I fix it?

Answer 1

You have some errors in your code:
Do not use gets. This function is dangerous because it doesn't take the
size of the buffer into account. Use fgets instead.
Your append function does not write the '\0'-terminating byte. It should
be
char* append (char s1[], char s2[]) {
int s1len = strlen (s1);
int s2len = strlen (s2);
int k;
for (k=0; k<s2len; k++) {
s1[k+s1len] = s2[k];
}
s1[k+s1len] = 0; // writing the 0-terminating byte
return s1;
}
str1 may be to short for holding both strings. If str2 contains "Hello"
and str2 contains "World!", you are going to overflow the buffer. Make the
buffer larger.
If you writing your own strcat, I would pass the size of the destination
buffer as well, so that you don't overflow the buffers:
char *mystrcat(char *t1, const char *t2, size_t maxsize)
{
if(t1 == NULL || t2 == NULL)
return NULL;
size_t s1 = strlen(t1);
size_t s2 = strlen(t2);
size_t i;
for(i = 0; i < s2 && (s1 + i) < maxsize - 1 ; ++i)
t1[i + s1] = t2[i];
t1[i + s1] = 0; // terminating the
return t1;
}
int main(void)
{
char str1[30] = "Hello ";
char str2[30] = "World!";
printf("mystrcat(\"%s\", \"%s\") = %s\n", str1, str2,
mystrcat(str1, str2, sizeof str1));
char str3[100] = "This is a long sentence";
printf("mystrcat(\"%s\", \"%s\") = %s\n", str1, str3,
mystrcat(str1, str3, sizeof str1));
char line[100];
printf("Enter some text: ");
fflush(stdout);
fgets(line, sizeof line, stdin);
line[strcspn(line, "\n")] = 0; // removing possible newline
strcpy(str3, "User input was: ");
printf("mystrcat: %s\n", mystrcat(str3, line, sizeof str3));
return 0;
}
That would return
mystrcat("Hello World!", "World!") = Hello World!
mystrcat("Hello World!This is a long se", "This is a long sentence") = Hello World!This is a long se
Enter some text: ABC DEF user input is great
mystrcat: User input was: ABC DEF user input is great

Answer 2

Your resulting string is not properly terminated.
Strings in C are always terminated with a NUL (0) character.
gets is unsafe, use fgets instead.
Get in the habit to check buffer sizes.
To give you an idea, here a minimalistic implementation using fgets + buffer size checks:
#include <stdio.h> // fprintf, fgets
#include <string.h> // strlen
const char *concatenate(char *dst, size_t sz, const char *s1, const char *s2) {
size_t l1 = strlen(s1);
size_t l2 = strlen(s2);
// Check for overflow
if ((l1 + l2 + 1) > sz) {
return NULL;
}
// Copy first string
for (size_t i = 0; i < l1; ++i) {
dst[i] = s1[i];
}
// Copy second string
for (size_t i = 0; i < l2; ++i) {
dst[l1 + i] = s2[i];
}
// Add NUL terminator
dst[l1 + l2 + 1] = 0;
return dst;
}
int main() {
// Allocate two strings (9 chars max.)
char first_string[10];
char second_string[10];
char concatenated_string[20];
// Read first string from stdin
fprintf(stdout, "str1 = ");
// !!! fgets return value check omitted for simplicity.
fgets(first_string, sizeof(first_string), stdin);
// Read second string from stdin
fprintf(stdout, "str2 = ");
// !!! fgets return value check omitted for simplicity.
fgets(second_string, sizeof(second_string), stdin);
const char *tmp = concatenate(concatenated_string, sizeof(concatenated_string), first_string, second_string);
if (!tmp) {
fprintf(stderr, "would overflow\n");
} else {
fprintf(stdout, "concatenated: %s\n", concatenated_string);
}
return 0;
}