Is it guaranteed to be safe to perform memcpy(0,0,0)?

by

I have a draft version of the C standard (ISO/IEC 9899:1999), and it has some fun things to say about that call. For starters, it mentions (§7.21.1/2) in regards to memcpy that

Where an argument declared as size_t n specifies the length of the array for a
function, n can have the value zero on a call to that function. Unless explicitly stated
otherwise in the description of a particular function in this subclause, pointer arguments
on such a call shall still have valid values, as described in 7.1.4. On such a call, a
function that locates a character finds no occurrence, a function that compares two
character sequences returns zero, and a function that copies characters copies zero
characters.

The reference indicated here points to this:

If an argument to a function has an invalid value (such as a value
outside the domain of the function, or a pointer outside the address space of the program,
or a null pointer, or a pointer to non-modifiable storage when the corresponding
parameter is not const-qualified) or a type (after promotion) not expected by a function
with variable number of arguments, the behavior is undefined.

So it looks like according to the C spec, calling

memcpy(0, 0, 0)

results in undefined behavior, because null pointers are considered “invalid values.”

That said, I would be utterly astonished if any actual implementation of memcpy broke if you did this, since most of the intuitive implementations I can think of would do nothing at all if you said to copy zero bytes.

More Related Contents:

  1. When does invoking a member function on a null instance result in undefined behavior?
  2. Are there any non-twos-complement implementations of C?
  3. What is the behavior of printing NULL with printf’s %s specifier?
  4. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  5. Does printf(“%x”,1) invoke undefined behavior?
  6. Representation of negative numbers in C?
  7. How undefined is undefined behavior?
  8. Is dereferencing null pointer valid in sizeof operation [duplicate]
  9. Does &((struct name *)NULL -> b) cause undefined behaviour in C11?
  10. Can code that will never be executed invoke undefined behavior?
  11. Is argv[n] writable?
  12. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  13. What is the difference between memmove and memcpy?
  14. Why “initializer element is not a constant” is… not working anymore?
  15. faster alternative to memcpy?
  16. Is int main() { } (without “void”) valid and portable in ISO C?
  17. How do I make an infinite empty loop that won’t be optimized away?
  18. How do we check if a pointer is NULL pointer?
  19. Very fast memcpy for image processing?
  20. How are multiple prior declarations resolved for a new declaration with extern?
  21. When is it valid to access a pointer to a “dead” object?
  22. Returning struct containing array
  23. Can the following code be true for pointers to different things
  24. Is it Undefined Behaviour to cast away the constness of a function parameter?
  25. Which section in C89 standard allows the “implicit int” rule?
  26. Is it undefined behavior to redefine a standard name?
  27. C – is an indeterminate value indeterminable?
  28. Why can’t a modifiable lvalue have an array type?
  29. How a stream error indicator affects following input code?
  30. Initialization vs Assignment in C

Leave a Comment