The C++ STL Handbook

Containers, Algorithms, Iterators, Ranges, and Beyond

Introduction: What Is the STL?

1. The Original STL and Stepanov’s Vision
2. Separation of Containers, Iterators, and Algorithms
3. Generic Programming as a Design Philosophy
4. What This Book Covers and How to Read It

Chapter 1: Templates and Genericity

1. Function Templates: Syntax, Deduction, and Instantiation
2. Class Templates and Specialization
3. Template Constraints and SFINAE (Historical Context)
4. Concepts as Modern Compile-Time Constraints
5. How Templates Enable Zero-Cost Abstractions

Chapter 2: Iterators — The Bridge Between Containers and Algorithms

1. What Is an Iterator and Why Does It Exist?
2. Iterator Categories: Input, Output, Forward, Bidirectional, Random Access, Contiguous
3. Iterator Concepts in Modern C++
4. Dereferencing, Incrementing, Comparing: The Core Operations
5. Building Custom Iterators for Your Types

Chapter 3: Sequence Containers — Vectors, Deques, Lists, and Arrays

1. std::vector: Dynamic Arrays, Growth Strategy, Cache Locality, and Invalidation Rules
2. std::deque: Double-Ended Queues and Their Trade-offs
3. std::list and std::forward_list: Linked Lists in Modern C++
4. std::array and std::span: Fixed-Size and View-Based Alternatives
5. Choosing Your Sequence Container: A Decision Framework

Chapter 4: Associative Containers — Ordered Trees

1. How Balanced Trees Power std::map and std::set
2. Lookup, Insertion, Deletion: Complexity and Iterator Stability
3. Multisets and Multimaps: Handling Duplicate Keys
4. Key Comparison: Default Behavior and Custom Comparators
5. Range Queries and Ordered Traversal Patterns

Chapter 5: Unordered Containers — Hash Tables

1. Hash Tables: The Core Idea Behind Unordered Containers
2. std::unordered_set and std::unordered_map: Interfaces and Guarantees
3. Custom Hashers for User-Defined Types
4. Load Factor, Rehashing, and Performance Tuning
5. Ordered vs. Unordered: When Each Wins

Chapter 6: Container Adapters and Specialized Containers

1. Stack and Queue: Restricting Interfaces for Safety
2. Priority Queue: Heaps Behind a Simple Interface
3. std::bitset: Efficient Bit-Level Operations
4. Modern Specialized Containers: optional, variant, any, string_view
5. Adapter Design: Why Limiting an Interface Is a Feature

Chapter 7: Allocators — Controlling Memory Management

1. What Is an Allocator and Why Does It Matter?
2. The Default Allocator and How Containers Use It
3. Writing Custom Allocators: Requirements and Patterns
4. Pool Allocators and Arena Allocation for Performance
5. When (and When Not) to Customize Allocation

Chapter 8: Algorithms — Non-Modifying Operations

1. Iteration Patterns: For_Each, Find, Count, and Their Variants
2. Searching Algorithms: Binary Search, Lower Bound, Equal Range
3. Numeric Algorithms: Accumulate, Inner Product, Reduce
4. Relational Algorithms: Comparing Ranges Element-Wise
5. Predicates, Lambdas, and Projections in Algorithm Calls

Chapter 9: Algorithms — Modifying Operations

1. Copying and Moving: From std::copy to Transformative Operations
2. Filling and Generating Ranges Programmatically
3. The Erase-Remove Idiom and Modern Alternatives
4. Sorting Algorithms: Sort, Stable_Sort, Partial_Sort, and Their Guarantees
5. Merging, Shuffling, and Permuting Elements

Chapter 10: Function Objects, Lambdas, Predicates, and Comparators

1. Function Objects: Operator Overloading for Callability
2. Lambda Expressions: Syntax, Captures, and Mutability
3. Predicates: Boolean Conditions That Drive Algorithms
4. Comparators: Strict Weak Ordering and Custom Sort Keys
5. Projections: Extracting Values Before Applying Operations

Chapter 11: Utility Types and Helper Facilities

1. Pair and Tuple: Grouping Heterogeneous Values
2. Type Traits: Compile-Time Introspection for Generic Code
3. Reference Wrappers and Move Semantics Utilities
4. Chrono Library: Time Points, Durations, and Clocks
5. How Utilities Enable Advanced STL Patterns

Chapter 12: Ranges — The Modern C++ Revolution

1. From Iterators to Ranges: Why This Evolution Matters
2. Range Concepts: Borrowed Ranges, Sized Ranges, and Viewability
3. Views and Adapters: Filter, Transform, Take, Drop, and More
4. Pipelines: Composing Operations Readably and Lazily
5. Ranges Algorithms: The Modern Way to Process Data

Chapter 13: Parallelism and Execution Policies

1. Execution Policies: Sequential, Parallel, Vectorized, and Unsequenced
2. Thread Safety Requirements for Parallel Algorithms
3. When Parallelism Helps — And When It Hurts
4. Practical Patterns for Safe and Effective Parallel STL

Chapter 14: Design, Performance, and Expert Patterns

1. Internal Implementation Ideas: How STL Containers Are Built
2. Cache Locality, Allocation Costs, and Real-World Performance
3. Compile-Time Optimization: Inlining, Monomorphization, and NOOP Elimination
4. Advanced Composition Patterns for Production Code
5. Debugging STL Code: Tools, Diagnostics, and Common Pitfalls
6. STL Common Anti-Patterns and Modern Alternatives
7. Best Practices for Production-Quality STL Code

Conclusion: The STL as a Living System

1. What Mastery of the STL Actually Means
2. Design Principles That Transfer to Your Own Code
3. The Future: Ranges Evolution, Coroutines Integration, and Beyond
4. A Final Word on Writing C++ That Lasts

References