Difference between revisions of "cpp/named req/AllocatorAwareContainer"
From cppreference.com
(typo) |
(+more content) |
||
| Line 2: | Line 2: | ||
{{cpp/concept/navbar}} | {{cpp/concept/navbar}} | ||
| − | + | An {{concept|AllocatorAwareContainer}} is a {{concept|Container}} that stores and uses an instance of an {{concept|Allocator}} to allocate and deallocate memory as needed. | |
| + | |||
| + | The following rules apply to object construction | ||
| + | |||
| + | * Copy constructors of {{concept|AllocatorAwareContainer}}s obtain their instances of the allocator by calling {{c|std::allocator_traits<allocator_type>::select_on_container_copy_construction}}. | ||
| + | * Move constructors obtain their instances of allocators by move-constructing from the allocator belonging to the old container. | ||
| + | * All other constructors take an allocator parameter. | ||
| + | |||
| + | The only way to replace an allocator is copy-assignment, move-assignment, and swap: | ||
| + | |||
| + | * Copy-assignment will replace the allocator only if {{c|std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value}} is {{c|true}} | ||
| + | * Move-assignment will replace the allocator only if {{c|std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value}} is {{c|true}} | ||
| + | * Swap will replace the allocator only if {{c|std::allocator_traits<allocator_type>::propagate_on_container_swap::value}} is {{c|true}}. Specifically, it will exchange the allocator instances through an unqualified call to the non-member function swap, see {{concept|Swappable}}. | ||
| + | |||
| + | Note: swapping two containers with unequal allocators if {{tt|propagate_on_container_swap}} is {{c|false}} is undefined behavior. | ||
| + | |||
| + | * The accessor {{tt|get_allocator()}} obtains a copy of the allocator that was used to construct the container or installed by the most recent allocator replacement operation. | ||
===Requirements=== | ===Requirements=== | ||
| Line 53: | Line 69: | ||
;X | ;X | ||
* {{concept|CopyAssignable}} | * {{concept|CopyAssignable}} | ||
| + | |||
| + | ===Standard library=== | ||
| + | All standard library containers except {{c|std::array}} are {{concept|AllocatorAwareContainers}}: | ||
| + | * {{c|std::basic_string}} | ||
| + | * {{c|std::deque}} | ||
| + | * {{c|std::forward_list}} | ||
| + | * {{c|std::list}} | ||
| + | * {{c|std::vector}} | ||
| + | * {{c|std::map}} | ||
| + | * {{c|std::multimap}} | ||
| + | * {{c|std::set}} | ||
| + | * {{c|std::multiset}} | ||
| + | * {{c|std::unordered_map}} | ||
| + | * {{c|std::unordered_multimap}} | ||
| + | * {{c|std::unordered_set}} | ||
| + | * {{c|std::unordered_multiset}} | ||
Revision as of 15:05, 3 December 2012
Template:cpp/concept/title Template:cpp/concept/navbar
An Template:concept is a Template:concept that stores and uses an instance of an Template:concept to allocate and deallocate memory as needed.
The following rules apply to object construction
- Copy constructors of Template:concepts obtain their instances of the allocator by calling std::allocator_traits<allocator_type>::select_on_container_copy_construction.
- Move constructors obtain their instances of allocators by move-constructing from the allocator belonging to the old container.
- All other constructors take an allocator parameter.
The only way to replace an allocator is copy-assignment, move-assignment, and swap:
- Copy-assignment will replace the allocator only if std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value is true
- Move-assignment will replace the allocator only if std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value is true
- Swap will replace the allocator only if std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true. Specifically, it will exchange the allocator instances through an unqualified call to the non-member function swap, see Template:concept.
Note: swapping two containers with unequal allocators if propagate_on_container_swap is false is undefined behavior.
- The accessor
get_allocator()obtains a copy of the allocator that was used to construct the container or installed by the most recent allocator replacement operation.
Contents |
Requirements
Legend | |
X
|
Container type |
T
|
Element type |
A
|
Allocator for T
|
a, b
|
Objects of type X (non-const lvalue)
|
t
|
Object of type T (lvalue or const rvalue)
|
rv
|
Object of type T (non-const rvalue)
|
m
|
Object of type A
|
Q
|
Allocator type |
| expression | return type | pre/requirements | post/effects | complexity |
|---|---|---|---|---|
| allocator_type | A |
allocator_type::value_type must be the same as X::value_type | constant | |
| get_allocator() | A |
constant | ||
| X u; | u.empty() == true && u.get_allocator() == A() | constant | ||
| X u(m); | u.empty() == true && u.get_allocator() == m | constant | ||
| X u(t,m); | u == t && u.get_allocator() == m | linear | ||
| X u(rv); | Move constructor of A must not throw exceptions
|
u has the same elements and an equal allocator as rv had before the construction |
constant | |
| X u(rv,m); | The elements of u are the same or copies of those of rv and u.get_allocator() == m
|
constant if m == rv.get_allocator(), otherwise linear | ||
| a = t | X& | a == t | linear | |
| a = rv | X& | All existing elements of a are either move assigned to or destroyed |
linear | |
| a.swap(b) | void | Exchanges the contents of a and b |
constant |
Concept requirements
- A
- T
- X
Standard library
All standard library containers except std::array are Template:concept:
