⚡C++ Programming

<vector> Reference

Updated 2026-05-12

30 min read

<vector> Reference

The <vector> container is one of the most commonly used containers in C++ due to its dynamic array capabilities. It provides a flexible way to store elements that can grow and shrink as needed, making it ideal for applications where the number of elements isn't known at compile time.

In this tutorial, we'll explore all the essential methods provided by the <vector> container, including push_back, pop_back, insert, erase, resize, reserve, capacity, shrink_to_fit, data, and emplace. Understanding these methods will help you effectively manage dynamic arrays in your C++ programs.

Introduction

The <vector> container is part of the Standard Template Library (STL) and provides a dynamic array that can resize itself automatically when elements are added or removed. This makes it a versatile choice for various programming tasks, from simple data storage to complex algorithms.

In this tutorial, we'll cover each method in detail, providing clear explanations, code examples, and expected outputs. By the end of this guide, you'll have a solid understanding of how to use <vector> effectively in your C++ projects.

Core Content

1. `push_back`

The push_back method adds an element to the end of the vector.

Example:

push_back.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  vec.push_back(10);
7  vec.push_back(20);
8 
9  for (int num : vec) {
10      std::cout << num << " ";
11  }
12 
13  return 0;
14}

Output:

Output

10 20

2. `pop_back`

The pop_back method removes the last element from the vector.

Example:

pop_back.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.pop_back();
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20

3. `insert`

The insert method adds an element at a specified position in the vector.

Example:

insert.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  auto it = vec.insert(vec.begin() + 1, 15);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 15 20 30

4. `erase`

The erase method removes an element from a specified position in the vector.

Example:

erase.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  auto it = vec.erase(vec.begin() + 1);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 30

5. `resize`

The resize method changes the size of the vector to a specified number of elements.

Example:

resize.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.resize(2);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20

6. `reserve`

The reserve method allocates enough memory to hold a specified number of elements, without changing the size of the vector.

Example:

reserve.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  vec.reserve(10);
7 
8  std::cout << "Capacity: " << vec.capacity() << std::endl;
9 
10  return 0;
11}

Output:

Output

Capacity: 10

7. `capacity`

The capacity method returns the maximum number of elements that the vector can hold without needing to reallocate memory.

Example:

capacity.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  std::cout << "Capacity: " << vec.capacity() << std::endl;
7 
8  return 0;
9}

Output:

Output

Capacity: 4

8. `shrink_to_fit`

The shrink_to_fit method reduces the capacity of the vector to fit its size, freeing up memory.

Example:

shrink_to_fit.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.reserve(10);
7  std::cout << "Capacity before shrink_to_fit: " << vec.capacity() << std::endl;
8 
9  vec.shrink_to_fit();
10  std::cout << "Capacity after shrink_to_fit: " << vec.capacity() << std::endl;
11 
12  return 0;
13}

Output:

Output

Capacity before shrink_to_fit: 10
Capacity after shrink_to_fit: 3

9. `data`

The data method returns a pointer to the underlying array used by the vector.

Example:

data.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  int* arr = vec.data();
7 
8  for (size_t i = 0; i < vec.size(); ++i) {
9      std::cout << arr[i] << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20 30

10. `emplace`

The emplace method constructs an element in-place at a specified position, avoiding unnecessary copying or moving of elements.

Example:

emplace.cpp

1#include <iostream>
2#include <vector>
3#include <string>
4 
5int main() {
6  std::vector<std::string> vec;
7  vec.emplace_back("Hello");
8  vec.emplace_back("World");
9 
10  for (const auto& str : vec) {
11      std::cout << str << " ";
12  }
13 
14  return 0;
15}

Output:

Output

Hello World

Practical Example

Let's put all these methods together in a practical example. We'll create a program that manages a list of integers, allowing users to add, remove, and display elements.

vector_practical.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  int choice, num;
7 
8  while (true) {
9      std::cout << "1. Add element
102. Remove last element
113. Display elements
124. Exit
13";
14      std::cout << "Enter your choice: ";
15      std::cin >> choice;
16 
17      switch (choice) {
18          case 1:
19              std::cout << "Enter an integer to add: ";
20              std::cin >> num;
21              vec.push_back(num);
22              break;
23          case 2:
24              if (!vec.empty()) {
25                  vec.pop_back();
26              } else {
27                  std::cout << "Vector is empty!" << std::endl;
28              }
29              break;
30          case 3:
31              for (int n : vec) {
32                  std::cout << n << " ";
33              }
34              std::cout << std::endl;
35              break;
36          case 4:
37              return 0;
38          default:
39              std::cout << "Invalid choice!" << std::endl;
40      }
41  }
42 
43  return 0;
44}

Summary

Method	Description
`push_back`	Adds an element to the end of the vector.
`pop_back`	Removes the last element from the vector.
`insert`	Inserts an element at a specified position in the vector.
`erase`	Removes an element from a specified position in the vector.
`resize`	Changes the size of the vector to a specified number of elements.
`reserve`	Allocates enough memory to hold a specified number of elements.
`capacity`	Returns the maximum number of elements that the vector can hold without reallocating.
`shrink_to_fit`	Reduces the capacity of the vector to fit its size, freeing up memory.
`data`	Returns a pointer to the underlying array used by the vector.
`emplace`	Constructs an element in-place at a specified position, avoiding unnecessary copying or moving.

What's Next?

Now that you have a comprehensive understanding of the <vector> container and its methods, you can move on to learning about other STL containers and algorithms. The next topic is "<algorithm> Reference," where we'll explore various algorithms available in the C++ Standard Library and how to use them effectively.

Stay tuned for more tutorials and happy coding!

⚡C++ Programming

<vector> Reference

