关于std::is_trivially_move_*与memcpy的使用及类型差异的技术问询

Let’s tackle your two questions one by one—they’re great ones that get to the heart of how C++ handles trivial operations under the hood.

1. Can we directly use memcpy with types marked by std::is_trivially_move_*? #

Short answer: Yes, you can safely use memcpy with these types.

Here’s why: The std::is_trivially_move_constructible and std::is_trivially_move_assignable traits indicate that a type’s move operations (move constructor and move assignment) are trivial. By definition, a trivial move operation behaves exactly like copying the object’s underlying bytes—there’s no custom logic, no resource ownership transfer, no side effects beyond a raw byte-for-byte copy.

Since memcpy does exactly that (copies bytes from one memory location to another), it’s functionally equivalent to the compiler-generated trivial move operation. The only thing to keep in mind is that after a "move" via memcpy, the original object’s state is identical to before (unlike non-trivial moves where the original might be left in a "valid but unspecified" state). But for trivial types, this isn’t a problem—their destructors are also trivial, so there’s no risk of double-freeing resources or invalid state.

2. What’s the difference between std::is_trivially_copy_* and std::is_trivially_move_*? Can we use memcpy for move construction/assignment on std::is_trivially_move_* types? #

First, let’s break down the difference:

• std::is_trivially_copy_constructible/std::is_trivially_copy_assignable check if a type’s copy operations are trivial.
• std::is_trivially_move_constructible/std::is_trivially_move_assignable check if a type’s move operations are trivial.

For most types (like primitive types, plain-old-data structs, arrays of trivial types), these traits will return the same value—copy and move operations are both trivial. But there are edge cases where they differ:

• Types with const members: For example, struct Foo { const int x; };. The default copy constructor/assignment for Foo is trivial (it just copies the const int byte-for-byte). However, the default move constructor/assignment is deleted by the compiler (since you can’t move into a const member), so std::is_trivially_move_constructible_v<Foo> will be false, while std::is_trivially_copy_constructible_v<Foo> is true.
• Types with reference members: Similar to const members, a class with a reference member (e.g., struct Bar { int& y; };) will have a trivial copy constructor/assignment, but its default move operations are deleted. So again, the copy traits will be true, move traits false.

As for using memcpy for move operations on std::is_trivially_move_* types: As we covered in the first question, yes, this is safe and valid. Trivial move operations have the same byte-copy semantics as memcpy, so using memcpy to implement move construction or assignment will produce identical behavior to the compiler’s default trivial move implementation.

Just remember: This only applies to types where std::is_trivially_move_* is true. For non-trivial move types (like std::unique_ptr or std::vector), memcpy would be unsafe—it would copy raw pointers without transferring ownership, leading to double-frees or invalid state.

内容的提问来源于stack exchange，提问作者J. Doe