vector copy assignment

• Standard Template Library
• STL Priority Queue
• STL Interview Questions
• STL Cheatsheet
• C++ Templates
• C++ Functors
• C++ Iterators

Ways to copy a vector in C++

• Copy File To Vector in C++ STL
• How to Declare a Vector in C++?
• How to Copy a Vector to an Array in C++?
• How to Shuffle a Vector in C++?
• Different ways to copy a string in C/C++
• How to Create a Set of Vectors in C++?
• Convert Set To Vector in C++
• Passing Vector to a Function in C++
• How to Resize a 2D Vector in C++?
• How does a vector work in C++?
• Deque vs Vector in C++ STL
• Vector in C++ STL
• Different Ways to Convert Vector to Array in C++ STL
• Array of Vectors in C++ STL
• vector::emplace_back in C++ STL
• How to Create a Deque of Vectors in C++?
• Initialize a vector in C++ (7 different ways)
• Different ways to print elements of vector
• How to convert a Vector to Set in C++
• How to Check if a Vector is Empty in C++?
• vector :: assign() in C++ STL
• std::partial_sort_copy in C++
• C++ Vector of Pointers
• How to Create a Vector of Pairs in C++?
• partition_copy in C++ STL
• Slicing a Vector in C++
• How to Create a Vector of Tuples in C++?
• How to create an empty vector in R ?
• Vector copyInto() Method in Java

In the case of arrays, there is not much choice to copy an array into another, other than the iterative method i.e running a loop to copy each element at its respective index. But Vector classes have more than one method for copying entire vectors into others in easier ways.

There are basically two types of copying:- 

Method 1: Iterative method. This method is a general method to copy, in this method a loop is used to push_back() the old vector elements into the new vector. They are deeply copied 

In the above code, changing the value at one vector did not alter the value at another vector, hence they are not allocated at the same address, hence deep copy.

Method 2: By assignment “=” operator . Simply assigning the new vector to the old one copies the vector. This way of assignment is not possible in the case of arrays. 

Method 3: By passing vector as constructor. At the time of declaration of vector, passing an old initialized vector copies the elements of the passed vector into the newly declared vector. They are deeply copied. 

Method 4: copy(first_iterator_o, last_iterator_o, back_inserter()) :- This is another way to copy old vector into new one. This function takes 3 arguments, first, the first iterator of the old vector, second, the last iterator of the old vector and third is back_inserter function to insert values from the back. This also generated a deep copy. 

Method 5: assign(first_iterator_o, last_iterator_o): This method assigns the same values to the new vector as the old one. This takes 2 arguments, the first iterator to the old vector and the last iterator to the old vector. This generates a deep copy. 

Method 6: By using insert function. The vector class has a standard function, insert() , that can insert elements from a specified range.

Please Login to comment...

Similar reads.

• cpp-algorithm-library
• cpp-strings-library

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Ace your Coding Interview

• DSA Problems
• Binary Tree
• Binary Search Tree
• Dynamic Programming
• Divide and Conquer
• Linked List
• Backtracking

Copy a vector in C++

This post will discuss how to copy a vector in C++. Copying a vector includes constructing a new vector with a copy of each of the elements in the original vector and in the same order.

1. Using Copy Constructor

The recommended approach is to use the copy constructor, which internally takes care of all copying.

Download    Run Code

  We can also use a range constructor for this:

2. Using vector::operator=

Here, the idea is to create an empty vector and use its member function operator= for copying all elements of the given vector to it.

  We know that an object is passed by value to a function in C++ by default. That means the stack will create the copy of the whole object if the object is passed by value. We can take advantage of this fact and force a copy of the vector, as shown below:

3. Using std::copy function

The standard algorithm for copying is std::copy . We can use it for copying elements from the source vector to the destination vector. But make sure that the destination vector has sufficient space to accommodate all elements of the source sequence.

  If the destination vector doesn’t have enough space for copying, prefer using std::back_insert iterator, which will call vector::push_back on the destination vector, as shown below:

4. Using vector::insert function

The vector class has a standard function, insert() , that can insert elements from a specified range.

5. Using vector::assign function

Here’s another solution using the public member function assign() of the vector class, which replaces the vector contents with contents of the specified range.

6. Using vector::push_back function

Finally, we can call vector::push_back on each of the elements in the given vector using a range-based for-loop. Simple yet efficient.

  Important Note:

Please note that all above solutions perform a shallow copy on the vector object. C++ doesn’t offer any utility function for performing a deep copy. If a deep copy is needed, we can write our own routine, which traverses the vector and manually copy the references to other objects.

That’s all about copying a vector in C++.

Get a slice or a sub-vector from a vector in C++

Split a vector into sub-vectors of size n in C++

Convert a map to a vector of key-value pairs in C++

Rate this post

Average rating 4.69 /5. Vote count: 13

No votes so far! Be the first to rate this post.

We are sorry that this post was not useful for you!

Tell us how we can improve this post?

Thanks for reading.

To share your code in the comments, please use our online compiler that supports C, C++, Java, Python, JavaScript, C#, PHP, and many more popular programming languages.

Like us? Refer us to your friends and support our growth. Happy coding :)

Software Engineer | Content Writer | 12+ years experience

C++ Cookbook by D. Ryan Stephens, Christopher Diggins, Jonathan Turkanis, Jeff Cogswell

Get full access to C++ Cookbook and 60K+ other titles, with a free 10-day trial of O'Reilly.

