Data Structures and Algorithms with the C++ STL

Data Structures and Algorithms with the C++ STL

by John Farrier
Released February 2024
Publisher(s): Packt Publishing
ISBN: 9781835468555

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

Explore the C++ 23 STL with practical guidance on vectors, algorithms, and custom types for intermediate developers, enriched by real-world examples.

Key Features

  • Master the std::vector and understand why it should be your default container of choice
  • Understand each STL algorithm and its practical applications
  • Gain insights into advanced topics such as exception guarantees and thread safety
  • Purchase of the print or Kindle book includes a free PDF eBook

Book Description

While the Standard Template Library (STL) offers a rich set of tools for data structures and algorithms, navigating its intricacies can be daunting for intermediate C++ developers without expert guidance. This book offers a thorough exploration of the STL’s components, covering fundamental data structures, advanced algorithms, and concurrency features.

Starting with an in-depth analysis of the std::vector, this book highlights its pivotal role in the STL, progressing toward building your proficiency in utilizing vectors, managing memory, and leveraging iterators. The book then advances to STL’s data structures, including sequence containers, associative containers, and unordered containers, simplifying the concepts of container adaptors and views to enhance your knowledge of modern STL programming. Shifting the focus to STL algorithms, you’ll get to grips with sorting, searching, and transformations and develop the skills to implement and modify algorithms with best practices. Advanced sections cover extending the STL with custom types and algorithms, as well as concurrency features, exception safety, and parallel algorithms.

By the end of this book, you’ll have transformed into a proficient STL practitioner ready to tackle real-world challenges and build efficient and scalable C++ applications.

What you will learn

  • Streamline data handling using the std::vector
  • Master advanced usage of STL iterators
  • Optimize memory in STL containers
  • Implement custom STL allocators
  • Apply sorting and searching with STL algorithms
  • Craft STL-compatible custom types
  • Manage concurrency and ensure thread safety in STL
  • Harness the power of parallel algorithms in STL

Who this book is for

This book is for intermediate-level C++ developers looking to enhance their software development skills. Familiarity with basic C++ syntax and object-oriented programming (OOP) as well as some exposure to data structures and algorithms is assumed. Tailored to software engineers, computer science students, and hobbyist programmers, this book delves into C++ STL for practical application, performance enhancement, and efficient coding practices.

