Vectors are a cornerstone of modern C++ programming. If you’re working on dynamic arrays or need a versatile data structure, vectors are one of the best tools in your toolkit. Unlike traditional arrays, they can adjust their size automatically. This flexibility, combined with a host of built-in functions, makes them a popular choice among developers.
Let’s explore how vectors work, common use cases, and some practical examples to help you get started.
What Are Vectors in C++?
Vectors in C++ are part of the Standard Template Library (STL). They’re dynamic arrays that grow or shrink as needed. While built-in arrays have a fixed size, vectors handle memory allocation and resizing for you. This makes them incredibly convenient for scenarios where the size of your data isn’t known upfront.
Think of vectors as a more intelligent version of arrays. They not only hold multiple elements of the same type but also offer functionalities like adding, removing, or accessing elements without manual memory management.
How to Declare and Initialize Vectors
Declaring a vector is straightforward. Here's a basic syntax:
#include <vector>
// Creating a vector of integers
std::vector<int> numbers;
You can also initialize vectors with values at the time of declaration:
std::vector<int> evenNumbers = {2, 4, 6, 8};
Advantages of Using Vectors
- Dynamic resizing: They can grow or shrink automatically based on the number of elements.
- Built-in functions: Adding, removing, and accessing elements is quick and easy.
- Memory management: No need to manually allocate or free memory.
- Safety: They eliminate common pitfalls of raw pointers and arrays, like buffer overflows, by handling boundaries internally.
Adding and Removing Elements
One of the standout features of vectors is their ability to add or remove elements easily. Let’s see how these operations work.
Adding Elements
You can use push_back() to add elements at the end of the vector:
std::vector<int> numbers;
numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);
// Output: 10, 20, 30
Removing Elements
To remove the last element from a vector, use pop_back():
numbers.pop_back();
// Output: 10, 20
For removing specific elements, you can use the erase() function along with an iterator:
numbers.erase(numbers.begin()); // Removes the first element
// Output: 20
Accessing Elements in a Vector
Vectors allow you to interact with their elements in several ways. Here are the most common methods:
Using the Index Operator
Just like an array, vectors support accessing elements with the index operator:
std::vector<int> numbers = {1, 2, 3, 4};
std::cout << numbers[2]; // Output: 3
With the at() Method
If you want bounds-checking (to prevent accessing invalid indices), use at():
std::cout << numbers.at(2); // Output: 3
Accessing First and Last Elements
C++ vectors also offer convenient functions for accessing the first and last elements:
std::cout << numbers.front(); // Output: 1
std::cout << numbers.back(); // Output: 4
Iterating Through a Vector
Need to loop through all elements in a vector? Here’s how you can do it.
Using a Simple for Loop
for (size_t i = 0; i < numbers.size(); ++i) {
std::cout << numbers[i] << " ";
}
With a Range-Based for Loop
If you don’t need explicit indices, this approach is cleaner:
for (int num : numbers) {
std::cout << num << " ";
}
Using Iterators
For more control or flexibility, iterators are a great choice:
for (std::vector<int>::iterator it = numbers.begin(); it != numbers.end(); ++it) {
std::cout << *it << " ";
}
Common Functions of C++ Vectors
Vectors come with a rich set of functions to make your life easier. Here are some of the most commonly used:
size(): Returns the number of elements in the vector.capacity(): Tells you the current storage capacity (how much space is reserved).resize(): Changes the number of elements in the vector.empty(): Checks if the vector is empty.clear(): Removes all elements from the vector.
Example: Resize and Capacity
std::vector<int> numbers = {1, 2, 3};
numbers.resize(5); // Expands the vector to hold 5 elements, filling new spots with 0
std::cout << "Size: " << numbers.size(); // Output: 5
std::cout << "Capacity: " << numbers.capacity(); // May exceed 5, depending on implementation
When Should You Use Vectors?
Vectors are ideal in situations where:
- You need a resizable array-like structure.
- The number of elements varies during runtime.
- You want to avoid the complexities of manual memory management.
However, keep in mind that vectors can be slower than arrays for very specific use cases, such as fixed-size data structures requiring high performance.
Practical Code Examples
Here’s a quick recap with some real-world vector use cases to solidify your understanding.
Example 1: Creating and Printing a Vector
std::vector<std::string> names = {"Alice", "Bob", "Charlie"};
for (const std::string& name : names) {
std::cout << name << std::endl;
}
Example 2: Removing Even Numbers
std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
numbers.erase(
std::remove_if(numbers.begin(), numbers.end(), [](int n) { return n % 2 == 0; }),
numbers.end()
);
for (int num : numbers) {
std::cout << num << " ";
}
// Output: 1 3 5
Example 3: Sorting a Vector
std::sort(numbers.begin(), numbers.end());
Example 4: Combining Two Vectors
std::vector<int> v1 = {1, 2, 3};
std::vector<int> v2 = {4, 5, 6};
v1.insert(v1.end(), v2.begin(), v2.end());
// Output: 1 2 3 4 5 6
Example 5: Finding an Element
auto it = std::find(numbers.begin(), numbers.end(), 3);
if (it != numbers.end()) {
std::cout << "Found: " << *it;
} else {
std::cout << "Not found";
}
Conclusion
C++ vectors offer a modern, flexible way to manage dynamic arrays. They’re packed with features that let you focus on solving problems instead of worrying about memory management. While raw arrays might still have niche uses, vectors are often the better choice in most scenarios. Try experimenting with vectors in your next project to see just how useful they can be.