There are also live events, courses curated by job role, and more.

6.3. Copying a vector

You need to copy the contents of one vector into another.

There are a couple of ways to do this. You can use a copy constructor when you create a vector , or you can use the assign member function. Example 6-3 shows how to do both.

Example 6-3. Copying vector contents

Copying a vector is easy; there are two ways to do it. You can copy construct one vector from another, just like any other object, or you can use the assign member function. There is little to say about the copy constructor; just pass in the ...

Get C++ Cookbook now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Don’t leave empty-handed

Get Mark Richards’s Software Architecture Patterns ebook to better understand how to design components—and how they should interact.

It’s yours, free.

Check it out now on O’Reilly

Dive in for free with a 10-day trial of the O’Reilly learning platform—then explore all the other resources our members count on to build skills and solve problems every day.

• TutorialKart
• SAP Tutorials
• Salesforce Admin
• Salesforce Developer
• Visualforce
• Informatica
• Kafka Tutorial
• Spark Tutorial
• Tomcat Tutorial
• Python Tkinter

Programming

• Bash Script
• Julia Tutorial
• CouchDB Tutorial
• MongoDB Tutorial
• PostgreSQL Tutorial
• Android Compose
• Flutter Tutorial
• Kotlin Android

Web & Server

• Selenium Java
• C++ Tutorials
• C++ Tutorial
• C++ Hello World Program
• C++ Comments
• C++ Variables
• Print datatype of variable
• C++ If Else
• Addition Operator
• Subtraction Operator
• Multiplication Operator
• Division Operator
• Modulus Operator
• Increment Operator
• Decrement Operator
• Simple Assignment
• Addition Assignment
• Subtraction Assignment
• Multiplication Assignment
• Division Assignment
• Remainder Assignment
• Bitwise AND Assignment
• Bitwise OR Assignment
• Bitwise XOR Assignment
• Left Shift Assignment
• Right Shift Assignment
• Bitwise AND
• Bitwise XOR
• Bitwise Complement
• Bitwise Left shift
• Bitwise Right shift
• Logical AND
• Logical NOT
• Not Equal to
• Greater than
• Greater than or Equal to
• Less than or Equal to
• Ternary Operator
• Do-while loop
• Infinite While loop
• Infinite For loop
• C++ Recursion
• Create empty string
• String length
• String comparison
• Get character at specific index
• Get first character
• Get last character
• Find index of substring
• Iterate over characters
• Print unique characters
• Check if strings are equal
• Append string
• Concatenate strings
• String reverse
• String replace
• Swap strings
• Convert string to uppercase
• Convert string to lowercase
• Append character at end of string
• Append character to beginning of string
• Insert character at specific index
• Remove last character
• Replace specific character
• Convert string to integer
• Convert integer to string
• Convert string to char array
• Convert char array to string
• Initialize array
• Array length
• Print array
• Loop through array
• Basic array operations
• Array of objects
• Array of arrays
• Convert array to vector
• Sum of elements in array
• Average of elements in array
• Find largest number in array
• Find smallest number in array
• Sort integer array
• Find string with least length in array
• Create an empty vector
• Create vector of specific size
• Create vector with initial values
• Copy a vector to another
• Vector length or size
• Vector of vectors
• Vector print elements
• ADVERTISEMENT
• Vector iterate using For loop
• Vector iterate using While loop
• Vector Foreach
• Get reference to element at specific index
• Check if vector is empty
• Check if vectors are equal
• Check if vector contains element
• Update/Transform
• Add element(s) to vector
• Append element to vector
• Append vector
• Insert element at the beginning of vector
• Remove first element from vector
• Remove last element from vector
• Remove element at specific index from vector
• Remove duplicates from vector
• Remove elements from vector based on condition
• Resize vector
• Swap elements of two vectors
• Remove all elements from vector
• Reverse a vector
• Sort a vector
• Conversions
• Convert vector to map
• Join vector elements to a string
• Filter even numbers in vector
• Filter odd numbers in vector
• Get unique elements of a vector
• Remove empty strings from vector
• Sort integer vector in ascending order
• Sort integer vector in descending order
• Sort string vector based on length
• Sort string vector lexicographically
• Split vector into two equal halves
• Declare tuple
• Initialise tuple
• Swap tuples
• Unpack tuple elements into variables
• Concatenate tuples
• Constructor
• Copy constructor
• Virtual destructor
• Friend class
• Friend function
• Inheritance
• Multiple inheritance
• Virtual inheritance
• Function overloading
• Operator overloading
• Function overriding
• C++ Try Catch
• Math acos()
• Math acosh()
• Math asin()
• Math asinh()
• Math atan()
• Math atan2()
• Math atanh()
• Math cbrt()
• Math ceil()
• Math copysign()
• Math cosh()
• Math exp2()
• Math expm1()
• Math fabs()
• Math fdim()
• Math floor()
• Math fmax()
• Math fmin()
• Math fmod()
• Math frexp()
• Math hypot()
• Math ilogb()
• Math ldexp()
• Math llrint()
• Math llround()
• Math log10()
• Math log1p()
• Math log2()
• Math logb()
• Math lrint()
• Math lround()
• Math modf()
• Math nearbyint()
• Math nextafter()
• Math nexttoward()
• Math remainder()
• Math remquo()
• Math rint()
• Math round()
• Math scalbln()
• Math scalbn()
• Math sinh()
• Math sqrt()
• Math tanh()
• Math trunc()
• Armstrong number
• Average of three numbers
• Convert decimal to binary
• Factorial of a number
• Factors of a number
• Fibonacci series
• Find largest of three numbers
• Find quotient and remainder
• HCF/GCD of two numbers
• Hello World
• LCM of two numbers
• Maximum of three numbers
• Multiply two numbers
• Sum of two numbers
• Sum of three numbers
• Sum of natural numbers
• Sum of digits in a number
• Swap two numbers
• Palindrome number
• Palindrome string
• Pattern printing
• Power of a number
• Prime number
• Prime Numbers between two numbers
• Print number entered by User
• Reverse a Number
• Read input from user
• ❯ C++ Tutorial
• ❯ C++ Vectors
• ❯ Copy a vector to another

