C++23 STL Concepts

This document covers new or evolved C++23 STL concepts, with simple explanations, real-world scenarios, and short code snippets. Full examples will be added in examples folder. Only additions or evolutions from C++98/C++03/C++11/C++14/C++17/C++20 are included.

Containers

std::flat_map (C++23 Addition)

Explanation: A sorted, contiguous key-value container with flat storage for efficiency.

Real-World Scenario: Store game settings with fast lookup in a performance-critical system.

Snippet:

#include <flat_map> std::flat_map<int, std::string> fm = {{1, "one"}};

Example: flat_map.cpp

std::flat_set (C++23 Addition)

Explanation: A sorted, contiguous set container for efficient storage and lookup.

Real-World Scenario: Store unique player IDs in a game with minimal memory overhead.

Snippet:

#include <flat_set> std::flat_set<int> fs = {1, 2, 3};

Example: flat_set.cpp

std::flat_multimap (C++23 Addition)

Explanation: A sorted key-value container allowing duplicate keys, backed by contiguous storage for cache-friendly access.

Real-World Scenario: Store multiple event timestamps per event type in a sorted, cache-efficient logging system.

Snippet:

#include <flat_map>
std::flat_multimap<std::string, int> scores;
scores.insert({"Alice", 95}); scores.insert({"Alice", 87});

Example: flat_multimap.cpp

std::flat_multiset (C++23 Addition)

Explanation: A sorted container allowing duplicate elements, backed by contiguous storage for optimal iteration performance.

Real-World Scenario: Maintain a sorted list of response times (including duplicates) for latency analysis.

Snippet:

#include <flat_set>
std::flat_multiset<double> latencies = {1.2, 0.8, 1.2, 0.5};

Example: flat_multiset.cpp

std::mdspan (C++23 Addition)

Explanation: Multidimensional array view for accessing data with dynamic extents.

Real-World Scenario: Process a 2D grid in a scientific simulation without copying.

Snippet:

#include <mdspan> std::mdspan<int, std::extents<size_t, 2, 2>> ms(data);

Example: mdspan.cpp

std::generator (C++23 Addition)

Explanation: Coroutine-based range for lazy generation of sequences.

Real-World Scenario: Generate game events on-demand in a simulation.

Snippet:

#include <generator> std::generator<int> gen() { for (int i = 0; i < 5; ++i) co_yield i; }

Example: generator.cpp

Range Views

std::ranges::zip_view (C++23 Addition)

Explanation: View that combines multiple ranges into tuples of corresponding elements.

Real-World Scenario: Pair player names and scores in a leaderboard.

Snippet:

#include <ranges> auto zv = std::ranges::zip_view(names, scores);

Example: ranges_zip_view.cpp

std::ranges::zip_transform_view (C++23 Addition)

Explanation: View that applies a function to zipped range elements.

Real-World Scenario: Compute weighted scores from paired data in a game.

Snippet:

#include <ranges> auto ztv = std::ranges::zip_transform_view([](int x, int y) { return x + y; }, vec1, vec2);

Example: ranges_zip_transform_view.cpp

std::ranges::adjacent_view (C++23 Addition)

Explanation: View that yields adjacent element pairs from a range.

Real-World Scenario: Process consecutive frames in a video stream.

Snippet:

#include <ranges> auto av = std::ranges::adjacent_view<2>(vec);

Example: ranges_adjacent_view.cpp

std::ranges::adjacent_transform_view (C++23 Addition)

Explanation: View that applies a function to adjacent element pairs.

Real-World Scenario: Compute differences between consecutive sensor readings.

Snippet:

#include <ranges> auto atv = std::ranges::adjacent_transform_view<2>(vec, [](int a, int b) { return b - a; });

Example: ranges_adjacent_transform_view.cpp

std::ranges::chunk_view (C++23 Addition)

Explanation: View that splits a range into chunks of fixed size.

Real-World Scenario: Process data in fixed-size batches for a network packet.

Snippet:

#include <ranges> auto cv = std::ranges::chunk_view(vec, 3);

Example: ranges_chunk_view.cpp

std::ranges::chunk_by_view (C++23 Addition)

Explanation: View that splits a range into chunks based on a predicate.

