Open In App

std::inserter in C++

Last Updated : 27 Jul, 2017
Summarize
Comments
Improve
Suggest changes
Like Article
Like
Save
Share
Report
News Follow

std::inserter constructs an insert iterator that inserts new elements into x in successive locations starting at the position pointed by it. It is defined inside the header file .

An insert iterator is a special type of output iterator designed to allow algorithms that usually overwrite elements (such as copy) to instead insert new elements automatically at a specific position in the container.
Syntax:

std::inserter(Container& x, typename Container::iterator it);
x: Container in which new elements will 
be inserted.
it: Iterator pointing to the insertion point.

Returns: An insert_iterator that inserts elements into 
x at the position indicated by it.




// C++ program to demonstrate std::inserter
#include <iostream>
#include <iterator>
#include <deque>
#include <algorithm>
using namespace std;
int main()
{
    // Declaring first container
    deque<int> v1 = { 1, 2, 3 };
  
    // Declaring second container for
    // copying values
    deque<int> v2 = { 4, 5, 6 };
  
    deque<int>::iterator i1;
    i1 = v2.begin() + 1;
    // i1 points to next element of 4 in v2
  
    // Using std::inserter inside std::copy
    std::copy(v1.begin(), v1.end(), std::inserter(v2, i1));
    // v2 now contains 4 1 2 3 5 6
  
    // Displaying v1 and v2
    cout << "v1 = ";
  
    int i;
    for (i = 0; i < 3; ++i) {
        cout << v1[i] << " ";
    }
  
    cout << "\nv2 = ";
    for (i = 0; i < 6; ++i) {
        cout << v2[i] << " ";
    }
  
    return 0;
}


Output:

v1 = 1 2 3
v2 = 4 1 2 3 5 6 

How is it helpful ?

  • Inserting values anywhere : Now, just imagine, if we had to copy value into a container such as a vector, firstly, we had to move elements and then copy, but with the help of std::insert() we can insert at any position with ease.




    // C++ program to demonstrate std::inserter
    #include <iostream>
    #include <iterator>
    #include <vector>
    #include <algorithm>
    using namespace std;
    int main()
    {
        // Declaring first container
        vector<int> v1 = { 1, 2, 3, 7, 8, 9 };
      
        // Declaring second container
        vector<int> v2 = { 4, 5, 6 };
      
        vector<int>::iterator i1;
        i1 = v2.begin() + 2;
        // i1 points to next element of 5 in v2
      
        // Using std::inserter inside std::copy
        std::copy(v1.begin(), v1.end(), std::inserter(v2, i1));
        // v2 now contains 4 5 1 2 3 7 8 9 6
      
        // Displaying v1 and v2
        cout << "v1 = ";
      
        int i;
        for (i = 0; i < 6; ++i) {
            cout << v1[i] << " ";
        }
      
        cout << "\nv2 = ";
        for (i = 0; i < 9; ++i) {
            cout << v2[i] << " ";
        }
      
        return 0;
    }

    
    

    Output:

    v1 = 1 2 3 7 8 9
    v2 = 4 5 1 2 3 7 8 9 6
    

    Explanation: Here, we started copying v1 into v2 but not from the beginning, but after the second position of v2, i.e., after 5, so all the elements of v1 were inserted after 5, and before 6. In this way, we inserted value where we wanted quite easily.

Points to Remember:

  1. One of the pitfalls of std::inserter is that it can be used with only those containers that have insert as one of its methods like in case of vector, list and deque, and so on.
  2. insert() vs std::inserter(): Now, you may be thinking that insert() and std::inserter() are similar, but they are not. When you have to pass an iterator in the algorithm, then you should use inserter() like in above case, while for normally inserting the values in the container, insert() can be used.
  3. In place of using std::inserter, we can create a insert_iterator and then use it, as eventually, std::inserter returns a insert_iterator only.




    // C++ program to demonstrate insert_iterator
    #include <iostream>
    #include <iterator>
    #include <deque>
    #include <algorithm>
    using namespace std;
    int main()
    {
        // Declaring first container
        deque<int> v1 = { 1, 2, 3 };
      
        // Declaring second container for
        // copying values
        deque<int> v2 = { 4, 5, 6 };
      
        deque<int>::iterator ii;
        ii = v2.begin() + 1;
        // ii points after 4 in v2
      
        // Declaring a insert_iterator
        std::insert_iterator<std::deque<int> > i1(v2, ii);
      
        // Using the iterator in the copy()
        std::copy(v1.begin(), v1.end(), i1);
        // v2 now contains 4 1 2 3 5 6
      
        // Displaying v1 and v2
        cout << "v1 = ";
      
        int i;
        for (i = 0; i < 3; ++i) {
            cout << v1[i] << " ";
        }
      
        cout << "\nv2 = ";
        for (i = 0; i < 6; ++i) {
            cout << v2[i] << " ";
        }
      
        return 0;
    }

    
    

    Output:

    v1 = 1 2 3
    v2 = 4 1 2 3 5 6
    