How to copy a vector in C++?

In this C++ tutorial, you shall learn how to copy a vector into another using Assignment Operator, with example programs.

Copy a Vector

To copy a vector into another in C++, we can use Assignment Operator . Assign the given original vector to the new vector (copy), and the expression copies the elements of the original vector to the copy.

The syntax of the statement to copy the original vector vectorX to a new copy vectorXCopy is

C++ Program

In the following program, we take a string vector in fruits , and copy this vector into a new vector say fruitsCopy .

In this C++ Tutorial , we learned how to copy a given vector into another vector, using Assignment Operator.

Popular Courses by TutorialKart

App developement, web development, online tools.

Search anything:

Different ways to copy a vector in C++

Software engineering c++.

Open-Source Internship opportunity by OpenGenus for programmers. Apply now.

Reading time: 30 minutes | Coding time: 5 minutes

An array has a fixed size when it is declared. But if we want a dynamic array whose size can vary at runtime then we use vector. Elements are inserted in vector from end using push_back(). Like arrays, elements in vector are also stored contiguously and they can traversed using iterators. Iterators return pointers to elements.

In this article, we will explore different methods to copy a vector in C++ and all covered methods use deep copy that the memory address of new copy is different from the original vector.

Ways of copying a vector into other

1. iterative method :-.

In this method a loop runs over the old vector and elements are inserted in new vector using push_back().This function inserts elements in vector from back.

Output :- (If inputs are 10,20,30,40)

Old vector elements are : 10 20 30 40 New vector elements are : 10 20 30 40

Complexity :- As the loop traverses all the elements once so complexity is O(n) where n is number of elements in old vector.

2. Assignment operator(=) :-

In this method elements from old vector are inserted into new vector by assigning new vector to old vector. This does not happen in arrays.

Output :- (If inputs are 1,2,3,4) Old vector elements are : 1 2 3 4 New vector elements are : 1 2 3 4

Complexity :- Linear time complexity as elements have to traversed once to assign them to new vector.

3. Passing vector as constructor :-

At the time of declaration of vector, passing old vector as an argument of constructor, copies the elements of passed vector into the newly declared vector.

Output :- Old vector elements are : 1 2 3 4 New vector elements are : 1 2 3 4

Complexity :- O(n) as elements are traversed once when old vector is passed as argument to constructor.

4. Using inbuild functions :-

• copy(first_iterator, last_iterator, back_inserter()) :-

This function takes 3 arguments, the first iterator of old vector, the last iterator of old vector and third is back_inserter function to insert values from back. We can also pass first iterator + number of elements in place of last iterator and last iterator of new vector in place of back_inserter() if we want to copy a certain portion of elements starting from first element of old vector.

Output :- Old vector elements are : 1 2 3 4 New vector elements of v2 are : 1 2 3 4 New vector elements of v3 are : 1 2 3 0

Complexity :- O(n) as copy() takes linear time to traverse elements. But begin(),end() and back_inserter() takes constant time.

• assign(first_iterator, last_iterator) :-

This function takes 2 arguments, first iterator to old vector and last iterator to old vector. It then assigns values of old vector to new vector.

Complexity :- O(n) as assign() takes O(n) time where n is the number of elements in old vector.

Apart from these there are more methods in C++ STL(Standard Template Library) which allows copying of vectors in different manners. They are :-

• copy_n(iterator_source, num, iterator_dest) :

By using this method we can choose how many elements have to be copied to new vector. It takes 3 arguments :-

iterator_source : The pointer to the beginning of source vector, from where elements have to be started copying. num : Integer specifying how many numbers would be copied to destination vector starting from iterator_source. If a negative number is entered, no operation is performed. iterator_dest : The pointer to the beginning of destination vector, to where elements have to be started copying.

Output :- The new vector elements entered using copy_n() : 1 2 3 4 0 0

Complexity :- Best case of O(1) if no traversal is required. Worst case of O(n) if all elements from old vector are copied to new vector.

copy_if() : This function copies elements according to result of a “condition“ which is provided with the help of a 4th argument, a function returning a boolean value. This function takes 4 arguments, 3 of them similar to copy() and additional function, which when returns true, a number is copied, else number is not copied.

copy_backwards() : This function starts copying elements into the destination vector from backwards and keeps on copying till all numbers are not copied. The copying starts from the “iterator_dest” but in backward direction. It also takes similar arguments as copy().

Output :- The new vector elements entered using copy_if() : 1 3 5 0 0 0 The new vector elements entered using copy_backward() : 0 1 2 3 4 0

Complexity :- Best case of O(1) if no traversal required. Worst case of O(n) as in case of copy() function.

