XQA
Back to C++
2026-01-216 min read

C++ Vectors

Learn C++ Vectors step by step with clear examples and exercises.

Title: Mastering C++ Vectors: A full guide for Programmers

Why This Matters

In programming, data structures play a crucial role in organizing and manipulating data efficiently. One such data structure is the vector, which is a dynamic array that can resize itself as elements are added or removed. Understanding vectors is essential for tackling complex problems, writing efficient code, and preparing for interviews. This guide will provide you with a comprehensive understanding of C++ vectors, their usage, common mistakes, practice questions, and FAQs.

Prerequisites

Before diving into the core concept of C++ vectors, it is essential to have a good grasp of the following:

  1. Basic C++ syntax and programming concepts (variables, functions, loops, and control structures)
  2. Understanding of arrays and their limitations (fixed size, manual resizing)
  3. Familiarity with the Standard Template Library (STL) in C++
  4. Knowledge of basic data types such as integers, floats, and strings
  5. Comfortable using IDEs like Visual Studio Code or Code::Blocks for writing and compiling C++ code

Core Concept

A vector is a container from the STL that can store elements of the same data type. It provides a dynamic array-like behavior, allowing elements to be added or removed without worrying about resizing the array manually. Vectors are defined using the vector template, where the data type is specified as a template argument.

#include <vector>
std::vector<int> myVector; // Declare a vector of integers

Vector Operations

Vectors support various operations such as:

  1. Accessing elements: Use the square bracket notation to access elements by their index, similar to arrays.
myVector[0] = 5; // Assign value to first element
int value = myVector[2]; // Access third element
  1. Size and capacity: To check the number of elements in a vector, use the size() function. The capacity() function returns the maximum number of elements that can be stored without reallocation.
int size = myVector.size(); // Get the size of the vector
myVector.resize(10); // Resize the vector to hold 10 elements
int capacity = myVector.capacity(); // Get the current capacity of the vector
  1. Iterators: Vectors can be traversed using iterators, which provide a way to access and manipulate the elements sequentially.
for (auto it = myVector.begin(); it != myVector.end(); ++it) {
// Perform an operation on each element
}
  1. Push and Pop: Use the push_back() function to add elements to the end of the vector, and the pop_back() function to remove the last element.
myVector.push_back(3); // Add an integer 3 to the vector
myVector.pop_back(); // Remove the last element from the vector
  1. Insert: Use the insert() function to insert elements at a specific position in the vector.
myVector.insert(myVector.begin(), 2); // Insert integer 2 as the first element
  1. Erase: Use the erase() function to remove elements from the vector.
myVector.erase(myVector.begin()); // Remove the first element
myVector.erase(myVector.begin() + 1, myVector.end() - 2); // Remove elements from index 1 to second last
  1. Reserve: Use the reserve() function to reserve a specific amount of memory for the vector. This can improve performance when adding many elements in quick succession.
myVector.reserve(20); // Reserve memory for 20 elements
  1. Shrink-to-fit: Use the shrink_to_fit() function to reduce the vector's capacity to its current size, which can help free up memory.
myVector.shrink_to_fit(); // Reduce the vector's capacity if possible

Worked Example

Let's create a simple program that reads integers from the user, stores them in a vector, and calculates their sum.

#include <iostream>
#include <vector>
#include <limits>

int main() {
std::vector<int> numbers;
int num, sum = 0;

std::cout << "Enter integers (enter -1 to stop):\n";
while (std::cin >> num) {
if (num == -1) break;
numbers.push_back(num);
sum += num;
}

std::cout << "\nSum of entered integers: " << sum << '\n';

return 0;
}

Common Mistakes

  1. Forgetting to include necessary headers: Make sure you include the `` and any other required headers for your program.
  2. Accessing out-of-bounds elements: Always check the index of the element you are accessing to avoid segmentation faults due to out-of-bounds access.
  3. Misusing iterators: Be aware of the iterator's position and use it correctly when traversing the vector or performing operations on its elements.
  4. Ignoring capacity: If a vector is frequently resized, consider using reserved capacity to improve performance.
  5. Copying vectors incorrectly: When copying vectors, be mindful of the deep-copy vs. shallow-copy distinction and use std::vector newVector(myVector); for a deep copy.
  6. Incorrectly initializing vectors: Initializing a vector with no elements (e.g., std::vector myVector;) creates an empty vector, but if you want to pre-initialize the vector with specific values, use std::vector myVector(n); where n is the number of elements.
  7. Using uninitialized iterators: When using iterators, make sure they are initialized before being used, or else you may encounter undefined behavior.
  8. Not handling exceptions: Be aware of potential exceptions that can occur when manipulating vectors (e.g., running out of memory) and handle them appropriately in your code.
  9. Confusing iterators with pointers: Iterators are not pointers, although they behave similarly in some cases. Make sure you understand the differences between the two.
  10. Using vector operations inappropriately: Use vector operations judiciously to ensure efficient and correct execution of your code. For example, avoid using push_back() when appending large amounts of data, as it can result in poor performance due to frequent reallocations.

Practice Questions

  1. Write a program that sorts a vector of integers in ascending order using the sort() function from the STL.
  2. Create a program that finds the second-largest number in a vector of integers.
  3. Implement a function that takes a vector of integers as an argument and returns the sum of all even numbers.
  4. Write a program that reverses the order of elements in a vector using iterators.
  5. Create a program that finds the maximum sum of three consecutive elements in a vector of integers.
  6. Implement a function that takes two vectors of the same size as arguments and returns another vector containing their element-wise product.
  7. Write a program that removes all duplicate elements from a sorted vector of integers using a custom unique() function.
  8. Create a program that finds the kth smallest number in an unsorted vector of integers, where k is provided as input.
  9. Implement a function that takes a vector of integers and returns the index of the first occurrence of a specific value, or -1 if the value is not found.
  10. Write a program that concatenates two vectors of the same data type into a single vector using iterators.

FAQ

  1. What happens when I try to access an out-of-bounds element in a vector? Accessing an out-of-bounds element will result in a segmentation fault, causing your program to crash.
  2. Why should I use reserved capacity for my vector? Reserving capacity can improve performance by reducing the number of reallocations when adding elements to the vector.
  3. What is the difference between deep and shallow copying of vectors? Deep copying creates a new vector with a separate memory allocation, while shallow copying shares the same memory location as the original vector.
  4. How can I iterate through a vector in reverse order? Use the rbegin() and rend() functions to get a reverse iterator, then traverse the vector in reverse order using the increment operator (++it).
  5. Is it possible to create a vector of custom data types? Yes, you can create a vector of custom data types by defining a class and specifying it as a template argument when declaring the vector.
  6. What is the time complexity of common vector operations? Common vector operations have the following time complexities:
  • Accessing an element: O(1)
  • Inserting an element at the beginning or end: O(n) (amortized O(1) with reserved capacity)
  • Inserting an element in the middle: O(n)
  • Removing an element from the beginning or end: O(1)
  • Removing an element in the middle: O(n)
  • Sorting a vector: O(n log n) using sort() function from STL
  1. Can I use vectors with different data types? No, vectors can only store elements of the same data type. If you need to store multiple data types in a single container, consider using containers like std::map, std::unordered_map, or std::tuple.
C++ Vectors | C++ | XQA Learn