Does memcpy Implicitly Construct Objects in C ?

Implicit Object Creation in C : A Tricky Case of "constructing"

In C , the behavior of memory copy (memcpy) when used with trivially copyable types can raise questions about object lifecycle. The following code snippet illustrates the ambiguity:

#include <cstdlib>
#include <cstring>

struct T {
    int x, y;
};

int main() {
    void *buf = std::malloc(sizeof(T));
    if (!buf) return 0;

    T a{};
    std::memcpy(buf, &a, sizeof a);
    T *b = static_cast<T *>(buf);

    b->x = b->y;

    free(buf);

    return 0;
}

The key question is whether the code segment starting with T *b = static_cast creates an object whose lifetime has started. The C standards lack clarity on this issue, referring to it as unspecified.

N3751, a paper suggesting that memcpy be recognized as an object construction operation, has not been accepted into the standard yet. The current draft standard mentions object creation through definitions, new-expressions, or implementation needs, but does not explicitly address copies made using memcpy.

The proposal p0593 aims to address this ambiguity by introducing the concept of implicit object creation for low-level memory manipulation. It proposes that memcpy and similar operations implicitly create objects within newly allocated storage. This would provide well-defined behavior for the code snippet presented.

However, it is important to note that p0593 has not been reviewed or accepted yet. Therefore, the behavior of memcpy when used with trivially copyable types remains unspecified in the C standard.

The above is the detailed content of Does memcpy Implicitly Construct Objects in C ?. For more information, please follow other related articles on the PHP Chinese website!