In C++ vectors are dynamic arrays. Unlike arrays, they don’t have a fixed size. They can grow or shrink as required. Vectors are assigned memory in blocks of contiguous locations. When the memory allocated for the vector falls short of storing new elements, a new memory block is allocated to vector and all elements are copied from the old location to the new location. This reallocation of elements helps vectors to grow when required. However, it is a costly operation and time complexity is involved in this step is linear.

**std::vector** class provides a useful function **reserve** which helps user specify the minimum size of the vector.It indicates that the vector is created such that it can store at least the number of the specified elements without having to reallocate memory.

**std::vector::reserve**

void reserve(size_type n) Return Type: none Arguments: n which denotes the no of elements to be stored in vector Requests that vector is large enough to store n elements in the least. If the current vector capacity is less than n, then reallocation will take place. In other cases, reallocation will not happen. Function does not modify existing elements in the vector

Each vector object has two parameters–size and capacity. The size denotes the number of elements currently stored in the vector while capacity is the maximum number of elements that the vector can store without reallocation. Evidently capacity >= size. When the vector runs out of space to store new elements i.e when size is becoming greater than capacity, the runtime library will request fresh memory from the heap and once memory is allocated, it will copy all elements in the vector from their old addresses to the newly allocated memory address. A call to the function reserve modifies the capacity parameter of the vector and so the vector requests sufficient memory to store the specified number of elements.

Here is a program to demonstrate the performance improvement that can be obtained by using reserve function. In this program, we fill two vectors with a large number of elements and count the time taken to perform this step. For the first vector, we don’t specify the capacity, while for the second vector we specify the capacity using reserve().

`// CPP program to demonstrate use of ` `// std::vector::reserve ` `#include <chrono> ` `#include <iostream> ` `#include <vector> ` ` ` `using` `std::vector; ` `using` `std::cout; ` `using` `namespace` `std::chrono; ` ` ` `int` `main() ` `{ ` ` ` `// No of charactes ` ` ` `int` `N = (` `int` `)1e6; ` ` ` ` ` `vector<` `int` `> v1, v2; ` ` ` ` ` `// Reserve space in v2 ` ` ` `v2.reserve(N); ` ` ` ` ` `// Start filling up elements in v1 ` ` ` `// To measure execution time in C++, refer below ` ` ` ` ` `auto` `start = high_resolution_clock::now(); ` ` ` `for` `(` `int` `i = 0; i < N; ++i) ` ` ` `v1.push_back(i); ` ` ` `auto` `stop = high_resolution_clock::now(); ` ` ` `auto` `duration = duration_cast<microseconds>(stop - start); ` ` ` ` ` `cout << ` `"Method I took "` `<< duration.count() << ` `" microseconds\n"` `; ` ` ` ` ` `// Start filling up elements in v2 ` ` ` `start = high_resolution_clock::now(); ` ` ` `for` `(` `int` `i = 0; i < N; ++i) ` ` ` `v2.push_back(i); ` ` ` `stop = high_resolution_clock::now(); ` ` ` `duration = duration_cast<microseconds>(stop - start); ` ` ` ` ` `cout << ` `"Method II took "` `<< duration.count() ` ` ` `<< ` `" microseconds \n"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

Output: (Machine Dependent)

Method I took 18699 microseconds Method II took 16276 microseconds

**Note:**

It is guaranteed that reserving space beforehand will take less time than trying to insert the elements without specifying the size of the vector. Further, it adds semantic utility to the code and we get to know at least how large the vector is going to be.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Remove first adjacent pairs of similar characters until possible
- All possible values of floor(N/K) for all values of K
- Count number of unique Triangles using STL | Set 1 (Using set)
- Queue using Stacks
- Sort a stack using recursion
- Kruskal's Minimum Spanning Tree using STL in C++
- Dijkstra’s shortest path algorithm using set in STL
- Dijkstra's Shortest Path Algorithm using priority_queue of STL
- Prim's algorithm using priority_queue in STL
- Permutations of a given string using STL
- std::tuple, std::pair | Returning multiple values from a function using Tuple and Pair in C++
- Merge operations using STL in C++ | merge(), includes(), set_union(), set_intersection(), set_difference(), ., inplace_merge,
- Counts of distinct consecutive sub-string of length two using C++ STL
- Graph implementation using STL for competitive programming | Set 1 (DFS of Unweighted and Undirected)
- Graph implementation using STL for competitive programming | Set 2 (Weighted graph)
- Convert an array to reduced form | Set 2 (Using vector of pairs)
- Counting Inversions using Set in C++ STL
- How to implement Min Heap using STL?
- Print prime numbers in a given range using C++ STL
- Searching in a map using std::map functions in C++

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.