Index

Symbols

( ) (parentheses), 187

{} (curly braces), 144, 166

A

ABI (application binary interface), 23–24

Abrahams, David, 280

abstract class, 101, 102

abstraction, 167, 302–304

access

memory, 225–229

nonexisting element of a std::string, 404

objects, 114–117

sequence containers, 229

accounts, comparing, 326

accumulate algorithm, 166

acquire-release semantics, singletons, 218

ADL (argument-dependent lookup), 126, 314, 315–316

algorithms, 8

Euclidean, 223

expressing, 304

function objects, 305–307

gcd, 223–225

generic programming, 301, 302. See also generic programming

parallel, 266

preference over raw loops, 201

std::accumulate, 166

std::transform_exclusive_scan, 269

STL (Standard Template Library), 12, 266

aliases

defining, 311

smart pointers, 162–164

templates, 310, 311

ALL_CAPS, 134, 170–171

allocation

memory, 147, 246

resource management, 145–150

analysis, enabling code, 448

annotated graphs, 243

anonymous unions, 128–129

application binary interface. See ABI (application binary interface)

architecture, 423–425

code stability, 423

cycles among libraries, 425

expressing reusable parts as libraries, 424–425

argument-dependent lookup. See ADL (argument-dependent lookup)

arguments

binary callables, 21, 22

defaults, 49, 113–114

functions, 359

metafunctions, 343

order of evaluation, 195–196

Regular type/SemiRegular type, 313–314

template argument deduction, 313

templates, 359

va_arg, 49–52

arithmetic

errors, 208–210

rules, 204

signed/unsigned integers, 204–208

array, 401–403

arrays, deleting, 194

artificial scope, 144

assembler instructions, 30

assertions, 443

assignments

classes, 59–60, 78–80

copy-assignment operator, 221, 222

pointers, 117

auto, applying, 171–172

automatic management of devices, 435, 449

automatic memory management, 398. See also memory

automatic type deduction, 179

availability of source code, 376–377

B

bad functions, example of, 28–29

Bartosz, Milewski, 276

base classes, 101

basic exception safety, 280

behaviors

default, 71

defining, 368

implementation-defined, 9

regular types, 58

shadowing, 111–113

undefined, 9, 22, 42, 63, 234–235. See also undefined behaviors

unspecified, 196

big six, 59, 60, 61, 85, 130, 222

binary callables, 21, 22

binding, late, 114

bit manipulation, 205

block scope, 166

Boost C++ Library, 280

boundaries, 282, 403–404

bounds

errors, 403–404

safety, 439

built-in types, 283–285, 294

byte, 409

C

calculating (at compile time), 339–341

callables

definition of, 21, 22

providing, 305

C-arrays

bounds errors, 403–404

size of, 402

std::array instead of, 401–403

std::vector instead of, 398–400

case-sensitivity, 363

casts

avoiding, 197

naming, 198

Visual Studio compiler, 197

catch-clauses, ordering, 288

catch-fire semantics, 9

catching exceptions, 285–286. See also exceptions

D

data members

accessing specifiers, 105

non-const, 107

data races, 234–235

in CppMem, 245

data sharing, concurrency, 257–261

deadlocks, 248

deallocation, resource management, 145–150

decay, 117

declaration

classes, 431

expressions, 168

functions, 427–428

naming, 168–169, 171

statements, 168

static_assert, 10

deduction

automatic type, 179

template argument, 311-312

deep copying, 80. See also copying

polymorphic classes, 103

=default, 89–90

defaults

arguments, 49, 113–114

behaviors, 71

constructors, 68–74, 69–74

operations, 60–66, 88–98

statements, 202–204

=delete, 89, 90–91

deleting

arrays, 194

destructors, 91

dependencies

avoiding, 390

cyclic, 388–390

injection, 18–20

minimizing context, 320–321

non-dependent class template members, 323–325

between special member functions, 61

deque, 226

