Return to Discovering Modern C++, C++ DevOps, C++ books, C++ courses, C++ topics, C++

Subject Index

_MSC_VER, 68

__cpp_lib_chrono, 69

__cpp_modules, 68

Abrahams, David, 398

abs, 167

return type, 298

abs

in Mandelbrot set, 239

abs_view, 402

abstraction

penalty, 347

providing an, 72

access, 74–76

modifier, 74

Accumulatable, 196

accumulate, 231

abstraction penalty, 347

and concepts, 193

for summation, 154

from STL, 149

generic, 184

in STL, 212

accumulate, 354

accumulate_array, 152

Ada, 491

Adams, Douglas, 1

add, 355

address

0, 55

mapping, 422

space, 422

Adelstein, Bryce, 430

adjacent_difference, 231

ADL, 141–146

for selecting templates, 142

in specialization, 165

with operators, 142

with third-party libraries, 144

advance, 216

on vector iterator, 217

advance, 197

aggregate, 90

initialization, 90

Ahnert, Karsten, 284

Alexandrescu, Andrei, 75, 305

Algebra, 413

algebra, 355

linear, 52, 64

dense, 353

libraries, 284

package, 417

algorithm

block, 450

in STL, see STL, algorithm

numerical, 407

alias, 60

∼ing effect, 93

alignof, 19

all, 235

allocator

user-defined, 226

ambiguity

in specialization and overloading, 165

and, 16

anti-pattern, 366

any, 474

type, 262

<any>, 261

any, 261

any_cast, 261

application

scientific, 63

apply, 204

archive, 422, 428

argument

macro, 448

replication, 449

with explicit conversion, 137

with implicit conversion, 137

with uniform initialization, 89

argument-dependent lookup, see ADL

ARPREC, 283

array, 52–53

container, 62–64

declaration, 52

intrinsic support, 52

missing index check, 53

of higher dimensions, 52

operations, 52

size deduction, 53

two-dimensional, 461

array, 279, 413

as_const, 215

assembler, 477

output, 491

reading ∼ code, 175

assembly, 422

assert, 36, 445, 449

in debugger, 494

assert, 36

assignment, 17, 23, 88–89

as method only, 118

copy, 88

generation rule, 468–470

move, 94

generation rule, 470

self, 89

with initializer list, 90

assoc_laguerre, 251

assoc_legendre, 251

AST, 329

async, 273

async_executor, 278

asynchronous, 275

ATLAS, 353

atof, 444

atomic, 220, 277

assignment, 278

atomic, 282

atomic operation, 277

atomic_flag, 282

atomic_ref, 282

Austern, Matt, 212

auto, 155

auto_ptr, 57

AVX, 238, 334

back_insert_iterator, 233

bad_alloc, 93

bad_any_cast, 262

bad_cast, 393

bad_variant_access, 260

Baker, Lewis, 282

barrier, 282

Barton, John, 397

Barton-Nackman trick, 397

base_matrix, 380

basic_iteration, 275

Battista, Orlando Aloysius, 35

begin, 90, 153, 227, 315, 413

benchmarking, 353

beta, 251

bidirectional_iterator, 197

BidirectionalIterator, 217

in lists, 222

BidirectionalIterator, 213

binary, 8

BinaryFunction, 184

bind, 249

bit

masking, 163

bit-field, 501

Black, Fischer, 249

Black-Scholes model, 249

BLAS, 305, 353

Goto-, 354

HPR, see HPR, BLAS

in linker flags, 492

BLITZ++, 284

bool, 4, 162, 442

boolalpha, 45

Boost, 420

Asio, 44

Bindings, 305

Filesystem, 52

Function, 389

Graph Library (BGL), 285

Interval, 283

IOStream, 44

MPL, 307, 484

odeint, 284, 417

Operators, 398

Rational, 283

type traits, 254

BOOST_STATIC_ASSERT, 485

brace, 2, 90

elimination

in templates, 474

elision, 91

notation, 460

branching, 23

break, 26, 29

Brecht, Bertolt, 435

Brown, Rita Mae, 20

Brown, Walter, 243

Bruce, Craig, 491

buffer, 42

build, 419–427

process, 423

tools, 423–427

build_example.cpp, 420

Butcher tableau, 410

byte, 163

C

array initialization, 89

C code linked with C++ programs, 489

C code with C++ compiler, 489

casting, 390

emulated namespace, 139

impact on interfaces, 72

library, 107

naming, 489

block notation, 489

preprocessed, 420

struct, 75

type traits for ∼ compatibility, 255

C++

as superset of C, 489

managed, 448

project, 64–69, 407–434

C++03

array initialization, 52

C++11, 448

in MTL4, 451

narrowing in arrays, 52

smart pointers, 57

c++filt, 304

C99

not a subset of C++, 489

cache

coherency, 335

invalidation, 335, 350

L1, 321, 332

L2, 321

call

by reference, 30

by value, 30

stack, 40

caller, 204

Cantor dust, 286

capture, see lambda

<cassert>, 36

cast, 446

cross, 393

down, 391

reinterpret, 394

up, 390

ambiguous, 391

catch, 39

CCS, 206

chaotic

attractor, 409

dynamics, 409

Chapman, George, 365

char, 4, 446

chicken and egg, 149

<chrono>, 3, 267, 337

Church, Alonzo, 359

cin, 42

circular_area, 252

class, 39, 71–127

base, 79, 368

