The code in this chapter can be found on GitHub:

https://github.com/PacktPublishing/Data-Structures-and-Algorithms-with-the-CPP-STL

In C++, std::vector is a frequently chosen data structure. While beginners might initially see parallels between it and the basic arrays in C, the advantages of std::vector become evident with deeper exploration. Additionally, a solid grasp of std::vector facilitates a smoother transition to understanding other components of STL.

Both vectors and arrays function as containers for collections of elements. The critical distinction between them lies in their flexibility and capabilities. Arrays are static in size, set at declaration time, and cannot be altered afterward.

In contrast, vectors are dynamic. They can expand or contract based on the operations performed on them. Unlike arrays, which commit to a fixed memory block upon declaration, vectors dynamically manage memory. They frequently allocate extra memory to anticipate future growth, optimizing efficiency and flexibility. While arrays offer simple index-based element access and modification...

Having established the foundational knowledge of std::vector in C++ development, it’s time to delve into its practical applications—expressly, how to declare and initialize vectors.

The essence of std::vector lies in its dynamic nature. Unlike traditional arrays with fixed sizes, vectors can grow or shrink as necessary, making them a versatile tool for developers.

Declaring a vector

The performance of std::vector stems from its design, which combines the benefits of a contiguous memory layout (such as arrays) with the flexibility of dynamic resizing. It reserves memory to hold that many elements when initialized with a specified size. But if the vector fills up and more capacity is needed, it allocates a larger memory block, transfers the existing elements, and deallocates the old memory. This dynamic resizing process is optimized to reduce overhead, ensuring that vectors remain efficient. The fusion of contiguous storage...

Having discussed the declaration and initialization of std::vector, our focus now shifts to accessing and manipulating the contained data. Multiple methods in C++ allow you to access vector elements with both speed and safety.

Random access

The subscript [] operator allows direct element access via indices, similar to arrays. In the following example, given a vector, the expression numbers[1] returns the value 20. However, using this operator doesn’t involve boundary checks. An index that is out of range, such as numbers[10], results in undefined behavior, leading to unpredictable outcomes.

This is shown in the following example:

#include <iostream>
#include <vector>
int main() {
  std::vector<int> numbers = {10, 20, 30, 40, 50};
  const auto secondElement = numbers[1];
  std::cout << "The second element is: " << secondElement
        ...

One of the advantages of std::vector over traditional arrays is its ability to resize dynamically. As applications evolve, so do data requirements; static data structures do not cut it. In this section, we will explore dynamic data management with std::vector, learning to seamlessly add to and remove from vectors while making sure we are staying safe.

Adding elements

Let’s start with adding elements. The push_back() member function is possibly the most straightforward way to add an element to the end of a vector. Suppose you have std::vector<int> scores; and wish to append a new score, say 95. You would simply invoke scores.push_back(95);, and voilà, your score is added.

Here’s a simple illustrative code example:

#include <iostream>
#include <vector>
int main() {
  std::vector<int> scores;
  std::cout << "Initial size of scores: " << scores.size()
  ...

In this chapter, you have learned the foundational aspects of std::vector in C++ STL. The chapter began by explaining the significance of std::vector, highlighting its advantages over C-style arrays, particularly regarding memory management and ease of use. The chapter thoroughly compared C-style arrays and std::vector, demonstrating how std::vector facilitates dynamic size adjustment and safer memory operations.

Next, you were guided through the processes of declaring and initializing vectors. You learned how to declare std::vector and initialize these instances using different methods. The chapter then explored the myriad ways of accessing elements within std::vector, from random access to accessing the first and last elements, and underscored the importance of understanding vector size.

Further, the chapter delved into the intricacies of adding and removing elements. This section illuminated the best practices for modifying the contents of a vector, including when...