Strings, Vectors, and Arrays

Chapter 1: string — Text That Manages Itself

The std::string type manages a dynamically-sized sequence of characters. Unlike a C-style char array, a string knows its own length, can grow and shrink, and handles memory allocation for you.

c++
#include <string>
using std::string;

string s1;                // default init: empty string ""
string s2 = "hello";      // copy from string literal
string s3(5, 'x');       // "xxxxx" — 5 copies of 'x'
string s4 = s2 + " world";// concatenation

Key Operations

Chapter 2: vector — The Workhorse Container

A std::vector is a dynamically-sized array. It stores its elements in contiguous memory, just like a C array, but it handles allocation and resizing for you. When you push_back an element and the vector is full, it allocates a new, larger block (typically 2x), copies everything over, and frees the old block.

c++
#include <vector>
using std::vector;

vector<int> v1;                 // empty vector of ints
vector<int> v2(10, 0);          // 10 elements, all 0
vector<int> v3 = {1,2,3,4,5}; // list initialization
v1.push_back(42);               // add element to end

Size vs Capacity

Size is how many elements the vector currently holds. Capacity is how many it can hold before needing to reallocate. When size exceeds capacity, the vector doubles its capacity (on most implementations), copies all elements, and frees the old memory. This is why push_back is amortized O(1) but occasionally O(n).

Chapter 3: Iterators — Generalized Pointers

An iterator is an object that points to an element in a container. You can advance it (like incrementing a pointer), dereference it (to get the element), and compare two iterators (to check if you've reached the end). Iterators are the glue between containers and algorithms.

c++
vector<int> v = {10, 20, 30};
auto it = v.begin();   // points to first element (10)
*it;                    // 10 — dereference
++it;                   // advance to next element (20)
it == v.end();          // false — end() is one past the last

begin() and end()

begin() returns an iterator to the first element. end() returns an iterator to one past the last element. This is a half-open range [begin, end). If the container is empty, begin() == end().

Iterator Invalidation

This is the trap. Operations that change a container's size can invalidate existing iterators. If a vector reallocates, all iterators are invalidated. Using an invalidated iterator is undefined behavior — the dreaded "dangling iterator."

Chapter 4: Arrays — The Low-Level Foundation

A built-in array is a fixed-size, contiguous block of memory. Unlike a vector, its size must be known at compile time (or allocated dynamically). Unlike a vector, it has no member functions, no bounds checking, and no automatic resizing.

c++
int arr[5] = {1, 2, 3, 4, 5};  // fixed size = 5
int *p = arr;                     // array name decays to pointer
arr[2];                            // 3 — subscript
*(p + 2);                          // 3 — pointer arithmetic (same thing)

Array Decay

In most contexts, the name of an array decays to a pointer to its first element. This is why you can write int *p = arr; without the address-of operator. It also means arrays cannot be copied or assigned — what looks like a copy actually just copies the pointer.

Chapter 5: Pointer Arithmetic

Pointer arithmetic is the key to understanding how arrays work under the hood. When you add an integer n to a pointer, the pointer moves forward by n * sizeof(element) bytes. The subscript operator arr[i] is literally defined as *(arr + i).

c++
int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;       // points to arr[0]
*(p + 2);            // 30 — same as arr[2]
p[3];                // 40 — subscript works on pointers too
int *q = p + 5;     // one past the end (like end())
q - p;               // 5 — pointer difference = number of elements

Chapter 6: Memory Layout Explorer

Let's see how strings, vectors, and arrays actually live in memory. A vector object on the stack holds three pointers: one to the start of the data on the heap, one to the end of the used region, and one to the end of the allocated region. When it grows, the heap data moves — but the stack object stays put.

Chapter 7: Range For — The Modern Idiom

C++11 introduced the range-based for loop, which iterates over every element in a container without explicit iterator management:

c++
vector<int> v = {1, 2, 3, 4, 5};
for (auto x : v)        // x is a COPY of each element
    cout << x;
for (auto &x : v)       // x is a REFERENCE — can modify
    x *= 2;
for (const auto &x : v) // read-only reference — efficient, safe
    cout << x;

Under the Hood

The compiler translates for (auto x : v) into:

c++
for (auto __begin = v.begin(), __end = v.end();
     __begin != __end; ++__begin) {
    auto x = *__begin;
    // loop body
}

This means the range-for works with any type that has begin() and end(). It also means you must not modify the container's size during iteration — the cached end() would be stale.

Chapter 8: Beyond — Connections

This chapter introduced the three fundamental ways C++ stores sequences: arrays (low-level, fixed), strings (text-specific, dynamic), and vectors (general-purpose, dynamic). The iterator abstraction unifies them all.

Continue Reading

Next up: Chapter 6: Functions — where we learn how to pass these containers efficiently.