Real-World Scenario: Group log entries by timestamp in a logger.

Snippet:

#include <ranges> auto cbv = std::ranges::chunk_by_view(vec, [](int a, int b) { return a <= b; });

Example: ranges_chunk_by_view.cpp

std::ranges::slide_view (C++23 Addition)

Explanation: View that yields sliding windows of a fixed size from a range.

Real-World Scenario: Compute moving averages in a financial dataset.

Snippet:

#include <ranges> auto sv = std::ranges::slide_view(vec, 3);

Example: ranges_slide_view.cpp

std::ranges::stride_view (C++23 Addition)

Explanation: View that yields every nth element from a range.

Real-World Scenario: Sample every nth frame in a video analysis.

Snippet:

#include <ranges> auto sv = std::ranges::stride_view(vec, 2);

Example: ranges_stride_view.cpp

std::ranges::cartesian_product_view (C++23 Addition)

Explanation: View that yields the Cartesian product of multiple ranges.

Real-World Scenario: Generate all possible coordinate pairs in a grid-based game.

Snippet:

#include <ranges> auto cpv = std::ranges::cartesian_product_view(vec1, vec2);

Example: ranges_cartesian_product_view.cpp

std::ranges::repeat_view (C++23 Addition)

Explanation: Generates a view that repeats a value a specified number of times, or infinitely.

Real-World Scenario: Fill a test harness with N identical default configurations for benchmarking.

Snippet:

for (int x : std::views::repeat(42, 5)) { /* 42, 42, 42, 42, 42 */ }

Example: repeat_view.cpp

std::ranges::join_with_view (C++23 Addition)

Explanation: Flattens nested ranges into one, inserting a delimiter between each inner range.

Real-World Scenario: Join a collection of words into a sentence with spaces between them.

Snippet:

std::vector<std::string> words = {"Hello", "World"};
auto joined = words | std::views::join_with(' ');

Example: join_with_view.cpp

std::ranges::as_rvalue_view (C++23 Addition)

Explanation: Wraps a range so that every element is cast to an rvalue reference, enabling move operations.

Real-World Scenario: Move all elements from a source container into a destination without copying.

Snippet:

auto moved = source | std::views::as_rvalue;

Example: as_rvalue_view.cpp

std::ranges::as_const_view (C++23 Addition)

Explanation: Wraps a range so that all elements are accessed as const references, preventing modification.

Real-World Scenario: Pass a mutable collection to a read-only analysis function safely.

Snippet:

auto readonly = data | std::views::as_const;

Example: as_const_view.cpp

std::ranges::enumerate_view (C++23 Addition)

Explanation: Pairs each element with its zero-based index, similar to Python's enumerate().

Real-World Scenario: Display numbered search results with their positions in a result list.

Snippet:

for (auto [idx, val] : data | std::views::enumerate) {
    std::println("#{}: {}", idx, val);
}

Example: enumerate_view.cpp

Range Adaptors

std::ranges::views::zip, zip_transform, adjacent, adjacent_transform, chunk, chunk_by, slide, stride, cartesian_product (C++23 Addition)

Explanation: Adaptors for creating corresponding range views with specific transformations.

Real-World Scenario: Chain operations to process paired data in a pipeline (e.g., zip and transform).

Snippet:

#include <ranges> auto v = vec | std::views::zip(vec2) | std::views::transform([](auto p) { return std::get<0>(p) + std::get<1>(p); });

Example: ranges_adaptors.cpp

Range Algorithms

std::ranges::fold_left, fold_right, fold_left_first, fold_right_last (C++23 Addition)

Explanation: Algorithms to fold a range left or right, with or without the first/last element.

Real-World Scenario: Compute cumulative scores in a game with custom operations.

Snippet:

#include <ranges> auto sum = std::ranges::fold_left(vec, 0, std::plus{});

Example: ranges_fold.cpp

std::ranges::find_last, find_last_if, find_last_if_not (C++23 Addition)

Explanation: Algorithms to find the last occurrence of a value or matching a predicate.

Real-World Scenario: Find the last error entry in a log file.

Snippet:

#include <ranges> auto it = std::ranges::find_last(vec, 42);

Example: ranges_find_last.cpp

