C++ named requirements:MoveConstructible(since C++11)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

C++ named requirements

Basic DefaultConstructible MoveConstructible (C++11) CopyConstructible CopyAssignable MoveAssignable (C++11) Destructible Type properties ScalarType PODType TriviallyCopyable (C++11) TrivialType (C++11) StandardLayoutType (C++11)   ImplicitLifetimeType Library-wide BooleanTestable EqualityComparable LessThanComparable Swappable ValueSwappable (C++11) NullablePointer (C++11) Hash (C++11) Allocator FunctionObject Callable Predicate BinaryPredicate Compare

Container Container ReversibleContainer AllocatorAwareContainer SequenceContainer ContiguousContainer (C++17) AssociativeContainer UnorderedAssociativeContainer (C++11)   Container element DefaultInsertable (C++11) CopyInsertable (C++11) MoveInsertable (C++11) EmplaceConstructible (C++11) Erasable (C++11) Iterator LegacyIterator LegacyInputIterator LegacyOutputIterator LegacyForwardIterator LegacyBidirectionalIterator LegacyRandomAccessIterator LegacyContiguousIterator (C++17) ConstexprIterator (C++20) Stream I/O FormattedInputFunction UnformattedInputFunction FormattedOutputFunction UnformattedOutputFunction Formatters BasicFormatter (C++20) Formatter (C++20)

Random Numbers SeedSequence (C++11) RandomNumberEngine (C++11) RandomNumberDistribution (C++11) UniformRandomBitGenerator (C++11) RandomNumberEngineAdaptor (C++11) Concurrency BasicLockable (C++11) Lockable (C++11) TimedLockable (C++11) SharedLockable (C++14) SharedTimedLockable (C++14) Mutex (C++11) TimedMutex (C++11) SharedMutex (C++17) SharedTimedMutex (C++14) Ranges RangeAdaptorObject (C++20) RangeAdaptorClosureObject (C++20) Multidimensional View LayoutMapping (C++23) LayoutMappingPolicy (C++23) AccessorPolicy (C++23) Other CharTraits RegexTraits (C++11)   BitmaskType LiteralType (C++11) NumericType UnaryTypeTrait (C++11) BinaryTypeTrait (C++11) TransformationTrait (C++11) Clock (C++11) TrivialClock (C++11)

 

Specifies that an instance of the type can be constructed from an rvalue argument.

Requirements

The type T satisfies MoveConstructible if

Given

• rv, an rvalue expression of type T,
• u, an arbitrary identifier.

The following expressions must be valid and have their specified effects.

Expression	Post-conditions
T u = rv;	The value of u is equivalent to the value of rv before the initialization. The new value of rv is unspecified.
T(rv)	The value of T(rv) is equivalent to the value of rv before the initialization. The new value of rv is unspecified.

Notes

A class does not have to implement a move constructor to satisfy this type requirement: a copy constructor that takes a const T& argument can bind rvalue expressions.

If a MoveConstructible class implements a move constructor, it may also implement move semantics to take advantage of the fact that the value of rv after construction is unspecified.

Extended content

Being a MoveConstructible class implies std::is_move_constructible but not vice versa since std::is_move_constructible will only check for the ability to call the constructor with the correct arguments, not a post-condition value. Run this code #include <iostream>   struct S {int n; S(int in): n{in}{} S(S&& other){ n = other.n+1;}}; static_assert(std::is_move_constructible_v<S>);   int main(){ S v{1};std::cout<<"v.n = "<< v.n<<'\n'; S u = std::move(v);   // Class `S` doesn't satisfy a MoveConstructible requirement// The value of `u` is NOT equivalent to the value of `v` before the `u` initializationstd::cout<<"u.n = "<< u.n<<'\n';} Output: v.n = 1 u.n = 2

References

Extended content
C++23 standard (ISO/IEC 14882:2024): 16.4.4.2 Template argument requirements [utility.arg.requirements]

See also

is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible (C++11)(C++11)(C++11)	checks if a type can be constructed from an rvalue reference (class template)
move_constructible (C++20)	specifies that an object of a type can be move constructed (concept)