dereferencing pointers, 191–193, 194

design

classes, 102–117

error handling, 281–282

Gang of Four (GoF), 111

optimizations, 219–222

Design Patterns: Elements of Reusable Object-Oriented Software (Gamma, Helm, Johnson, Vlissides), 111

destructors, 145

calling virtual functions, 91–98

classes, 59–60, 83–88

defining, 84, 85

deleting, 91

failing, 88

need for, 83

nonvirtual, 87

protected, 87

public, 86–87

virtual, 86–87

detection

errors, 10

overflow, 208

deterministic, definition of, 437

devices, automatic management of, 435, 449

direct ownership, 286–287

discriminated unions, 126

documentation, intention of, 9

don’t repeat yourself. See DRY (don’t repeat yourself)

do while loops, 199, 200

DRY (don’t repeat yourself), 49, 291, 364, 365

dynamic-cast, 114–117

E

enable_if, 319–320, 352, 356

enabling code analysis, 448

endl, 415–418

enforcing rules, 447–452

enumerations, 131–137

ALL_CAPS, 134

constants, 133

enum class, 133–134

enumerator values, 136

over macros, 132–133

strongly typed enums, 131

underlying types, 135

unnamed, 134–135

equality operators, 94–96, 97–98

equivalent operations, 124–125

error handling, 279, 280–281. See also errors

design, 281–282

implementation, 283–291

errors

arithmetic, 208–210

bounds, 403–404

with C++ compilers, 377

compilation, 174

compiler, 387

detecting, 10

run-time, 11

SFINAE (Substitution Failure Is Not An Error), 320, 352

single pointers and, 22–23

static_assert declarations, 10

use-before-set, 177

Euclidean algorithm, 223

evaluation, order of, 150, 194–195, 194–196

exceptions

avoiding, 429–431

basic exception safety, 280

catching, 285–286

dynamic-cast, 116

error handling, 283. See also error handling

ordering catch-clauses, 288

purpose-designed user-defined types, 283–285

safety, 280

sending, 270–271

specifications, 287–288

strong exception safety, 280

throwing, 68

execution

conditional, 360

metafunctions, 342

policies, 267

selecting, 243

single-threaded, 218

explicit constructors, 121

explicit sharing, minimizing, 236–237

expressions, 165–166, 186

complicated, 186

constant, 29–30

conversions, 197–199

general rules, 166–168

magic constants, 190

operator precedence, 187

order of evaluation, 194–195

pointers, 187–190, 191–193

range checking, 190–191

statements, 148–150

summation with fold, 51

expressiveness, 46–47

function objects, 307

F

failing destructors, 88

failure transparency, 280

fallthrough, 201, 202

files

.cpp, 384, 386–387

.h, 384, 385–386, 388

header, 391, 393–394

source. See source files

final, 102, 103

flushing, 415–418

fold expressions, summation with, 51

for loops, 199, 200

format strings, 413–414

for-statements, 168–169

forwarding, perfect, 333–335

forward_list, 226

forward parameters, 34–36

forward std, 144, 198, 226

free, 145–146

func, 39

function objects

advantages of, 307–310

algorithms, 305–307

as sorting criteria, 307

with state, 309

functions, 27–28

ADL (argument-dependent lookup), 126

arguments, 359

callables, 21, 22

classes, 55

cleanup actions, 433–435

clone, 103–105

communication, 20–22

constant expressions, 357

constexpr, 29–30, 298, 342, 356

declarations, 427–428

=default, 89–90

defining, 368, 385

definitions, 28–29

=delete, 89, 90–91

dependencies between special member, 61

free, 145–146

helper, 57

invariants for, 15

ISP (interface segregation principle), 100

lambdas, 46

main, 42

malloc, 145–146

members, 56

metafunctions, 342–345

naming, 28–29

noexcept, 30–31, 88

nonmember, 118–122

order of evaluation, 195–196

overloading, 379

