Implementation of strcpy and strcat that deals with exceptions

Question

I have to write strcpy() and strcat() in 7 lines of code and deal with any exceptions there could be. This is my code so far. Does anyone have any suggestions on how I can reduce the number of lines?

char *mystrcpy(char *dst, const char *src)
{
    char *ptr;
    ptr = dst;
    while(*dst++=*src++);
    return(ptr);
}

void strcat(char *dest, const char *src)
{

    while (*dest!= '\0')
        *dest++ ;
    do
    {
        *dest++ = *src++;
    }
    while (src != '\0') ;
}

Answer 1

You have a problem with your code: you are testing src itself against '\0', and not the char it is pointing to.

while (src != '\0');

should be

while (*src != '\0');

First get it right, then get it short / fast.

---

You are writing about being exception safe all over this page. Since you are using C, there is no native language concept like exceptions (as opposed to C++).

Anyway, the only type of exceptions that your code could raise are hardware exceptions (page fault, stack fault, alignment check, ...) which can't be caught by a normal C++ try-catch. Since the handling of hardware exceptions is platform dependent, you would need to use a platform specific mechanism to catch them (like SEH for Windows, or a signal handler for Unix). This approach is nothing I would recommended, read on.

Much better than catching a hardware exception is to try as hard as you can to prevent it. In your code this would just mean testing the input pointers for != 0. Note that you have no chance to identify an invalid pointer like char* dst = 0xDEADBEEF; and the only way to handle the exception after it was accessed would be platform dependent code like mentioned above. But hard errors like this typically shouldn't be handled by your program at all.

Example:

// Returns the new string length, or -1 on error.
int strcat(char* dst, char const* src)
{
    // Check arguments before doing anything.
    if (dst == 0)
        return -1;
    if (src == 0)
        return -1;

    // Store begin of destination to compute length later on.
    char const* const dstBegin = dst;

    // Skip to end of destination.
    while (*dst != '\0')
        *dst++ ;

    // Copy source to destination.
    do
    {
        *dst++ = *src++;
    }
    while (*src != '\0');

    // Return new length of string (excluding terminating '\0').
    return (dst - dstBegin - 1);
}

Optionally you could introduce a dstSize parameter which would indicate the size of the destination buffer, so that you could effectively detect and prevent buffer overflows.

Answer 2

char *mystrcpy(char *dst, const char *src){
    return (*dst=*src) ? (mystrcpy(dst+1, src+1), dst) : dst;
}
char *mystrcat(char *dst, const char *src){
    return (*dst ? mystrcat(dst+1, src) : mystrcpy(dst, src)), dst;
}