contained classes, 73

data member, see member variable difficult types, 467

derived, 75, 368

for both C and C++, 255

high-level, 472

member, see member variable

direct setting, 90

initialization list, see constructor

member function, see method

member variable, 73

access, 112

default value, 88

private, 75, 113

template, 62

to establish abstractions, 73

type definition, 73

class

instead of typenameclass, 130

class

abstract, 375

clear, 233

clock, 267

clone, 301

closure, 186

CMake, 425–427

<cmath>, 239, 489

co_await, 282

co_return, 282

co_yield, 282

code

assembler, 421

complexity, 389

conditional, 421

explosion, 347

hexadecimal, 422

legacy, 91

object, 422

coercion, 7, 15

Collatz series, 26

color coding, 239

column-major, 206

comment, 64

single-line, 4

common, 235

common_type, 317

common_type_t, 317, 325

common_view, 357

Commutative, 358

commutative, 344

CommutativeMonoid, 358

comp_ellint_1, 251

comp_ellint_2, 251

comp_ellint_3, 251

compilation, 421

ambiguous term, 419

conditional, 68

phases, 422

separate, 427–434

compile

time, 52

if, see conditional

compiler

call, 419

flag, 36

optimization, 353, 452

on tag types, 217

support

for garbage collection, 448

<complex>, 239

complex, 73

comparing magnitudes, 298

in mixed arithmetic, 241

library, 239

missing operator, 135

sorting ∼, 230

complex_abs, 86

complexity, 453

constant, 225, 231

linear, 231

logarithmic, 223, 225, 231

O(n log n), 230, 231

quadratic, 230, 231

compressed, 206

compressed_matrix, 395

computability theory, 359

concept, 354, 192–354

dispatching, 197

for a simple matrix, 302

for tuning, 329

model, 193

ordering, 197

refinement, 193

requirement, 193

semantic, 344

stream, 43

subsumption, 193

concept, 194

concurrency, 270–282

conditional, 256

implementation, 306

conditional_t, 256

Conjugate Gradients, 435

const, 6

advantages of, 452

method, 114

variable, 295

const_cast, 393

for third-party libraries, 305

const_iterator, 214

constant, 6

as macro, 448

global, 10

consteval, 291

constexpr, 190, 289–297, 448

for loop unrolling, 332

function at run time, 291

function template, 290

constinit, 296

construction

assignment-like notation, 86

explicit, 86

constructor, 43, 78–88

argument names, 81

converting, 395

copy, 83

default implementation, 83

generation rule, 468–470

mandatory user implementation, 84

reasons for generation, 83

with mutable reference, 469

with value argument, 83

default, 82

and references, 82

call, 82

generation rule, 467

in late initialization, 82

needed for containers, 82

default argument, 81

delegating, 87

exception-free, 301

explicit, 86

for complex, 79

illegal call, 80

implicit, 86

initialization list

braced notation, 92

initilization list, 79

move, 93

generation rule, 470

special, 82

syntax, 79

with initializer list, 90

container

as class template, 147

as return value, 453

associative, 224

in STL, 218

of references, 266

container_algebra, 414

continue, 29

convergence

quadratic, 268

conversion, 15

explicit, 137

function-style, 394

implicit, 7, 86, 455

in templates, 136

of numeric types, 396

coordinate, 175

copy

-constructable, 474

constructor, see constructor, copy

deep, 93

elision, 32, 94

explicitly deep, 93

instead of move, 472

shallow, 93

copy, 90, 229, 474

copy, 256

coroutine, 280

correctness

independent of storage, 73

counted, 236

cout, 2, 41, 213

setf, 45

__cplusplus, 490

CppCoro, 282

creature, 375

cref, 266

CRS, 206

CRTP, 397–401

cryptography, 247

<cstdint>, 446

<cstdlib>, 39

ctime, 267

<ctime>, 267

CUDA, 255

in MTL4, 284

static code analysis, 353

curiously recurring template pattern, see CRTP

cyl_bessel_i, 251

cyl_bessel_j, 251

cyl_bessel_k, 251

cyl_neumann, 251

Czarnecki, Krzysztof, 306, 483

D, 491

data

persistent, 93

transfer as bottle neck, 321

Davis, Sammy, Jr., 289

de Morgan’s law, 397

dead lock, 279

deallocation, 55

automatic, 56

double, 85

debugger

compiler flags for ∼, 492

text-based, 492

vs. logs in methods, 78

debugging, 492–496

dec, 45

declaration

in header, 427

variable, 23, 74

declare_no_pointers, 448

declare_reachable, 448

decltype, 155

declval, 171

declval, 403

decomposition, see also factorization

default, 111, 465

default-constructible, 80, 467

default_operations, 417

default_random_engine, 246

delete, 18, 55

declarator, 111, 117, 465

delete[], 54

deleter, 109

denominator, 75

dense_matrix

in conversion, 395

department, 100

<deque>, 221

deque, 221

emplace, 221

erase, 222

insert, 222

derivation, 43

from ostream, 121

derivative, 177, 408

higher-order, 181

derived, 367

design

domain-driven, 71

design guides

for method generation, 470

designated initialization, 91

destructor, 105–107

arguments, 105

generation rule, 467

main task, 105

virtual, 105

determinant, 450

development

test-driven, 450

diagonal

unit, 451

diamond shape, 381, 390

digit separator, 8

Dijkstra, Edsger W., 71

discard_block_engine, 247