Table of contents

  1. Data Structures and Algorithms with the C++ STL
  2. Contributors
  3. About the author
  4. About the reviewer
  5. Preface
    1. Who this book is for
    2. What this book covers
    3. To get the most out of this book
    4. Download the example code files
    5. Conventions used
    6. Get in touch
    7. Share Your Thoughts
    8. Download a free PDF copy of this book
  6. Part 1: Mastering std::vector
  7. Chapter 1: The Basics of std::vector
    1. Technical requirements
    2. The significance of std::vector
      1. A basic comparison of C-style arrays and std::vector
      2. Comparison of C-style arrays and std::vector for memory management
    3. Declaring and initializing std::vector
      1. Declaring a vector
      2. Initializing a vector
    4. Accessing elements
      1. Random access
      2. Accessing the first and last elements
      3. Vector size
    5. Adding and removing elements
      1. Adding elements
      2. Removing elements
      3. Capacity
      4. Prefer using empty() when possible
      5. Clearing all elements
    6. Summary
  8. Chapter 2: Mastering Iterators with std::vector
    1. Technical requirements
    2. Types of iterators in the STL
      1. Input iterators
      2. Output iterators
      3. Forward iterators
      4. Reverse iterators
      5. Bidirectional iterators
      6. Random access iterators
    3. Basic iteration techniques with std::vector
      1. Iterating over std::vector
      2. Basic iteration using iterators
      3. Using constant iterators
      4. Benefits of iteration
    4. Using std::begin and std::end
    5. Understanding iterator requirements
    6. Range-based for loops
      1. Overview of range-based for loops
      2. When to use range-based for loops
      3. Modifying elements during iteration
    7. Creating a custom iterator
      1. The appeal of custom iterators
      2. Core requirements
      3. Iterator categories and their specialties
      4. A custom iterator example
      5. Custom iterator challenges and use cases
      6. Illustrative use cases of custom iterators
    8. Summary
  9. Chapter 3: Mastering Memory and Allocators with std::vector
    1. Technical requirements
    2. Understanding capacity versus size
      1. Revisiting the basics
      2. What exactly is capacity?
      3. Why this distinction matters
      4. Looking under the hood
    3. Resizing and reserving memory
      1. The power of resize()
      2. Enter reserve()
      3. Optimizing with shrink_to_fit()
      4. Real-world relevance
    4. Custom allocator basics
      1. The role and responsibility of an allocator
      2. Under the hood – the allocator interface
      3. Trade-offs and the need for custom allocators
      4. Choosing std::allocator over new, delete, and managed pointers
    5. Creating a custom allocator
      1. Custom allocators – the heart of memory flexibility
      2. Understanding the motivation behind custom allocators
      3. Memory pools – a popular custom allocator strategy
      4. Unlocking the potential of custom allocators
    6. Allocators and container performance
      1. Why allocators matter in performance
      2. The performance characteristics of std::allocator
      3. When to consider alternative allocators
      4. Profiling – the key to making informed decisions
    7. Summary
  10. Chapter 4: Mastering Algorithms with std::vector
    1. Technical requirements
    2. Sorting a vector
      1. Getting started with std::sort
      2. The engine under the hood – introsort
      3. Efficiency unparalleled – O(n log n)
      4. Sorting in descending order
      5. Sorting custom data types
      6. Pitfalls and precautions
    3. Searching elements
      1. Linear search with std::find
      2. Binary search techniques
      3. Using std::lower_bound and std::upper_bound
      4. Binary search versus linear search – efficiency and versatility
    4. Manipulating vectors
      1. Transforming with std::copy
      2. Reversing elements with std::reverse
      3. Rotating vectors with std::rotate
      4. Filling a vector with std::fill
      5. Putting manipulation to use
      6. Considerations in manipulation
    5. Custom comparators and predicates
      1. Understanding comparators
      2. The power of predicates
      3. Crafting effective comparators and predicates
      4. User-defined structs and classes
    6. Understanding container invariants and iterator invalidation
      1. Understanding iterator invalidation
      2. Strategies to counteract invalidation
      3. Dealing with invalidation in multi-threaded scenarios
    7. Summary
  11. Chapter 5: Making a Case for std::vector
    1. Performance considerations
      1. Comparison with other containers
      2. The memory advantage
      3. The takeaway
    2. Practical use cases
      1. A resizable dynamic array at heart
      2. Data processing and analytics
      3. Graphics and game development
      4. Beyond just containers
    3. Versatility and efficiency
      1. A testament to versatility
      2. Efficiency isn’t just about speed
      3. A safe default, but not the only option
    4. Summary
  12. Part 2: Understanding STL Data Structures
  13. Chapter 6: Advanced Sequence Container Usage
    1. Technical requirements
    2. std::array
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    3. std::vector
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    4. std::deque
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    5. std::list
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    6. std::forward_list
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    7. std::string
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
  14. Chapter 7: Advanced Ordered Associative Container Usage
    1. Technical requirements
    2. std::set
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    3. std::map
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    4. std::multiset
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    5. std::multimap
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
  15. Chapter 8: Advanced Unordered Associative Container Usage
    1. Technical requirements
    2. std::unordered_set
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    3. std::unordered_map
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    4. std::unordered_multiset
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    5. std::unordered_multimap
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
  16. Chapter 9: Advanced Container Adaptor Usage
    1. Technical requirements
    2. std::stack
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    3. std::queue
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    4. std::priority_queue
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    5. std::flat_set
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Best practices
    6. std::flat_map
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Best practices
    7. std::flat_multiset
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Best practices
    8. std::flat_multimap
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Best practices
  17. Chapter 10: Advanced Container View Usage
    1. Technical requirements
    2. std::span
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Example
      14. Best practices
    3. std::mdspan
      1. Purpose and suitability
      2. Ideal use cases
      3. Performance
      4. Memory management
      5. Thread safety
      6. Extensions and variants
      7. Sorting and searching complexity
      8. Special interface and member functions
      9. Comparisons
      10. Interactions with algorithms
      11. Exceptions
      12. Customization
      13. Best practices
  18. Part 3: Mastering STL Algorithms
  19. Chapter 11: Fundamental Algorithms and Searching
    1. Technical requirements
    2. Sorting
    3. Checking conditions
    4. Counting and finding
    5. Searching and comparison
    6. Best practices
    7. Summary
  20. Chapter 12: Manipulation and Transformation
    1. Technical requirements
    2. Copying and moving in STL containers
      1. Copying semantics in the STL
      2. Moving semantics in the STL
      3. Copying versus moving – a deliberate choice
    3. Exploring return value optimization
    4. Filling and generating in STL containers
      1. Populating with static assignment
      2. Dynamic generation with the STL
      3. Ensuring relevance and efficiency
    5. Removing and replacing in STL containers
      1. The essence of removal
      2. Replacement
      3. A balancing act
    6. Swapping and reversing in STL containers
      1. Swapping – the art of interchanging
      2. Reversing – a glimpse from the end
      3. Deduplication – singling out the unique
      4. Sampling – a slice of the whole
    7. Best practices
    8. Summary
  21. Chapter 13: Numeric and Range -Based Operations
    1. Technical requirements
    2. Basic numeric operations
      1. Generating sequences with std::iota
      2. Summing elements with std::accumulate
      3. Adjacent elements and their interactions with std::adjacent_difference
      4. Inner products with std::inner_product
    3. Advanced numeric operations
    4. Operations on sorted ranges
    5. Best practices
    6. Summary
  22. Chapter 14: Permutations, Partitions, and Heaps
    1. Technical requirements
    2. Partitioning
      1. std::partition and its power
      2. Checking partitions with std::is_partitioned
      3. The utility of std::partition_point
      4. Partitioning beyond basic sequences
    3. Permutations
      1. Generating permutations with std::next_permutation
      2. Predecessor permutations with std::prev_permutation
      3. Shuffling elements randomly with std::shuffle
      4. Rotating sequences with std::rotate
    4. Heap operations
      1. Constructing heaps with std::make_heap
      2. Adding and removing elements – std::push_heap and std::pop_heap
      3. Heap-based sorting – the power of std::sort_heap
      4. Checking heap validity with std::is_heap
      5. The significance of heaps in today’s computing
    5. Best practices
    6. Summary
  23. Chapter 15: STL with Ranges
    1. Technical requirements
    2. Introduction to ranges
      1. Understanding the essence of ranges
      2. Why the shift to ranges?
      3. A glimpse into range operations
      4. Looking ahead – the power of modern STL
    3. Ranges for sorting algorithms
      1. Traditional STL sorting – a recap
      2. Range-based sorting – the basics
      3. Embracing composability in sorting
      4. Advantages beyond syntax – why ranges shine in sorting
      5. The revolution of ranges in sorting
    4. Ranges for searching algorithms
      1. Finding elegance – range-based searching
      2. Chaining and filtering – the beauty of composability
      3. Understanding views in searches
      4. The extended toolkit – more than just find
    5. Best practices
      1. Embracing the power of chaining
      2. Guarding against range pitfalls – lifetime awareness
      3. Performance considerations – laziness and evaluation
      4. Readability over brevity – striking the balance
      5. Adhering to range idioms – keep it standard
    6. Summary
  24. Part 4: Creating STL-Compatible Types and Algorithms
  25. Chapter 16: Creating STL-Types Containers
    1. Technical requirements
    2. The advantages of STL-compatible types
      1. One language, one approach
      2. Reusability – the gift that keeps giving
      3. Efficiency in the familiar
      4. Paving the way forward
    3. Interacting with STL algorithms
      1. The centrality of iterators
      2. Adapting to algorithmic expectations
      3. Error handling and feedback mechanisms
      4. Algorithmic efficiency and your type
      5. Laying a solid foundation
    4. Essential requirements for compatibility
      1. The cornerstones of compatibility
      2. The vitality of iterators
      3. Embracing value semantics
      4. Operational guarantees
      5. Size and capacity queries
      6. Element access and manipulation
      7. Consistency in exception safety
      8. Looking forward to enhanced integration
    5. Crafting iterators for custom types
      1. Choosing the right iterator type
      2. Crafting the basic components
      3. Addressing iterator categories with type traits
      4. End iterators – signifying the finish line
      5. Considerations for const iterators
      6. Performance optimizations and advanced techniques
      7. Embracing the iterative spirit
    6. Effective operator overloading
      1. Operator overloading in C++
      2. Considerations in overloading
      3. Implementing arithmetic operators for custom types
      4. Overloading relational operators for clear comparisons
      5. Simplifying tasks with assignment and compound assignment
      6. Stream operators for efficient I/O
      7. Operator precedence and associativity in overloading
      8. The role of operator overloading in C++
    7. Creating custom hash functions
      1. Interoperability with STL containers
      2. Custom type semantics
      3. The characteristics of a good hash function
      4. Example for the creation of a custom hash function
    8. Summary
  26. Chapter 17: Creating STL -Compatible Algorithms
    1. Technical requirements
    2. Template functions
      1. A primer on function templates
      2. Variadic templates – multiplicity in templates
      3. SFINAE – fine-tuning template substitution
      4. Harnessing SFINAE with std::enable_if
    3. Overloading
      1. Crafting multiple algorithm versions for STL containers
      2. Function resolution – navigating the intricacies
      3. Overloading with care – clarity and consistency
    4. Creating generic algorithms
      1. Toward a type-independent approach
      2. Embracing iterators – the bridge to generics
      3. Predicates – customizing algorithm behavior
      4. The magic of functors – enhancing flexibility
    5. Customizing existing algorithms
      1. Looking at the decorator pattern in action
      2. Harnessing the power of lambda functions
      3. Mixing patterns with lambdas for ultimate customization
    6. Summary
  27. Chapter 18: Type Traits and Policies
    1. Technical requirements
    2. Understanding and using type traits
      1. Enhancing code adaptability with type traits
      2. Empowering metaprogramming with type traits
      3. Toward more informed and adaptable code
    3. Utilizing type traits with the STL
      1. Working with data types
      2. Working with algorithms
    4. Understanding and using policies in C++
      1. Benefits with respect to the STL
      2. Building modular components using policies
      3. Potential challenges
      4. The role of policies in modern C++
    5. Using policies with the STL
      1. Memory allocation policies
      2. Sorting policies for versatile algorithms
      3. Fine-tuning data structures with policies
    6. Summary
  28. Part 5: STL Data Structures and Algorithms: Under the Hood
  29. Chapter 19: Exception Safety
    1. Technical requirements
    2. Basic exception safety
      1. The pivotal role of program invariants in the STL
      2. Resource integrity – the guardian of robust software
      3. Harnessing the STL for basic exception safety
    3. Strong exception safety
      1. Navigating STL containers with strong guarantees
      2. Crafting custom STL containers with strong guarantees
      3. Infusing exception safety into custom STL algorithms
      4. Exception safety is the path to robust applications
    4. The effect of noexcept on STL operations
      1. An introduction to noexcept
      2. Application to STL data types
      3. Application to STL algorithms
    5. Summary
  30. Chapter 20: Thread Safety and Concurrency with the STL
    1. Technical requirements
    2. Concurrency versus thread safety
      1. Thread safety – a pillar for stable concurrency
      2. The interplay of concurrency and thread safety
      3. Challenges and rewards
      4. Concurrency without thread safety – a recipe for chaos
    3. Understanding thread safety
      1. Thread safety in STL containers – laying the groundwork
      2. Grasping the thread-safe nature of STL algorithms
      3. Race conditions – the ghosts in the machine
      4. Safeguarding concurrency – the way forward
    4. Race conditions
      1. Steering clear of a silent peril – race conditions in the STL
      2. The anatomy of a race condition in the STL
      3. More than meets the eye
      4. Anticipating race conditions
      5. Safeguarding your code – a proactive stance
    5. Mutexes and locks
      1. From manual to automatic – lock guards and unique locks
      2. Avoiding the stalemate – deadlock prevention
      3. Incorporating mutexes with STL containers
    6. STL containers and thread safety
      1. When safety needs reinforcements – concurrent modifications
      2. Container iterators – the fragile bridge
      3. Containers with a built-in shield – concurrent containers
    7. Specific container concerns
      1. Behaviors of std::vector in multi-threading
      2. Characteristics of std::list in concurrency
      3. Considerations with associative containers
      4. Concurrency aspects of unordered containers
      5. Insights into container adaptors
    8. Concurrency support within the STL
      1. Introduction to threads
      2. The advent of asynchronous tasks
      3. Atomic operations
      4. Potential concurrent challenges
      5. Using the STL’s concurrency features
    9. Using std::thread, std::async, std::future, and thread -local storage
      1. Initiating threads using std::thread
      2. Managing asynchronous operations with std::async and std::future
      3. Preserving data consistency using thread-local storage
      4. Integrating tools for proficient concurrency
    10. Concurrent data structures in the STL
      1. The STL’s concurrency-optimized containers
      2. Striving for maximum efficiency in concurrent environments
      3. Best practices in action
    11. Summary
  31. Chapter 21: STL Interaction with Concepts and Coroutines
    1. Technical requirements
    2. Concepts
      1. A brief introduction to concepts
      2. Refined constraints in STL algorithms
      3. Effectively constraining templates
      4. Enhanced data structures with explicit requirements
      5. Custom concepts and STL interactions
      6. Potential challenges and caveats
    3. Coroutines
      1. Understanding coroutines – a refresher
      2. STL algorithms and coroutine integration
      3. Coroutines and STL data structures
      4. Potential synergies with ranges and views
      5. Looking ahead – a paradigm shift
    4. Summary
  32. Chapter 22: Parallel Algorithms with the STL
    1. Technical requirements
    2. Introduction to execution policies
      1. The <execution> header– enabling parallelism in STL algorithms
      2. Implementing parallel execution
      3. Reflecting on the transition to parallel STL
      4. Incorporating execution policies
      5. Integrating policies with standard algorithms
      6. Understanding parallel execution policies
      7. Selecting the appropriate execution policy
    3. The impact of constexpr on algorithms and containers
      1. Evolution of constexpr
      2. Algorithms and the role of constexpr
      3. Containers and constexpr integration
    4. Performance considerations
      1. Parallelism overhead
      2. Determining optimal data size
      3. Data access and synchronization challenges
      4. False sharing – a subtle performance issue
      5. Load balancing
      6. The importance of profiling
    5. Summary
  33. Index
    1. Why subscribe?
  34. Other Books You May Enjoy
    1. Packt is searching for authors like you
    2. Share Your Thoughts
    3. Download a free PDF copy of this book

Product information

  • Title: Data Structures and Algorithms with the C++ STL
  • Author(s): John Farrier
  • Release date: February 2024
  • Publisher(s): Packt Publishing
  • ISBN: 9781835468555