Catenating chars in c: argument of type "char" is incompatible with parameter of type "const char*"

Question

I'm trying to write a program that catenate 2 values in C without using strcat().

char cat (char s1, char s2){
    char s3[200];
    strcpy(s3,s1);
    strcpy(s3+strlen(s1),s2);
    return s3;
}

This is my code but it's giving this error:

argument of type "char" is incompatible with parameter of type "const char*"

What should l do? (I recently start to learn C so please answer me in an easy way)

Answer 1

In your function, the parameters s1 and s2 are of type char which means a single character. Inorder for them to be strings, they must be character arrays. So

char cat (char s1[], char s2[]){

or

char cat (char *s1, char *s2){

instead of

char cat (char s1, char s2){

After this correction, you could just use sprintf() if the destination string is large enough like

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

And in your program,

s3 is allocated on the stack as it is an automatic variable.

It goes out of scope when the program control exits the cat() function. If you really need to return the string, either allocate memory for s3 on the heap using malloc() and return a pointer to that memory as in

char* cat (char s1[], char s2[]){
    char *s3 = NULL;
    if( (s3=malloc(sizeof(char)*( strlen(s1)+strlen(s2)+1 )))==NULL )
    {
            perror("Not enough memory");  
            return NULL;
    }
    sprintf(s3, "%s%s", s1, s2);
    return s3;
}

or create the s3 character array in the calling function and pass it to cat() as in

char s3[200];
cat(s3, s1, s2);

........

void cat (char s3[], char s1[], char s2[]){
    if( strlen(s1) + strlen(s2) < 200 )//where 200 is the size of s3
    {
        sprintf(s3, "%s%s", s1, s2);
    }
    else
    {
        printf("\nInput strings too large");
    }
}

See Returning C string from a function.

Answer 2

You're taking chars as arguments and using it as a return value. You probably want s1, s2 to be const char *:

char *cat (const char *s1, const char *s2){

You will have to return a char * too, which means you will have to allocate something that isn't on the stack.

char *cat (const char *s1, const char *s2){
    char *s3 = (char*)malloc(200);
    strcpy(s3,s1);
    strcpy(s3+strlen(s1),s2); // strcat(s3, s1);
   return s3;
}

Answer 3

A char is a small integer type (a byte), which can hold just a single encoded character, not a string. Strings in C don't have a dedicated type, they're just defined as a sequence of characters, ending with a 0 byte. So, you naturally store strings in arrays of char. E.g. the array

char str[30];

Can store a string of up to 29 characters (one more is needed for the terminating 0).

Furthermore, you have to know that arrays can't be passed to or returned from functions in C. Instead, pointers are used. If you write arrays as function arguments or return values, these types are automatically adjusted to the corresponding pointer types. It's common to say the array "decays" as a pointer. So, in your code, you attempt to return an array. Instead, a pointer to the first array element is returned. Because this array is local to your function, it doesn't exist any more after the return, so you are returning an invalid pointer.

That's why the library function strcat expects the caller to give a pointer to the result, instead of returning the result. A typical simple strcat function could look like this (not the original, returning nothing here to make the code simple):

void mystrcat(char *s, const char *append)
{
    while (*s) ++s; // search end of s
    while ( (*s++ = *append++) ); // copy until end of append
}

To understand this code, you have to know that 0 is false in C when evaluated in a boolean context, and any other value is true. ++ increments, so applied to pointers, moves them to point to the next element. Therefore, this code examines each character in *s until it finds a 0 byte and then starts copying characters from *append there until the 0 byte in *append is hit.

---

If you absolutely want to return the result, you have to dynamically allocate memory for it in your function. This could look like the following:

char *concatenate(const char *s1, const char *s2)
{
    size_t resultlen = strlen(s1) + strlen(s2) + 1; // one more for the 0 byte
    char *result = malloc(resultlen);
    if (!result) return 0; // allocation failed, out of memory

    char *p = result;
    while ( (*p = *s1++) ) ++p; // copy from s1 until 0
    while ( (*p++ = *s2++) );   // copy from s2 until 0

    return result;
}

Of course, in this case, the caller has to free() the result when it's no longer needed.