parameter packs, 35, 51, 335, 336

parameters, 156–159

passing parameters, 32–38. See also parameters

printf, 413–414

pure, 31–32

refactoring, 29

return-statements in, 428–429

as sorting criteria, 307

specialization of templates, 367–372

std::move(local), 45–46

struct, 55

swap, 92–94

templates, 311–313

unit tests, 18

virtual, 82, 102, 223, 331, 357

virtual clone member, 105

fundamental types, 176, 181

G

Gang of Four design. See GoF (Gang of Four) design

GCC compiler, 172, 174, 196, 197, 219, 354

gcd algorithm, 223–225

general rules. See rules

generic code. See also code

templates, 10

generic programming, 301, 302

getters, 106

global containers, threads as, 250–251

global scope, 176

global variables, non-const, 16–17

GoF (Gang of Four) design, 111

graphs, annotated, 243

GSL (Guidelines Support Library), 441–444

assertions, 443

ownership pointers, 442–443

utilities, 443–444

views, 441–442

guarantees

evaluation order, 150, 196

exceptions, 280. See also exceptions

Guidelines Support Library. See GSL (Guidelines Support Library)

H

hardware/compiler combinations, 274–276

Haskell, 32

header files, 391

unnamed namespaces, 394

using namespaces, 393–394

helper functions, 57

.h files, 384, 385–386

#include guard, 388

hiding

implementation details, 310

member functions, 174

hierarchies

catching exceptions, 285–286

classes, 53, 59, 98–117, 331. See also classes

equality operators, 97–98

navigating, 115

templates, 330–332

hints, compilers, 223

I

IILE (Immediately Invoked Lambda Expression), 183

Immediately Invoked Lambda Expression. See IILE (Immediately Invoked Lambda Expression)

immutable data, 12, 293–298

implementation

classes, 56

error handling, 283–291

hiding details, 310

inheritance, 98, 107–111

Plmpl idiom, 23–24, 109

singletons, 18

source files, 384–391

templates with specializations, 325–330

ThreadSanitizer, 239–241

implementation-defined behavior, 9, 205

implicit conversion operators, 122–124

in-class initializers, 75

inheritance

classes, 54

implementation, 98, 107–111

interfaces, 107–111

multiple, 107, 111

initialization, 177–182

lambdas, 183–184

objects, 175–176

two-phase, 431–433

variables, 175–184

injection

dependency, 18–20

inline, 30, 354, 357, 385

in-out parameters, 36

in parameters, 34

input/output. See I/O (input/output)

integers, signed/unsigned, 204–208

interfaces, 15–16

ABI (application binary interface), 23–24

abstract classes, 101

applying classes, 56

base classes, 101

C-style programming, 378–380

defining, 386–387

dependency injection, 18–20

function communication, 20–22

functions, 27–28. See also functions

inheritance, 107–111

multiple inheritance, 111

non-const global variables, 16–17

segregation principle, 100

single pointers, 22–23

singletons, 17–18

source files, 384–391

templates, 305–320

interface segregation principle. See ISP (interface segregation principle)

internal linkage, 394–395

invariants

error handling, 282

for functions, 15

I/O (input/output)

character-level input, 411

iostreams, 413–414

std::endl, 415–418

STL (Standard Template Library), 411–418

stream synchronization, 414–415

iostreams, 411, 413–414

ISO Standards, 8, 9

ISP (interface segregation principle), 100

iteration

statements, 199–201

through containers, 366

iterator categories, 366–367

J

jthread, 251–253

K

keep it simple, stupid. See KISS (keep it simple, stupid)

keywords, overriding, 102

KISS (keep it simple, stupid), 59

Koenig lookup, 126, 314, 315–316

L

lambdas, 46

initializing, 183–184

overloading, 117

references, 47, 48–49

as sorting criteria, 307

with state, 310

unnamed, 364–365

languages

features, 167–168

Haskell, 32

late binding, 114