All the ways discussed above implements deep copy which means the location address of old and new vector are different. So, when values of old vector are changed, it does not reflect in new vector.

copy_if() takes how many arguments?

It is same as copy() and one extra argument is for the function returning boolean value according to condition (adsbygoogle = window.adsbygoogle || []).push({}); (adsbygoogle = window.adsbygoogle || []).push({}); riya deb.

Read more posts by this author.

Improved & Reviewed by:

How to Copy a Vector Container Object in C++

• How to Copy a Vector Container Object in …

Use the Iterative Method to Copy a Vector in C++

Use the initializer list notation to copy a vector container object in c++, use the std::copy algorithm to copy a vector container object in c++, use the copy assignment operator to copy a vector in c++, use the copy constructor for copying a vector in c++, pass a vector as a constructor to carry out copy operation of a vector in c++, use the copy(first_iterator_o, last_iterator_o, back_inserter()) function to carry out deep copy operations of vectors in c++, use the assign() function to copy a vector in c++, use the insert() function to copy a vector in c++.

Vectors are versatile data structures in C++ that provide dynamic array-like functionality.

Whether you’re working on a small project or a large-scale application, the need to copy vectors arises frequently. Copying a vector allows you to manipulate data without altering the original, making it an important skill for C++ developers.

In this article, we will explore various methods for copying vectors in C++. We will delve into standard library functions, user-defined functions, and modern techniques like the copy constructor and the std::vector assignment operator.

A general method for copying a vector is by making use of a loop to push the elements of the old vector back into a new vector using the push_back() function. We should note that this is one of those rare methods that can implement deep copying of a vector.

This function, which is a pre-defined function in C++, is utilized to load up elements at the end of the given vector. In other words, the elements are pushed from the back into the vector.

The push_back() function is declared inside the <bits/stdc++.h> and the <vector> header files. The syntax for this particular function is as follows:

In the above syntax, the term vector represents the vector to which we have to add elements. This function contains only one parameter, which is the value parameter as seen above, and is utilized to specify the value that needs to be pushed inside at the back of the specified vector.

Consider the following code example:

In the above code, v1 specifies the original vector, and v2 defines the vector in which we need to add the elements by copying it from v1 . The push_back() function is then utilized along with a simple for loop as multiple elements are copied from the v1 vector.

The code proceeds to add the copied elements into v2 and displays them.

As seen in the output above, the push_back() function successfully copies the contents of the v1 vector into the v2 vector. The code also changes the first element of the v1 vector, which, in this case, does not change the value of the v2 vector.

Note: Here, we can observe that a change in the value of one vector did not alter the value of another vector, leading us to assume that both vectors do not exist by having the same address, which is proof enough that the process that is being carried out is, in fact, a deep copy operation.

Initializer list notation in C++ is not limited to just initializing data members; it also offers a concise and expressive way to copy the contents of one vector into another. This notation streamlines the process of creating a new vector by specifying the range of elements to be copied from an existing vector.

In the context of copying vectors, the syntax involves using the std::vector type and passing the begin and end iterators of the original vector within braces {} .

Here, sourceVector represents the original vector from which elements are to be copied, and destinationVector is the new vector being created.

It’s crucial to note that the initializer list does not conclude with a semicolon.

The std::vector is the core data structure provided in the STL containers library. It implements dynamically sized array elements, which are stored contiguously. Memory management is done automatically as the user adds or removes elements from the array.

We can make a copy of the vector object using the initializer list notation when constructing a new variable of the std::vector type. Note that we just need to pass the begin and end iterators of the original vector object that needs to be copied into a new object.

Using the same notation, you can extract any sub-vector of the object by specifying the corresponding iterators as the arguments in the braces.

Let us consider an example code:

In the above code, we make use of the original vector vec1 that we already defined to copy the elements to two fresh vectors, vec1_c and vec1_cc . The first copy, or the vec1_c vector copies all eight elements, while the vec1_cc1 copies the first four elements from the original vector.

As we can see in the output above, both vec1_c and vec1_cc are displayed, which contain eight and four elements, respectively.

Another method to copy the std::vector object is to invoke the std::copy function from the STL algorithms library. It provides the generic copy operation for range-based objects.

To use the C++ STL std::copy() function, you simply need to define the <bits/stdc++.h> header file. The syntax for this particular function is as follows.

Parameters:

• iterator source_begin, iterator source_end : This marks the starting and the ending point of the source container.
• iterator target_begin : This marks the beginning position of the iterator of the target container.

The function has multiple overloads, but the overload utilized in the following code snippet takes three iterator arguments. The first two specify the original vector range, while the third iterator indicates the beginning of the destination vector range.

Let us take a look at the example code below:

The above code makes use of the std::copy algorithm and takes in the original vector vec1 to copy the elements to the newly created vector vec1_c .

The output above displays the contents of the vector vec1_c , which are copied from the vector vec1 .

Alternatively, you can use the copy assignment operator to copy the contents of the std::vector container object. This notation is the most concise solution for this problem.

As the copy assignment operator is a non-static and non-template member, it has multiple forms. Let us consider an operator of class A ; it can have either of the following forms.

This method is relatively simple, as we just need to assign the variable of the original vector to the newly declared vector object. The example code below shows its implementation.

Inside the main function, a new vector, vec1_c , is declared and initialized with the elements of the original vector, vec1 , using the copy assignment operator. This results in a shallow copy of the original vector, meaning both vectors now share the same underlying elements.

