Is a Moved-From `std::vector` Guaranteed to Be Empty?

Is a Moved-From Vector Guaranteed to Be Empty?

In general, the C standard provides minimal guidance on the state of objects after they have been moved from. As stated in N3485 17.6.5.15 [lib.types.movedfrom]/1:

Objects of types defined in the C standard library may be moved from (12.8). Move operations may be explicitly specified or implicitly generated. Unless otherwise specified, such moved-from objects shall be placed in a valid but unspecified state.

While this provision doesn't exclude vector from being subject to this behavior, it leaves room for interpretation.

Vector's Specific Behavior

There is no explicit standard requirement that excludes vector from being affected by the general rule for moved-from objects. However, given the requirements for vector's implementation, there are limited options:

Move Constructor:

• The move constructor must have constant complexity.
• The only option is to steal resources from the source vector (v) to construct the new vector, leaving v empty.

Move Assignment Operator:

• Behavior depends on the vector's allocator:

Case One:

• allocator_traits::propagate_on_container_move_assignment::value == true
• All elements in the destination vector (*this) are destructed.
• Capacity is deallocated using the allocator from *this.
• Allocators and memory buffer ownership are transferred from v to *this.
• *this is typically empty before the move assignment.

Case Two:

• allocator_traits::propagate_on_container_move_assignment::value == false and get_allocator() == v.get_allocator()
• Similar behavior to Case One, but allocators are not moved.
• The decision between Case Two and Case Three is made at runtime, which impacts the requirements on T.

Case Three:

• allocator_traits::propagate_on_container_move_assignment::value == false and get_allocator() != v.get_allocator()
• Allocators cannot be moved, and resources cannot be transferred from v to *this.
• The only way to implement the move assignment is to move each T individually from v to *this using the assign operation.
• This requires T to be either MoveAssignable or MoveInsertable (depending on the availability of capacity and size in *this).

Conclusion:

For vector's move constructor, the moved-from vector is always empty. For the move assignment operator, the moved-from vector is usually empty, but may not be in certain specific scenarios where allocators are not compatible and T is MoveAssignable or MoveInsertable.

The above is the detailed content of Is a Moved-From `std::vector` Guaranteed to Be Empty?. For more information, please follow other related articles on the PHP Chinese website!