std::ranges::contains, starts_with, ends_with (C++23 Evolution)

Explanation: Range-based versions of contains, starts_with, and ends_with, moved to std::ranges.

Real-World Scenario: Check if a command sequence starts with a prefix in a parser.

Snippet:

#include <ranges> bool starts = std::ranges::starts_with(vec, subvec);

Example: ranges_contains_starts_ends.cpp

std::ranges::to (C++23 Addition)

Explanation: Converts a range to a container or another range type.

Real-World Scenario: Convert a filtered view to a vector in a data processor.

Snippet:

#include <ranges> auto vec = std::ranges::to<std::vector<int>>(view);

Example: ranges_to.cpp

Utilities

std::expected (C++23 Addition)

Explanation: Represents a value or an error, safer than exceptions for error handling.

Real-World Scenario: Handle file operation results in a file manager.

Snippet:

#include <expected> std::expected<int, std::string> result = 42;

Example: expected.cpp

std::print, std::println (C++23 Addition)

Explanation: Type-safe, efficient printing to streams with formatting.

Real-World Scenario: Print formatted logs in a console application.

Snippet:

#include <print> std::print("Value: {}\n", 42);

Example: print.cpp

std::stacktrace, std::stacktrace_entry, std::basic_stacktrace (C++23 Addition)

Explanation: Capture and manipulate stack traces for debugging.

Real-World Scenario: Log stack traces on errors in a server application.

Snippet:

#include <stacktrace> auto trace = std::stacktrace::current();

Example: stacktrace.cpp

std::to_underlying (C++23 Addition)

Explanation: Converts an enum to its underlying type.

Real-World Scenario: Convert an enum to an integer for serialization in a game.

Snippet:

#include <utility> enum class E { A = 1 }; auto val = std::to_underlying(E::A);

Example: to_underlying.cpp

std::byteswap (C++23 Addition)

Explanation: Reverses the byte order of an integral value.

Real-World Scenario: Handle endianness in a network protocol.

Snippet:

#include <bit> auto swapped = std::byteswap(0x1234);

Example: byteswap.cpp

std::assume_aligned (C++23 Addition)

Explanation: Informs the compiler of pointer alignment for optimization.

Real-World Scenario: Optimize memory access in a graphics renderer.

Snippet:

#include <memory> int* p = std::assume_aligned<alignof(int)>(ptr);

Example: assume_aligned.cpp

std::unreachable (C++23 Addition)

Explanation: Marks code as unreachable, triggering undefined behavior if executed.

Real-World Scenario: Indicate impossible cases in a state machine.

Snippet:

#include <utility> if (false) std::unreachable();

Example: unreachable.cpp

std::invoke_r (C++23 Addition)

Explanation: Invokes a callable with a specified return type.

Real-World Scenario: Call a function with type-safe return in an event system.

Snippet:

#include <functional> auto result = std::invoke_r<int>(func, args...);

Example: invoke_r.cpp

std::forward_like (C++23 Addition)

Explanation: Forwards arguments with the same value category as a reference.

Real-World Scenario: Preserve value category in a generic forwarding function.

Snippet:

#include <utility> auto x = std::forward_like<T>(arg);

Example: forward_like.cpp

std::move_only_function (C++23 Addition)

Explanation: Function wrapper for move-only callables (e.g., lambdas with unique_ptr).

Real-World Scenario: Store move-only callbacks in an event queue.

Snippet:

#include <functional> std::move_only_function<void()> f = []{ /* action */ };

Example: move_only_function.cpp

std::out_ptr / std::inout_ptr (C++23 Addition)

Explanation: Smart pointer adaptors for C APIs that write to an output pointer parameter (T**).

Real-World Scenario: Pass a std::unique_ptr to a C library function that allocates and returns a handle via output parameter.

Snippet:

std::unique_ptr<FILE, decltype(&fclose)> file(nullptr, &fclose);
c_api_open_file(std::out_ptr(file));

Example: out_ptr.cpp

std::spanstream (C++23 Addition)

Explanation: A stream class backed by a std::span buffer, enabling I/O operations on existing memory without allocation.

Real-World Scenario: Format data into a pre-allocated fixed-size buffer for a network protocol.

Snippet:

