##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::set::set

From cppreference.com
< cpp‎ | container‎ | set

[edit template]

| (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 = Allocator() ); |  | (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 = Allocator() ); |  | (since C++14)

Constructs new container from a variety of data sources and optionally using user supplied allocator `alloc` or comparison function object `comp`.

1) Default constructor. Constructs empty container.

2) Constructs the container with the contents of the range `[first, last)`.

3) Copy constructor. Constructs the container with the copy of the contents of `other`. If `alloc` is not provided, allocator is obtained by calling std::allocator_traits<allocator_type>::select_on_copy_construction(other).

4) Move constructor. Constructs the container with the contents of `other` using move semantics. If `alloc` is not provided, allocator is obtained by move-construction from the allocator belonging to `other`.

5) Constructs the container with the contents of the initializer list `init`.

### [edit] Parameters

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`.

### [edit] Complexity

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()`.

### [edit] Example

Run this code

    #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}

### [edit] See also

operator= | assigns values to the container (public member function) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/container/set/set&oldid=71728"