discretization

equidistant, 409

temporal, 409

distance, 217

distance, 199

distribution

normal, 249

do while, 26

documentation

as text, 450

compilable, 450

domain

-specific embedded language, 117

expert, 71

dot, 87

double, 4

DSEL, see domain-specific embedded language

Du Toit, Stefanus, 72

Duff’s device, 444

dummy, 202

duration, 267

dxdt, 411

dynamic binding, 371

dynamic_cast, 393

dynamic_extent, 263

-E (flag), 420

/E (flag), 420

Eclipse, 3, 426

Einstein, Albert, 20

Eisenecker, Ulrich, 306

Eisenecker, Ulrich, 483

1. elif, 68

ellint_1, 251

ellint_2, 251

ellint_3, 251

ellipsis, 404

in parameter packs, 201

1. else, 68

else, 23–24

empty, 236

enable_if, 256, 312

enable_if_t, 256

enable_matrix_t, 314

encapsulation, 69

end, 90, 153, 227, 413

1. endif, 68

endl, 2, 42

entropy, 247

eof, 50

equal, 124

equivalent, 123

error

code, 37

compile-time ∼, 176

estimation, 275

flag, 49

handling, 35–41

in template programs, 135

message

from macros, 448

parsing, 130

pointer-related, 56

program, 36

run-time ∼, 176

Euler scheme, 410

euler_step, 411

event

hardware, 247

operating system, 247

exception, 37–41, 49

and resource release, 106

in destructor, 105

exception, 39, 378

what, 378

<exception>, 378

exclusive_scan, 238

executable

size, 137

execution, 238

par, 238

par_unseq, 238

seq, 238

exit, 39

exit code, 444

expint, 251

explicit, 86, 119

in C++03, 87

in C++11, 87

export, 431

expression, 22

in C++, 22

conditional, see conditional operator

logic, 442

template, 32, 318–354

first library with ∼, 284

extension

.C, 420

.a, 422

.asm, 422

.c++, 420

.cc, 420

.cpp, 420, 427

.cxx, 420

.dll, 422

.hpp, 427

.i, 420

.ii, 420

.lib, 422

.o, 422

.obj, 422

.s, 422

.so, 422

extern, 430

factorization

in-place, 451

LU, 40, 89, 257, 450, 488

factory, 388

fallthrough, 26

false_type, 310

Fast Fourier Transformation, 441

Fatou dust, 286

featurism, 450

FEEL++, 285

FEM, 284

FEniCS, 284

Fertig, Andreas, 255

field, 73

FIFO, 221

file

close, 43

eof, 50

I/O, 43

in C++ project, 64

non-existing, 49

object, 428

open, 43

stream, 43, 106, 471

file_clock, 269

<filesystem>, 51

filter, 234

filter_view, 234

fin_diff, 177

final, 374

finance

quantitative, 249

find, 226

find_if, 229

find_if, 285

finite difference, 177

Fitzmaurice, Sue, 1

float, 4

floating_point, 252

<fmt>, 46, 172

for, 27

range-based, 215

for

range-based, 28

for_each, 414

for_each3, 415

for_each6, 415

for_each_n, 238

formal concept analysis, 129

<format>, 46, 172

formatter, 172

Forth, 457

Fortran, 439, 491 77, 72

forward, 134

forward_iterator, 199

forward_list, 150, 223

<forward_list>, 223

forward_range, 199

ForwardIterator, 209

ForwardIterator, 213

fprintf, 447

Fracassi, Fabio, 85

Franklin, Benjamin, 20

friend, 76, 113

inline, 103

fscanf, 447

fsize_mat_vec_mult, 333

fsize_mat_vec_mult_aux, 336

fsize_mat_vec_mult_reg, 336

fsize_matrix, 333

fsize_vector

compiler optimization, 330

fstream, 43

function, 30–35, 501

argument, 30–32

default, 31

constrained, 194

differentiable, 177

dispatching, 216

dynamic, 387

free, 113

generic, see template function

getter and setter, 75

header, 115

inline, 33, 429

address of ∼, 264

linear

piecewise, 210

local declaration, 429

main, 2, 35

missing in linkage, 428

no return value, 35

return value, 35

signatures of, 35

twice in linkage, 428

member vs. free, 118

nested call, 22

no match for, 136

nullary, 201

overloading, 33, 129

ambiguous, 165

parameter, 137

pointer, 411

vs. std::function, 265

redefinition, 429

result, 32–33

semantics, 450

signature, 453

template, see template, function

function, 161, 263, 273

function

in code selection, 389

<functional>, 249, 263, 266

functor, 177–185, 260, 411

argument, 210

exercise, 210

for loop unrolling, 331

short-hand, 185

via inheritance, 376

functor_base, 377

future, 272

wait, 274

<future>, 272

future_status

ready, 274

g++

constexpr, 291

implicit include, 135

register usage, 347

garbage collection, 447

interface, 448

Gauß circle problem, 108

Gauss-Jordan, 450

generator, 282

generic

reduction, 184

get, 273

GLAS, 493

GMP, 283

GNU, 2

Goethe, Johann Wolfgang von, 192

goto, 29

GPGPU, see GPU, 439

gps_clock, 269

GPU, 353, 441

and ODE, 409

graph, 56

Gregoire, Marc, 191

Grimm, Rainer, 282

Hamel, Lutz, 360

harmonic oscillator, 408

__has_include, 421