leaks

memory, 287

resources, 11

libraries, 166. See also STL (Standard Template Library)

Boost C++ Library, 280

cycles among, 425

expressing reusable parts as, 424–425

GSL (Guidelines Support Library), 441–444

reusing code, 232

STL (Standard Template Library). See STL (Standard Template Library)

support, 13

type-traits, 345–346, 351

life cycles of objects, 59

lifetimes

objects, 142

safety, 439

semantics, 157–159

limiting scope, 168–169

linker errors, 387

Linux systems

creation of threads, 262

flushing, 418

size of threads, 261

list, 226

literal type, 224

LoadLoad, 276

local names, 169–170

local objects, 140, 141, 287. See also objects

lock-free programming, 273–276

lock_guard, 264–266

locks

concurrency, 246–250

mutexes, 264

std::lock_guard, 264–266

std::unique_lock, 264–266

logical constness, 295

logical structure, expressing, 394

lookups, 126, 314, 315

loops, 199, 200

raw, 201

recursion versus, 360

lost wakeups, 255, 256

lvalue references, 42–46

M

macros

enumerations over, 132–133

statements, 184–185

magic constants, 190

malloc, 145–146

management

automatic management of devices, 435, 449

automatic memory management, 398

memory, 398, 405

resources, 139–140. See also resource management

Martin, Robert C., 100

mathematical functions, 32. See also pure functions

member functions, 56

boundary-checking, 403–404

compiler errors, 332

const, 294–296

hiding, 174

reserve, 399

shadowing, 112

virtual member function templates, 331–332

members

accessing specifiers for data, 105

declaring, 74

dependencies between special functions, 61

initializing, 74–76, 75

ISP (interface segregation principle), 100

minimizing exposure, 58

non-dependent class template, 323–325

nonpublic, 58

parameters, 321–322

pointers, 85

variables, 75

memory

accessing, 225–229

allocation, 147, 246

automatic memory management, 398

leaks, 287

management, 398, 405

models, 242

ROM (readonly memory), 29

saving, 126

sequence containers, 229

messages

as exceptions and values, 271

passing, 269–273

messy code, 12, 13

metadata, templates, 341

metafunctions, templates, 342–345

metaprogramming, 336–356

constexpr function, 358

templates, 351

meta-rules. See philosophical rules

Metaware compiler, 338

Meyers singleton, 217

Microsoft Visual Studio Compiler, 30

minimizing

context dependencies, 320–321

context switching, 261

thread creation/destruction, 261–263

time locking mutexes, 264

models, memory, 242

modification versus new value, 359

most vexing parse, 177, 179

move(local) function, 45–46

moving

classes, 78–83

semantics, 80–83

std::unique_ptr, 153

MSVC compiler, 172

multiple inheritance, 107, 111

multiple mutexes, acquiring, 247–248

multi-threaded programs, 232–234

mutable data, 12

mutexes

acquiring, 247–248

locks, 264

MyGuard, 265

myths, 427–436

N

naked unions, 127–128

Named Return Value Optimization. See NRVO (Named Return Value Optimization)

names

ALL_CAPS, 170–171

casts, 198

common names, 169–170

conventions, 342

declarations, 168–169, 171

expressions, 168–185

functions, 28–29

local names, 169–170

mangling, 380

operations, 362–364

redundancy, 171–172

reusing names, 172–175

similar names, 170

statements, 168–185

templates, 314–319

namespaces, 57

defining overloaded operators, 125–126

source code, 391–395

narrowing conversion, 180–182

negative values, 206–208

nested scopes, reusing names, 172–175

NNM (No Naked Mutex), 246

NNN (No Naked New), 147, 246

noexcept, 30, 31, 79, 95

destructors, 88

function definition, 88

noexcept function, 30–31, 88

no exception safety, 280

no-leak guarantee, 280

No Naked Mutex. See NNM (No Naked Mutex)

No Naked New. See NNN (No Naked New)

