如何创建strcat的副本？

Question

I have to create a copy of some elements of the standard library in C and I have to create a copy of strcat. So I have to create a function that concatenate two strings in C. I know arrays in C can't change the allocated size. The only fonction i'm allowed to use is copies i made of strlen, strstr, and write() ... My code looks like this :

char    *my_strcat(char *dest, char *src)
{
    int  dest_size;
    int  src_size;
    int  current_pos;
    int  free_space;
    int  pos_in_src;

    src_size = my_strlen(src);
    dest_size = my_strlen(dest);
    while (dest[current_pos] != '\0')
        current_pos = current_pos + 1;
    free_space = dest_size - current_pos;
    if (free_space < src_size)
        return (0);
    while (src[pos_in_src] != '\0')
    {
        dest[current_pos] = src[pos_in_src];
        pos_in_src = pos_in_src + 1;
        current_pos = current_pos + 1;
    }
    return (dest);
}

But I don't know how to declare my dest and src in the main. I don't know how to create an array with a big size, declare it as a string like dest = "Hello\\0" but this array has to still contains more than 6 characters.

Can you help me please ?

Answer 1

char dest[19] = "epite";
char *src = "chor42spotted";

my_strcat(dest, src);

---

Also, read the man for strcat(3)

the dest string must have enough space for the result.

https://linux.die.net/man/3/strcat

So your function is behaving incorrectly, you do not need to check that you have enough free space in dest

Answer 2

You want a function mystrcat which behaves exactly like stdlib strcat.

So the prototype is

 /*
    concatenate src to dest
    dest [in / out] - the string to add to (buffer must be large enough)
    src [in] - the string to concatenate.
    Returns: dest (useless little detail for historical reasons). 
 */
 char *mystrcat(char *dest, const char *src);

Now we call it like this

int main(void)
{
 char buff[1024];  // nice big buffer */

 strcpy(buff, "Hello ");
 mystrcat(buff, "world");

 /* print the output to test it */
 printf("%s\n", buff);

 return 0;
} 

But I'm not going to write mystrcat for you. That would make your homework exercise pointless.

Answer 3

The 1st parameter of the array simply has to be large enough to contain both strings + one null terminator. So if you for example have "hello" and "world" , you need 5 + 5 +1 = 11 characters. Example:

#define LARGE_ENOUGH 11

int main (void)
{
  char str[LARGE_ENOUGH] = "hello";
  my_strcat(str, "world");
  puts(str); // gives "helloworld"
}

In real world applications, you would typically allocate space for the array to either be same large number (couple of hundred bytes) or with a length based on strlen calls.

---

As for the implementation itself, your solution is needlessly complicated. Please note that the real strcat leaves all error checking to the caller. It is most likely implemented like this:

char* strcat (char* restrict s1, const char* restrict s2)
{
  return strcpy(&s1[strlen(s1)], s2);
}

The most important part here is to note the const-correctness of the s2 parameter.

The restrict keywords are just micro-optimizations from the C standard, that tells the compiler that it can assume that the pointers point at different memory areas.

If you wish to roll out your own version with no library function calls just for fun, it is still rather easy, you just need two loops. Something like this perhaps:

char* lolcat (char* restrict s1, const char* restrict s2)
{
  char* s1_end = s1;
  while(*s1_end != '\0') // find the end of s1
  {
    s1_end++;
  }

  do // overwrite the end of s1 including null terminator
  {
    *s1_end = *s2;
    s1_end++;
    s2++;
  } while(*s1_end != '\0'); // loop until the null term from s2 is copied

  return s1;
}