hash table, 225

Herbert

and ADL, 142

and CG, 436

and error handling, 37

and headers, 427

and his database, 108

and his hidden C sources, 489

offers header file, 489

hermite, 251

Hestenes, Magnus R., 435

hex, 45

hexadecimal, 8

hh_mm_ss, 269

hiding, see name, hiding

high_resolution_clock, 269

Hinnant, Howard, 98

hourglass API, 72

hours, 267

HPC, 283, 329

HPR, 284

BLAS, 284

Tensor, 284

-I (flag), 66

/I (flag), 66

I/O, 41–52

binary, 446

with variadic function, 478

C-style, 447

catching errors, 50

error, 49

format library, 46

formatting, 44

sufficient digits, 253

in expressions, 22

manipulator, 44

robust, 50

with exceptions, 50

with files, 43

without ADL, 142

iall, 456

IDE, 3

debugging, 496

identity

element, 253

identity, 358

identity element, 355

IEEE 754, 283

1. if, 68

if, 23–24

constexpr, 170, 192

nested, 442

with initializer, textbf24, 257

1. ifdef, 68

1. ifndef, 68

ifstream, 43

implementation

generic, 129, 412

modularized, 412

import

name, 140

namespace, 141

include

standard ∼ directories, 66

1. include, 66, 420

guards, 67

slash in, 67

with angle brackets, 66

with quotes, 66

inclusion, 66

inclusive_scan, 238

independent_bits_engine, 247

index

zero-based, 27

index_sequence, 203, 280

inequality, 398

inheritance, 73, 365–405

inheriting, 310

initial value problem, see IVP

initialization

aggregate, 90

braced, see initialization, uniform

designated, 91

non-narrowing, 9

uniform, 9, 87, 90–92, 451

in templates, 474

of arguments, 89

of empty pointer, 55

of return values, 92

with =, 82

initializer list, 89

in assignment, 90

in constructor, 90

vs. constructor, initialization list, 89

with trailing comma, 459

initializer_list, 151

<initializer_list>, 89

initilization list

in constructor, see constructor

inline, 33, see function, inline, see variable, inline

unrolled loop, 332

inner_product, 231

inorder, 281

input, 42

input_iterator, 195

InputIterator, 217

InputIterator, 213

insanity, 20

instantiation, 130–135

and executable size, 137

explicit, 131

implicit, 131

int, 4

int32_t, 446

integer_sequence, 203

integral, 356

integral_constant, 487

Integrated Development Environment, see IDE

Intel i7-3820, 337

interface

concise, 72

inter-language, 107

intuitive, 72

productive, 63

interoperation

with C and Fortran, 72

interruptible_iteration, 275

interruption

point, 275

interval

arithmetic, 283

closed, 152

right-open, 152, 214

invariant, 75, 369

inverse, 452

<iomanip>, 44

ios::binary, 446

ios_base, 45

<iostream>, 41

iostream, 43

<iostream>, 1, 420

iota, 200, 231

iota, 234

irange, 125, 456

irange, 234

is_a_matrix, 403

is_const

implementation, 306

in standard library, 254

is_literal_type, 291

is_matrix, 310

is_nothrow_assignable, 254

is_nothrow_copy_constructible, 301

is_pod, 255

is_prime, 431

is_reference, 298

is_rvalue_reference, 135

is_standard_layout, 255

is_trivially_copyable, 256

istream, 43

read, 446

iterator, 28, 153, 212–217

as generalized pointer, 212

beyond, 231

category, 213

dispatching on ∼ categories, 216

operations, 216

<iterator>, 216

IVPs, 408

Järvi, Jaakko, 312

Java, 3

generic functions, 137

join, 236

Josuttis, Nicolai, 211

jthread, 275, 282

Julia set, 286

Kalb, Jon, 107

KDE, 3

KDevelop, 3

kernel, 444

Kerr, Kenny, 282

key, 224

knuth_b, 247

Koenig, Andrew, 106

König, Tilmar, 407

label

in assembler, 422

laguerre, 251

lambda, 185–190

capture, 186

by reference, 187

by value, 186

init, 189

move, 189

constexpr, 296

exercise, 210

for sort, 230

in methods, 188

nested, 186

object, 411

return type, 186

language

core, 1, 62

feature

use new one, 68

functional, 22

machine, 421, 422

LAPACK, 305

latch, 282

late binding, 371

LATEX, 118

lazy evaluation, 274

left-adjusted, 45

legendre, 251

length, 103

less, 224

library, 211–287

for PDEs, 284–285

graph, 285

matrix template ∼ 4, see MTL4

scientific, 282–285

standard, 1, 38, 56, 62, 211–282

chrono, 267, 269

complex, 239–242

numerics, 239–252

random, 242–250

template, see STL

tutorial, 211

utilities, 256–269

with C interface, 53

LIFO, 221

<limits>, 245, 253, 298

linear_congruential_engine, 247

linearity, 73

linkage, 422, 428

block, 489

external, 429

internal, 429

order, 428

to C code, 489

linker

standard, 428

LINPACK, 329

Linux, 2, 498

Lipschitz-continuous, 409

Lisp interpreter, 483

list, 56

list, 150

erase, 222

in STL, 212, 222

performance, 222

<list>, 222

list_iterator, 153

literal, 7, 86

0, 55

binary, 8

hexadecimal, 8

octal, 8

user-defined, 103

local_t, 269

lock, 279

