Index
A
- absolute time
- and relative time, converting with std chrono / Converting between absolute and relative times with std::chrono
- acyclic directed graph (DAG) / Implementing a tiny automatic parallelization library with std::future
- algorithms
- implementing, in terms of iterators / Implementing algorithms in terms of iterators
- composing, from standard gather algorithm / Composing useful algorithms from standard algorithms - gather
- aliasing / Sampling large vectors
- amortized complexity / There's more...
- ASCII Mandelbrot renderer
- implementing / Implementing an ASCII Mandelbrot renderer
- parallelizing, with std async / Parallelizing the ASCII Mandelbrot renderer using std::async
- automatic file renamer
- implementing / Implementing an automatic file renamer
B
- bidirectional iterator / Bidirectional iterator
- binary folds / There's more...
- Boyer-Moore-Horspool algorithm / How it works...
- Boyer-Moore algorithm / How it works...
- bracket initializer rules
- profiting from / Profiting from the new bracket initializer rules
- bundled return values
- unpacking, structured bindings used / Using structured bindings to unpack bundled return values
C
- c++ / Introduction
- C++ reference
- reference link / Introduction
- C++ standard library / Introduction
- canonical file paths
- obtaining, from relative paths / Getting canonical file paths from relative paths
- cartesian product
- pairs, generating of input at compile time / Generating cartesian product pairs of any input at compile time
- about / Generating cartesian product pairs of any input at compile time
- checked iterators
- iterator code, verifying / Automatically checking iterator code with checked iterators
- clock objects
- characteristics / How it works...
- code
- parallelizing, that uses standard algorithms / Automatically parallelizing code that uses standard algorithms
- compile time
- cartesian product pairs, generating of input / Generating cartesian product pairs of any input at compile time
- compile time decisions
- simplifying, with constexpr if / Simplifying compile time decisions with constexpr-if
- complex objects
- initializing, from file input / Initializing complex objects from file input
- complex predicates
- creating, with logical conjunction / Creating complex predicates with logical conjunction
- concatenation
- functions, composing / Composing functions by concatenation
- constexpr if
- compile time decisions, simplifying / Simplifying compile time decisions with constexpr-if
- constructor calls
- deducing, template class type result / Letting the constructor automatically deduce the resulting template class type
- container adapters / Container adapters
- containers
- items, copying to other containers / Copying items from containers to other containers
- sorting / Sorting containers
- items, removing / Removing specific items from containers
- contents, transforming / Transforming the contents of containers
- filling, from std istream iterators / Filling containers from std::istream iterators
- contents
- transforming, of containers / Transforming the contents of containers
- contiguous iterator / Contiguous iterator
- contiguous storage / Contiguous storage
- custom string classes
- creation, by inheriting from std / Creating custom string classes by inheriting from std::char_traits
- custom types
- std unordered map, using / Using std::unordered_map with custom types
D
- data structures
- composing, with std tuple / Quickly composing data structures with std::tuple
- deadlocks
- avoiding, with std scoped lock / Avoiding deadlocks with std::scoped_lock
- dictionary merging tool
- implementing / Implementing a dictionary merging tool
- different member values
- sharing, of same object / Sharing different member values of the same object
- directories
- files, listing / Listing all files in directories
- disk usage counter
- implementing / Implementing a disk usage counter
- distribution
- uniform int distributions / How it works...
- normal distribution / How it works...
- Bernoulli distribution / How it works...
- discrete distribution / How it works...
E
- erase-remove idiom
- using, on std vector / Using the erase-remove idiom on std::vector
- exception safe shared locking
- with std unique lock / Performing exception safe shared locking with std::unique_lock and std::shared_lock
- std shared lock / Performing exception safe shared locking with std::unique_lock and std::shared_lock
- mutex classes / Mutex classes
- lock classes / Lock classes
F
- failure
- signalizing, with std optional / Safely signalizing failure with std::optional
- Fibonacci iterator / There's more...
- file input
- complex objects, initializing / Initializing complex objects from file input
- files
- output, redirecting to / Redirecting output to files for specific code sections
- listing, in directories / Listing all files in directories
- file types
- statistics, calculating / Calculating statistics about file types
- filtering
- algorithms, used / How it works...
- first in, first out (FIFO) / Implementing a personal to-do list using std::priority_queue
- folder size
- reducing, with symlinks and tool implementing / Implementing a tool that reduces folder size by substituting duplicates with symlinks
- fold expressions
- handy helper functions, implementing / Implementing handy helper functions with fold expressions
- about / How it works...
- folding / How it works...
- format guard / How to do it...
- formatting modifiers / How it works...
- format types
- forward iterator / Forward iterator
- Fourier transform formula
- about / Implementing the Fourier transform formula with STL numeric algorithms
- implementing, with STL numeric algorithms / Implementing the Fourier transform formula with STL numeric algorithms
- fractal / Implementing an ASCII Mandelbrot renderer
- functional objects
- reference link / There's more...
- functions
- defining, on run with lambda expressions / Defining functions on the run using lambda expressions
- capture list / Capture list
- mutable / mutable (optional)
- constexpr / constexpr (optional)
- exception attr / exception attr (optional)
- return type / return type (optional)
- composing, by concatenation / Composing functions by concatenation
- applying, on tuples / Applying functions on tuples
G
- generic data structures
- filling, iterator adapters used / Using iterator adapters to fill generic data structures
- grep-like text search tool
- implementing / Implementing a grep-like text search tool
H
- handy helper functions
- implementing, with fold expressions / Implementing handy helper functions with fold expressions
- ranges, matching against individual items / Match ranges against individual items
- multiple insertions, verifying / Check if multiple insertions into a set are successful
- parameters, verifying within range / Check if all the parameters are within a certain range
- multiple items, pushing into vector / Pushing multiple items into a vector
- hash tables / Hash tables
- header-only libraries
- enabling, with inline variables / Enabling header-only libraries with inline variables
I
- I/O manipulators / Formatting your output with I/O stream manipulators
- I/O stream manipulators
- used, for output formatting / Formatting your output with I/O stream manipulators
- if statement
- variable scopes, limiting / Limiting variable scopes to if and switch statements
- initialization
- postponing, with std call once / Safely postponing initialization with std::call_once
- inline variables
- header-only libraries, enabling / Enabling header-only libraries with inline variables
- input
- tokenizing, with regular expression library / Tokenizing input with the regular expression library
- input iterator / Input iterator
- input sequences
- permutations, generating / Generating permutations of input sequences
- insertion hints / How it works...
- insertion hint semantics
- of std map insert / Knowing the new insertion hint semantics of std::map::insert
- items
- inserting, into std map efficiently / Inserting items efficiently and conditionally into std::map
- inserting, into std map conditionally / Inserting items efficiently and conditionally into std::map
- copying, from containers to other containers / Copying items from containers to other containers
- removing, from containers / Removing specific items from containers
- finding, in ordered vector / Finding items in ordered and unordered vectors
- finding, in unordered vectors / Finding items in ordered and unordered vectors
- iterable range
- building / Building your own iterable range
- iterations
- terminating, over ranges with iterator sentinels / Terminating iterations over ranges with iterator sentinels
- iterator adapters
- using, to fill generic data structures / Using iterator adapters to fill generic data structures
- about / Using iterator adapters to fill generic data structures
- std back insert iterator / std::back_insert_iterator
- std front insert iterator / std::front_insert_iterator
- std insert iterator / std::insert_iterator
- std istream iterator / std::istream_iterator
- std ostream iterator / std::ostream_iterator
- iterator categories
- about / Iterator categories
- input iterator / Input iterator
- forward iterator / Forward iterator
- bidirectional iterator / Bidirectional iterator
- random access iterator / Random access iterator
- contiguous iterator / Contiguous iterator
- output iterator / Output iterator
- mutable iterator / Mutable iterator
- iterator code
- verifying, with checked iterators / Automatically checking iterator code with checked iterators
- iterators
- about / Introduction
- compatibility, with STL iterator categories / Making your own iterators compatible with STL iterator categories
- algorithms, implementing / Implementing algorithms in terms of iterators
- iterator sentinels
- iterations, terminating over ranges / Terminating iterations over ranges with iterator sentinels
K
- keys
- modifying, of std map items / Efficiently modifying the keys of std::map items
L
- lambda expressions
- about / Introduction
- used, for defining functions on run / Defining functions on the run using lambda expressions
- lambdas
- wrapping, into std function for polymorphy adding / Adding polymorphy by wrapping lambdas into std::function
- used, for implementing transform if / Implementing transform_if using std::accumulate and lambdas
- launch policy / How it works...
- legacy APIs
- resource handling, simplified with smart pointers / Simplifying resource handling of legacy APIs with smart pointers
- list storage / List storage
- lock classes / Lock classes
- logical conjunction
- complex predicates, creating / Creating complex predicates with logical conjunction
M
- merge / Implementing a dictionary merging tool
- multiple functions
- calling, with same input / Calling multiple functions with the same input
- mutex classes / Mutex classes
O
- object
- different member values, sharing / Sharing different member values of the same object
- One Definition Rule (ODR) / How it works...
- optimal implementation
- ordered vetors
- items, finding / Finding items in ordered and unordered vectors
- output
- formatting, with I/O stream manipulators / Formatting your output with I/O stream manipulators
- redirecting, to files / Redirecting output to files for specific code sections
- output iterator / Output iterator
P
- parallelization
- about / Introduction
- code, that uses standard algorithms / Automatically parallelizing code that uses standard algorithms
- STL algorithms, supporting / Which STL algorithms can we parallelize this way?
- execution policies, working / How do those execution policies work?
- vectorization / What does vectorization mean?
- library, implementing with std future / Implementing a tiny automatic parallelization library with std::future
- path normalizer
- implementing / Implementing a path normalizer
- permutations
- generating, of input sequences / Generating permutations of input sequences
- personal to do list
- implementing, std priority queue used / Implementing a personal to-do list using std::priority_queue
- policy flags / How it works...
- polymorphy
- adding, by wrapping lambdas into std function / Adding polymorphy by wrapping lambdas into std::function
- predicates / Creating complex predicates with logical conjunction
- producer/consumer idiom
- implementing, with std condition variable / Implementing the producer/consumer idiom with std::condition_variable
- producers/consumers idiom
- implementing, with std condition variable / Implementing the multiple producers/consumers idiom with std::condition_variable
- program
- suspending, for specific time with thread / Putting a program to sleep for specific amounts of time
R
- random access iterator / Random access iterator
- random number engine
- random numbers
- ranges library
- about / Ranges library
- reference link / Ranges library
- readable exceptions
- catching from std iostream errors / Catching readable exceptions from std::iostream errors
- regular expression library
- input, tokenizing / Tokenizing input with the regular expression library
- regular expressions / Introduction
- relative paths
- canonical file paths, obtaining from / Getting canonical file paths from relative paths
- Resource Acquisition Is Initialization (RAII) / How it works...
- resource handling
- simplifying, of legacy APIs with smart pointers / Simplifying resource handling of legacy APIs with smart pointers
- resources
- handling, with std unique ptr / Automatically handling resources with std::unique_ptr
- resulting template class type
- deducing, with constructor / Letting the constructor automatically deduce the resulting template class type
- return value optimization (RVO) / There's more...
- reverse iterator adapters
- using, for iterating other way round / Iterating the other way around using reverse iterator adapters
- about / Iterating the other way around using reverse iterator adapters
- RPN calculator
- implementing, with std stack / Implementing a simple RPN calculator with std::stack
S
- sanitizer
- detecting, bugs example / How it works...
- sanitizers
- about / How it works...
- references / There's more...
- search input suggestion generator
- implementing, with trie / Implementing a search input suggestion generator with tries
- search trees / Search trees
- shared heap memory
- handling, with std shared ptr / Automatically handling shared heap memory with std::shared_ptr
- shared objects
- weak pointers, dealing with / Dealing with weak pointers to shared objects
- smart pointers
- resource handling, simplified of legacy APIs / Simplifying resource handling of legacy APIs with smart pointers
- sorting
- algorithms, used / How it works...
- split algorithm
- building / Building our own algorithm - split
- standard algorithms
- code, parallelizing / Automatically parallelizing code that uses standard algorithms
- standard gather algorithm
- algorithms, composing / Composing useful algorithms from standard algorithms - gather
- std accumulate
- used, for implementing transform if / Implementing transform_if using std::accumulate and lambdas
- std any
- void , replacing with / Replacing void* with std::any for more type safety
- std async
- used, for pushing the execution task to background / Pushing the execution of tasks into the background using std::async
- using, for parallelizing ASCII Mandelbrot renderer / Parallelizing the ASCII Mandelbrot renderer using std::async
- std back insert iterator / std::back_insert_iterator
- std binary search algorithm / How it works...
- std call once
- initialization, postponing / Safely postponing initialization with std::call_once
- using / Safely postponing initialization with std::call_once
- std char traits
- inheriting, custom string classes creation / Creating custom string classes by inheriting from std::char_traits
- std chrono
- absolute and relative times, converting between / Converting between absolute and relative times with std::chrono
- std clamp
- vector, values limiting to numeric range / Limiting the values of a vector to a specific numeric range with std::clamp
- std condition variable
- producer/consumer idiom, implementing / Implementing the producer/consumer idiom with std::condition_variable
- about / Implementing the producer/consumer idiom with std::condition_variable
- producers/consumers idiom, implementing / Implementing the multiple producers/consumers idiom with std::condition_variable
- std count use
- synchronizing, concurrently / Synchronizing concurrent std::cout use
- std equal range / How it works...
- std find algorithm / How it works...
- std find if algorithm / How it works...
- std front insert iterator / std::front_insert_iterator
- std function
- polymorphy, added by wrapping lambdas / Adding polymorphy by wrapping lambdas into std::function
- std future
- parallelization library, implementing / Implementing a tiny automatic parallelization library with std::future
- std insert iterator / std::insert_iterator
- std iostream errors
- readable exceptions, catching / Catching readable exceptions from std::iostream errors
- std istream iterator / std::istream_iterator
- std istream iterators
- containers, filling / Filling containers from std::istream iterators
- std lower bound / How it works...
- std map
- items, inserting conditionally / Inserting items efficiently and conditionally into std::map
- items, inserting efficiently / Inserting items efficiently and conditionally into std::map
- word frequency counter, implementing / Implementing a word frequency counter with std::map
- std map insert
- insertion hint semantics / Knowing the new insertion hint semantics of std::map::insert
- std map items
- keys, modifying / Efficiently modifying the keys of std::map items
- std multimap
- writing style helper tool, implementing to find long sentences in texts / Implement a writing style helper tool for finding very long sentences in text with std::multimap
- std optional
- failure, signalizing / Safely signalizing failure with std::optional
- std ostream iterator / std::ostream_iterator
- std ostream iterators
- generic printing / Generic printing with std::ostream iterators
- std priority queue
- used, for implementing personal to do list / Implementing a personal to-do list using std::priority_queue
- std ratio
- used, for converting time units / Converting between different time units using std::ratio
- std scoped lock
- deadlock, avoiding / Avoiding deadlocks with std::scoped_lock
- std shared lock
- exception safe shared locking / Performing exception safe shared locking with std::unique_lock and std::shared_lock
- std shared ptr
- shared heap memory, handling / Automatically handling shared heap memory with std::shared_ptr
- std stack
- RPN calculator, implementing / Implementing a simple RPN calculator with std::stack
- handling / Stack handling
- operands, distinguishing from operations / Distinguishing operands from operations from user input
- operands, distinguishing from user input / Distinguishing operands from operations from user input
- mathematical operation, selecting / Selecting and applying the right mathematical operation
- mathematical operation, applying / Selecting and applying the right mathematical operation
- std string
- std tuple
- data structures, composing with / Quickly composing data structures with std::tuple
- std unique lock
- exception safe shared locking / Performing exception safe shared locking with std::unique_lock and std::shared_lock
- std unique ptr
- resources, handling with / Automatically handling resources with std::unique_ptr
- std unordered map
- using, with custom types / Using std::unordered_map with custom types
- std upper bound / How it works...
- std variant
- different types, storing / Storing different types with std::variant
- std vector
- erase-remove idiom, using / Using the erase-remove idiom on std::vector
- instances, accessing / Accessing std::vector instances the fast or the safe way
- instances, sorting / Keeping std::vector instances sorted
- STL algorithms
- about / Making your own iterators compatible with STL iterator categories, Introduction, Introduction
- benefits / Introduction
- used, for implementing trie class / Implementing a trie class using STL algorithms
- for distribution / Generating random numbers and letting the STL shape specific distributions
- STL iterator categories
- iterators, compatibility / Making your own iterators compatible with STL iterator categories
- STL numeric algorithms
- Fourier transform formula, implementing / Implementing the Fourier transform formula with STL numeric algorithms
- stream classes / Introduction
- stream state manipulators / How it works...
- strings
- patterns, locating with std search / Locating patterns in strings with std::search and choosing the optimal implementation
- compressing / Compressing and decompressing strings
- decompressing / Compressing and decompressing strings
- about / Introduction
- creating / Creating, concatenating, and transforming strings
- concatenating / Creating, concatenating, and transforming strings
- transforming / Creating, concatenating, and transforming strings
- whitespace, trimming from beginning / Trimming whitespace from the beginning and end of strings
- whitespace, trimming from end / Trimming whitespace from the beginning and end of strings
- structured bindings
- using, to unpack bundled return values / Using structured bindings to unpack bundled return values
- about / Using structured bindings to unpack bundled return values
- switch statement
- variable scopes, limiting / Limiting variable scopes to if and switch statements
- symlinks
- used, reducing folder size and tool implementing / Implementing a tool that reduces folder size by substituting duplicates with symlinks
T
- tasks
- execution, pushing to background std async used / Pushing the execution of tasks into the background using std::async
- text file
- words, counting / Counting all words in a file
- threads
- starting / Starting and stopping threads
- stopping / Starting and stopping threads
- time units
- converting, std ratio used / Converting between different time units using std::ratio
- tool
- implementing, for reducing folder size with symlinks / Implementing a tool that reduces folder size by substituting duplicates with symlinks
- transform if
- implementing, std accumulate used / Implementing transform_if using std::accumulate and lambdas
- implementing, lambdas used / Implementing transform_if using std::accumulate and lambdas
- trie
- about / Implementing a trie class using STL algorithms
- search input suggestion generator, implementing / Implementing a search input suggestion generator with tries
- trie class
- implementing, STL algorithms used / Implementing a trie class using STL algorithms
- tripwire feature / How it works...
- tuples
- functions, applying / Applying functions on tuples
- operator / operator<< for tuples
- zip function / The zip function for tuples
U
- unary fold / How it works...
- unordered vectors
- items, finding / Finding items in ordered and unordered vectors
- unpacking / Using structured bindings to unpack bundled return values
- unsorted std vector
- items, deleting in O (1) time / Deleting items from an unsorted std::vector in O(1) time
- user input
- values, reading from / Reading values from user input
V
- values
- reading, from user input / Reading values from user input
- variable scopes
- limiting, to if statement / Limiting variable scopes to if and switch statements
- limiting, to switch statement / Limiting variable scopes to if and switch statements
- vectorization / What does vectorization mean?
- vectors
- values, limiting to numeric range with std clamp / Limiting the values of a vector to a specific numeric range with std::clamp
- sampling / Sampling large vectors
- error sum, calculating / Calculating the error sum of two vectors
- void
- replacing, with std any / Replacing void* with std::any for more type safety
W
- weak pointers
- dealing with, to shared objects / Dealing with weak pointers to shared objects
- word frequency counter
- implementing, with std map / Implementing a word frequency counter with std::map
- words
- consecutive whitespace, removing / Removing consecutive whitespace between words
- writing style helper tool
- implementing, to find long sentences in text with std multimap / Implement a writing style helper tool for finding very long sentences in text with std::multimap
Z
- zip iterator adapter
- building / Building your own zip iterator adapter
- ranges library / Ranges library