non-const data members, 107

non-const global variables, 16–17

non-dependent class template members, 323–325

nongeneric code, writing, 365–367

nonmember functions, 118–122

nonpublic members, 58

nonrules, 427–436

nonvirtual, destructors, 87

normal parameter passing, 32

no-throw guarantees, 280

notifications

sending, 272–273

with tasks, 273

NRVO (Named Return Value Optimization), 36, 37

NULL, 192

nullptr, 191–193, 192–193. See also pointers

O

objects

accessing, 114–117

constructors creating, 67

creating, 145

defining, 297–298, 385–386

direct ownership, 286–287

function objects. See function objects

immutable data and, 294

initializing, 175–176

life cycles of, 59

lifetimes, 142

local, 140, 141

moving, 80

scoped, 143–144

ODR (One Definition Rule), 385

One Definition Rule. See ODR (One Definition Rule)

operands, defining overloaded operators, 125–126

operations

cheap, 33

equivalent, 124–125

naming, 362–364

naming functions, 28–29

passing to algorithms, 305–307

reordering, 276

operators

ADL (argument-dependent lookup), 126

conventional usage, 118–126

copy-assignment, 221, 222

defining, 125–126

equality, 94–96, 97–98

implicit conversion, 122–124

overloading, 117–126

precedence, 187

symmetric, 118–122

optimization, 17

code, 167

design, 219–222

enabling, 218–229

type-traits library, 354–356

wrong, 214

order of evaluation, expressions, 194–195

out_of_range, 190, 403

out parameter, 52

output parameters, 36–37

out values, 37–38

overflow, 208

overloading, 49

ADL (argument-dependent lookup), 126

classes, 111

conventional usage, 118–126

defining operators, 125–126

functions, 379

function templates, 369–370

implicit conversion operators, 122–124

operators, 117–126

override, 102

ownership

direct, 286–287

pointers/references, 143, 442–443

semantics, 38–41

sharing, 164, 258–261

std::shared_ptr, 151–153

std::unique_ptr, 150–151

P

packing parameters, 35

parallelism, concurrency and, 232, 266–269

parameters

in, 34

forward, 34–36

functions, 156–159

in-out, 36

members, 321–322

normal parameter passing, 32

out, 52

output, 36–37

ownership semantics, 38–41

packs, 35, 51, 335, 336

passing, 32–38

value return semantics, 42–46

Parent, Sean, 167

parentheses ( ), 187

passing

messages, 269–273

pointers, 297

references, 297

passing parameters, 32–38

normal parameter passing, 32

ownership semantics, 38–41

value return semantics, 42–46

perfect forwarding, 333–335

performance, 213

enabling optimization, 218–229

function objects, 307

measurements, 214

Meyers singleton, 217

wrong assumptions, 214–218

wrong optimizations, 214

philosophical rules, 7

compile-time checking, 10

expressing ideas in code, 8

expressing intent, 9

immutable data, 12

messy code, 12, 13

resource leaks, 11

run-time checking, 11

run-time errors, 11

saving space and time, 11–12

statically type safe programs, 10

supporting tools, 13

support libraries, 13

writing in ISO standard C++, 8–9

physical constness, 295

Pikus, Fedor, 274

Plain Old Data. See POD (Plain Old Data)

Plmpl idiom, 23–24, 109

POD (Plain Old Data), 33

pointers, 42–46, 84

assigning, 117

dereferencing, 191–193, 194

dynamic-cast, 114, 115, 116

expressions, 187–190, 191–193

members, 85

null, 191–193

passing, 162–164, 297

Plmpl idiom, 23–24, 109

raw, 85, 140, 143

rules, 191

single, 22–23

smart, 150–164

policy execution, 266, 267

polymorphic classes, 81–83, 103

portably enforceable, definition of, 437

POSIX Threads, 256

postconditions, 15

power as function/metafunction, 345

pragma once, 388