lock_guard, 276, 280

lock_shared, 277

long, 4

double, 4

long, 4

loop, 26–29

control, 29

overhead, 328

replaced by recursion, 332

size known at compile time, 330

unrolling, 328

automatic, 332

nested, 332

slowing down, 332

Lorenz system, 409, 417

lorenz, 418

lvalue, 13, 501

in tuple use, 259

in universal reference, 488

Mac OS, 498

macro, 12, 65, 421

as include guard, 67

definition, 65

enabling, 478

for constants, 448

function-like, 448

problems, 66

Magma, 357

Magnitude, 312

maintenance

with conditional compilation, 69

make, 423–424

make_index_sequence, 203

make_shared, 59

make_tuple, 258

Mandelbrot, Benoît B., 239

<map>, 224

map, 25, 224

at, 225

emplace, 267

find, 225, 267

insert, 267

of references, 266

map-reduce, 238

map_view, 401

<math.h>, 489

Mathematica, 441

mathematical

special functions, 250

MATLAB, 441

matrix

column, 456

dense, 329, 452, 461

row-wise, 462

exponentiation, 118

fixed-size, 332

Hilbert, 189

identity, 451

lower triangular, 450

norm, 452

permutation, 450

regular, 37

singular, 40

sparse, 413

square, 453

symmetric positive-definite, 435

transposed, 302

upper triangular, 450

matrix, 460

Maurer, Jens, 125

max, 129

max, 135

max_square, 448

maybe_unused, 203, 217

member_selector, 458

memcpy, 255

memmove, 255

memory

address, 54

allocation, 54, 412

as bottle neck, 321

automatic release, 447

dynamically allocated, 54

exhaustion, 56

hierarchy, 321, 322

leak, 55

management

encapsulation, 56

release, see deallocation

unused, 447

<memory>, 57

mersenne_twister_engine, 247

meta-function, 484

meta-programming, 156, 289–364

library support, 252

meta-tuning, 328–354

method, 73, 77–78

private, 75

public, 75

analytical, 407

Babylonian, 268

constant, 114

deletion

implicit vs. explicit, 472

generation, 111, 462

by base class, 466

by member, 466

design guides, 470

implicit, 466

of copy operations, 468–470

of default constructor, 467

of destructor, 467

of move operations, 470

suppression, 465

multi-step, 417

reference-qualified, 116

with default behavior, 111, 462

Meyers, Scott, 82, 133, 188, 473

Microsoft, 3

mile

nautical, 103

statute, 103

min_abs, 312

min_magnitude, 298

MinGW, 3

minimum, 317

minstd_rand, 247

minstd_rand0, 247

missing_exception, 405

MKL, 284, 354

mode

debug, 36

release, 36

modification

regarding private, 75

module, 430–434

interface, 431

std.core, 432

Monk, 477

Monoid, 358

monoid, 344

monoid_map, 358

Moore, Charles H., 456

move

assignment, 94

by copy, 472

constructor, 93

semantics, 32, 57, 93–96

move, 94, 95

abuse, 488

of tuple entries, 259

move-safe, 102

MPI, 412

mpi_algebra, 417

ms, 275

mt19937, 247

mt19937_64, 247

MTL4, 284, 449

abstraction penalty, 347

iteration control, 275

LU factorization, 451

nested unrolling, 350

terminology, 379

transposed view, 302

μ-recursive functions, 360

Mulansky, Mario, 284

mult_block, 351

multi_tmp, 345

multimap, 225

equal_range, 225

lower_bound, 225

upper_bound, 225

multiset, 223

contains, 223

Musser, David, 149, 212

mutable

in lambda, 187

mutable_copy, 469

mutex, 275

lock, 276

unlock, 276

Nackman, Lee, 397

Naipaul, V. S., 129

name

conflict, 64

demangler, 162, 304

hiding, 11, 474

in namespaces, 139

import, 140

in library, 139

in OS, 139

mangling, 422, 428

in RTTI, 304

incompatibility, 428

namespace, 12, 138–146

alias, 141

global, 139

import, 141

in generic programming, 138

qualification, 139

search in ∼, 139

NaN, 124

narrowing, 9, 397

in arrays, 52

in I/O, 51

in member initialization, 92

NDEBUG, 36

negate_view, 401, 403

.NET, 448

new, 18, 54

new[], 54

Newton’s equation, 408

next, 227

Niebler, Eric, 232

Niebuhr, Reinhold, 211

nodiscard, 38

noexcept, 41, 105

conditional, 301

in move operations, 94

norm

L1, 142, 312, 343

Frobenius, 188

norm, 239

not, 16

now, 267

nth_derivative, 181

NULL, 55

nullopt, 257

nullopt_t, 257

nullptr, 55, 94

num_cols, 379

num_rows, 379

number

amicable, 108

congruent, 108

Fibonacci, 289, 483

floating-point, 5, 15

integer, 4, 15

of arbitrary precision, 283

prime, 289, 481

rational, 283

<numbers>, 44, 251

numerator, 75

numeric

instability, 318

optimization, 328

<numeric>, 230

numeric_limits, 253

epsilon, 254

lowest, 254

max, 254

min, 254

-o (flag), 420

object, 74, 422, 501

emptied, 98

expired, 96

file, 422

and instantiation, 131

OCI, 107

oct, 45

octal, 8

odd_iterator, 209

ODE, 284, 407–418

autonomous, 408

explicit, 408

