Listen to this Post
Introduction:
The Standard Template Library (STL), initiated by Alexander Stepanov and Meng Lee, fundamentally transformed C++ by establishing generic programming as a first-class paradigm. Nearly three decades after its inclusion in the C++98 standard, the STL continues to evolve with every major language revision, with C++23 introducing Concepts, Ranges, Views, std::span, and constexpr improvements, while C++26 pushes boundaries with standardized SIMD support, richer Ranges, generators, and new execution capabilities. Bill Weinman’s C++ STL Cookbook (Second Edition, Packt Publishing, May 2026) offers a practical, hands-on guide to harnessing these modern STL features through implementation-specific recipes.
Learning Objectives:
- Master the latest C++23 and C++26 STL features including enhanced ranges, advanced concurrency, and coroutine-based generators
- Implement modern C++ techniques such as structured bindings, std::span, and braced initialization for safer, cleaner code
- Leverage new library facilities including std::expected, std::mdspan, std::flat_map, std::print, and standardized SIMD support
1. Modern Error Handling with std::expected (C++23)
`std::expectedE, providing a safer alternative to exceptions or error codes. It offers a composable interface for functional error handling.
Step-by-step guide:
include <expected>
include <string>
include <iostream>
enum class ParseError { InvalidInput, OutOfRange };
std::expected<int, ParseError> parse_int(const std::string& s) {
try {
int value = std::stoi(s);
if (value < 0 || value > 100)
return std::unexpected(ParseError::OutOfRange);
return value;
} catch (...) {
return std::unexpected(ParseError::InvalidInput);
}
}
int main() {
auto result = parse_int("42");
if (result) {
std::cout << "Parsed: " << result << '\n';
} else {
switch (result.error()) {
case ParseError::InvalidInput:
std::cout << "Invalid input\n"; break;
case ParseError::OutOfRange:
std::cout << "Out of range\n"; break;
}
}
// Using transform for composition
auto doubled = parse_int("50").transform([](int v) { return v 2; });
std::cout << "Doubled: " << doubled.value_or(0) << '\n';
return 0;
}
Compiler support: GCC 13+ supports `std::expected`.
2. Formatted Output with std::print and std::println (C++23)
`std::print` and `std::println` bring Python-style formatted output to C++, using C++20 format strings and supporting UTF-8. They will fundamentally change how we write “Hello, World”.
Step-by-step guide:
include <print>
include <vector>
include <tuple>
int main() {
// Basic formatted output
std::println("Hello, {}!", "World");
// Formatting with positional arguments
std::println("{1} + {0} = {2}", 10, 20, 30);
// Formatting collections
std::vector<int> nums = {1, 2, 3, 4, 5};
std::print("Vector: [");
for (const auto& n : nums) {
std::print("{} ", n);
}
std::println("]");
// Formatting tuples and pairs
auto t = std::make_tuple("answer", 42);
std::println("Tuple: ({}, {})", std::get<0>(t), std::get<1>(t));
// Format specifiers
std::println("{:.2f}", 3.14159); // 3.14
std::println("{:08d}", 42); // 00000042
std::println("{:x}", 255); // 0xff
return 0;
}
Compiler support: Requires GCC 14+ or Clang 17+.
3. Flat Associative Containers: std::flat_map and std::flat_set (C++23)
`std::flat_map` and `std::flat_set` provide the same interface as `std::map` and `std::set` but store elements in contiguous memory (default std::vector), offering cache-friendly performance.
Step-by-step guide:
include <flat_map>
include <flat_set>
include <print>
include <string>
int main() {
// flat_map with vector as underlying storage
std::flat_map<std::string, int> ages = {
{"Alice", 30},
{"Bob", 25},
{"Charlie", 35}
};
// Insertion and access
ages["Diana"] = 28;
ages.emplace("Eve", 32);
// Iteration is cache-friendly
for (const auto& [name, age] : ages) {
std::println("{}: {}", name, age);
}
// Find and modify
if (auto it = ages.find("Bob"); it != ages.end()) {
it->second = 26;
}
// flat_set example
std::flat_set<int> numbers = {5, 2, 8, 1, 9, 3};
numbers.insert(7);
numbers.erase(1);
for (int n : numbers) {
std::print("{} ", n);
}
std::println();
return 0;
}
Performance note: `flat_map` offers better cache locality and iteration performance than std::map, though insertions and deletions may be O(n) due to contiguous storage.
4. Multidimensional Array Views with std::mdspan (C++23)
`std::mdspan` provides a non-owning view of multidimensional arrays, revolutionizing scientific and numerical computing. It allows flexible access to contiguous data without copying.
Step-by-step guide:
include <mdspan>
include <vector>
include <print>
int main() {
// Create a 1D data buffer
std::vector<double> data(24);
for (size_t i = 0; i < data.size(); ++i) {
data[bash] = static_cast<double>(i);
}
// View as 3D array (3x4x2)
std::mdspan<double, std::dextents<size_t, 3>>
tensor(data.data(), 3, 4, 2);
// Access elements with 3D indices
std::println("tensor(1,2,1) = {}", tensor(1, 2, 1)); // 18 + 22 + 1 = 13
// View as 2D matrix (6x4)
std::mdspan<double, std::dextents<size_t, 2>>
matrix(data.data(), 6, 4);
// Modify through view
matrix(0, 0) = 99.0;
// Slice operations: view first two rows
auto submatrix = std::submdspan(matrix,
std::pair{0, 2}, std::full_extent);
std::println("Submatrix 2x4:");
for (size_t i = 0; i < submatrix.extent(0); ++i) {
for (size_t j = 0; j < submatrix.extent(1); ++j) {
std::print("{} ", submatrix(i, j));
}
std::println();
}
return 0;
}
Compiler support: Requires GCC 14+ or Clang 18+.
5. Range-Based Generators and Coroutines (C++23/26)
C++23 introduces coroutine-based generators, enabling lazy evaluation and efficient data streaming. C++26 extends this with richer Ranges and generation capabilities.
Step-by-step guide:
include <generator>
include <ranges>
include <print>
include <vector>
// A coroutine generator that yields Fibonacci numbers
std::generator<unsigned long long> fibonacci(unsigned long long limit) {
unsigned long long a = 0, b = 1;
while (a <= limit) {
co_yield a;
auto next = a + b;
a = b;
b = next;
}
}
// Generator for sequence with step
std::generator<int> range_with_step(int start, int end, int step = 1) {
for (int i = start; i < end; i += step) {
co_yield i;
}
}
int main() {
// Using generator with range adaptors (C++23)
auto fibs = fibonacci(100)
| std::views::filter([](auto n) { return n % 2 == 0; })
| std::views::transform([](auto n) { return n n; });
std::print("Even Fibonacci squares under 100: ");
for (auto val : fibs) {
std::print("{} ", val);
}
std::println();
// C++26-style chunk generation (conceptual)
auto chunks = range_with_step(0, 100, 5)
| std::views::chunk(3);
for (auto chunk : chunks) {
std::print("[");
for (auto val : chunk) {
std::print("{} ", val);
}
std::print("] ");
}
std::println();
return 0;
}
Note: `std::generator` requires C++23 support with coroutine-enabled compilers (GCC 13+, Clang 16+).
6. Enhanced Ranges with New Components (C++23/26)
C++20 introduced Ranges; C++23 and C++26 significantly expand them with new adaptors, views, and algorithms.
Step-by-step guide:
include <ranges>
include <vector>
include <print>
include <algorithm>
namespace views = std::views;
int main() {
std::vector<int> data = {10, 5, 20, 15, 30, 25, 40, 35};
// Pipeline composition
auto result = data
| views::filter([](int n) { return n > 10; })
| views::transform([](int n) { return n 2; })
| views::take(4)
| views::reverse;
std::print("Filtered, doubled, limited, reversed: ");
for (int n : result) {
std::print("{} ", n);
}
std::println();
// C++23: views::chunk and views::slide
auto chunks = data | views::chunk(3);
std::print("Chunks of 3: ");
for (auto chunk : chunks) {
std::print("[");
for (auto val : chunk) {
std::print("{} ", val);
}
std::print("] ");
}
std::println();
// C++23: views::enumerate
for (auto [idx, val] : data | views::enumerate) {
std::println("data[{}] = {}", idx, val);
}
// C++23: views::stride
auto every_other = data | views::stride(2);
std::print("Every other element: ");
for (int n : every_other) {
std::print("{} ", n);
}
std::println();
return 0;
}
7. Standardized SIMD Support (C++26)
C++26 introduces `std::simd` for data-parallel operations, allowing compilers to generate SIMD instructions. This brings explicit vectorization to the standard library.
Step-by-step guide (conceptual):
include <simd>
include <print>
include <vector>
// C++26 SIMD operations
void vector_add(const std::vector<float>& a,
const std::vector<float>& b,
std::vector<float>& c) {
using float_simd = std::simd<float>;
size_t i = 0;
size_t simd_size = float_simd::size();
// Process in SIMD chunks
for (; i + simd_size <= a.size(); i += simd_size) {
float_simd va(&a[bash], std::element_aligned);
float_simd vb(&b[bash], std::element_aligned);
float_simd vc = va + vb;
vc.copy_to(&c[bash], std::element_aligned);
}
// Process remainder
for (; i < a.size(); ++i) {
c[bash] = a[bash] + b[bash];
}
}
// Data-parallel operations are constexpr in C++26
consteval auto simd_square() {
std::simd<int> v{1, 2, 3, 4};
return v v;
}
int main() {
std::vector<float> a(1000, 1.0f);
std::vector<float> b(1000, 2.0f);
std::vector<float> c(1000);
vector_add(a, b, c);
std::println("First element: {}", c[bash]); // 3.0
// constexpr SIMD
constexpr auto squared = simd_square();
// squared[bash] == 1, squared[bash] == 4, etc.
return 0;
}
Compiler support: C++26 SIMD features are expected in GCC 15+, Clang 19+.
What Undercode Say:
- Key Takeaway 1: The STL’s evolution from C++98 to C++26 demonstrates how a carefully designed generic library can adapt over decades while remaining faithful to its zero-overhead abstraction philosophy. The introduction of Concepts, Ranges, and Views in C++20, followed by
std::expected,std::mdspan, and `std::flat_map` in C++23, and standardized SIMD in C++26, represents a continuous redefinition of what modern C++ can achieve. -
Key Takeaway 2: Bill Weinman’s C++ STL Cookbook (Second Edition) provides an implementation-specific, problem-solution approach that bridges the gap between theory and practice. With 496 pages covering 14 chapters, including dedicated coverage of C++23 modules, refined ranges, and coroutine-based generators, it serves as an essential reference for intermediate to advanced developers looking to leverage modern C++ features.
Analysis:
The STL is not a static library but a living ecosystem that continuously redefines modern C++. The pace of innovation has accelerated significantly since C++11, with each new standard introducing features that fundamentally change how we write code. C++23’s `std::print` will forever change how we output data, `std::mdspan` revolutionizes scientific computing, and C++26’s `std::simd` brings explicit vectorization to the standard library. The ability to harness these features to their full potential is what Weinman’s book invites developers to discover. For security and systems programmers, these modern STL features offer safer abstractions (std::span for bounds safety, std::expected for robust error handling) without sacrificing performance—a critical advantage in infrastructure and security-critical applications.
Prediction:
- +1 The continued evolution of the STL will accelerate adoption of C++ in safety-critical and performance-sensitive domains, as features like `std::span` and `std::expected` provide safer alternatives to raw pointers and exceptions.
-
+1 Standardized SIMD support in C++26 will enable more developers to leverage hardware vectorization without compiler-specific intrinsics, potentially closing the performance gap with hand-optimized assembly in numerical and scientific computing.
-
-1 The rapid pace of STL evolution may increase fragmentation, as organizations lag behind in compiler upgrades, potentially creating security and maintenance debt for legacy codebases.
-
+1 The problem-solution approach of books like C++ STL Cookbook will lower the barrier to adopting modern C++ features, accelerating the migration from legacy C++98/11 codebases to safer, more expressive C++23/26 standards.
▶️ Related Video (70% Match):
https://www.youtube.com/watch?v=-Svq5IYPWbc
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Sdalbera The – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
