Difference between revisions of "cpp/named req/MoveInsertable"
m (→See Also: s/A/a) |
(P1072R10) |
||
| Line 1: | Line 1: | ||
| − | {{cpp/named req/title|MoveInsertable {{mark since c++11}} }} | + | {{cpp/named req/title|MoveInsertable|notes={{mark since c++11}} }} |
{{cpp/named req/navbar}} | {{cpp/named req/navbar}} | ||
| Line 24: | Line 24: | ||
And after evaluation, the value of {{tt|*p}} is equivalent to the value formerly held by {{tt|rv}} ({{tt|rv}} remains valid, but is in an unspecified state.) | And after evaluation, the value of {{tt|*p}} is equivalent to the value formerly held by {{tt|rv}} ({{tt|rv}} remains valid, but is in an unspecified state.) | ||
| − | If {{ttb|X}} is not allocator-aware, the term is defined as if {{ttb|A}} were {{lc|std::allocator<T>}}, except that no allocator object needs to be created, and user-defined specializations of {{lc|std::allocator}} are not instantiated. | + | If {{ttb|X}} is not allocator-aware{{rev inl|since=c++23| or is a {{lc|std::basic_string}} specialization}}, the term is defined as if {{ttb|A}} were {{lc|std::allocator<T>}}, except that no allocator object needs to be created, and user-defined specializations of {{lc|std::allocator}} are not instantiated. |
===Notes=== | ===Notes=== | ||
| − | If {{tt|A}} is {{c|std::allocator<T>}}, then this will call placement-new, as by {{c|::new((void*)p) T(rv)}}. This effectively requires {{tt|T}} to be move constructible. | + | If {{tt|A}} is {{c|std::allocator<T>}}, then this will call placement-new, as by {{rev inl|until=c++20|{{c|::new((void*)p) T(rv)}}}}{{rev inl|since=c++20|{{c|std::construct_at(p, rv)}}}}. This effectively requires {{tt|T}} to be move constructible. |
| − | If {{c|std::allocator<T>}} or a similar allocator is used, a class does not have to implement a [[cpp/language/move constructor|move constructor]] to satisfy this type requirement: a [[cpp/language/copy constructor|copy constructor]] that takes a {{ | + | If {{c|std::allocator<T>}} or a similar allocator is used, a class does not have to implement a [[cpp/language/move constructor|move constructor]] to satisfy this type requirement: a [[cpp/language/copy constructor|copy constructor]] that takes a {{c|const T&}} argument can bind rvalue expressions. If a {{named req/core|MoveInsertable}} class implements a move constructor, it may also implement [[cpp/utility/move|move semantics]] to take advantage of the fact that the value of {{tt|rv}} after construction is unspecified. |
===See also=== | ===See also=== | ||
| Line 36: | Line 36: | ||
{{dsc end}} | {{dsc end}} | ||
| − | {{langlinks|ja|zh}} | + | {{langlinks|de|es|ja|ru|zh}} |
Revision as of 18:10, 27 October 2021
Specifies that an object of the type can be constructed into uninitialized storage from an rvalue of that type by a given allocator.
Requirements
The type T is MoveInsertable into the container X whose value_type is identical to T if, given
A
|
an allocator type |
m
|
an lvalue of type A
|
p
|
the pointer of type T* prepared by the container
|
rv
|
rvalue expression of type T
|
where X::allocator_type is identical to std::allocator_traits<A>::rebind_alloc<T>,
the following expression is well-formed:
std::allocator_traits<A>::construct(m, p, rv);
And after evaluation, the value of *p is equivalent to the value formerly held by rv (rv remains valid, but is in an unspecified state.)
If X is not allocator-aware or is a std::basic_string specialization(since C++23), the term is defined as if A were std::allocator<T>, except that no allocator object needs to be created, and user-defined specializations of std::allocator are not instantiated.
Notes
If A is std::allocator<T>, then this will call placement-new, as by ::new((void*)p) T(rv)(until C++20)std::construct_at(p, rv)(since C++20). This effectively requires T to be move constructible.
If std::allocator<T> or a similar allocator is used, 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 MoveInsertable 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.
See also
| CopyInsertable |