first order, 408

implicit, 408

non-linear, 408

order of, 408

real-valued, 408

ofstream, 43

omp_algebra, 417

on_each_nonzero, 188

one_norm, 313, 343

one_norm_ftor, 343

OOP, 365–405

opencl_algebra, 417

OpenMP, 353, 412

Operation, 413

operation

independent ∼s, 330

operator, 12–22

access ∼, 76–77

+ (addition), 13, 118, 319

&(address of), 19, 55

alignof, see alignof

() (application), 80, 118, 302, 461

() (application), 178

arithmetic, 13

arity, 118

= (assign), 18, 94, 136, 323, 330, 88–330

binary, 119

&(bitwise and), 17, 164

&= (bitwise and by), 18, 486

call, see operator, application

, (comma), 18, 23, 28, 203

∼x (complement), 17

?: (conditional), 18, 23, 25, 455

conversion, 164, 315, 395

-= (decrease by), 18

delete, see delete

→

• (deref member deref), 19, 458

• (derefer), 19, 55, 153

→ (derefer member), 19, 77, 117, 118

• = (divide by), 18

/ (division), 13

== (equal), 16, 153

default, 398

generated, 121

≫ (extraction), 42

(greater), 16, 135

= (greater equal), 16

+= (increase by), 18

≪ (insertion), 42, 120, 142

≪ (left shift), 17

≪= (left shift by), 18

< (less), 16

⇐ (less equal), 16

linear, 71

&&(logical and), 16

. (member), 19, 74, 76

.* (member deref), 19, 458

% (modulo), 13

%= (modulo by), 18

• (multiplication), 13

new, see new

! (not), 16

!= (not equal), 16, 153

generated, 121, 399

overloading, 19, 117–126

consistent, 117

exceptions, 19

priority, 118

return type, 118

– (post-decrement), 13

++ (post-increment), 13

– (pre-decrement), 13

– (pre-decrement), 213

++ (pre-increment), 13, 153

++ (pre-increment), 213

precedence, 20, 456

≫ (right shift), 17

≫= (right shift by), 18

• = (scale by), 18

semantics, 456

≪ (shift), 2

sizeof, see sizeof

sizeof…, see sizeof…

spaceship, see operator, 3-way comparison

[] (subscript), 19, 114, 118, 323, 333, 456

[] (subscript), 214

- (subtraction), 13

⇔ (3-way comparison), 16, 122–125

throw, see throw

typeid, see typeid

- (unary minus), 13, 120

+ (unary plus), 13

optimization, see performance optimization

optional, 256

or, 16

or_eq, 16

order

of accuracy, 410

ordering

strict weak, 224

ordinary differential equations, see ODE

ostream, 43, 44, 120, 203, 446

write, 446

ostream_iterator, 213, 229

out of range, 27

output, 41

overflow, 27

overhead

exponential, 485

in HPC software, 347

of virtual functions, 365

overload

in specialization, 165

resolution, 474

override, 373

overriding

explicit, 372

/P (flag), 420

packaged_task, 272

pair, 259

first, 259

second, 259

parallelism, 270

parameter pack, 201

packing, 201

unpacking, 201

Parent, Sean, 233

parse, 51

most vexing, 82

partial_ordering, 123

partial_sort, 230

partial_sum, 231, 238

Pascal

assignment, 17

pattern matching, 329

PDE, 284

performance

in generic programs, 222

of templates, 137

optimization, 483

concept-based, 329

tuning, 318–354, 478

variation, 73

permutation, 457, 487

row, 451

person, 366

all_info, 367

PETSc, 489

π, 11, 430

Picard-Lindelöf theorem, 409

Pike, Kenneth L., 501

pipe, 499

pipeline, 268

pitfalls

in method generation, 470

plain old data type

seePOD, 255

POD, 255

point, 397

pointer, 54–60

deleter, 58

initialization, 55

initialize as empty, 55

polymorphic, 388

raw, 56, 471

referring other variable, 55

smart, 57–60, 117

shared_ptr, see shared_ptr (top level)

unique_ptr, see unique_ptr (top level)

weak_ptr, see weak_ptr (top level)

stale, 61

to member, 77, 458

Poisson, 439

polymorphism

dynamic, 371

run-time, 365

static, 371

polynomial, 126

popcount, 292

posit (number system), 283

postorder, 281

practice, 407

1. pragma once, 67

precision (method of I/O streams), 253

preconditioners

dynamic selection, 387

predicate, 229

preorder, 281

preprocessing, 420

directive, 65

flag, 420

print, 202

printf, 447

printf, 404

private, 74

probability, 246

processor

many-core, 353

multi-core, 270

processors

super-scalar, 334

product

scalar, 87

program

deterministic, 21

error

static, 41

flow, 17

reliability, 452

source, 419

structure of, 10

programming

defensive, 36

extreme, 450

generic, 129–210

meta-∼, see meta-programming

object-oriented, 75, see OOP

with getters and setters, 77

paradigm, 129

structured, 29

template, 129

promise

in coroutines, 282

promise, 272

promoted, 396

property

mathematical, 73

protected, 74

proxy, 163, 462

Prud’homme, Christophe, 285

ptask, 273

public, 74

Python

as API for C++, 284

dynamic types, 155

range operations, 456

quantum phenomena, 242

queue, 56

RAII, 56, 106, 107, 276, 448

and rule of zero, 471

rand, 242

<random>, 242

