View source for Template:cpp/container/note iterator invalidation

← Template:cpp/container/note iterator invalidation

You do not have permission to edit this page, for the following reasons:

The action you have requested is limited to users in one of the groups: Users, Administrators.
The title "Template:cpp/container/note iterator invalidation" has been banned from creation. It matches the following disallowed titles list entry: Template:.* <autoconfirmed|noedit>

You can view and copy the source of this page.

<!--

-->{{#vardefine:cont|{{{1|inplace_vector}}}}}<!--
-->{{#vardefine:func|{{{2|emplace}}}}}<!--

-->{{#vardefine:invalidated|iterators (including the {{rlpf|end}} iterator) and all references to the elements are invalidated.}}<!--
-->{{#vardefine:All invalidated|All {{#var:invalidated}}}}<!--
-->{{#vardefine:all invalidated|all {{#var:invalidated}}}}<!--

-->{{#vardefine:realloc note|If after the operation the new {{rlpf|size}} is greater than old {{rlpf|capacity}} a reallocation takes place, in which case {{#var:all invalidated}}}}<!--

-->{{#vardefine:rehash note|If after the operation the new number of elements is greater than old {{box|{{rlpf|max_load_factor}}{{tt| *}}{{nbspt}}{{rlpf|bucket_count}}}} a rehashing takes place.<br>If rehashing occurs (due to the insertion), all iterators are invalidated. Otherwise (no rehashing), iterators are not invalidated.}}<!--

-->{{#vardefine:insertion note|{{rev inl|since=c++17|If the insertion is successful, pointers and references to the element obtained while it is held in the node handle are invalidated, and pointers and references obtained to that element before it was extracted become valid.}}}}<!--

-->{{#vardefine:erase note|Iterators (including the {{rlpf|end}} iterator) and references to the elements at or after the point of the erase are invalidated.}}<!--

-->{{#vardefine:pop_back note|Iterators and references to the last element are invalidated. The {{rlpf|end}} iterator is also invalidated.}}<!--

-->{{#vardefine:all but end ok|All iterators and references remain valid. The {{rlpf|end}} iterator is invalidated.}}<!--

-->{{#switch:{{#var:cont}}
|vector={{#switch:{{#var:func}}
  |assign
  |assign_range
  = {{#var:All invalidated}}
  |emplace
  |insert
  |insert_range
  = {{#var:realloc note}} Otherwise, only the iterators and references before the insertion point remain valid.
  |erase
  = {{#var:erase note}}
  |append_range
  |emplace_back
  |push_back
  = {{#var:realloc note}} Otherwise only the {{rlpf|end}} iterator is invalidated.
  |pop_back
  = {{#var:pop_back note}}
  |reserve
  = If {{c|new_cap}} is greater than {{lc|capacity()}}, {{#var:all invalidated}} Otherwise, no iterators or references are invalidated.
  |shrink_to_fit
  = If reallocation occurs, {{#var:all invalidated}} If no reallocation occurs, no iterators or references are invalidated.
  |swap
  = {{#var:all but end ok}}
  }}
|inplace_vector={{#switch:{{#var:func}}
  |assign
  |assign_range
  |emplace
  |insert
  |insert_range
  = {{todo}}
  |push_back
  |try_push_back
  |unchecked_push_back
  |emplace_back
  |try_emplace_back
  |unchecked_emplace_back
  = No iterators or references are invalidated, except {{rlpf|end}}, which is invalidated if the insertion occurs.
  |erase
  = {{#var:erase note}}
  |pop_back
  = {{#var:pop_back note}}
  }}
|deque={{#switch:{{#var:func}}
  |assign
  |assign_range
  = {{#var:All invalidated}}
  |emplace
  |insert
  |insert_range
  = All iterators (including the {{rlpf|end}} iterator) are invalidated. References are invalidated too, unless {{box|{{c/core|1=pos ==}}{{nbspt}}{{rlpf|begin}}}} or {{box|{{c/core|1=pos ==}}{{nbspt}}{{rlpf|end}}}}, in which case they are not invalidated.
  |erase
  = All iterators and references are invalidated, unless the erased elements are at the end or at the beginning of the container, in which case only the iterators and references to the erased elements are invalidated. The {{rlpf|end}} iterator is also invalidated unless the erased elements are at the beginning of the container and the last element is not erased.
  |append_range
  |emplace_back
  |emplace_front
  |prepend_range
  |push_back
  |push_front
  = All iterators (including the {{rlpf|end}} iterator) are invalidated. No references are invalidated.
  |pop_back
  = {{#var:pop_back note}}
  |pop_front
  = Iterators and references to the erased element are invalidated. If the element is the last element in the container, the {{rlpf|end}} iterator is also invalidated. Other references and iterators are not affected.
  |shrink_to_fit
  = {{#var:All invalidated}}
  |swap
  = {{#var:all but end ok}}
  }}
|forward_list
|list={{#switch:{{#var:func}}
  |assign
  = All iterators, pointers and references to the elements of the container are invalidated.
  |assign_range
  = {{#var:All invalidated}}
  |append_range <!--list only-->
  |emplace
  |emplace_after
  |emplace_back
  |emplace_front
  |insert
  |insert_after
  |insert_range <!--list only-->
  |prepend_range
  |push_back
  |push_front
  = No iterators or references are invalidated.
  |erase
  = References and iterators to the erased elements are invalidated. Other references and iterators are not affected.
  |pop_back
  |pop_front
  = References and iterators to the erased element are invalidated.
  |swap
  = All iterators and references remain valid. It is unspecified whether an iterator holding the {{rlpf|end}} value in this container will refer to this or the other container after the operation.
  }}
|set
|map
|multiset
|multimap={{#switch:{{#var:func}}
  |insert
  = No iterators or references are invalidated. {{#var:insertion note}}
  |at
  |emplace
  |emplace_hint
  |insert_or_assign
  |insert_range
  |operator_at
  = No iterators or references are invalidated.
  |erase
  = References and iterators to the erased elements are invalidated. Other references and iterators are not affected.
  |swap
  = {{#var:all but end ok}}
  }}
|unordered_set
|unordered_map
|unordered_multiset
|unordered_multimap={{#switch:{{#var:func}}
  |insert
  = {{#var:rehash note}} {{#var:insertion note}}
  |emplace
  |emplace_hint
  |insert_range
  |insert_or_assign
  |at
  |operator_at
  = {{#var:rehash note}}
  |erase
  = References and iterators to the erased elements are invalidated. Other iterators and references are not invalidated.
  |swap
  = {{#var:all but end ok}}
  }}
|{{ambox
  |type  = notice
  |small = {{{small|left}}}
  |text  = Information on iterator invalidation is copied from [[Template:cpp/container/note iterator invalidation|here]]
  |image = none
}}
}}<noinclude>{{documentation}}</noinclude>

Templates used on this page:

Template:ambox (view source) (protected)
Template:ambox/category (view source)
Template:ambox/core (view source)
Template:box (view source)
Template:cat handler (view source)
Template:cat handler/blacklist (view source)
Template:cat handler/numbered (view source)
Template:cpp/container/note iterator invalidation/doc (view source)
Template:documentation (view source) (protected)
Template:documentation/docspace (view source)
Template:documentation/end box (view source)
Template:documentation/end box2 (view source)
Template:documentation/start box (view source)
Template:documentation/start box2 (view source)
Template:documentation/template page (view source)
Template:fmbox (view source)
Template:mark rev (view source) (protected)
Template:mark since c++17 (view source)
Template:namespace detect (view source) (protected)
Template:nbsp (view source) (protected)
Template:nbspt (view source)
Template:purge (view source) (protected)
Template:rev inl (view source)
Template:rlpf (view source)
Template:template other (view source)
Template:tl (view source) (protected)
Template:todo (view source) (protected)
Template:trim (view source) (protected)
Template:tt (view source) (protected)

Return to Template:cpp/container/note iterator invalidation.

cppreference.com

Search

Namespaces

Variants

Views

Actions

View source for Template:cpp/container/note iterator invalidation

Navigation

Tools