Can I call memcpy() and memmove() with "number of bytes" set to zero?

When the 'byte count' (numBytes) parameter is set to zero, calling memcpy() or memmove() is permitted, and this typically does not cause runtime errors because no memory is actually copied. However, even in this case, it is essential to verify that the source pointer (src) and destination pointer (dest) are valid, even though they are not used for copying data.

About memcpy()

The memcpy() function is used to copy memory regions, with the following prototype:

c
void *memcpy(void *dest, const void *src, size_t n);

Here, n represents the number of bytes to copy. If n is zero, no bytes are copied. However, memcpy() does not handle overlapping memory regions, so it is necessary to ensure that the source and destination memory regions do not overlap.

About memmove()

The memmove() function is also used to copy memory regions. Unlike memcpy(), memmove() can handle overlapping memory regions. Its prototype is as follows:

c
void *memmove(void *dest, const void *src, size_t n);

Similarly, if n is zero, the function performs no copying.

Example

Consider the following code example:

c
#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "hello";
    char dest[6]; // Extra space for the null terminator

    // Using memcpy and memmove with byte count of 0
    memcpy(dest, src, 0);
    memmove(dest, src, 0);

    printf("dest after memcpy with n=0: '%s'\n", dest);
    printf("dest after memmove with n=0: '%s'\n", dest);

    return 0;
}

In this example, calling memcpy() and memmove() does not change the content of dest because the number of bytes to copy is zero. This is valid, provided that src and dest are valid pointers.

Conclusion

Although calling these functions with a byte count of zero is safe, in practice, it is generally more straightforward to check for a zero byte count and bypass the call. This avoids unnecessary function calls, especially in performance-sensitive applications. Additionally, valid pointers are a fundamental prerequisite for calling these functions.