random number, 242–250

distribution, 246, 248–249

generator, 246

pseudo-∼ generator, 242

truly ∼, 247

random_access_iterator, 198, 356

random_device, 247

random_numbers, 246

RandomAccessIterator, 216

RandomAccessIterator, 214

range, 125, 152, 199, 231–237, 455

adaptor, 234

checking, 462

<ranges>, 421

ranlux24, 247

ranlux24_base, 247

ranlux48, 247

ranlux48_base, 247

ratio, 268

rational, 126

rational, 74

real, 112

record, 260

recursion

in variadic templates, 201

infinite, 182

reduce, 238

ref, 266

refactoring, 454

reference, 30, 60–62

constant, 31

counting, 93

cyclic, 60

forward, 133

mutable, 44

not out-dating, 113

of member data, 112

of temporaries, 113

stale, 61

to local data, 61

universal, 133, 488

reference_wrapper, 60, 266

get, 266

referring, 206

register, 33

register, 335

reinterpret_cast, 394

replication

code, 429

requires, 194

reserve, 233

residuum, 275

ResizableRange, 233

resize, 413

resource

acquisition, see also RAII, 106

managed, 106

by user, 107, 471

release, 105

after exception, 106

return, 2

type, 32

automatic, 137

declaration, 156

deduction, 137

of lambda, 186

of mixed-type templates, 136

trailing, 156

value optimization, 95

Returnable, 196

reusability, 457

reverse, 236

riemann_zeta, 251

ROSE, 329

rotation, 175

RTTI, 303, 393

Rudl, Jan, 249

rule

of five, 471

of five defaults, 473

of six, 473

of zero, 471

trapezoid, 210

run time, 137

run-time type information, see RTTI

Runge-Kutta, 408

algorithm, 408

method, 410, 418

scheme

explicit, 409

RK4, 410

runge_kutta4, 413

runge_kutta4, 416

runtime_error, 378

rvalue, 93, 501

accept only ∼ argument, 488

and raw-pointers, 94

in tuple use, 259

with deleted move operations, 472

scale_sum2, 415

scale_sum5, 415

scanf, 447

scheme

explicit, 417

implicit, 417

predictor-corrector, 417

Scholes, Myron, 249

science

computer, 71, 470

scope, 10–12, 24

global, 10

in constructor, 81

local, 10

nested, 11

out of, 11

scoped_lock, 280

scr1, 448

seed, 242

segmentation fault, see segmentation violation

segmentation violation

in array, 53

selection

run-time, 459

semantics, 450

inconsistent, 87

operator vs. function notation, 321

semaphore, 282

semicolon, 23

SemiGroup, 358

sentinel, 235

separation of concerns, 21

set

sub-, 368

super-, 368

<set>, 223

set, 223

contains, 223

count, 223

find, 223

setprecision, 44

setw, 45

SFINAE, 312

Shabalin, Alex, 191

share price, 249

shared_mutex, 277

lock_shared, 277

unlock_shared, 277

shared_pointer, 467

shared_ptr, 58, 107, 448, 471

for resource rescue, 109

use_count, 59

shared_ptr, 282

shared_timed_mutex, 277

short, 4

shuffle_order_engine, 247

side effect, 14, 20, 73

in constexpr functions, 290

in lambda, 188

Siek, Jeremy, 26, 285, 398

signature, 34

of overridden methods, 372

signed, 4

Simple DirectMedia Layer, 239

simulation

large-scale, 318

single, 236

single responsible principle, see SRP

singleton, 77

size

compile-time, 330

compile-time ∼, 52, 174

run-time ∼, 54

static, see compile-time size

size, 413

size, 233

sized_range, 233

sizeof, 19

on arrays, 53

sizeof…, 19, 202

Skarupke, Malte, 474

slicing, 372

software

break, 49

confidence, 117

developer, 71

development, 450

domain-specific, 71

engineering, 71

high-performance, 321

non-portable, 68

scientific, 71, 435

structure of, 64

solver

asynchronous, 275

direct, 450

dynamic selection, 387

iterative

interruptible, 275

triangular, 453

solver, 220

sort, 230

intro-∼, 230

quick, 230

sort, 135, 238

with user-defined iterator, 209

source

preprocessed, 421

span, 263

sparse, 206

specialization, 162

ambiguity, 165

for hardware, 477

for type traits, 299

full, 167

of functions, 165

partial, 166, 300

sph_bessel, 251

sph_legendre, 251

sph_neumann, 251

split, 236

sqrt

in Mandelbrotsqrt set, 239

square root, 254

srand, 242

SRP, 107, 111

SSE, 238, 334, 353, 477

stable_sort, 230

stack, 208, 428

stack

specialization for boolstack, 209

with custom size, 209

stackless, 281

state_type, 413

statement, 23

compound, 2, 23

empty, 23

in Pascal, 22

static

in constexprstatic, 292

member variable, 77

method, 77

random engine, 246

variable, 441

static_assert, 41, 311

replacement, 485

std::

‘name’, see ‘name’ at top level

user code in ∼, 142

steady_clock, 269

period, 268

Stepanov, Alex, 149, 212, 347

Stiefel, Eduard, 435

STL, 25, 211–239

algorithm, 226–231

containers, 218–226

stof, 444

strcpy, 21

string, 2

C, 447

format, 447

string, 5, 44

<string>, 5, 8

string_view, 262

stringstream, 44

str, 44

strong_ordering, 124