As we can see, the output above displays the elements of the newly created vector vec1_c that have been copied from the already existing vector vec1 .

Initializing an object with the help of another object of the same class is what the copy constructor is mainly utilized for. The syntax of the copy constructor is as follows:

Inside the copy constructor, you typically copy the data members from the old_object to the current object.

The const qualifier ensures that the original object ( old_object ) is not modified during the copy process. This method is a viable option when working on any version after C++ 11.

A copy constructor of the std::vector class offers a similar method to copy the vector into a newly declared vector object. In this case, we need to pass the variable of the original vector into the parentheses when the newly created vector variable is declared.

In this example, the main function has a copy constructor that initializes a new vec1_c vector by copying the values from an existing vector vec1 .

The output of this code displays the contents of the new vector vec1_c , the elements of which have been copied from the vector vec1 with the help of the copy constructor.

Another efficient approach to copy the contents of a vector is by passing an already initialized vector as a constructor parameter. This method not only simplifies the copying process but also facilitates a deep copy operation, ensuring that modifications to the original vector do not affect the newly created one.

Take a look at the example code below:

In this code, the first vector, v1 , is initialized with some elements, and then a new vector, v2 , is created by passing v1 as a constructor. The output verifies that the elements of both vectors are initially identical.

Subsequently, the code modifies the first element of the original vector ( v1[0] ), and by examining the first element of both vectors afterward, it demonstrates the deep copy operation, highlighting that changes to the original vector do not affect the newly created vector.

This output highlights the effectiveness of passing a vector as a constructor for copy operations in C++, providing a clean and reliable mechanism for duplicating vector contents.

In C++, the copy() function, coupled with back_inserter() , offers another efficient way to conduct deep copy operations on vectors. This function requires three necessary arguments:

• The first iterator of the original specified vector.
• The last iterator of the original specified vector.
• The back_inserter() function, which appends the values to the new vector from last to first.

Consider the following illustrative code:

Here, the copy() function is used to copy the elements from the beginning ( v1.begin() ) to the end ( v1.end() ) of the original vector v1 into the new vector v2 . The back_inserter() function is then used as the third argument to ensure that elements are appended to v2 from the back, facilitating a deep copy.

Subsequently, the code displays the elements of both the original and the newly created vectors, providing a clear visual confirmation of the successful deep copy operation. Following this display, the code modifies the first element of the original vector ( v1[0] = 2 ), and it then compares and displays the first elements of both vectors to emphasize that modifications to the original vector do not impact the copied vector.

We should also note that this method requires heavy use of the for loop alongside the specified function.

The output above displays the elements of both the original and the copied vector and also provides proof for checking that it is a deep copy operation.

The assign() function serves as a versatile tool for assigning new values to a vector, making it a powerful choice for copying vector contents. This function offers two syntax options:

In the first syntax, (first, last) defines a range, where first points to the first element, and last refers to the last element. The second syntax involves n , specifying the number of times a particular value ( val ) should occur in the vector.

The std::vector container provides the assign() member function, enabling the replacement of one vector’s contents with the elements of another vector. Notably, this can be achieved by initializing an empty vector and then invoking the assign() function to copy the contents of another vector.

Consider the following example code:

In this example, the assign() function is used to copy the elements from the original vector vec1 into the new vector vec1_c . The code then displays the elements of the copied vector, showcasing the successful copying process.

As we see, the elements of the copied vector vec1_c are displayed. The process is a shallow copy process and, therefore, is not checked further.

The insert() function is a standard vector class function that can be utilized in cases where we are dealing with a specified range of elements that need to be copied.

Let us consider a vector x . Below is the syntax for the insert() function:

• iterator : This defines the position in which the new elements will be inserted.
• val : This marks the value that needs to be inserted. It can be multiple when used with a for loop.
• n : This marks the number of times that we need to insert the values.
• (first, last) : This marks the specified range of elements that need to be inserted.

Let’s take an example code:

Here, the insert() function is used to copy the elements from the beginning ( v1.begin() ) to the end ( v1.end() ) of the original vector v1 into the new vector v2 . Following this, the code proceeds to display the elements of both the original and the newly created vectors using cout statements and a for loop.

To further validate that a deep copy operation has taken place, the code modifies the first element of the original vector ( v1[0] = 2 ) and subsequently compares and displays the first elements of both vectors.

The output displays both vectors and verifies if the carried-out process is a deep copy operation or not.

Note: The insert() function is also a method that can carry out deep copy operations.

In conclusion, copying vectors in C++ offers a variety of methods, each catering to different needs and scenarios.

The iterative method, employing a loop and the push_back() function, stands out for its simplicity and capability to perform deep copy operations. On the other hand, the std::copy algorithm, the copy constructor, and the assign() function provide straightforward and efficient options suitable for most use cases, creating shallow copies that are easy to understand.

The assignment operator offers a concise way to replace the contents of an existing vector, whereas passing a vector as a constructor provides a simple method for deep copying. The copy(first_iterator_o, last_iterator_o, back_inserter()) function and the insert() function are efficient copy methods, especially for smaller vectors or specified ranges.

While the initializer list notation method is versatile and applicable to vectors of any size, its complexity might pose challenges for beginners. In most cases, the copy constructor is recommended for its simplicity, clarity, and efficiency in creating vector copies.

It’s important to consider the specific requirements of your project when choosing a vector copying method in C++. Each method has its strengths and trade-offs, and understanding the context will guide you toward the most appropriate choice for your programming needs.

Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.