#include <spanstream>
char buf[64];
std::ospanstream os(buf);
os << "Value: " << 42;

Example: spanstream.cpp

std::basic_string::contains / std::basic_string_view::contains (C++23 Addition)

Explanation: Member function that checks if a string contains a substring, character, or string view.

Real-World Scenario: Filter log lines that contain a specific error keyword.

Snippet:

std::string msg = "Error: file not found";
if (msg.contains("Error")) { /* handle */ }

Example: string_contains.cpp

Container Improvements

std::string constexpr Support (C++23 Evolution)

Explanation: Enhanced constexpr support for std::string operations.

Real-World Scenario: Generate compile-time strings for a configuration parser.

Snippet:

constexpr std::string s = "hello"; constexpr auto len = s.size();

Example: constexpr_string.cpp

std::vector constexpr Support (C++23 Evolution)

Explanation: Enhanced constexpr support for std::vector operations.

Real-World Scenario: Create compile-time lookup tables in a data processor.

Snippet:

constexpr std::vector<int> vec = {1, 2, 3};

Example: constexpr_vector.cpp

std::optional Monadic Operations (C++23 Addition)

Explanation: Adds and_then, transform, and or_else for monadic-style operations.

Real-World Scenario: Chain optional operations in a configuration parser.

Snippet:

#include <optional> auto result = opt.transform([](int x) { return x * x; });

Example: optional_monadic.cpp

std::variant Monadic Operations (C++23 Addition)

Explanation: Adds and_then and transform for monadic-style operations on variants.

Real-World Scenario: Transform variant data in a game’s event system.

Snippet:

#include <variant> auto result = var.transform([](int x) { return x * x; });

Example: variant_monadic.cpp

std::expected Monadic Operations (C++23 Addition)

Explanation: Adds and_then, transform, and or_else to std::expected, enabling functional-style chaining of operations that may fail.

Real-World Scenario: Chain file read, parse, and validate steps where each may return an error.

Snippet:

auto result = read_file("config.json")
    .and_then(parse_json)
    .transform(extract_settings)
    .or_else(use_defaults);

Example: expected_monadic.cpp

std::span subspan, as_bytes, as_writable_bytes (C++23 Evolution)

Explanation: Adds methods for creating subviews and accessing bytes of a std::span.

Real-World Scenario: Process a subset of pixel data in a renderer.

Snippet:

#include <span> auto sub = span.subspan(1, 2);

Example: span_enhancements.cpp

std::reference_wrapper Improvements (C++23 Evolution)

Explanation: Adds conversion to underlying type and better functor support.

Real-World Scenario: Use std::reference_wrapper in a generic algorithm with type conversion.

Snippet:

#include <functional> std::reference_wrapper<int> ref(x); int val = ref;

Example: reference_wrapper.cpp

Filesystem Improvements

std::filesystem::recursive_directory_iterator Improvements (C++23 Evolution)

Explanation: Enhanced performance and usability for recursive directory iteration.

Real-World Scenario: Traverse a directory tree efficiently in a file explorer.

Snippet:

#include <filesystem> for (auto& p : std::filesystem::recursive_directory_iterator("dir")) {}

Example: filesystem_recursive.cpp

Chrono Improvements

std::chrono::parse, std::chrono::format (C++23 Addition)

Explanation: Parse and format time points and durations with string patterns.

Real-World Scenario: Parse user-input dates in a calendar application.

Snippet:

#include <chrono> auto tp = std::chrono::parse("%Y-%m-%d", "2025-09-09");

Example: chrono_parse_format.cpp

std::chrono::zoned_traits, std::chrono::choose, std::chrono::leap_second (C++23 Addition)

Explanation: Enhances time zone support and leap second handling.

Real-World Scenario: Handle time zones and leap seconds in a global scheduler.

Snippet:

#include <chrono> auto zt = std::chrono::zoned_time{"UTC", std::chrono::system_clock::now()};

Example: chrono_zoned_leap.cpp

Modules

import std (Standard Library Module) (C++23 Addition)

Explanation: Imports the entire C++ standard library as a module.

Real-World Scenario: Simplify standard library usage in a modular game engine.

Snippet:

import std; std::vector<int> vec = {1, 2, 3};

Example: import_std.cpp