C++ Containers and Views

C++ Containers and Views

Sequence containers, associative containers, adapters, spans, mdspan, and the main rules that matter when choosing among them.

How to use this reference page

Use reference pages to confirm names, categories, nearby facilities, and the constraints that matter before writing or reviewing code.

Scan the top of the page first to identify the primary types, functions, or algorithm families involved.
Use the nearby-page links when your question is really about a companion header, related algorithm family, or broader subsystem.
Validate tricky behavior with a small compileable example before relying on memory for details like invalidation, ordering, allocation, or lifetime rules.

C++ Containers and Views

Sequence containers

std::array: fixed-size contiguous sequence
std::vector: dynamic contiguous sequence and default first choice in most code
std::deque: efficient growth at both ends
std::list: doubly-linked list, niche but stable iterators
std::forward_list: singly-linked list for specialized cases

Ordered associative containers

std::map, std::multimap
std::set, std::multiset

These are tree-based and maintain sorted order.

Unordered associative containers

std::unordered_map, std::unordered_multimap
std::unordered_set, std::unordered_multiset

These are hash-based and trade ordering for average constant-time lookup.

Container adapters

std::stack
std::queue
std::priority_queue

Adapters restrict the underlying interface to emphasize a specific data-structure behavior.

Views and non-owning wrappers

std::span: contiguous view over existing storage
std::mdspan: multidimensional non-owning view
iterators and ranges views: borrowed traversals rather than owners

High-value choice rules

default to std::vector
use std::array when size is compile-time fixed
use std::unordered_map or std::unordered_set when ordering does not matter
use ordered containers when sorted traversal or tree-order queries matter
use std::span for read-only or borrowed contiguous access parameters

Important operational facts

growth may invalidate iterators and references in vector
node-based containers often preserve references and iterators better
reserve() can reduce reallocations in vector and unordered_* containers
views never extend the lifetime of owned data

Example in practice

#include <map>
#include <string>

int main() {
    std::map<std::string, int> counts{std::pair{"Ada", 1}, std::pair{"Bjarne", 2}};
    auto [it, inserted] = counts.insert({"Grace", 3});
    return inserted ? it->second : 1;
}