Related Article - C++ Vector

• How to Iterate Through a Vector in C++
• Vector Iterator in C++
• How to Resize 2D Vector C++
• How to Calculate Angle Between Two Vectors in C++
• How to Deallocate a std::vector Object in C++
• Multidimensional Vectors in C++

• <cassert> (assert.h)
• <cctype> (ctype.h)
• <cerrno> (errno.h)
• C++11 <cfenv> (fenv.h)
• <cfloat> (float.h)
• C++11 <cinttypes> (inttypes.h)
• <ciso646> (iso646.h)
• <climits> (limits.h)
• <clocale> (locale.h)
• <cmath> (math.h)
• <csetjmp> (setjmp.h)
• <csignal> (signal.h)
• <cstdarg> (stdarg.h)
• C++11 <cstdbool> (stdbool.h)
• <cstddef> (stddef.h)
• C++11 <cstdint> (stdint.h)
• <cstdio> (stdio.h)
• <cstdlib> (stdlib.h)
• <cstring> (string.h)
• C++11 <ctgmath> (tgmath.h)
• <ctime> (time.h)
• C++11 <cuchar> (uchar.h)
• <cwchar> (wchar.h)
• <cwctype> (wctype.h)

Containers:

• C++11 <array>
• <deque>
• C++11 <forward_list>
• <list>
• <map>
• <queue>
• <set>
• <stack>
• C++11 <unordered_map>
• C++11 <unordered_set>
• <vector>

Input/Output:

• <fstream>
• <iomanip>
• <ios>
• <iosfwd>
• <iostream>
• <istream>
• <ostream>
• <sstream>
• <streambuf>

Multi-threading:

• C++11 <atomic>
• C++11 <condition_variable>
• C++11 <future>
• C++11 <mutex>
• C++11 <thread>
• <algorithm>
• <bitset>
• C++11 <chrono>
• C++11 <codecvt>
• <complex>
• <exception>
• <functional>
• C++11 <initializer_list>
• <iterator>
• <limits>
• <locale>
• <memory>
• <new>
• <numeric>
• C++11 <random>
• C++11 <ratio>
• C++11 <regex>
• <stdexcept>
• <string>
• C++11 <system_error>
• C++11 <tuple>
• C++11 <type_traits>
• C++11 <typeindex>
• <typeinfo>
• <utility>
• <valarray>
• adjacent_find
• C++11 all_of
• C++11 any_of
• binary_search
• copy_backward
• C++11 copy_if
• C++11 copy_n
• equal_range
• find_first_of
• C++11 find_if_not
• inplace_merge
• C++11 is_heap
• C++11 is_heap_until
• C++11 is_partitioned
• C++11 is_permutation
• C++11 is_sorted
• C++11 is_sorted_until
• lexicographical_compare
• lower_bound
• max_element
• min_element
• C++11 minmax
• C++11 minmax_element
• C++11 move_backward
• next_permutation
• C++11 none_of
• nth_element
• partial_sort
• partial_sort_copy
• C++11 partition_copy
• C++11 partition_point
• prev_permutation
• random_shuffle
• remove_copy
• remove_copy_if
• replace_copy
• replace_copy_if
• reverse_copy
• rotate_copy
• set_difference
• set_intersection
• set_symmetric_difference
• C++11 shuffle
• stable_partition
• stable_sort
• swap_ranges
• unique_copy
• upper_bound

Return value

• Data Structure
• Coding Problems
• C Interview Programs
• C++ Aptitude
• Java Aptitude
• C# Aptitude
• PHP Aptitude
• Linux Aptitude
• DBMS Aptitude
• Networking Aptitude
• AI Aptitude
• MIS Executive
• Web Technologie MCQs
• CS Subjects MCQs
• Databases MCQs
• Programming MCQs
• Testing Software MCQs
• Digital Mktg Subjects MCQs
• Cloud Computing S/W MCQs
• Engineering Subjects MCQs
• Commerce MCQs
• More MCQs...
• Machine Learning/AI
• Operating System
• Computer Network
• Software Engineering
• Discrete Mathematics
• Digital Electronics
• Data Mining
• Embedded Systems
• Cryptography
• CS Fundamental
• More Tutorials...
• Tech Articles
• Code Examples
• Programmer's Calculator
• XML Sitemap Generator
• Tools & Generators

Home » C++ STL

Different ways to copy a vector in C++

C++ STL | Copying a vector : Learn - different ways to copy a vector in C++ STL, Shallow copy vs Deep copy, Different copy methods, etc. Submitted by Radib Kar , on July 07, 2020

In this article, we are going to see how to copy a vector into another vector in various ways? We will also learn about shallow copy and deep copy , their differences, and consequences while checking each of the vector copy methods.

Before starting with the methods for copying a vector into the other, let's discuss what shallow copy and deep copy are. What are differences b/w them, and why do we need two different terms to classify the copy process.

Shallow copy vs Deep copy

A vector is essentially an object which has some memory allocation upon execution. Now say you have defined and declared some vector A and you want to copy the content of A into another vector B . Now, there can be two cases, one case is we define a new vector B , but doesn't allocate any new memory for that, rather just link up to the vector A similar like vector B is pointing to the same location of vector A . Thus it has the same copy of vector A . This is known as a shallow copy. If we make any changes to vector A even after our copy operation is done, vector B will have the same changes which are not intended.

