Arrays and Vectors in C++

Arrays and vectors are both sequential containers, but they differ significantly in flexibility, safety, and interface.

1. Size: C-style arrays have a fixed size determined at compile time. Vectors (std::vector) are dynamic — they grow and shrink at runtime automatically.

2. Memory management: C-style arrays allocated on the stack are limited by stack size and cannot be resized. Vectors manage heap memory internally and handle allocation and deallocation automatically, eliminating manual new/delete.

3. Type safety and bounds checking: C-style arrays decay to pointers, losing size information. In debug builds, vector::at() throws std::out_of_range on invalid access; operator[] has no such check. std::array (fixed-size, stack-allocated) solves the decay problem for fixed sizes.

4. Interface: Vectors provide a rich STL interface — push_back, emplace_back, erase, insert, iterators, range-based for, and compatibility with all STL algorithms. C-style arrays have none of this.

5. Modern alternative — std::span (C++20): When you need to pass an array or vector to a function without copying, prefer std::span. It is a non-owning view over any contiguous sequence (raw array, std::array, or std::vector) and preserves size information.

   void process(std::span data) {
       for (int x : data) { /* ... */ }
   }

   int arr[] = {1, 2, 3};
   std::vector vec = {4, 5, 6};
   process(arr);  // works
   process(vec);  // works

1. Performance: For small, fixed-size collections, std::array matches raw-array performance with zero overhead and full STL compatibility. std::vector has a slight overhead from the heap allocation but is generally negligible and preferred for runtime-sized collections.

When to use each:

• Use std::vector when size is unknown at compile time or may change.
• Use std::array as a safer, STL-compatible replacement for fixed-size C-style arrays.
• Use std::span to accept any contiguous range in function parameters.
• Avoid raw C-style arrays in new code unless interfacing with a C API.

In C++, arrays can be declared and initialized in several ways depending on whether you need a fixed-size compile-time array or a safer modern alternative.

C-style array (traditional)

int numbers[5] = {1, 2, 3, 4, 5};

If fewer initializers are provided than the declared size, the remaining elements are zero-initialized:

int numbers[5] = {1, 2};  // {1, 2, 0, 0, 0}

You can omit the size when providing a full initializer list, and the compiler deduces it:

int numbers[] = {1, 2, 3, 4, 5};  // size deduced as 5

std::array (preferred for fixed-size collections)

std::array is the modern replacement for C-style arrays. It has the same stack-allocated, zero-overhead characteristics but preserves size information, supports STL algorithms, and does not decay to a pointer:

#include 

std::array numbers = {1, 2, 3, 4, 5};
std::array zeros{};  // value-initialized to all zeros

std::vector (for runtime-sized arrays)

When the size is not known at compile time, use std::vector:

#include 

std::vector numbers = {1, 2, 3, 4, 5};
std::vector repeated(5, 0);  // five zeros

std::span (C++20, for non-owning views)

To pass any contiguous array to a function without copying or losing size:

#include <span>

void print(std::span data) {
    for (int x : data) std::cout &lt;&lt; x &lt;&lt; ' ';
}

In new code, prefer std::array over C-style arrays for fixed sizes, and std::vector when the size is dynamic.

Vectors in C++ (std::vector) support a wide range of operations. The key ones an interviewer expects you to know:

Adding elements

• push_back(val) — appends an element; amortized O(1).
• emplace_back(args...) — constructs in-place at the back; avoids an extra copy/move compared to push_back.
• insert(pos, val) — inserts before an iterator position; O(n).

Removing elements

• pop_back() — removes the last element; O(1).
• erase(pos) / erase(first, last) — removes one or a range of elements; O(n).
• clear() — removes all elements; does not release memory (capacity unchanged).

Accessing elements

• operator[] — unchecked access; undefined behavior on out-of-bounds.
• at(i) — bounds-checked; throws std::out_of_range.
• front() / back() — first and last elements.
• data() — raw pointer to the underlying array; useful when passing to C APIs.

Size and capacity

• size() — number of elements currently stored.
• capacity() — number of elements that fit before reallocation.
• resize(n) — changes the logical size; new elements are value-initialized.
• reserve(n) — pre-allocates capacity without changing size; avoids repeated reallocations.
• shrink_to_fit() — requests capacity to be reduced to size (non-binding).
• empty() — returns true if size is zero.

Iteration

• Range-based for: for (auto& x : v)
• STL iterators: v.begin(), v.end(), v.rbegin(), v.rend()
• Compatible with all `functions such asstd::sort,std::find,std::transform`.

Algorithms (C++20 Ranges)

With C++20 ranges, you can compose operations without naming iterators:

#include 
#include 

std::vector v = {5, 3, 1, 4, 2};
std::ranges::sort(v);                        // sort in place
auto evens = v | std::views::filter([](int x){ return x % 2 == 0; });

Example — common operations

#include 
#include 

std::vector v;
v.reserve(10);           // pre-allocate
v.push_back(3);
v.emplace_back(7);
v.insert(v.begin(), 1); // insert at front

std::sort(v.begin(), v.end());
v.erase(v.begin());     // remove first element

Gotcha: push_back and insert can invalidate all iterators and pointers into the vector if a reallocation occurs. Use reserve up front when the eventual size is known.

C++ provides several approaches for multidimensional arrays, each with different trade-offs.

C-style 2D arrays (fixed dimensions)

Declare by specifying all dimensions at compile time:

int arr[3][4];          // 3 rows, 4 columns, all on the stack
arr[1][2] = 42;         // row 1, column 2

You can initialize inline:

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

Gotcha with function parameters: C-style 2D arrays decay to int (*)[4] — only the outermost dimension is lost. You must specify all inner dimensions in the parameter:

void process(int arr[][4], int rows);  // columns must be specified

This makes the interface fragile. Prefer the modern alternatives below.

std::array for fixed-size 2D arrays

#include 
using Matrix2x3 = std::array, 2>;

Matrix2x3 m = {{{1, 2, 3}, {4, 5, 6}}};
m[0][1] = 99;

No pointer decay, full STL compatibility, and size is always known.

std::vector for runtime-sized 2D arrays

#include 

int rows = 3, cols = 4;
std::vector> grid(rows, std::vector(cols, 0));
grid[1][2] = 42;

This works but has non-contiguous memory (each inner vector allocates separately). For performance-critical code, use a flattened 1D vector and compute the index manually:

std::vector flat(rows * cols, 0);
flat[i * cols + j] = 42;  // equivalent to grid[i][j]

A flattened layout is cache-friendly because all data is contiguous.

std::span for viewing existing 2D data (C++20)

std::span can view a contiguous block but is inherently 1D. Use std::mdspan (C++23) for a true multidimensional non-owning view:

#include 

std::vector data(12);
auto view = std::mdspan(data.data(), 3, 4);  // 3×4 view
view[1, 2] = 42;   // C++23 multidimensional subscript operator

Summary of choices:

• int arr[M][N] or std::array,M> — fixed compile-time dimensions, stack allocated.
• std::vector> — fully dynamic but non-contiguous.
• Flattened std::vector with manual indexing — dynamic and cache-friendly.
• std::mdspan (C++23) — non-owning multidimensional view over any contiguous storage; the preferred modern approach when available.

size() and capacity() represent two distinct but related properties of a std::vector:

• size() returns the number of elements currently stored in the vector — the elements that are actually present and accessible.
• capacity() returns the total number of elements the vector can hold in its currently allocated memory before it needs to allocate a new, larger block.

The invariant is always size() <= capacity().

Why they differ — the growth strategy

When you call push_back and size() == capacity(), the vector must reallocate. It typically doubles the capacity (implementation-defined, but doubling is standard in libstdc++ and libc++), copies or moves all existing elements to the new buffer, and then inserts the new element. This makes the amortized cost of push_back O(1) while avoiding a reallocation on every insertion.

std::vector v;
// size=0, capacity=0

v.push_back(1);
// size=1, capacity=1 (or more, implementation-defined)

v.push_back(2);
// size=2, capacity=2 (or more)

v.push_back(3);
// size=3, capacity=4 (typical doubling)

std::cout << v.size();      // 3
std::cout << v.capacity();  // 4 (implementation-defined)

reserve(n) — pre-allocating capacity

If you know the approximate final size, call reserve to avoid repeated reallocations:

std::vector v;
v.reserve(1000);    // capacity >= 1000, size still 0
// 1000 push_backs cause zero reallocations

This is one of the most impactful micro-optimizations for vectors.

resize(n) vs reserve(n)

• reserve(n) changes capacity only — no new elements are created, size is unchanged.
• resize(n) changes the logical size — new elements are value-initialized; capacity is increased if needed.

shrink_to_fit()

Requests that excess capacity be released so capacity approaches size. The request is non-binding (the implementation may ignore it), but it is useful for long-lived vectors that held temporarily large data.

v.shrink_to_fit();  // capacity may drop to size()

Interview gotcha: Every reallocation invalidates all iterators, pointers, and references into the vector. Storing a pointer or iterator to a vector element and then calling push_back is a classic source of undefined behavior — avoided by calling reserve first.