Htfukiy

After all, they do the same thing. Don't they?

No. They are different. The first method using std::vector::push_back will undergo several reallocations compared to std::vector::insert.

The insert will internally allocate memory, according to the current std::vector::capacity before copying the range. See the following discussion for more:

Does std::vector::insert reserve by definition?

But is there any difference in performance?

Due to the reason explained above, the second method would show slight performance improvement.

For instance, see the quick benck-mark below, using http://quick-bench.com:

See online bench-mark

// Method 1: push_back
std::vector<int> vec = { 1 };
vec.push_back(2);
vec.push_back(3);
vec.push_back(4);
vec.push_back(5);

// Method 2: insert_range
std::vector<int> vec = { 1 };
int arr[] = { 2,3,4,5 };
vec.insert(std::end(vec), std::begin(arr), std::end(arr))

There may be a difference between the two approaches if the vector needs to reallocate.

Your second method, calling the insert() member function once with an iterator range:

vec.insert(std::end(vec), std::begin(arr), std::end(arr));

would be able to provide the optimisation of allocating all the memory needed for the insertion of the elements in one blow since insert() is getting random access iterators, i.e., it takes constant time to know the size of the range, so the whole memory allocation can be done before copying the elements, and no reallocations during the call would follow.

Your first method, individual calls to the push_back() member function, may trigger several reallocations, depending on the number of elements to insert and the memory initially reserved for the vector.

Note that the optimisation explained above may not be available for forward or bidirectional iterators since it would take linear time in the size of the range to know the number of elements to be inserted. However, the time needed for multiple memory allocations likely dwarfs the time needed to calculate the length of the range for these cases, so probably they still implement this optimisation. For input iterators, this optimisation is not even possible since they are single-pass iterators.

push_back inserts a single element, hence in the worst case you may encounter multiple reallocations.

For the sake of the example, consider the case where the initial capacity is 2 and increases by a factor of 2 on each reallocation. Then

std::vector<int> vec = { 1 }; 
vec.push_back(2);             
vec.push_back(3);                 // need to reallocate, capacity is 4
vec.push_back(4);                   
vec.push_back(5);                  // need to reallocate, capacity is 8

You can of course prevent unnecessary reallocations by calling

vec.reserve(num_elements_to_push);

Though, if you anyhow insert from an array, the more idomatic way is to use insert.

The major contributing factor is going to be the re-allocations. vector has to make space for new elements.

Consider these 3 sinppets.

 //pushback
 std::vector<int> vec = {1};
 vec.push_back(2);
 vec.push_back(3);
 vec.push_back(4);
 vec.push_back(5);

 //insert
 std::vector<int> vec = {1};
 int arr[] = {2,3,4,5};
 vec.insert(std::end(vec), std::begin(arr), std::end(arr));


 //cosntruct
 std::vector<int> vec = {1,2,3,4,5};

To confirm the reallocations coming into picture, after adding a vec.reserve(5) in pushback and insert versions, we get the below results.