Difference between revisions of "cpp/container/set/insert"
(Added LWG issue #264 DR (part 1/4).) |
(Clarified amortized constness conditions for insert with hint until C++11) |
||
Line 75: | Line 75: | ||
@1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}. | @1-2@ Logarithmic in the size of the container, {{tt|O(log(size()))}}. | ||
− | @3-4@ Amortized constant if the insertion happens in the position just ''before'' {{c|pos}}, logarithmic in the size of the container otherwise. | + | @3-4@ Amortized constant if the insertion happens in the position just {{rev inl|until=c++11|''after''}} or {{rev inl|since=c++11|''before''}} {{c|pos}}, logarithmic in the size of the container otherwise. |
@5-6@ {{tt|O(N*log(size() + N))}}, where {{tt|N}} is the number of elements to insert. | @5-6@ {{tt|O(N*log(size() + N))}}, where {{tt|N}} is the number of elements to insert. |
Revision as of 09:38, 10 January 2023
std::pair<iterator, bool> insert( const value_type& value ); |
(1) | |
std::pair<iterator, bool> insert( value_type&& value ); |
(2) | (since C++11) |
(3) | ||
iterator insert( iterator pos, const value_type& value ); |
(until C++11) | |
iterator insert( const_iterator pos, const value_type& value ); |
(since C++11) | |
iterator insert( const_iterator pos, value_type&& value ); |
(4) | (since C++11) |
template< class InputIt > void insert( InputIt first, InputIt last ); |
(5) | |
void insert( std::initializer_list<value_type> ilist ); |
(6) | (since C++11) |
insert_return_type insert( node_type&& nh ); |
(7) | (since C++17) |
iterator insert( const_iterator pos, node_type&& nh ); |
(8) | (since C++17) |
Inserts element(s) into the container, if the container doesn't already contain an element with an equivalent key.
[first, last)
. If multiple elements in the range have keys that compare equivalent, it is unspecified which element is inserted (pending LWG2844).No iterators or references are invalidated. 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.(since C++17)
Contents |
Parameters
pos | - | iterator to the position before which the new element will be inserted |
value | - | element value to insert |
first, last | - | range of elements to insert |
ilist | - | initializer list to insert the values from |
nh | - | a compatible node handle |
Type requirements | ||
-InputIt must meet the requirements of LegacyInputIterator.
|
Return value
insert_return_type
with the members initialized as follows:
- If nh is empty,
inserted
is false,position
is end(), andnode
is empty. - Otherwise if the insertion took place,
inserted
is true,position
points to the inserted element, andnode
is empty. - If the insertion failed,
inserted
is false,node
has the previous value of nh, andposition
points to an element with a key equivalent to nh.key().
Exceptions
This section is incomplete Reason: cases 5-8 |
Complexity
O(log(size()))
.O(N*log(size() + N))
, where N
is the number of elements to insert.O(log(size()))
.Notes
The hinted insert (3,4) does not return a boolean in order to be signature-compatible with positional insert on sequential containers, such as std::vector::insert. This makes it possible to create generic inserters such as std::inserter. One way to check success of a hinted insert is to compare size()
before and after.
The overloads (5,6) are often implemented as a loop that calls the overload (3) with end() as the hint; they are optimized for appending a sorted sequence (such as another set) whose smallest element is greater than the last element in *this.
Example
#include <set> #include <cassert> #include <iostream> int main() { std::set<int> set; auto result_1 = set.insert(3); assert(result_1.first != set.end()); // it's a valid iterator assert(*result_1.first == 3); if (result_1.second) std::cout << "insert done\n"; auto result_2 = set.insert(3); assert(result_2.first == result_1.first); // same iterator assert(*result_2.first == 3); if (!result_2.second) std::cout << "no insertion\n"; }
Output:
insert done no insertion
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 233 | C++98 | pos was just a hint, it could be totally ignored | the insertion is required to be as close as possible to the position just prior to pos |
LWG 264 | C++98 | the complexity of overload (5) was required to be linear if the range [first, last) is sorted according to Compare
|
removed the linear requirement in this special case |
See also
(C++11) |
constructs element in-place (public member function) |
(C++11) |
constructs elements in-place using a hint (public member function) |
creates a std::insert_iterator of type inferred from the argument (function template) |