preconditions, 15

predicates, condition variables without, 257

predictability, 225–229

Preshing, Jeff, 276

primary type categories, 346–349

principle of least astonishment, 118

printf function, 413–414

profiles, 437–439

Pro.boundsBounds safety, 439

Pro.lifetimeLifetime safety, 439

Pro.typeType safety, 438

programming

C-style, 375. See also C-style programming

generic. See generic programming

metaprogramming, 336–356, 351, 358. See also metaprogramming

programs

multi-threaded, 232–234

statically type safe, 10

property types, 348–349

protected data, 106–107, 436

protected destructors, 87

public destructors, 86–87

pure functions, 31–32. See also functions

purpose-designed user-defined types, 283–285

Q

quality of code, 167

R

race conditions, 253

RAII (Resource Acquisition Is Initialization), 140–142, 246, 264, 287, 288, 289

range checking, 190–191

ranges, expressing, 305

raw loops, 201

raw pointers, 85, 140, 143

raw references, 143

read-only memory. See ROM (read-only memory)

recursion versus loop, 360

redundancy, naming, 171–172

refactoring, 17, 29

references, 84, 140

catching exceptions, 285–286

dynamic-cast, 114, 115, 116

lambdas, 47, 48–49

to locals, 42–44

lvalue, 42–46

passing, 297

raw, 143

SemiRegular type, 315

universal, 334

referential transparency, 31

Regular, 313–314

regular types, 58, 59

relations, enabling, 243

relaxed semantics, 275

reordering operations, 276

repetition of code, 291

reserve function, 399

Resource Acquisition Is Initialization. See RAII (Resource Acquisition Is Initialization)

resource management, 139–140

allocation, 145–150

deallocation, 145–150

general rules, 140–144

smart pointers, 150–164

resources

concurrency, 261–264

leaks, 11

ownership of, 39

return-statements in functions, 428–429

Return Value Optimization. See RVO (Return Value Optimization)

return values

metafunctions, 343

simulations, 361

reusing

expressing reusable parts as libraries, 424–425

operations, 362–364

ROM (read-only memory), 29

rule of five, 61, 83, 84, 89

rule of six, 61

rule of zero, 60

rules

arithmetic, 204

class hierarchies, 99–101

configuring applied, 449

enforcing, 447–452

expressions, 166–168

interfaces, 20–22

NNN (No Naked New), 147

ODR (One Definition Rule), 385

passing parameters, 32–38

philosophical, 7. See also philosophical rules

pointers, 191

resource management, 140–144

statements, 166–168

summary, 54–58

templates, 362–372

user-defined types, 53

running code analysis, 449

run time

calculating at, 343

checking, 10, 11

constant expression in ROM, 29–30

errors, 11

gcd algorithms, 223–225

RVO (Return Value Optimization), 36, 37

S

safety

basic exception, 280

bounds, 439

exceptions, 280

lifetimes, 439

types, 438

scoped enums, 131, 135, 137

scoped objects, 143–144

scopes

block, 166

global, 176

limiting, 168–169

reusing names, 172–175

sizes, 168

selection statements, 201–204

self-assignment, 79–80

semantics

acquire-release, 218

catch-fire, 9

copy, 65

copying, 80–83

copy-only type, 221

lifetime, 157–159

moving, 80–83

ownership, 38–41

relaxed, 275

summary rules, 54–58

value return, 42–46

SemiRegular, 313–314

sequence containers, 229

sequential consistency, 218, 243, 274, 275

setters, 106

SFINAE (Substitution Failure Is Not An Error), 320, 352

shadowing, 111–113

shallow copying, 80. See also copying

sharing ownership, 258–261

signed/unsigned integers, 204–208

SIMD (Single Instruction, Multiple Data), 267

similar names, 170. See also naming

simulations, return values, 361

single-argument constructors, 72–74

Single Instruction, Multiple Data. See SIMD (Single Instruction, Multiple Data)

