https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Return to Tour of C++, 3rd Edition by Bjarne Stroustrup, C++ Fundamentals, C++ Bibliography - C++ People, C++, C++ DevOps - C++ SRE - C++ CI/CD, Cloud Native C++ - C++ Microservices - Serverless C++, C++ Security - C++ DevSecOps, Functional C++, C++ Concurrency, C++ Data Science - C++ and Databases, C++ Machine Learning, C++ Courses, C++ Glossary, Awesome C++, C++ GitHub, C++ Topics

Index

“Knowledge is of two kinds. We know a subject ourselves, or we know where we can find information on it.” – Samuel Johnson

Token

!=

container 169

not-equal operator 7

“

]]

* [[CPP literal operator 85

]]

* [[CPP string literal 3

$, regex 131 % modulus operator 7 remainder operator 7 %=, operator 7 & address-of operator 11 pointer 11

reference to 12

&&, rvalue reference 77

’

char 8

digit separator 6

(, regex 131

(), call operator 94

(?: pattern 134

), regex 131

contents-of operator 11

iterator 179

multiply operator 7

operator 220

pointer 11

regex 131

• =, scaling operator 7

• ? lazy 132

+

iterator 192

plus operator 7

regex 131

string concatenation 125

++

increment operator 7

iterator 179, 192

+=

iterator 192

operator 7

string append 126

+? lazy 132

-

iterator 192

minus operator 7

–

decrement operator 7

iterator 192

-=, iterator 192

→

member access 23

operator 220

return type 40

.

member access 23

regex 131

…, variadic template 114

/, divide operator 7

// comment 2

/=, scaling operator 7

: public 61

«

output operator 3, 84

output ostream 138

⇐

container 169

less-than-or-equal operator 7

⇔

container 169

spaceship operator 81

<

container 169

less-than operator 7

=

0 60

and == 7

assignment 17

auto 8

container 169

default 56

initializer 7

initializer narrowing 8

string assignment 126

= and 7

container 169

equal operator 7

iterator 192

string 126

container 169

greater-than operator 7

=

container 169

greater-than-or-equal operator 7

input istream 139

input operator 84

?, regex 131

?: operator 82

?? lazy 132

[, regex 131

[&] 95

[=] 95

tour_of_c_plus_plus_3rd_edition_by_bjarne_stroustrup_index attribute syntax 263

[]

array 11

array 203

auto 41

iterator 192

string 126

subscript operator 25

subscripting 169

\, backslash 3

], regex 131

{, regex 131

{}

format() argument 144

grouping 2

initializer 8

{}? lazy 132

pipeline 188

regex 131

}, regex 131

~, destructor 57

0

= 60

nullptr NULL 14

:%A, format() 146

abort() 225

abs() 228

abstract class 60

access

., member 23

→, member 23

accumulate() 229

acquisition RAII, resource 197

Ada 208

adaptor

function 216

lambda as 216

range 187

address, memory 16

address-of operator & 11

adjacent_difference() 229

aims, C++11 261

Alexander Fraser 259

algorithm 173

container 175

lifting 113

numerical 229

parallel 183

standard library 181

<algorithm> 123, 182

alias

template 100

type 234

using 100

alignas 263

alignof 263

allocation 57

allocator new, container 167

almost container 201

alnum, regex 133

alpha, regex 133

alpha letter 133

alternatives, error handling 47

Annemarie 127

ANSI C++ 260

any 211

Anya 208

append +=, string 126

argument

{}, format() 144

constrained 89

constrained template 90

default function 38

default template 108

function 37

lambda as 96

order, format() 145

passing, function 72

type 90

value 90

arithmetic

conversions, usual 7

operator 7

vector 233

Arithmetic example 108, 219

ARM 260

array

[] 11

array vs. 203

array 202

[] 203

data() 203

initialize 202

size() 203

vs. array 203

vs. vector 203

<array> 123

asin() 228

assembler 257

assert(), assertion 49

assertion

assert() 49

expect() 48

static_assert 50

assignable_from, concept 190

assignment

= 17

=, string 126

copy 72, 75

initialization and 18

move 72, 78

assignment-to-string-literal, removed 267

associate type 222

associative array – see map

async() launch 247

at() 161

atan() 228

atan2() 228

atexit() 225

atomic 243

AT&T Bell Laboratories 260

attribute

carries_dependency 263

deprecated 264

fallthrough 264

likely 265

maybe_unused 264

nodiscard 98, 264

noreturn 263

no_unique_address 265

syntax, tour_of_c_plus_plus_3rd_edition_by_bjarne_stroustrup_index 263

unlikely 265

auto

[] 41

= 8

concept and 110

return type 40

auto_ptr, removed 267

:%B, format() 146

:b, format() 145

back_inserter() 175

backslash \ 3

bad_variant_access 210

base

and derived class 61

destructor for 65

basic_string 128

BCPL 269

begin() 83, 163, 169, 175

beginner, book for 1

Bell Laboratories, AT&T 260

beta() 228

bibliography 271

bidirectional_iterator, concept 192

bidirectional_range, concept 193

binary search 182

binding, structured 41

bit manipulation 224

bit_cast 224

bit-field, bitset and 204

bitset 204

and bit-field 204

and enum 204

blank, regex 133

block

as function body, try 161

try 44

body, function 2

book for beginner 1

bool 6

Boolean, concept 191

bounded_range, concept 193

break 15

Brian Kernighan 259

buffer overrun 200

built-in type 21

byte, std::byte 224

C

C 257

and C++ compatibility 268

Classic 269

difference from 268

K&R 269

style 269

with Classes 256

with Classes language features 258

with Classes standard library 259

C++

ANSI 260

compatibility, C and 268

Core Guidelines 262

core language 2

evolution 256

history 255

ISO 260

meaning 257

model 262

modern 262

pronunciation 257

standard, ISO 2

standard library 2

standardization 260

style 269

timeline 256

use 262

users, number of 262

C++03 260

C++0x, C++11 257, 260

C++11

aims 261

C++0x 257, 260

language features 263

library components 265

C++14 261

language features 264

library components 266

C++17 261

language features 264

library components 266

C++20 1, 185, 261

concept 104

language features 265

library components 266

module 33

C++98 260

standard library 259

C11 268

C+23, spanstream 149

C89 and C99 268

C99, C89 and 268

calendar 214

call operator () 94

callback 217

capacity() 159, 169

capture list 95

carries_dependency attribute 263

cast 59

catch

clause 44

every exception 161

catch(…) 161

cbegin() 83

ceil() 228

cend() 83

cerr 138

char 6

’ 8

character sets, multiple 128

check

compile-time 50

run-time 48

Checked_iter example 174

checking

cost of range 162

template definition 109

chrono, namespace 214

<chrono> 123, 214, 243

cin 139

class 23, 54

abstract 60

and struct 25

base and derived 61

concrete 54

hierarchy 63

interface 23

member 23

scope 9

template 88

Classic C 269

clause, requires 105

clear(), iostream 141

C-library header 123

clock 214

clock timing 243

<cmath> 123, 228

cntrl, regex 133

code complexity, function and 5

comment, // 2

common_reference_with, concept 190

common_type_t 190, 221

common_view 187

common_with, concept 190

communication, task 245

comparison operator 7, 81

compatibility, C and C++ 268

compilation

model, template 117

separate 30

compiler 2

compile-time

check 50

computation 218

evaluation 10

if 101

complex 55, 230

<complex> 123, 228, 230

complexity, function and code 5

components

C++11 library 265

C++14 library 266

C++17 library 266

C++20 library 266

computation, compile-time 218

concatenation +, string 125

concept 89

assignable_from 190

bidirectional_iterator 192

bidirectional_range 193

Boolean 191

bounded_range 193

common_reference_with 190

common_with 190

constructible_from 191

contiguous_iterator 192

contiguous_range 193

convertible_to 190

copy_constructible 191

default_initializable 191

derived_from 190

destructible 191

equality_comparable 190

equality_comparable_with 190

equivalence_relation 191

floating_point 190

forward_iterator 192

forward_range 193

input_iterator 192

input_or_output_iterator 192

input_range 193

integral 190

invocable 191

mergeable 192

mopyable 191

movable 191

move_constructible 191

output_iterator 192

output_range 193

permutable 192

predicate 191

random_access_iterator 192

random_access_range 193

range 185

range 193

regular 191

regular_invocable 191

relation 191

same_as 190

semiregular 191

sentinel_for 192

signed_integral 190

sized_range 193

sized_sentinel_for 192

sortable 192

strict_weak_order 191

swappable 190

swappable_with 190

three_way_comparable 190

three_way_comparable_with 190

totally_ordered 190

totally_ordered_with 190

unsigned_integral 190

view 193

concept 104

and auto 110

and type 111

and variable 111

based overloading 106

C++20 104

definition of 107

in <concepts> 190

in <iterator> 190

in <ranges> 190

static_assert and 108

use 104

concepts

iterator 192

range 193

type 190

<concepts> 123

concept in 190

concrete

class 54

type 54

concurrency 237

condition, declaration in 67

condition_variable 244

notify_one() 245

wait() 244

<condition_variable> 244

const

immutability 10

member function 56

constant

expression 10

mathematical 234

const_cast 59

consteval, immutability 10

constexpr

function 10

if 101

immutability 10

const_iterator 179

constrained

argument 89

template 90

template argument 90

constructible_from, concept 191

construction, order of 67

constructor 24

and destructor 258

copy 72, 75

default 56

delegating 264

explicit 73

inherited 161

inheriting 264

initializer-list 58

invariant and 45

move 72, 77

consumer() example, producer() 244

container 57, 88, 157

= 169

== 169

169

= 169

< 169

⇐ 169

⇔ 169

!= 169

algorithm 175

allocator new 167

almost 201

object in 160

operation 83

overview 168

return 176

specialized 201

standard library 168

contents-of operator * 11

contiguous_iterator, concept 192

contiguous_range, concept 193

conventional operation 81

conversion 73

explicit type 59

narrowing 8

conversions, usual arithmetic 7

convertible_to, concept 190

cooperative multitasking example 251

copy 74

assignment 72, 75

constructor 72, 75

cost of 76

elision 40, 72

elision 78

memberwise 72

copy() 182

copy_constructible, concept 191

copy_if() 182

Core Guidelines, C++ 262

core language, C++ 2

co_return 250

coroutine 250, 259

generator 250

promise_type 253

cos() 228

cosh() 228

cost

of copy 76

of range checking 162

count() 182

count_if() 181–182

Courtney 208

cout 138

output 3

co_yield 250

<cstdlib> 123

C-style

error handling 228

I/O 149

string 13

CTAD 93

D

:d, format() 145

\d, regex 133

\D, regex 133

d, regex 133

dangling pointer 196

data

member 23

race 239

data(), array 203

D&E 256

deadlock 242

deallocation 57

debugging template 113

declaration 6

function 4

in condition 67

interface 29

using 36

declarator operator 12

decltype 263

decltype() 218

decrement operator – 7

deduction

guide 210

guide 92

return type 40

default

= 56

constructor 56

function argument 38

member initializer 74

operation 72

template argument 108

=default 72

defaultfloat 143

default_initializable, concept 191

definition

checking, template 109

implementation 30

of concept 107

delegating constructor 264

=delete 73

delete

naked 58

operator 57

delete[], operator 57

Dennis Ritchie 259

deprecated

feature 267

strstream 148, 267

deprecated attribute 264

deque 168

derived class, base and 61

derived_from, concept 190

destructible, concept 191

destruction, order of 67

destructor 57, 72

~ 57

constructor and 258

for base 65

for member 65

virtual 65

dictionary – see map

difference from C 268

digit

digit 133

separator ’ 6

digit, regex 133

digit digit 133

directive, using 36

directory_iterator 151–152

distribution, random 231

divide operator / 7

domain error 228

double 6

double-checked locking 243

Doug McIlroy 259

drop_view 187

duck typing 117

duration 214

duration_cast 214

dynamic memory 57

dynamic_cast 67

is instance of 67

is kind of 67

E

e 234

EDOM macro 228

element requirements 160

elision, copy 40, 72

emplace_back() 169

empty() 169

enable_if 221

enable_if_t 221

encapsulation 72

end() 83, 163, 169, 175

endl 154

engine, random 231

enum

bitset and 204

class enumeration 26

enumeration 25

using 26

enumeration

enum 25

enum class 26

equal operator == 7

equality preserving 192

Equality_comparable example 108

equality_comparable, concept 190

equality_comparable_with, concept 190

equal_range() 182

equivalence_relation, concept 191

ERANGE macro 228

erase() 163, 169

errno 228

error

domain 228

handling 43

handling alternatives 47

handling, C-style 228

range 200, 228

recovery 47

run-time 44

error-code, exception vs 47

error_code 153

essential operation 72

evaluation

compile-time 10

order of 8

event driven simulation example 251

evolution, C++ 256

Example, expect() 48

example

Arithmetic 108, 219

Checked_iter 174

cooperative multitasking 251

Equality_comparable 108

event driven simulation 251

finally() 98

find_all() 176

Hello, World! 2

Number 108

producer() consumer() 244

Rand_int 231

Sentinel 193

Sequence 109

sum() 104

task 253

tau 235

Value_type 109

Vec 161

Vector 22–23, 29, 33–34, 57–58, 73, 75, 77, 88–89, 91–92, 100

exception 44

and main() 161

catch every 161

specification, removed 267

vs error-code 47

exclusive_scan() 229

execution policy 183

exists() 150

exit, program 225

exit() termination 225

exp() 228

exp2() 228

expect()

assertion 48

Example 48

explicit type conversion 59

explicit constructor 73

exponential_distribution 231

export

module 33

removed 267

expression

constant 10

fold 115

lambda 95

requires 106

extension() 152

extern template 264

F

fabs() 228

facilities, standard library 120

fallthrough attribute 264

feature

deprecated 267

removed 267

features

C with Classes language 258

C++11 language 263

C++14 language 264

C++17 language 264

C++20 language 265

file

header 31

open a 151

system operation 153

type 154

file_name(), source_location 222

<filesystem> 150

filesystem_error 153

filter() 189

filter_view 186

final 264

Final_action 98

finally() example 98

find() 175, 182

find_all() example 176

find_if() 181–182

fixed 143

floating-point literal 6

floating_point, concept 190

floor() 228

fold expression 115

for

statement 12

statement, range 12

format, output 143–144

format()

:%A 146

argument {} 144

argument order 145

:%B 146

:b 145

:d 145

:o 145

precision 145

:x 145

<format> 123, 144

forward() 116, 223

forwarding, perfect 224

forward_iterator, concept 192

forward_list 168

singly-linked list 164

<forward_list> 123

forward_range, concept 193

Fraser, Alexander 259

free store 57

friend 193

<fstream> 123, 147

__func__ 264

function 2

adaptor 216

and code complexity 5

argument 37

argument, default 38

argument passing 72

body 2

body, try block as 161

const member 56

constexpr 10

declaration 4

implementation of virtual 62

mathematical 228

member 23

name 5

object 94

overloading 5

return value 37

template 93

type 217

value return 72

function 217

and nullptr 217

<functional> 123

function_name(), source_location 222

fundamental type 6

future

and promise 245

member get() 245

<future> 123, 245

G

garbage collection 79

Gavin 208

gcd() 229

generator

coroutine 250

type 221

generic programming 103, 112, 258

get<>()

by index 207

by type 207

get(), future member 245

getline() 140

graph, regex 133

greater-than operator > 7

greater-than-or-equal operator >= 7

greedy match 132, 135

grouping, {} 2

guide, deduction 92

Guidelines, C++ Core 262

H

half-open sequence 182

handle 24, 58

resource 75, 198

hardware, mapping to 16

hash table 165

hash<>, unordered_map 84

header

C-library 123

file 31

problems 32

standard library 121, 123

unit 279

heap 57

Hello, World! example 2

hexfloat 143

hierarchy

class 63

navigation 67

history, C++ 255

HOPL 256

I

if

compile-time 101

constexpr 101

statement 14

ifstream 147

immutability

const 10

consteval 10

constexpr 10

implementation

definition 30

inheritance 66

iterator 178

of virtual function 62

push_back() 159

string 127

import 3

and #include 277

1. include and 34

module 33

in-class member initialization 264

1. include 3, 31

and import 34

import and 277

inclusive_scan() 229

incompatibility, void* 270

increment operator ++ 7

index, get<>() by 207

infinite range 185

inheritance 61

implementation 66

interface 65

multiple 259

inherited constructor 161

inheriting constructor 264

initialization

and assignment 18

in-class member 264

initialize 58

array 202

initializer

= 7

{} 8

default member 74

lambda as 97–98

narrowing, = 8

initializer-list constructor 58

initializer_list 58

inline 55

namespace 264

inlining 55

inner_product() 229

input

istream » 139

of user-defined type 141

operator » 84

string 140

input_iterator, concept 192

input_or_output_iterator, concept 192

input_range, concept 193

insert() 163, 169

instantiation 89

instantiation time, template 117

instruction, machine 16

int 6

output bits of 204

int32_t 234

integer literal 6

integral, concept 190

interface

class 23

declaration 29

inheritance 65

invalidation 159

invariant 45

and constructor 45

invocable, concept 191

invoke_result_t 221

I/O 138

C-style 149

iterator and 179

state 141

<iomanip> 143

<ios> 123, 143

iostream

clear() 141

kinds of 146

setstate() 141

unget() 141

<iostream> 3, 123

iota() 229

is

instance of, dynamic_cast 67

kind of, dynamic_cast 67

is_arithmetic_v 218

is_base_of_v 218

is_constructible_v 218

is_directory() 151

is_integral_v 218

ISO

C++ 260

C++ standard 2

ISO-14882 260

is_same_of_v 218

istream 138

, input 139

<istream> 139

istream_iterator 179

istringstream 147

iterator 83–84, 175

== 192

+ 192

– 192

+= 192

-= 192

- 192

++ 179, 192

• 179

[] 192

and I/O 179

concepts 192

implementation 178

iterator 163, 179

<iterator>, concept in 190

iterator_t 109

iter_value_t 109

J

join(), thread 238

join_view 187

K

Kernighan, Brian 259

key and value 164

kinds of iostream 146

K&R C 269

L

\l, regex 133

\L, regex 133

lambda

as adaptor 216

as argument 96

as initializer 97–98

expression 95

language

and library 119

features, C with Classes 258

features, C++11 263

features, C++14 264

features, C++17 264

features, C++20 265

launch, async() 247

lazy

+? 132

{}? 132

?? 132

• ? 132

match 132, 135

lcm() 229

leak, resource 67, 78, 197

less-than operator < 7

less-than-or-equal operator ⇐ 7

letter, alpha 133

library

algorithm, standard 181

C with Classes standard 259

C++98 standard 259

components, C++11 265

components, C++14 266

components, C++17 266

components, C++20 266

container, standard 168

facilities, standard 120

language and 119

non-standard 119

standard 119

lifetime, scope and 9

lifting algorithm 113

likely attribute 265

<limits> 217, 234

line(), source_location 222

linker 2

list

capture 95

forward_list singly-linked 164

list 162, 168

literal

”, string 3

floating-point 6

integer 6

operator “ 85

raw string 130

suffix, s 127

suffix, sv 129

type of string 127

UDL, user-defined 84

user-defined 264

literals

string_literals 127

string_view_literals 129

ln10 234

ln2 234

local scope 9

lock, reader-writer 242

locking, double-checked 243

log() 228

log10() 228

log2() 228

log2e 234

long long 263

lower, regex 133

M

machine instruction 16

macro

EDOM 228

ERANGE 228

main() 2

exception and 161

make_pair() 207

make_shared() 199

make_unique() 199

management, resource 78, 197

manipulation, bit 224

manipulator 143

map 164, 168

and unordered_map 166

<map> 123

mapped type, value 164

mapping to hardware 16

match

greedy 132, 135

lazy 132, 135

mathematical

constant 234

function 228

function, standard 228

functions, special 228

<math.h> 228

Max Munch rule 132

maybe_unused attribute 264

McIlroy, Doug 259

meaning, C++ 257

member

access . 23

access → 23

class 23

data 23

destructor for 65

function 23

function, const 56

initialization, in-class 264

initializer, default 74

memberwise copy 72

mem_fn() 217

memory 79

address 16

dynamic 57

resource, polymorphic 167

safety 196

<memory> 123, 197, 199

merge() 182

mergeable, concept 192

midpoint() 229

minus operator - 7

model

C++ 262

template compilation 117

modern C++ 262

modularity 29

module

C++20 33

export 33

import 33

standard library 123

std 34, 277

std.compat 277

modulus operator % 7

month 214

mopyable, concept 191

movable, concept 191

move 72, 77

assignment 72, 78

constructor 72, 77

move() 78, 182, 223

move_constructible, concept 191

moved-from

object 78

state 224

move-only type 223

multi-line pattern 131

multimap 168

multiple

character sets 128

inheritance 259

return values 41

multiply operator * 7

multiset 168

mutex 241

<mutex> 241

N

\n, newline 3

naked

delete 58

new 58

name, function 5

namespace scope 9

namespace 35

chrono 214

inline 264

pmr 167

std 3, 36, 121

views 188

narrowing

= initializer 8

conversion 8

navigation, hierarchy 67

new

container allocator 167

naked 58

operator 57

newline \n 3

Nicholas 126

nodiscard attribute 98, 264

noexcept 50

noexcept() 263

nonhomogeneous operation 108

non-memory resource 79

non-standard library 119

Norah 208

noreturn attribute 263

normal_distribution 231

notation

regular expression 131

template 105

not-equal operator != 7

notify_one(), condition_variable 245

no_unique_address attribute 265

now() 214

NULL 0, nullptr 14

nullptr 13

function and 217

NULL 0 14

number

of C++ users 262

random 231

Number 108

example 108

<numbers> 234

<numeric> 229

numerical algorithm 229

numeric_limits 234

O

:o, format() 145

object 6

function 94

in container 160

moved-from 78

object-oriented programming 63, 258

ofstream 147

open a file 151

operation

container 83

conventional 81

default 72

essential 72

file system 153

nonhomogeneous 108

path 152

operator

→ 220

+= 7

%= 7

• 220

?: 82

&, address-of 11

(), call 94

• , contents-of 11

–, decrement 7

/, divide 7

==, equal 7

, greater-than 7

=, greater-than-or-equal 7

++, increment 7

, input 84

<, less-than 7

⇐, less-than-or-equal 7

”, literal 85

-, minus 7

%, modulus 7

• , multiply 7

!=, not-equal 7

«, output 3, 84

+, plus 7

%, remainder 7

• =, scaling 7

/=, scaling 7

⇔, spaceship 81

[], subscript 25

arithmetic 7

comparison 7, 81

declarator 12

delete[] 57

delete 57

new 57

overloaded 57

overloading 80

relational 81

user-defined 57

optimization, short-string 127

optional 210

order

format() argument 145

of construction 67

of destruction 67

of evaluation 8

of, public private 23

ostream 138

«, output 138

<ostream> 138

ostream_iterator 179

ostringstream 147

out_of_range 161

output 138

bits of int 204

cout 3

format 143–144

of user-defined type 141

operator « 3, 84

ostream « 138

string 140

output_iterator, concept 192

output_range, concept 193

overloaded operator 57

overloaded() 210

overloading

concept based 106

function 5

operator 80

override 61

overrun, buffer 200

overview, container 168

ownership 197

owning 196

P

packaged_task thread 247

par 183

parallel algorithm 183

parameterized type 88

partial_sum() 229

par_unseq 183

passing data to task 239

path 151

operation 152

pattern 130

(?: 134

multi-line 131

perfect forwarding 224

permutable, concept 192

phone_book example 158

pi 234

pipeline | 188

plus operator + 7

pmr, namespace 167

pointer 17

& 11

• 11

dangling 196

smart 84, 197, 220

policy, execution 183

polymorphic

memory resource 167

type 60

pow() 228

precision, format() 145

precison() 143

precondition 45

predicate 94, 181

type 218

predicate, concept 191

print, regex 133

printf() 149

private order of, public 23

problems, header 32

procedural programming 2

producer() consumer() example 244

program 2

exit 225

programming

generic 103, 112, 258

object-oriented 63, 258

procedural 2

promise

future and 245

member set_exception() 245

member set_value() 245

promise_type, coroutine 253

pronunciation, C++ 257

ptrdiff_t 234

public private order of 23

punct, regex 133

pure virtual 60

purpose, template 103

push_back() 58, 163, 169

implementation 159

push_front() 163

Q

quick_exit() termination 225

R

R“ 130

race, data 239

RAII 58, 98, 259

and resource management 45

and try-block 48

and try-statement 45

resource acquisition 197

scoped_lock and 241–242

Rand_int example 231

random

distribution 231

engine 231

number 231

<random> 123, 231

random_access_iterator, concept 192

random_access_range, concept 193

random_device 233

random_engine seed()

range

checking, cost of 162

checking Vec 161

concepts 193

error 200, 228

for statement 12

range

adaptor 187

concept 193

concept 185

infinite 185

range-checking, span 200

range-for, span and 200

<ranges> 123, 185

concept in 190

range_value_t 109

raw string literal 130

reader-writer lock 242

recovery, error 47

recursive_directory_iterator 152

reduce() 229

reference 18

&&, rvalue 77

rvalue 78

to & 12

regex

• 131

[ 131

+ 131

. 131

? 131

] 131

) 131

( 131

$ 131

{ 131

} 131

alnum 133

alpha 133

blank 133

cntrl 133

\D 133

\d 133

d 133

digit 133

graph 133

\L 133

\l 133

lower 133

print 133

punct 133

regular expression 130

repetition 132

s 133

\s 133

\S 133

space 133

\u 133

\U 133

upper 133

\W 133

\w 133

w 133

xdigit 133

<regex> 123, 130

regular expression 130

regex_iterator 135

regex_search 130

register, removed 267

regular

expression notation 131

expression regex 130

expression <regex> 130

regular, concept 191

regular_invocable, concept 191

reinterpret_cast 59

relation, concept 191

relational operator 81

remainder operator % 7

remove_const_t 221

removed

assignment-to-string-literal 267

auto_ptr 267

exception specification 267

export 267

feature 267

register 267

repetition, regex 132

replace() 182

string 126

replace_if() 182

request_stop() 249

requirement, template 104

requirements 105

element 160

requires

clause 105

expression 106

reserve() 159, 169

resize() 169

resource

acquisition RAII 197

handle 75, 198

leak 67, 78, 197

management 78, 197

management, RAII and 45

non-memory 79

retention 79

safe 262

safety 78

rethrow 46

return

container 176

function value 72

type → 40

type auto 40

type deduction 40

type, suffix 263

type suffix 40

type, void 4

value, function 37

values, multiple 41

returning results from task 240

reverse_view 187

rieman_zeta() 228

Ritchie, Dennis 259

rule

Max Munch 132

of zero 73

run-time

check 48

error 44

rvalue

reference 78

reference && 77

S

s literal suffix 127

\S, regex 133

\s, regex 133

s, regex 133

safe

resource 262

type 262

safety

memory 196

resource 78

same_as, concept 190

saving space 27

scaling

operator /= 7

operator *= 7

scanf() 149

scientific 143

scope

and lifetime 9

class 9

local 9

namespace 9

scoped_lock 197

and RAII 241–242

unique_lock and 245

scoped_lock() 242

scope_exit 98

search, binary 182

seed(), random_engine

semiregular, concept 191

Sentinel example 193

sentinel_for, concept 192

separate compilation 30

sequence 174

half-open 182

Sequence example 109

set 168

<set> 123

set_exception(), promise member 245

setstate(), iostream 141

set_value(), promise member 245

SFINAE 221

shared_lock 242

shared_mutex 242

shared_ptr 197

sharing data task 241

short-string optimization 127

sightseeing tour

signed_integral, concept 190

SIMD 183

Simula 251, 255

sin() 228

singly-linked list, forward_list 164

sinh() 228

size of type 6

size() 83, 169

array 203

sized_range, concept 193

sized_sentinel_for, concept 192

sizeof 6

sizeof() 217

size_t 100, 234

smart pointer 84, 197, 220

smatch 130

sort() 173, 182

sortable, concept 192

source_location

file_name() 222

function_name() 222

line() 222

space, saving 27

space, regex 133

spaceship operator ⇔ 81

span

and range-for 200

range-checking 200

string_view and 200

spanstream C+23 149

special mathematical functions 228

specialization 89

specialized container 201

sph_bessel() 228

split_view 187

sqrt() 228

<sstream> 123, 147

standard

ISO C++ 2

library 119

library algorithm 181

library, C++ 2

library, C with Classes 259

library, C++98 259

library container 168

library facilities 120

library header 121, 123

library module 123

library std 121

library suffix 121

mathematical function 228

standardization, C++ 260

state

I/O 141

moved-from 224

statement

for 12

if 14

range for 12

switch 15

while 14

static_assert 234

and concept 108

assertion 50

static_cast 59

std

module 34, 277

namespace 3, 36, 121

standard library 121

sub-namespaces 121

std::byte byte 224

std.compat, module 277

<stdexcept> 123

std.h 278

stem() 152

STL 259

stopping thread 248

stop_requested() 249

stop_source 249

stop_token 248

store, free 57

strict_weak_order, concept 191

string

C-style 13

literal ” 3

literal, raw 130

literal template argument 91

literal, type of 127

Unicode 128

string 125

[] 126

== 126

append += 126

assignment = 126

concatenation + 125

implementation 127

input 140

output 140

replace() 126

substr() 126

<string> 123, 125

string_literals, literals 127

stringstream 147

string_view 128

and span 200

string_view_literals, literals 129

strstream deprecated 148, 267

struct 22

class and 25

union and 27

structured binding 41

style

C++ 269

C 269

subclass, superclass and 61

sub-namespaces, std 121

subscript operator [] 25

subscripting, [] 169

substr(), string 126

suffix 84

return type 263

return type 40

s literal 127

standard library 121

sv literal 129

time 214

sum() example 104

superclass and subclass 61

sv literal suffix 129

swap() 84

swappable, concept 190

swappable_with, concept 190

switch statement 15

synchronized_pool_resource 167

syncstream 149

sync_with_stdio() 149

syntax, tour_of_c_plus_plus_3rd_edition_by_bjarne_stroustrup_index attribute 263

system_clock 214

T

table, hash 165

tagged union 28

take() 189

take_view 186–187

tanh() 228

task

and thread 238

communication 245

passing data to 239

returning results from 240

sharing data 241

task example 253

tau example 235

TC++PL 256

template

argument, string literal 91

type safty 90

template 87

…, variadic 114

alias 100

argument, constrained 90

argument, default 108

class 88

compilation model 117

constrained 90

debugging 113

definition checking 109

extern 264

function 93

instantiation time 117

notation 105

purpose 103

requirement 104

variable 99

virtual 94

terminate() termination 225

termination 48

exit() 225

quick_exit() 225

terminate() 225

this 76

[this] and [*this] 95

thread

join() 238

packaged_task 247

stopping 248

task and 238

<thread> 123, 238

thread_local 264

three_way_comparable, concept 190

three_way_comparable_with, concept 190

time 214

suffix 214

template instantiation 117

timeline, C++ 256

time_point 214

time_zone 216

timing, clock 243

to hardware, mapping 16

totally_ordered, concept 190

totally_ordered_with, concept 190

tour, sightseeing

transform_reduce() 229

transform_view 187

translation unit 32

try

block 44

block as function body 161

try-block, RAII and 48

try-statement, RAII and 45

type 6

alias 234

argument 90

associate 222

built-in 21

concept and 111

concepts 190

concrete 54

conversion, explicit 59

file 154

function 217

fundamental 6

generator 221

get<>() by 207

input of user-defined 141

move-only 223

of string literal 127

output of user-defined 141

parameterized 88

polymorphic 60

predicate 218

safe 262

safty template 90

size of 6

user-defined 21

typename 88, 177

<type_traits> 218

typing, duck 117

U

\U, regex 133

\u, regex 133

UDL, user-defined literal 84

uint_least64_t 234

unget(), iostream 141

Unicode string 128

uniform_int_distribution 231

uninitialized 8

union 27

and struct 27

and variant 28

tagged 28

unique_copy() 173, 182

unique_lock 242, 244

and scoped_lock 245

unique_ptr 68, 197

unlikely attribute 265

unordered_map 165, 168

hash<> 84

map and 166

<unordered_map> 123

unordered_multimap 168

unordered_multiset 168

unordered_set 168

unsigned 6

unsigned_integral, concept 190

upper, regex 133

use

C++ 262

concept 104

user-defined

literal 264

literal UDL 84

operator 57

type 21

type, input of 141

type, output of 141

using

alias 100

declaration 36

directive 36

enum 26

usual arithmetic conversions 7

<utility> 123, 206

V

valarray 233

<valarray> 233

value 6

argument 90

key and 164

mapped type 164

return, function 72

values, multiple return 41

Value_type example 109

value_type 100, 169

variable 5–6

concept and 111

template 99

variadic template … 114

variant 209

union and 28

Vec

example 161

range checking 161

vector arithmetic 233

Vector example 22–23, 29, 33–34, 57–58, 73, 75, 77, 88–89, 91–92, 100

vector 158, 168

array vs. 203

<vector> 123

vector<bool> 201

vectorized 183

vformat() 146

view 186

view, concept 193

views, namespace 188

virtual 60

destructor 65

function, implementation of 62

function table vtbl 62

pure 60

template 94

void* incompatibility 270

void return type 4

vtbl, virtual function table 62

W

w, regex 133

\W, regex 133

\w, regex 133

wait(), condition_variable 244

weekday 214

WG21 256

while statement 14

whitespace 139

X

:x, format() 145

X3J16 260

xdigit, regex 133

–Y==

year 214

zero, rule of 73

zoned_time 216

Fair Use Source: B0B8S35JWV, (TrCppBS 2022)

“ (TrCppBS 2022)

Fair Use Sources:

• A Tour of C++, 3rd Edition by Bjarne Stroustrup on DuckDuckGo
• B0B8S35JWV, (TrCppBS 2022)