Similar Reads

std::fixed, std::scientific, std::hexfloat, std::defaultfloat in C++
Formatting in the standard C++ libraries is done through the use of manipulators, special variables or objects that are placed on the output stream. There are two types of floating point manipulators namely, fixed floating point and scientific floating point. These all are defined in header <iostream>. Use of precision : In the default floati
3 min read
std::oct , std::dec and std::hex in C++
This function is used to set the base to octal, decimal or hexadecimal. It sets the basefield format flag for the str stream to the specified base std::oct : When basefield is set to octal, integer values inserted into the stream are expressed in octal base (i.e., radix 8). For input streams, extracted values are also expected to be expressed in oc
2 min read
std::legendre, std::legendref and std::legendrel functions in C++17
The legendre , legendref and legendrel are built functions in C++ STL that are used to compute the value of unassociated polynomials of degree n and argument x. Value of order-n unassociated Legendre Polynomial of x is given by : [Tex] \[ \ P_{n}(x)= \frac{1}{2^{n}n!}\frac{d^{n}}{dx^{n}}(x^{2}-1)^{n} \] [/Tex] The first few Legendre polynomials are
3 min read
std::string::length, std::string::capacity, std::string::size in C++ STL
Prerequisite: String in C++ String class is one of the features provided by the Standard template library to us, So it comes up with great functionality associated with it. With these Functionalities, we can perform many tasks easily. Let's see a few of the functionalities string class provides. Header File <string> String Functionalities The
6 min read
std::stod, std::stof, std::stold in C++
std::stod() : It convert string into double. Syntax: double stod( const std::string& str, std::size_t* pos = 0 ); double stod( const std::wstring& str, std::size_t* pos = 0 ); Return Value: return a value of type double Parameters str : the string to convert pos : address of an integer to store the number of characters processed. This param
3 min read
std::setbase, std::setw , std::setfill in C++
The useful input/output manipulators are std::setbase, std::setw and std::setfill. These are defined in and are quite useful functions. std::base : Set basefield flag; Sets the base-field to one of its possible values: dec, hex or oct according to argument base.Syntax : std::setbase (int base);decimal : if base is 10hexadecimal : if base is 16octal
3 min read
std::istream_iterator and std::ostream_iterator in C++ STL
The STL is a very powerful library in C++. It is strongly built on the principles of template programming. The STL library has three main components : Containers: These classes define the data structures which are used to contain the data. The data may be stored in linked lists, or trees or arrays. The containers provided in the STL are vector, deq
6 min read
Difference between std::swap and std::vector::swap
The std::swap is a general function used to exchange the given values whereas the std::vector::swap is a specialized function that can swap all the contents of two different vector containers.Below are some major key differences between std::swap and std::vector::swap, std::swapstd::vector::swapThe std::swap() is a built-in function in C++ STL whic
3 min read
std::bitset::to_ullong and std::bitset::to_ulong in C++ STL
Bitset: A bitset is an array of bool but each Boolean value is not stored separately instead bitset optimizes the space such that each bool takes 1 bit space only, so space taken by bitset bs is less than that of bool bs[N] and vector bs(N). However, a limitation of bitset is, N must be known at compile time, i.e., a constant (this limitation is no
2 min read
std::string::remove_copy(), std::string::remove_copy_if() in C++
remove_copy() It is an STL function in c++ which is defined in algorithm library. It copies the elements in the range [first, last) to the range beginning at result, except those elements that compare equal to given elements. The resulting range is shorter than [first,last) by as many elements as matches in the sequence, which are "removed". The re
4 min read
Difference between std::quick_exit and std::abort
std::quick_exit() It Causes normal program termination to occur without completely cleaning the resources. Syntax : void quick_exit(int exit_code) no except; In case of execution of threads the codes becomes complex and knowing the execution of threads is hard. While one the thread might be waiting for a process to end while the other thread is wai
3 min read
Difference between std::set::lower_bound and std::lower_bound in C++
Prerequisite: Random-access Iterators in C++, Bidirectional Iterators in C++. std::lower_bound in C++: The lower_bound() method in C++ is used to return an iterator pointing to the first element in the range [first, last) which has a value not less than the given value. This means that the function returns the index of the next smallest number just
4 min read
Difference between std::set::upper_bound and std::upper_bound in C++
Prerequisites: Random-access Iterators, Bidirectional Iterators Sets are a type of associative container in which each element has to be unique because the value of the element identifies it. The value of the element cannot be modified once it is added to the set, though it is possible to remove and add the modified value of that element. Functions
4 min read
std::tuple_element() and std::tuple_size() in C++ with Examples
A tuple is an object that can hold a number of elements. The elements can be different data types. The elements of tuples are initialized as arguments in the order in which they will be accessed. The functions- tuple_element() and tuple_size() are only defined for elements using tuple_like interface. tuple_element():The C++ function tuple_element(a
2 min read
std::tuple, std::pair | Returning multiple values from a function using Tuple and Pair in C++
There can be some instances where you need to return multiple values (maybe of different data types ) while solving a problem. One method to do the same is by using pointers, structures or global variables, already discussed here There is another interesting method to do the same without using the above methods,  using tuples (for returning multipl
2 min read
std::regex_match, std::regex_replace() | Regex (Regular Expression) In C++
Regex is the short form for “Regular expression”, which is often used in this way in programming languages and many different libraries. It is supported in C++11 onward compilers.Function Templates used in regex regex_match() -This function return true if the regular expression is a match against the given string otherwise it returns false. C/C++ C
3 min read
std::minmax() and std::minmax_element() in C++ STL
C++ defined functions to get smallest and largest elements among 2 or in a container using different functions. But there are also functions that are used to get both smallest and largest element using a single function, "minmax()" function achieves this task for us. This function is defined in "algorithm" header file. This article would deal in it
4 min read
std::string::replace_copy(), std::string::replace_copy_if in C++
replace_copy replace_copy() is a combination of copy() and replace(). It copies the elements in the range [first, last) to the range beginning at result, replacing the appearances of old_value by new_value.The range copied is [first, last), which contains all the elements between first and last, including the element pointed by first but not the el
4 min read
std::string::append vs std::string::push_back() vs Operator += in C++
To append characters, you can use operator +=, append(), and push_back(). All of them helps to append character but with a little difference in implementation and application. Operator += : appends single-argument values. Time complexity : O(n)append() : lets you specify the appended value by using multiple arguments. Time complexity: O(n)push_back
6 min read
std::replace and std::replace_if in C++
std::replace Assigns new_value to all the elements in the range [first, last) that compare to old_value. The function use operator == to compare the individual elements to old_value Function Template : void replace (ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value) first, last : Forward iterators to the in
4 min read
std::basic_string::at vs std::basic_string::operator[]
std::basic_string::at, std::basic_string::operator[]Both at() and operator[] can be used to access an element in the string. But there exists one difference between them on how to handle exceptional condition when pos>=size. std::basic_string::at throws std::out_of_range if pos >= size().std::bsic_string::operator[] throws no exception and pr
2 min read
std::find_if , std::find_if_not in C++
std :: find_if and std :: find_if_not are algorithm functions in C++ Standard Library in <algorithm> header file. These functions provide an efficient way to search for an element in a container using a predicate function. std :: find_if This function returns an iterator to the first element in the range [first, last) for which pred(Unary Fun
3 min read
std::next vs std::advance in C++
std::advance and std::next are used to advance the iterator by a certain position, such that we can make the iterator point to a desired position. Although both have same purpose, but their implementation is different from each other. This makes it important for us to understand the difference between the two. In C++11, std::next() will advance by
3 min read
std::rotate vs std::rotate_copy in C++ STL
rotate in STL:It rotates the order of the elements in the range [first, last), in such a way that the element pointed by middle becomes the new first element, i, e, to the left. // Illustrating the use of rotate algorithm #include <bits/stdc++.h> using namespace std; // Driver Program int main() { vector<int> arr; // set some values: 1
2 min read
std::stoul and std::stoull in C++
std::stoul Convert string to unsigned integer. Parses str interpreting its content as an integral number of the specified base, which is returned as an unsigned long value. unsigned long stoul (const string& str, size_t* idx = 0, int base = 10); Parameters : str : String object with the representation of an integral number. idx : Pointer to an
3 min read
std::vector::resize() vs. std::vector::reserve()
In C++, vectors are dynamically resizable arrays provided by STL. They can automatically change their size according to the number of elements and users also can change its size using the std::vector::resize()and std::vector::reserve(). But there is some difference in how these functions works. In this article, we will learn what are the difference
5 min read
std::upper_bound and std::lower_bound for Vector in C++ STL
Click here for Set 1 and Set 2 of Vectors. Vector - upper_bound and lower_boundIterator lower_bound (Iterator first, Iterator last, const val) lower_bound returns an iterator pointing to the first element in the range [first,last) which has a value not less than 'val' and if the value is not present in the vector then it returns the end iterator. I
4 min read
std::stol() and std::stoll() Functions in C++
In C++, std::stol() and std::stoll() are the library functions used to convert the given string to integer value of type long int and long long int respectively. They are defined inside <string> header file. In this article, we will learn about std::stol() and std::stoll() functions in C++. Example: [GFGTABS] C++ // C++ program to illustrate
4 min read
Why we should avoid using std::endl
It is a common practice to use std::endl to print newlines while using cout. For small programs with very little I/O operations this practice is acceptable, but if the bulk of I/O operations increase, then the efficiency of the program is compromised. std::endl not only adds newlines to the stream, it also flushes the buffer each time it is used.Th
3 min read
std::to_wstring in c++
This function is used to convert the numerical value to the wide string i.e. it parses a numerical value of datatypes (int, long long, float, double ) to a wide string. It returns a wide string of data type wstring representing the numerical value passed in the function. In this function data type is being internally typecasted to the wstring data
3 min read
Article Tags :
Practice Tags :
three90RightbarBannerImg