On the other hand, when we create a new location for vector B and copy contents from vector A , then it's known as deep copy . If we make any change to vector A after the copy operation it won't be reflected in vector B which is of course intended.

While discussing the copy method we will detail whether it's a shallow copy or deep copy and why so that you never make any mistake using the copy method and guess it's a deep copy ! (yes we often intend to have a deep copy normally).

Different copy methods

1) copy content iteratively.

Here we simply copy the contents of vector A into vector B iteratively. Vector B is defined as a new location, so it's of course a deep copy. We have verified that too by changing elements after our copy operation.

Example code:

2) Copy content recursively

Here we simply copy the contents of vector A into vector B recursively. Vector B is defined as a new location, so it's of course a deep copy. We have verified that too by changing elements after our copy operation.

3) Using assignment operator "=" (overwriting the current contents)

Another way to copy a vector into another is by using the assignment operator. Yes, it works perfectly! Don't try this at all for static array!. The reason behind why such assignment operator works because it simply overwrites the current members if any available, else assigns the value from where it's being copied. Below is an example and we can see, it's a deep copy.

Note: In Java, assignment operator does a shallow copy only.

4) Using copy constructor

We can also pass the vector A as a constructor to vector B which will invoke copy constructor and serve a deep copy .

5) std::copy() function

There is another method using the std function copy() . Though it's less used you should know a variety of functions the C++ standard library has. And yes, it does a deep copy. The copy function takes three argument

The first one is: iterator from where copy will be started: beginning of vector A

The second one is: iterator to where copy will be ended: the end of vector A

The third one is: output iterator which points to destination vector: beginning of Vector B

So the syntax is,

A very important note about the above code:

Check here I have defined vector B as vector<int> B(5) , but if you look in earlier codes you will find I had defined like vector<int> B

Now the question is why I made the change this time. Is there any reason or I just did that! Okay, let's say we do the same as before.

Then the code will be:

Oops! The output is segmentation fault! . Why? Probably now you get the point. Whenever we write vector<int> B the vector has no idea about how many elements will be there and it doesn't allocate memory for elements at all. But in our copy function there is the output iterator which tries to traverse vector B, but fails as no memory allocated for elements. That's why segmentation fault and we need to allocate memory, rather say define the vector along with its elements. That's why we need vector<int> B(5) . Go through my article on vector initialization methods to know in details about this. Oops, one little mistake can lead you to segmentation fault and you may just get insane to find the bug! Nice lesson I hope.

6) vector::assign() function

Vector has an inbuilt function too to copy contents from other content. It's named assign() function. It's again a deep copy method.

The syntax is like below,

Okay, that's all. So, we found all the copy methods actually do a good job as they all do deep copy and we can use any one of them blindly. Do comment and let us know which copy method you would prefer and why?

Related Tutorials

• Create and initialize a vector using different ways in C++ STL
• Access vector elements using for each loop in C++ STL
• Different ways to access elements from a Vector in C++ STL
• vector::size() function with example in C++ STL
• vector::max_size() function with example in C++ STL
• vector::resize() function with example in C++ STL
• vector::capacity() function with example in C++ STL
• vector::empty() function with example in C++ STL
• vector::reserve() function with example in C++ STL
• vector::shrink_to_fit() function with example in C++ STL
• vector::swap() function with Example in C++ STL
• Push and print elements in an integer vector in C++ STL
• Push and print elements in a float vector in C++ STL
• Check vector is empty or not | C++ STL
• Copy a vector to another in C++
• Copy a vector to another by using vector.assign() function in C++
• Erase elements in C++ Vector using vector::erase()
• Find largest and smallest elements in a vector | C++ STL
• Insert elements in vector using vector::insert() | C++ STL
• C++ STL sort function to sort an array or vector
• Appending a vector to a vector in C++ STL
• Difference between size and capacity of a vector in C++ STL
• Minimum and maximum elements of a vector in C++ STL
• How to find the maximum/largest element of a vector in C++ STL?
• How to find the minimum/smallest element of a vector in C++ STL?
• How to reverse vector elements in C++ STL?
• How to find the sum of elements of a vector in C++ STL?
• How to join two vectors in C++ STL?
• How to find common elements between two Vectors using in C++ STL?
• How to copy array elements to a vector in C++ STL?
• Changing a particular element of a vector in C++ STL
• 2D vector in C++ STL with user defined size
• How to check whether an element exists in a vector in C++ STL?

Comments and Discussions!

Load comments ↻

• Marketing MCQs
• Blockchain MCQs
• Artificial Intelligence MCQs
• Data Analytics & Visualization MCQs
• Python MCQs
• C++ Programs
• Python Programs
• Java Programs
• D.S. Programs
• Golang Programs
• C# Programs
• JavaScript Examples
• jQuery Examples
• CSS Examples
• C++ Tutorial
• Python Tutorial
• ML/AI Tutorial
• MIS Tutorial
• Software Engineering Tutorial
• Scala Tutorial
• Privacy policy
• Certificates
• Content Writers of the Month

Copyright © 2024 www.includehelp.com. All rights reserved.

How vector works - copy vs. move

When a vector resizes and needs to transfer existing values to the larger array: does it copy or does it move them? It’s more complicated than it should be.

In the previous articles I used ambiguous expressions such as “move/copy” when referring to the transfer of existing values when resizing a vector. This article explains why.

Pre C++11 the vector would copy on resize. That’s not a problem for built-in types like int s that can just be bitwise copied.

