C++ Programming Code Examples
Learn C++ Language
Set Library insert() Function in C++ Programming Language
Set Library insert() Function in C++
Insert element. Extends the container by inserting new elements, effectively increasing the container size by the number of elements inserted. Because elements in a set are unique, the insertion operation checks whether each inserted element is equivalent to an element already in the container, and if so, the element is not inserted, returning an iterator to this existing element (if the function returns a value).
The C++ set::insert function is used to insert new elements in the container. This results into increasing the set size by the number of elements inserted. As the elements in a set are unique, therefore the insertion operation first checks if the inserted element is unique to the set then the element is inserted.
For a similar container allowing for duplicate elements, see multiset.
Internally, set containers keep all their elements sorted following the criterion specified by its comparison object. The elements are always inserted in its respective position following this ordering.
The parameters determine how many elements are inserted and to which values they are initialized:
Syntax for Set insert() Function in C++
#include <set>
//single element (1)
pair<iterator,bool> insert (const value_type& val);
pair<iterator,bool> insert (value_type&& val);
//with hint (2)
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val);
//range (3)
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
//initializer list (4)
void insert (initializer_list<value_type> il);
val
Value to be copied (or moved) to the inserted elements. Member type value_type is the type of the elements in the container, defined in set as an alias of its first template parameter (T).
position
Hint for the position where the element can be inserted. The function optimizes its insertion time if position points to the element that will follow the inserted element (or to the end, if it would be the last). Notice that this is just a hint and does not force the new element to be inserted at that position within the set container (the elements in a set always follow a specific order).
Member types iterator and const_iterator are defined in map as a bidirectional iterator type that point to elements.
first, last
Iterators specifying a range of elements. Copies of the elements in the range [first,last) are inserted in the container.
Notice that the range includes all the elements between first and last, including the element pointed by first but not the one pointed by last.
The function template argument InputIterator shall be an input iterator type that points to elements of a type from which value_type objects can be constructed.
il
An initializer_list object. Copies of these elements are inserted. These objects are automatically constructed from initializer list declarators.
Member type value_type is the type of the elements in the container, defined in set as an alias of its first template parameter (T).
The single element versions (1) return a pair, with its member pair::first set to an iterator pointing to either the newly inserted element or to the equivalent element already in the set. The pair::second element in the pair is set to true if a new element was inserted or false if an equivalent element already existed.
The versions with a hint (2) return an iterator pointing to either the newly inserted element or to the element that already had its same value in the set.
Member type iterator is a bidirectional iterator type that points to elements.
pair is a class template declared in <utility> (see pair).
Complexity
If a single element is inserted, logarithmic in size in general, but amortized constant if a hint is given and the position given is the optimal.
If N elements are inserted, Nlog(size+N).
Implementations may optimize if the range is already sorted.
Iterator validity
No changes.
Data races
The container is modified. Concurrently accessing existing elements is safe, although iterating ranges in the container is not.
Exception safety
If a single element is to be inserted, there are no changes in the container in case of exception (strong guarantee).
Otherwise, the container is guaranteed to end in a valid state (basic guarantee).
If allocator_traits::construct is not supported with the appropriate arguments for the element constructions, or if an invalid position is specified, it causes undefined behavior.
/* insert new elements in the container by set::insert function code example. */
#include <iostream>
#include <set>
using namespace std;
int main (){
set<int> set1 = {10, 20, 30};
set<int> set2 = {10, 20, 30};
set<int>::iterator it;
//single element version
set1.insert(55);
//single element with hint version
it = set2.begin();
set2.insert(++it, 15);
cout<<"set1 contains: ";
for(it = set1.begin(); it != set1.end(); ++it)
cout<<*it<<" ";
cout<<"\nset2 contains: ";
for(it = set2.begin(); it != set2.end(); ++it)
cout<<*it<<" ";
return 0;
}
This is a C++ Program to check whether tree is Subtree of another tree. Given two binary trees, check if the first tree is subtree of the second one. A subtree of a tree T is a tree S
To check whether the entered character is an alphabet or not alphabet in the 'C++', enter a character and start checking for alphabet. To check for alphabet, use 'ASCII' of character, if
A function is block of code which is used to perform a particular task, for example let's say you are writing a "Larger C++ Program", in that program you want to do a particular
