Does memcpy Construct Trivially Copyable Objects in C ?

Unveiling the Compatibility of "constructing" Trivially-Copyable Objects with memcpy

In the realm of C programming, constructing trivially-copyable objects using bitwise copy methods like memcpy has sparked a debate regarding object lifetime. The question arises: Is the object pointed to by b in the following code guaranteed to have a well-defined lifetime?

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);
}

The Unresolved Issue

The C standard remains ambiguous on this matter, despite ongoing discussions and proposals. The lack of clear guidance has left this question unanswered, with implications for semantics-based analysis tools, optimizers, and lifetime tracking.

N3751 Proposal

N3751 suggests recognizing memcpy operations involving distinct trivial copyable objects as object construction, supporting binary IO while preserving lifetime analysis capabilities.

C 14 Standard

The C 14 standard defines object creation as occurring through definitions, new-expression, or when the implementation deems it necessary. The current language does not explicitly address the use of memcpy for constructing objects.

std::vector Implementation

The current implementation of std::vector highlights a practical scenario where this issue arises, leading to undefined behavior.

Proposal p0593: Implicit Object Creation

Proposal p0593 aims to address this ambiguity by explicitly defining scenarios where objects are implicitly created, including calls to malloc and memcpy. It proposes mechanisms to create objects on-demand, giving programs defined behavior. However, this proposal remains under review.

Conclusion

The status of object construction using memcpy remains a topic of ongoing debate in the C community. Until a consensus is reached and the standard is updated, the behavior of code like the example provided remains undefined, potentially leading to unpredictable program behavior.

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