single pointers, 22–23

single return-statements in functions, 428–429

single-threaded case, 218

singletons, 17–18

six, rule of, 61

sizes

of C-arrays, 402

of chars with C++ compilers, 377

of enumerators, 136

of scopes, 168

of threads, 261

of vectors, 399, 400

slicing, 81

smart pointers, 150–164

aliases, 162–164

cycles of, 154

as function parameters, 156

lifetime semantics of, 157–159

sharing ownership, 261

std::unique_ptr, 160–162

software units, 281

source code

availability of, 376–377

entire code not available, 378–380

namespaces, 391–395

source files, 383, 384

cyclic dependencies, 388–390

implementation, 384–391

interfaces, 384–391

span, 10, 23, 52, 101

special constructors, 76–78

specialization,

function templates, 367–372

templates, 360

special member functions, 61

specifications, exceptions, 287–288

spurious wakeups, 256

stability, code, 423

Standard Template Library. See STL (Standard Template Library)

state, function objects, 308–310

statements, 165–166, 199. See also declarations

defaults, 202–204

definitions of, 166

expressions, 148–150

for-statements, 168–169

general rules, 166–168

initializing variables, 175–184

iteration, 199–201

macros, 184–185

naming, 168–185

return-statements in functions, 428–429

selection, 201–204

switch, 201–202

statically type safe programs, 10

static_assert declarations, 10

static type systems, 222–223

std::forward, 144, 198, 226, 334

std::make_unique, 36, 148, 153, 334, 335

std::shared_ptr, 140, 151–153

std::unique_ptr, 140, 146–147, 150–151

moving, 152

smart pointers, 160–162

std::weak_ptr, 140, 154–156

STL (Standard Template Library), 8, 21, 305, 397

algorithms, 8, 12, 266

containers, 23, 60, 398–404

expressions, 166

I/O (input/output), 411–418

RAII (Resource Acquisition Is Initialization), 140–142

strings, 410

text, 404–411

streams

state, 411–413

synchronization, 414–415

strings

accessing nonexisting element of, 404

format, 413–414

owning character sequences, 405–406

STL (Standard Template Library), 410

string_view, referring to character sequences, 407–408

strong exception safety, 280

strongly typed enums, 131

Stroustrup, Bjarne, 169

struct, 55

case-sensitivity, 363

class versus, 54

structures, organizing data into, 54–55

Substitution Failure Is Not An Error. See SFINAE (Substitution Failure Is Not An Error)

suffixes, .cpp, 384

summary rules, 54–58

summation

with fold expressions, 51

with va_arg, 51

support

C-arrays, 403–404

libraries, 13

tools, 13

Sutter, Herb, 274, 276

swap function, 92–94

switch statements, 201–202

symbolic constants, 190

symmetric operators, 118–122

synchronization, 255

streams, 414–415

volatile for, 238

sync_with_stdio, 404, 415

T

tagged unions, 128–129

tasks

condition variables versus, 272

notifications with, 273

versus threads, 237–238

Technical Report on C++ Performance, 430

templates, 301, 302

aliases, 310, 311

applying, 302–305

argument deduction, 313

arguments, 359

constant expressions, 356–362

defining, 320–330

faking concepts, 319–320

function objects. See function objects

functions, 311–313

function template specialization, 367–372

generic code, 10

hierarchies, 330–332

implementations with specializations, 325–330

instantiation, 338

interfaces, 305–320

metadata, 341

metafunctions, 342–345

metaprogramming, 336–356, 351. See also metaprogramming

naming, 314–319

parameter packs, 35, 51, 335, 336

Regular type, 313–314

rules, 362–372

specialization, 360

STL (Standard Template Library), 8

variadic, 332–336

virtual member function, 331–332

terminate, 88, 251, 252, 287

termination characters, 405, 406

testability, 16

text

STL (Standard Template Library), 404–411

types of, 405

threads

concurrency, 250–257

