(1) | ||
explicit set( const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); | (until C++14) | |
set() : set( Compare() ) {} explicit set( const Compare& comp, const Allocator& alloc = Allocator() ); | (since C++14) | |
explicit set( const Allocator& alloc ); | (1) | (since C++11) |
(2) | ||
template< class InputIt > set( InputIt first, InputIt last, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); | ||
template< class InputIt > set( InputIt first, InputIt last, const Allocator& alloc) : set(first, last, Compare(), alloc) {} | (since C++14) | |
set( const set& other ); | (3) | |
set( const set& other, const Allocator& alloc ); | (3) | (since C++11) |
set( set&& other ); | (4) | (since C++11) |
set( set&& other, const Allocator& alloc ); | (4) | (since C++11) |
(5) | ||
set( std::initializer_list<value_type> init, const Compare& comp = Compare(), const Allocator& alloc = Allocator() ); | (since C++11) | |
set( std::initializer_list<value_type> init, const Allocator& alloc ) : set(init, Compare(), alloc) {} | (since C++14) |
Constructs new container from a variety of data sources and optionally using user supplied allocator alloc
or comparison function object comp
.
[first, last)
.other
. If alloc
is not provided, allocator is obtained by calling std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator())
.other
using move semantics. If alloc
is not provided, allocator is obtained by move-construction from the allocator belonging to other
.init
. alloc | - | allocator to use for all memory allocations of this container |
comp | - | comparison function object to use for all comparisons of keys |
first, last | - | the range to copy the elements from |
other | - | another container to be used as source to initialize the elements of the container with |
init | - | initializer list to initialize the elements of the container with |
Type requirements | ||
-
InputIt must meet the requirements of InputIterator . |
||
-
Compare must meet the requirements of Compare . |
||
-
Allocator must meet the requirements of Allocator . |
1) Constant.
2) N log(N) where N = std::distance(first, last)
in general, linear in N
if the range is already sorted by value_comp()
.
3) Linear in size of other
.
4) Constant. If alloc
is given and alloc != other.get_allocator()
, then linear.
5) N log(N) where N = init.size())
in general, linear in N
if init
is already sorted by value_comp()
.
After container move construction (overload (4)), references, pointers, and iterators (other than the end iterator) to other
remain valid, but refer to elements that are now in *this
. The current standard makes this guarantee via the blanket statement in §23.2.1[container.requirements.general]/12, and a more direct guarantee is under consideration via LWG 2321.
#include <iostream> #include <string> #include <set> // Helper function for printing pairs. template<class Ch, class Tr, class A, class B> inline std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& stream, std::pair<A,B> p) { return stream << '(' << p.first << ", " << p.second << ')'; } // Helper function for printing containers. template<class Ch, class Tr, class Co> std::basic_ostream<Ch, Tr>& operator<<(std::basic_ostream<Ch, Tr>& stream, Co& c) { stream << '{' << *c.begin(); for(auto it = ++(c.begin()); it != c.end(); ++it) stream << ", " << *it; stream << '}' << std::endl; return stream; } int main() { // (1) Default constructor std::set<std::string> a; a.insert("something"); a.insert("anything"); a.insert("that thing"); std::cout << "a = " << a; // (2) Iterator constructor std::set<std::string> b(a.find("anything"), a.end()); std::cout << std::string(80, '-') << std::endl; std::cout << "b = " << b; // (3) Copy constructor std::set<std::string> c(a); c.insert("another thing"); std::cout << std::string(80, '-') << std::endl; std::cout << "a = " << a; std::cout << "c = " << c; // (4) Move constructor std::set<std::string> d(std::move(a)); std::cout << std::string(80, '-') << std::endl; std::cout << "a = nullptr" << std::endl; std::cout << "d = " << d; // (5) Initializer list constructor std::set<std::string> e{ "one", "two", "three", "five", "eight" }; std::cout << std::string(80, '-') << std::endl; std::cout << "e = " << e; }
Output:
a = {anything, something, that thing} -------------------------------------------------------------------------------- b = {anything, something, that thing} -------------------------------------------------------------------------------- a = {anything, something, that thing} c = {another thing, anything, something, that thing} -------------------------------------------------------------------------------- a = nullptr d = {anything, something, that thing} -------------------------------------------------------------------------------- e = {eight, five, one, three, two}
assigns values to the container (public member function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/container/set/set