When is it Undefined Behavior to Use `std::memcpy` in C ?

TriviallyCopyable Objects and Undefined Behavior in std::memcpy

In C , std::memcpy is a powerful tool for copying data at the bit level. However, when used with objects that are not declared as "TriviallyCopyable," the behavior becomes undefined. This can lead to unpredictable consequences, as the standard specifies that the behavior under these circumstances is left to the implementation.

Trivial Copyability

Trivial copyability is a property of an object type that ensures it can be copied using a simple bitwise copy operation, without invoking any constructors or destructors. TriviallyCopyable objects do not contain references, pointers, or other non-primitive data types.

Undefined Behavior with Non-TriviallyCopyable Objects

When std::memcpy is used to copy non-TriviallyCopyable objects, the following consequences may occur:

• Invalid construction: The target object's constructor is not invoked, leaving it in an uninitialized state.
• Premature destruction: The source object's destructor is not invoked, potentially leading to resource leaks or dangling references.
• Data corruption: The copied bits may not correspond to valid data for the target object, resulting in incorrect behavior.

Standard Justification for Undefined Behavior

The C standard specifies that the behavior of std::memcpy for non-TriviallyCopyable objects is undefined to prevent undefined behavior from propagating through the program. As mentioned earlier, using a target object after it has been copied using std::memcpy is undefined, including calling its methods or destructors. This can lead to serious runtime errors and unpredictable behavior.

Workaround with Placement-New

While std::memcpy cannot be used directly to copy non-TriviallyCopyable objects, it is possible to use it in conjunction with placement-new to achieve a safe and well-defined copy operation. Placement-new allows a new object to be constructed in a pre-allocated memory location, effectively initializing it with the data from the source object.

Example Code:

class NonTrivial
{
public:
    int value;

    // Constructor and destructor are non-trivial
    NonTrivial(int val) : value(val) {}
    ~NonTrivial() { cout << "Destructor called" << endl; }
};

void CopyNonTriviallyCopyable(NonTrivial* src, NonTrivial* dst)
{
    // Create a new NonTrivial object using placement-new
    new (dst) NonTrivial(src->value);
}

In this example, CopyNonTriviallyCopyable uses placement-new to safely copy a NonTrivial object, ensuring that the target object is properly initialized and its destructor is invoked when necessary.

The above is the detailed content of When is it Undefined Behavior to Use `std::memcpy` in C ?. For more information, please follow other related articles on the PHP Chinese website!