Stroustrup, Bjarne, 65, 96, 106, 211

struct, 75

structured bindings, 159

student, 367

sub_matrix, 125

substitution failure is not an error, see SFINAE

subtract_with_carry_engine, 247

sufficient condition, 129

sum, 315

sum, 149

variadic, 200

Summable, 194

Sutter, Herb, 75, 100, 305

swap, 96, 145

switch, 26

in dynamic function dispatching, 387

with initializer, 26

symbol

found multiple times, 428

in object file, 422, 428

matching, 422, 428

not found, 428

weak, 429

symbol_counter, 260

system

linear, 417

system_clock, 269

to_time_t, 267

tag

dispatching, 217

type, 217

tai_clock, 269

take, 236

tangent, 183

Taylor series, 28, 182

TCP/IP, 44

template, 129–210

alias, 161

argument, 193

arbitrary number of ∼, 200

class, 147–185

function, 129–138

virtual, 389

library, 138

parameter, 192

non-type, 174

terse, 138

performance, 137

primary, 162

specialization, see specialization (top level)

variable, 191, 306

variadic, 200, 315

associtivity, 318

with mixed types, 136

tensor, 284

tensor, 161

termination criterion

type-dependent, 254

test, 37

testing, 206

randomized, 244

text

substitution, 66, 421

theory, 407

relativity, 176

string, 176

this, 88, 398

thread, 271

detach, 273

join, 272, 279

killing, 275

storage, 292

<thread>, 3

thread, 270

hardware_concurrency, 287

threads, 270

throw, 19, 38

re∼, 39

Thrust, 284

tie, 258

time

run, 54

time_point, 267

time_t, 267

time_type, 413

timer, 267, 269

to_string, 208

to_tuple_string(x, y, z), 208

trajectory, 408

discrete, 410

trans, 303

transform, 234

transform_exclusive_scan, 238

transform_inclusive_scan, 238

transform_reduce, 238

translation

unit, 421

transposed_view, 302

traverse, 281

tree, 56

trigonometry

with intervals, 283

try, 39

-catch-block, 39

in constexprtry, 292

tuple

access by entry type, 258

tuple, 204, 206, 257

get, 258

<tuple>, 257

Turing

machine, 359

Turing

computable, 360

Turing

complete, 360

Turing completeness, 360

Turing, Alan, 359

Twain, Mark, 20

type

-dependent behavior, 149

deduction, 131–135, 154–160, 176

for class templates, 156

for variables, 155

definition, 160–162

erasure, 261

exception, 38

generator, 205

generic, 129

in binary I/O, 446

intrinsic, 4, 7

introspection, 304

meaning of bites, 389

parameter

anonymous, 485

parametric, 129

pattern, 167

polymorphic, 370, 393

property, 291

safe, 422, 447

strongly ∼d, 4, 155

sub-∼, 368

super-∼, 368

trait, 298

in advance, 217

in standard library, 254

<type_traits>, 254, 298, 313, 317

typedef, 160

typedef, 402

typeid, 19

<typeinfo>, 303

typename, 130

UDL, see literal, user-defined

uint32_t, 446

UnaryFunction, 179

uncopyable, 195

uncover_members, 172

1. undef, 66

unexpected, 301

union, 259

unique, 229

unique_ptr, 57, 107, 448, 471

get, 90

universal number arithmetic, 283

Unix, 498

unmovable, 195

unordered, 123

Unruh, Erwin, 289, 481

unseq, 238

unsigned, 4

upper_trisolve, 453

user-declared, 466

purely, 466

user-implemented, 466

using, 160

declaration, 140, 368, 369

directive, 141

utc_clock, 269

v-shape, 380

valarray, 63

operations, 63

sliced access, 63

usage, 64

valid (interval arithmetic), 283

value_type, 413

Vandevoorde, Daveed, 322

variable, 4–12

accessibility, 10

constant, see constant

declaration, 4

global, 10

in multiple translation units, 430

independent, 408

inline, 429

life time, 11

local, 10

real-valued, 408

visibility, 10, 11

variadic, see template

variant, 259

get, 260

variation, 249

vector, 27

addition, 52, 62

column, 453

generic, 147

in linear algebra vs. STL, 147

space, 63, 71

changing dimension, 89

temporary, 93

unit, 455

<vector>, 218

vector, 56, 62, 89, 413

capacity, 218

emplace, 220

emplace_back, 220

in Magnitudevector type trait, 300

in STL, 212, 218

of any, 474

of bool, 162

push_back, 218

resize, 219

shrink_to_fit, 219

size, 62

slow addition, 319

vector_bool_proxy, 163

vector_sum, 323

Veldhuizen, Todd, 284, 322, 360

VexCL, 284

ViennaCL, 284

view, 301

views, 234

virtual, 365, 370

base class, 384, 391

function table, 371

method table, 371

virtual, 255

pure, 375

visibility, 10, 368

visit, 261, 480

Visual Studio, 3

macros, 66

preprocessing flag, 420

pretty printer in debugger, 496

void, 32

volatile, 393, 394

vtable, see virtual function table

weak_ordering, 124

weak_ptr, 60

weak_ptr, 282

while, 26

Wilcock, Jeremiah, 312, 486

Williams, Anthony, 282

Windows, 3

<windows.h>, 3

xor, 16

xvalue, 98

Fair Use Sources:

• B09HTJRJ3V, DMdrCpp, 2021