Index

allocated memory

managing, with std::unique_ptr –

associative containers

map

multimap

multiset

set

unordered_map

unordered_multimap

unordered_multiset

unordered_set

auto variables

initializing

await_ready() function

await_resume() function

await_suspend() function

backward iteration

with reverse iterator adaptor –

basic_string class ,

braced initialization

rules

using –

C++26

improvement ,

C-array

making safe, with span –

C-strings

iterator, building with –

char_traits

string class, customizing with –

complex structures

initializing, from file input –

concat() function

concatenation performance

discrepancy

consecutive whitespace characters

removing ,

container

initializing, from ranges ,

modifying, with std::transform() algorithm –

uniform erase functions, using to delete elements –

container adapter

container elements

into string –

container values

with std::clamp() function –

contains() method

content, finding in ranges

content, finding in strings

content

finding, in ranges with contains() method

finding, in strings with contains() method

contracts

copy algorithms –

working ,

coroutines

execution, resuming –

execution, suspending –

generator, creating with –

using, for producer-consumer solution –

count word frequency

with map container –

custom keys

unordered_map, using –

data sequences permutations

generating –

data sets

with std::sample() algorithm –

deque

RPN calculator, creating –

directory listing –

directory_iterator

using, for files renaming –

disk usage counter

creating –

working

erase_if() function

error sum

calculating –

file

words, counting ,

file input

complex structures, initializing –

files renaming

with regex and directory_iterator –

find() function

find_if() function

first-in, first-out (FIFO)

flags and values

sharing, with std::atomic class – ,

floating-point types

fold expressions

types

using, for generic tuples –

format library

text formatting with –

format text

with print() function

with printIn() function

gather() algorithm

using –

generator ,

creating, with coroutines –

creating, with iterators –

generator class

working ,

get_stack_string() function

if and switch conditionals

variable, initializing –

inner_product() algorithm

insert_sorted() function

integral types

is_lock_free() method

items

deleting, from unsorted vector –

iterable range

creating –

iterator adaptors

using, to populate STL containers –

iterator class

iterators

categories

concepts –

generator, creating with –

traits, using with for STL compatibility –

using –

jthread

jump table

creating, with mapped lambdas –

Lambda expressions

capture-list

closure ,

common parameters –

concatenating, with recursion ,

constexpr specifier

mutable modifier

noexcept attribute

parameters

syntax

trailing return type

usage –

with algorithms –

last-in, first-out (LIFO)

lazy evaluation

lightweight string object

string_view class, using as –

locks

using, to share data –

logical conjunction ,

manipulation functions

using, with path object –

map class

elements, inserting –

keys, modifying –

mapped lambdas

jump table, creating –

mdspan class

external data store, using

using, as multidimensional array –

working ,

memory integrity

preserving, with RAII –

merge sort containers ,

multidimensional array

mdspan class, using –

multiple producers and consumers

implementing –

mutually exclusive (mutex)

using, to share data –

narrowing conversion

numword class –

object members

sharing, with aliased smart pointers –

object sharing

with std::shared_ptr class –

objects of unknown length

iterating, with sentinel –

optional values

managing, with std::optional class –

pointers

polymorphic wrapper

creating, with std::function –

prefix tree

print() function ,

format text

strings, printing with –

working

printIn() function ,

format text

print_assoc() function

printc() function

println() function

strings, printing with –

printv() function

producer-consumer problem

resolving, with std::condition_variable –

promise and future objects

creating, with std::async() function

psorted() function

quick_delete() function

RAII

using, to preserve memory integrity –

RPN calculator

creating, with deque –

random number distribution generators

comparing –

random number engines

comparing –

random-access iterator

creating –

operator overloads ,

validation code –

working

ranges

container, initializing ,

working ,

ranges library

using –

ranges::contains_subrange() algorithm

regular expressions (regex)

strings, parsing with –

using, for files renaming –

remove_value() function

reverse iterator adaptor

backward, iterating with –

STL algorithms

running, with execution policies –

STL container types

associative containers

container adapter

overview

sequential containers

STL containers

populating, with iterator adaptors –

STL string class

search containers

with std::find() function –

search directory and files

with grep utility –

sentence length

finding, with vector –

sentinel

objects of unknown length, iterating with

using, with C-strings ,

sequential containers

array

deque

list

vector

set class

user input, filtering –

user input, sorting –

shared objects

weak pointers, using –

sleep_for() function

using ,

smart pointers ,

sort containers

with std::sort() algorithm –

span

used, for making C-array safe –

split() algorithm

building –

standard aliases

static reflection ,

std module

code simplification ,

working ,

std::any class

using, for type safety –

std::async() function –

std::atomic class

flags and values, sharing – ,

floating-point types

integral types

lock-free variations ,

pointers and smart pointers

specializations

standard aliases

std::call_once function

threads, initializing –

std::chrono library

clock classes

duration class ,

time events –

std::condition_variable

producer-consumer problem, resolving –

std::formatter class –

working ,

std::function

polymorphic wrapper, creating –

std::optional class

working

std::shared_ptr class

object sharing –

working

std::thread class –

std::unique_ptr

allocated memory, managing –

std::variant class

union primitive ,

value types, storing –

string class

customizing, with char_traits –

string::contains() method

working ,

string_view class

using, as lightweight string object –

strings

concatenating –

parsing, with regular expressions (regex) –

printing, with print() and println() function –

reading, from user input –

transforming –

whitespace, trimming ,

structural pattern matching ,

structured binding

using, to return multiple values –

synchronous generators

using –

ToDo list

creating, with multimap –

template argument deduction

using, for simplicity and clarity –

text formatting

with format library –

threads

initializing, with std::call_once function –

time events

with std::chrono library –

traits

using, with iterators for STL compatibility –

trie class

creating –

type safety

std::any class, using –

uniform erase functions

using, to delete elements from container –

unordered_map

using, with custom keys –

user input

filtering, with set class –

sorting, with set class –

value types

storing, with std::variant class –

vector

sentence length, finding –

vector elements

accessing –

sorting –

weak pointers

using, with shared objects –

word counting

in file

worker() function

zip iterator adaptor

building –

working –