creation/destruction, 261–263

detaching, 253

as global containers, 250–251

joining, 250

passing data to, 257–258

POSIX Threads, 256

sharing ownership, 258–261

sizes of, 261

std::jthread, 251–253

versus tasks, 237–238

ThreadSanitizer, 239–241

throwing exceptions, 68

direct ownership, 286–287

troubleshooting, 288–291

throwing functions, 30–31. See also functions

tools, 238

clang-tidy, 450–452

CppMem, 241–245

supporting, 13

ThreadSanitizer, 239–241

transform_exclusive_scan algorithm, 269

transform_reduce, 21, 22

transparency, referential, 31

troubleshooting throwing exceptions, 288–291

two-phase initializations, 431–433

typedef, defining aliases, 311

types

automatic type deduction, 179

built-in, 283–285, 294

categories, 346–349

concrete, 58–59

copy-only, 221

fundamental, 176, 181

literal, 224

manipulation at compile time, 340–341

modifying, 351–352

properties, 348–349

purpose-designed user-defined, 283–285

regular, 58, 59

Regular, 313–314

return, 103, 104

safety, 438

SemiRegular, 313–314

static type systems, 222–223

of text, 405

underlying, 135

unsigned, 205

user-defined, 357–358

type-traits library, 345–346

comparisons, 349–351

correctness, 353–354

metaprogramming, 351

modifying types, 351–352

optimization, 354–356

type categories, 346–349

U

Uncle Bob, 100

undefined behaviors, 9, 22, 42, 63

core dumps, 146

C-strings, 405

data races, 234–235

naked unions, 127

order of evaluation, 194–195

printf function, 414

underflow, 208. See also overflow

underlying types, 135

unions, 126–129

anonymous, 128–129

discriminated, 126

naked, 127

saving memory, 126–128

tagged, 128–129

unique_lock, 264–266

unit tests, 18

universal references, 334

unknown code, calling, 249–250

unnamed enumerations, 134–135

unnamed lambdas, 364–365

unnamed namespaces, 394

unpacking parameters, 35

Unruh, Erwin, 337, 338

unsigned/signed integers, 204–208

unspecified behavior, 196

use-before-set error, 177

user-defined types

constant expressions, 357–358

rules, 53

using

defining aliases, 311

namespaces, 393–394

utilities. See libraries; tools

V

va_arg arguments, 49–52

value return semantics, 42–46

values

declaring variables, 176–177

enumerations. See enumerations

enumerator, 136

negative, 206–208

out, 37–38

return, 343

sending, 270–271

Van Eerd, Tony, 274

variables

categories of, 235

condition, 254–257. See also condition variables

constant expressions, 356

declaring, 57

global, 16–17. See also global variables

initializing, 175–184, 176

introducing, 176

member, 74

mutable, 296

naming, 169–170

purposes of, 182–183

variadic templates, 332–336

vector, 398–400, 402–403

vectorization, 267

vectors, size of, 399, 400

views, 441–442

virtual, 82, 223, 331, 357

virtual clone member function, 105

virtual destructors, 86–87

virtual functions, 102

calling, 91–98

clone, 105

default arguments, 113-114

reasons for, 105

virtuality, 102–105

virtual member function templates, 331–332

visibility, modifying, 175

Visual Studio

casts, 197

enforcing C++ Core Guidelines, 448–450

volatile for synchronization, 238

W

wakeups

lost, 255

spurious, 256

warnings with C compilers, 376

while loops, 199, 200

Williams, Anthony, 274, 276

Windows systems

creation of threads, 262

flushing, 418

size of threads, 261

writing

code, 223

in ISO standard C++, 8–9

nongeneric code, 365–367

wrong assumptions, 214–218

wrong optimizations, 214

Y

YAGNI (you aren’t gonna need it), 424

Z

The Zen of Python, 198, 364, 365

zero. See also arithmetic

dividing by, 210

rule of, 60