Updated 2026-05-12

30 min read

<vector> Reference

Introduction

Core Content

1. `push_back`

The push_back method adds an element to the end of the vector.

Example:

push_back.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  vec.push_back(10);
7  vec.push_back(20);
8 
9  for (int num : vec) {
10      std::cout << num << " ";
11  }
12 
13  return 0;
14}

Output:

Output

10 20

2. `pop_back`

The pop_back method removes the last element from the vector.

Example:

pop_back.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.pop_back();
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20

3. `insert`

The insert method adds an element at a specified position in the vector.

Example:

insert.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  auto it = vec.insert(vec.begin() + 1, 15);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 15 20 30

4. `erase`

The erase method removes an element from a specified position in the vector.

Example:

erase.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  auto it = vec.erase(vec.begin() + 1);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 30

5. `resize`

The resize method changes the size of the vector to a specified number of elements.

Example:

resize.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.resize(2);
7 
8  for (int num : vec) {
9      std::cout << num << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20

6. `reserve`

The reserve method allocates enough memory to hold a specified number of elements, without changing the size of the vector.

Example:

reserve.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  vec.reserve(10);
7 
8  std::cout << "Capacity: " << vec.capacity() << std::endl;
9 
10  return 0;
11}

Output:

Output

Capacity: 10

7. `capacity`

The capacity method returns the maximum number of elements that the vector can hold without needing to reallocate memory.

Example:

capacity.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  std::cout << "Capacity: " << vec.capacity() << std::endl;
7 
8  return 0;
9}

Output:

Output

Capacity: 4

8. `shrink_to_fit`

The shrink_to_fit method reduces the capacity of the vector to fit its size, freeing up memory.

Example:

shrink_to_fit.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  vec.reserve(10);
7  std::cout << "Capacity before shrink_to_fit: " << vec.capacity() << std::endl;
8 
9  vec.shrink_to_fit();
10  std::cout << "Capacity after shrink_to_fit: " << vec.capacity() << std::endl;
11 
12  return 0;
13}

Output:

Output

Capacity before shrink_to_fit: 10
Capacity after shrink_to_fit: 3

9. `data`

The data method returns a pointer to the underlying array used by the vector.

Example:

data.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec = {10, 20, 30};
6  int* arr = vec.data();
7 
8  for (size_t i = 0; i < vec.size(); ++i) {
9      std::cout << arr[i] << " ";
10  }
11 
12  return 0;
13}

Output:

Output

10 20 30

10. `emplace`

The emplace method constructs an element in-place at a specified position, avoiding unnecessary copying or moving of elements.

Example:

emplace.cpp

1#include <iostream>
2#include <vector>
3#include <string>
4 
5int main() {
6  std::vector<std::string> vec;
7  vec.emplace_back("Hello");
8  vec.emplace_back("World");
9 
10  for (const auto& str : vec) {
11      std::cout << str << " ";
12  }
13 
14  return 0;
15}

Output:

Output

Hello World

Practical Example

Let's put all these methods together in a practical example. We'll create a program that manages a list of integers, allowing users to add, remove, and display elements.

vector_practical.cpp

1#include <iostream>
2#include <vector>
3 
4int main() {
5  std::vector<int> vec;
6  int choice, num;
7 
8  while (true) {
9      std::cout << "1. Add element
102. Remove last element
113. Display elements
124. Exit
13";
14      std::cout << "Enter your choice: ";
15      std::cin >> choice;
16 
17      switch (choice) {
18          case 1:
19              std::cout << "Enter an integer to add: ";
20              std::cin >> num;
21              vec.push_back(num);
22              break;
23          case 2:
24              if (!vec.empty()) {
25                  vec.pop_back();
26              } else {
27                  std::cout << "Vector is empty!" << std::endl;
28              }
29              break;
30          case 3:
31              for (int n : vec) {
32                  std::cout << n << " ";
33              }
34              std::cout << std::endl;
35              break;
36          case 4:
37              return 0;
38          default:
39              std::cout << "Invalid choice!" << std::endl;
40      }
41  }
42 
43  return 0;
44}

Summary

Method	Description
`push_back`	Adds an element to the end of the vector.
`pop_back`	Removes the last element from the vector.
`insert`	Inserts an element at a specified position in the vector.
`erase`	Removes an element from a specified position in the vector.
`resize`	Changes the size of the vector to a specified number of elements.
`reserve`	Allocates enough memory to hold a specified number of elements.
`capacity`	Returns the maximum number of elements that the vector can hold without reallocating.
`shrink_to_fit`	Reduces the capacity of the vector to fit its size, freeing up memory.
`data`	Returns a pointer to the underlying array used by the vector.
`emplace`	Constructs an element in-place at a specified position, avoiding unnecessary copying or moving.

What's Next?

Stay tuned for more tutorials and happy coding!

<vector> Reference

Introduction

Core Content

1. push_back

2. pop_back

3. insert

4. erase

5. resize

6. reserve

7. capacity

8. shrink_to_fit

9. data

10. emplace

Practical Example

Summary

What's Next?

<vector> Reference

Introduction

Core Content

1. push_back

2. pop_back

3. insert

4. erase

5. resize

6. reserve

7. capacity

8. shrink_to_fit

9. data

10. emplace

Practical Example

Summary

What's Next?

1. `push_back`

2. `pop_back`

3. `insert`

4. `erase`

5. `resize`

6. `reserve`

7. `capacity`

8. `shrink_to_fit`

9. `data`

10. `emplace`

1. `push_back`

2. `pop_back`

3. `insert`

4. `erase`

5. `resize`

6. `reserve`

7. `capacity`

8. `shrink_to_fit`

9. `data`

10. `emplace`