But vectors of containers, such as std::vector<std::string> would usually have to copy the values on resize. The library could have done something special about types it knew, such as std::string , but it will have to copy when faced with new types, even as simple as:

Also there are types that hold a resource, which are not copyable. Pre C++11 such types would have private copy operations to prevent accidental copying, but then they could not be stored easily in containers such as std::vector .

C++ 11 introduces the move semantics.

That means that std::vector<std::string> moves the std::string values instead of copying when it resizes, even if they are inside structures as some_struct above.

Also C++ 11 comes with std::unique_ptr , which can be put in a vector, i.e. std::vector<std::unique_ptr<int>> . The std::unique_ptr values are moved when the vector resizes. Note that you can’t take a copy of a std::vector<std::unique_ptr<int>> as the std::unique_ptr can’t be copied.

So it’s all good, right?

Standardese

It turns out it’s very difficult to determine based on the standard if a values of a vector are moved or copied. For example you might get that the choice depends on the result of !std::is_nothrow_move_constructible_v<T> && std::is_copy_constructible_v<T> .

But then it gets complicated. For example for std::is_move_constructible on which the nothrow version is based has edge cases where it returns true even if there is no move constructor, because types without a move constructor, but with a copy constructor that accepts const T & arguments, satisfy std::is_move_constructible .

Also std::is_copy_constructible returns true for types that cannot be copied e.g. std::vector<std::unique_ptr<int>> . In this case the std::vector has a copy constructor, which actually can’t be instantiated successfully.

Recommended idiom

But all this standardese is irrelevant if types that you might put into a container have a non throwing move constructor. That is a good idiom to follow:

• For low level classes, e.g. for RAII classes, for your own container classes, ensure you have a non-trowing move which just transfer ownership involving copying of handles/pointers and invalidating the ones at the source of the move. These operations don’t involve anything that might throw. Mark the move constructor and assignment as noexcept .
• For the rest of classes let the compiler generate moves. They will be noexcept assuming only types as above are used.

However there are also cases where move could throw.

One example is if you use certain kinds of allocators and you “move” from a container that uses a allocator in some area of memory to a container with allocation in some other area of memory. That “move” really involves copy, which means it might throw if allocations fail. If you don’t use custom allocators this does not apply to your application.

Containers with dynamically allocated sentinel

However there is another case that involves standard containers such as std::list , std::deque , std::map etc. even if custom allocators are not involved.

For example Microsoft’s std::list can throw in move constructors.

This is due to a combination of design decissions that end up having consequences.

• It uses a dynamically allocated sentinel: the dummy node with two pointers next and prev , but value. This has the advantage that it provides an end iterator that does not get invalidated in a variety of scenarios. E.g. the end iterator for std::vector gets invalidated on resizes, inserts etc.
• It does not have “moved from” state that is different from an empty container. This is a dubious decision, but I believe it’s mandated by the standard and would be difficult to change. A much better idiom would have been to say “moved from objects can be destroyed or assigned to, but not usable otherwise”.
• The way the move semantics is implemented in C++: the move constructor does not know if/how the “moved from” object will be used.

Therefore a vector of container with dynamically allocated sentinel, e.g. Microsoft’s std::vector<std::list<int>> , copies the values on a push_back resize, in order to maintain the strong guarantees, in face of the Microsoft’s std::list not having a noexcept move constructor.

It turns out that many other of Microsoft’s standard containers have the same issue std::map , std::unordered_map , std::deque etc.

g++ seems to kind of avoid this issue except for std::deque . To complicate further, std::vector<std::deque<int>> is fine, because of a special treatment.

However for both:

NOTE: I used Microsoft vs g++ compilers as a oversimplification. More precisely, the behaviour depends on the standard library implementation, not on the compiler. For a survey of container noexcept behaviour see:

Howard E. Hinnant: Container Survey - 2015-06-27

Ville Voutilainen et al. N4055: Ruminations on (node-based) containers and noexcept - 2014-07-02

Testing the vector behaviour source code .

cppreference.com

Std::vector<t,allocator>:: vector.

Constructs a new container from a variety of data sources, optionally using a user supplied allocator alloc .

[ edit ] Parameters

[ edit ] complexity.

• If first and last are both forward, bidirectional or random-access iterators,
• The copy constructor of T is only called N   times, and
• No reallocation occurs.
• Otherwise ( first and last are just input iterators),
• The copy constructor of T is called O(N) times, and
• Reallocation occurs O(log N) times.
• If R models ranges::forward_range or ranges::sized_range ,
• Initializes exactly N elements from the result of dereferencing successive iterators of rg , and
• Otherwise ( R models input range),
• The copy or move constructor of T is called O(N) times, and

[ edit ] Exceptions

Calls to Allocator :: allocate may throw.

[ edit ] Notes

After container move construction (overload (8) ), 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 [container.reqmts]/67 , and a more direct guarantee is under consideration via LWG issue 2321 .

The overload (4) zeroes out elements of non-class types such as int , which is different from the behavior of new[] , which leaves them uninitialized. To match the behavior of new [ ] , a custom Allocator::construct can be provided which leaves such elements uninitialized.

Note that the presence of list-initializing constructor (10) means list initialization and direct initialization do different things:

[ edit ] Example

[ edit ] defect reports.

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[ edit ] See also

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 5 November 2023, at 12:01.
• This page has been accessed 2,247,166 times.
• Privacy policy
• About cppreference.com
• Disclaimers