INDEX
Symbols and Numbers
::testing::, 328
=0 (pure virtual methods), 138
2001: A Space Odyssey, li, 353
42six, 500
<algorithm>, 576–628
<any>, 378–379
<array>, 408
<atomic>, 653
/bin/sh (and std::system), 697
<bitset>, 432–433
<boost/algorithm/
searching/boyer_moore.hpp>, 713
string/case_conv.hpp>, 515
string/classification.hpp>, 512, 513
string/find.hpp>, 519
string/finder.hpp>, 514
string/join.hpp>, 517
string/predicate.hpp>, 511
string/replace.hpp>, 515
string/split.hpp>, 517
string/trim.hpp>, 515
<boost/any.hpp>, 378
<boost/array.hpp>, 408
<boost/asio.hpp>, 664
<boost/bimap.hpp>, 453
<boost/chrono.hpp>, 387
<boost/circular_buffer.hpp>, 434
<boost/container/
deque.hpp>, 424
flat_map.hpp>, 453
flat_set.hpp>, 453
list.hpp>, 425
set.hpp>, 435
slist.hpp>, 434
small_vector.hpp>, 434
stable_vector.hpp>, 434
static_vector.hpp>, 434
<boost/date_time/
posix_time/posix_time.hpp>, 386
time_zone_base.hpp>, 386
<boost/graph/
adjacency_list.hpp>, 455
adjacency_matrix.hpp>, 455
edge_list.hpp>, 455
<boost/heap/*.hpp>, 453
<boost/intrusive/*.hpp>
associative containers, 453
sequential containers, 434
<boost/lexical_cast.hpp>, 500
<boost/logic/tribool.hpp>, 370
<boost/math/constants/constants.hpp>, 394
<boost/multi_array.hpp>, 434
<boost/multi_index_container.hpp>, 453
<boost/numeric/conversion/converter.hpp>, 401
<boost/optional.hpp>, 372
<boost/pair.hpp>, 374
<boost/program_options.hpp>, 700
<boost/property_tree/
json_parser.hpp>, 456
ptree.hpp>, 456
<boost/ptr_container/*.hpp>
associative containers, 453
sequential containers, 434
<boost/smart_ptr/
intrusive_ptr.hpp>, 363
shared_array.hpp>, 356
shared_ptr.hpp>, 356
<boost/test/included/unit_test.hpp>, 318
<boost/timer/timer.hpp>, 390
<boost/tuple/tuple.hpp>, 376
<boost/unordered_map.hpp>, 453
<boost/unordered_set.hpp>
multiset, 446
set, 442
<boost/variant.hpp>, 379
[[carries_dependency]], 224
<chrono>,
Chrono library, 387
literals, 197
<cmath>, 393
<complex>, 393
<condition_variable>, 656
__cplusplus, xlv
<csignal>, 699
<cstdarg>, 250
<cstddef>
size_t, 41
std::byte, 40
<cstdint>, 32
<cstdio>
Hello, world!, 4
printf pedagogy, 19
<cstdlib>
environment variables, 698
program termination, 693
<cstring>, 109
<cwchar>, 46
[[deprecated]], 224
<deque>, 424
#else, 709
<errno.h>, 353
<execution>, 575
[[fallthrough]], 224
<filesystem>, 552
<fstream>, 542
<functional>, 269
<future>, 640
#ifndef, 709
#include
double inclusion, 710
explanation of, 5
<initializer_list>, 457
<iomanip>, 554
<iostream>, 524
<istream>, 524
<iterator>
auxiliary functions, 472
insert iterators, 464
iterator adapters, 476
reverse iterator adapters, 477
std::size, 45
<limits>, 188
<list>, 425
<locale>, 521
<map>
maps, 446
multimaps, 452
[[maybe_unused]], 224
<memory>
memory operations, 636
shared pointer, 356
unique pointer, 349
<mutex>, 649
<new>
allocators, 365
overloading new, 189
[[nodiscard]], 224
<optional>, 372
<ostream>, 524
#pragma once, 710
<queue>, 429–430
<random>, 396–398
<ratio>, 403
<regex>, 503
<set>
multiset, 441
set, 435
<shared_mutex>, 649
<stack>, 427
<stdexcept>
runtime error, 98
standard exception classes, 101
<system_error>, 102
<thread>
low-level concurrency, 658
waiting, 389
<tuple>, 376
<type_traits>
example using, 227
explanation of, 164
<unordered_set>
unordered multiset, 446
unordered set, 442
<utility>, 374
<variant>, 379
<vector>, 415
A
A, 328
absolute path, 552
absolute value, 28
acceptance test, 282
access controls, 56
access violation, 76
acosh, 393
action, 324
addition +, 183
addition assignment, 184
address-of & operator, 185
address space layout randomization (ASLR), 69
adjacent difference (operation), 633
Advanced Package Tool (APT), 10
After (HippoMocks), 333
Alexandrescu, Andrei, 178
complexity, 574
allocation
object lifecycle, 90
dynamic storage, 95
smart pointers, 341
AlphaHistogram, 275
ALT-J, 526
American Standard Code for Information Interchange. See ASCII
An, 328
Anathem (Stephenson), 84
AND operator
Boolean &, 182
logical &&, 182
The Answer to the Ultimate Question of Life, the Universe, and Everything, 251
AnyNumber, 328
Approx, 307
APT (Advanced Package Tool), 10
Aqua Teen Hunger Force, 514
arg (std::complex), 394
argc and argv
Boost ProgramOptions, 704
main, 272
arguments (to a function), 16
arithmetic operators, 182
array
decay to a pointer, 72–74
description, 42–43
dynamic, 96
initialization of, 61
new/delete expressions, 96
reference, 175
size of, 45
std::array, 408
The Art of Assembly Language, 2nd Edition (Hyde), xxxix
ASCII (American Standard Code for Information Interchange)
table, 47
example histogram, 274
string comparisons, 488
asinh, 393
Asimov, Isaac, 273–274
ASLR (address space layout randomization), 69
ASSERT_
ANY_THROW, 312
DOUBLE_EQ, 312
EQ, 312
FALSE, 312
FLOAT_EQ, 312
GE, 312
GT, 312
HRESULT_FAILED, 312
HRESULT_SUCCEEDED, 312
LE, 312
LT, 312
NE, 312
NO_THROW, 312
STRCASEEQ, 312
STRCASENE, 312
STREQ, 312
STRNE, 312
THROW, 312
TRUE, 312
assertions
with Boost Test, 319
with Catch, 305
description of, 288
with Google Test, 312
assert_that, 288
assigned numbers (IANA), 667
assignment operator, 184
associative
arrays, 446
containers, 434
asterisk (the many uses of), 70
asynchronous
operations, 664
procedure call, 651
task, 640
atanh, 393
atomic, 653
AtLeast, 328
AtMost, 328
attribute, 223
Aumasson, Jean-Philippe, 396
Austin Powers: International Man of Mystery, 515
auto, xlii
code refactoring, 85
initialization, 84
modifiers, 85
type deduction, 84–86
automatic object, 90
automatic storage duration, 90
autonomous vehicle, 283
auto type deduction, 248
auxiliary iterator function, 472
Averageable (concept), 168
Avogadro’s number, 36
B
Bachmann-Landau notation, 574
Back to the Future, 641
badbit, 530
bad_file_descriptor (std:errc), 102
Bank, 134
Batman: The Dark Knight, 534
Battlestar Galactica, 110
begin (iterators), 467
benzodiazepine receptor agonist, 202–203
Between, 328
bgp, 667
bidirectional range, 511
The Big Lebowski, 534
Big O notation, 574
binary arithmetic operators, 183
binary integers, 33
binary mode (file), 542
binary search, 617
bitset, 432
bitwise logical operators, 182
Bladerunner, 121
blocks, 212
block scope, 212
Book of Revelation, 153
Boolean/integer conversion, 38
Boolean literal, 38
bool, 38
boost::
add_edge, 455
add_vertex, 455
adjacency_list, 455
adjacency_matrix, 455
adjacent_vertices, 455
array, 408
asio, 663–689
bimap, 453
char_separator, 520
circular_buffer, 434
compressed_pair, 374
container, 415–453
converter, 401
edge_list, 455
get, 376
heap, 453
intrusive_ptr, 363
lexical_cast, 500
logic, 370
math, 394
multi_array, 434
multi_index_container, 453
num_edges, 455
num_vertices, 455
numeric, 402
numeric_cast, 403
optional, 372
program_options, 701–704
property_tree, 456
ptr_list, 434
ptr_map, 453
ptr_set, 453
ptr_unordered_map, 453
ptr_unordered_set, 453
ptr_vector, 434
scoped_array, 348
scoped_ptr, 342
shared_array, 356
system, 664
timer, 390
tokenizer, 520
tuple, 376
unordered_map, 453
unordered_multimap, 453
unordered_multiset, 446
unordered_set, 442
variant, 379
weak_ptr, 361
Boost
Beast, 689
Libraries, 317
Container, 433
DateTime, 383
Graph Library, 455
IOStream, 549
Math, 392
ProgramOptions, 700
Python, 712
String Algorithms, 510
Test, 317–322
Tokenizer, 520
BOOST_
AUTO_TEST_CASE, 317–322
FIXTURE_TEST_CASE, 317–322
TEST, 317–322
TEST_MODULE, 317–322
Boston Corbett, 245
Boyer-Moore, 713
braced initialization, 59, 83, 417
braces, 15
BrakeCommand, 283
break
keyword, 50
statement, 238
Bucket (class), 190
buckets
for memory allocation, 190
for unordered sets, 442
buffer, 671
buffering, 532
buffer overflow, 74–75
BugblatterBeast, 379
built-in types, 31
byte pointer, 76
bytes, 40
C
The C++ Programming Language, 4th Edition (Stroustrup), xxxii, 137, 159, 198, 415
The C++ Standard Library, 2nd Edition (Josuttis), 164, 415, 444, 535
C++ Templates: The Complete Guide (Vandevoorde et al.), 178
Caesar cipher, 418
calculator program, 528
callable type, 255
callback, 664
call stack, 105
exception unwinding, 111
canonical path, 552
capture list (lambda), 262
carbon_thaw, 152
CarDetected, 283
casting, 201
cbegin (iterators), 467
cbrt, 392
ceil, 393
cend (iterators), 467
char, 36
character literals, 37
CharCategory, 613
Charles VII, 598
CheckedInteger, 187
Clang, 9
class
constructor, 58
fully featured, 54
hierarchy, 138
initialization, 59
initializing PODs, 60
as keyword, 56
methods, 55
plain-old-data, 52
as template parameter, 150
vs. struct, 57
client, 666
Clock of the Long Now, 55
closed range, 413
cmd.exe, 697
C++Now, 29
code instrumentation, 282
code reuse, 149
Color, 205
command line parameters, 272
comments, 21
comparison operators, 15, 185, 611
compiler, 4
definition of, 5
tool chain, 5
Compiler Explorer, 6
compiler-generated methods, 129
compiler optimization, 710
compile-time
control structures, 178
recursion, 252
complement ~, 182
completion condition (Boost Asio), 675
complexity, 574
complex number, 393
concepts, 163
concrete class/type, 150
concurrency, 640
hint, 664
conditional compilation, 709
conditional expression, 43, 232
condition variable, 656
conj (std::complex), 394
console
application, 3
printing to, 4
ConsoleLogger, 134
const
argument, 81
external, 287
member variable, 83
method, 82
constant expression, 204
const_cast, 152
constexpr, xxvii, xxxviii, 204
function, 244
if statement, 227
constructor acquires, destructor releases (CADRe), liii, 108
constructor injection, 145
const/volatile qualification, 246
adapters, 427
continue statement, 239
control block, 356
control code characters, 48
copy
assignment, 160
assignment operator, 119
command line, 272
guidelines, 122
semantics, 115
cosh, 393
CountIf, 257
cout vs. printf, 19
cp (command line), 272
CppCast, 29
CppCon, 29
Cryptonomicon (Stephenson), 536
C-style
APIs, 74
cast, 202
strings, 45
cumulative sum, 537
cursor (stream), 548
D
data buffer, 671
data execution prevention, 69
data structure, 370
date period, 385
daytime, 667
DeadMenOfDunharrow, 343
dead store, 208
deallocation, 90
Debian, 10
decimal integers, 33
declaration statements, 213
decomposition methods (path), 553
decorating, xlv
decrement operator, 185
deep copy, 117
default
case (switch), 50
capture (lambda), 264
copy, 121
delete
usage, 95
dependency injection, 323
deque, 424
Diablo, 424
Dick, Philip K., 549
Dirk Gently’s Holistic Detective Agency (Adams), 140
directory, 552
div, 392
division /, 183
domain, 667
dot operator (.), 54
dot product, 632
double, 35
double-inclusion problem, 708
double precision, 35
do-while loop, 231
DoubleEq, 328
Dr. Seuss, 577
Drozdek, Adam, 439
duck typing, 163
duration (time), 387
Dwarves of Middle Earth, 86
dynamic
allocation, 161
arrays, 96
memory, 342
object, 95
ports, 684
storage duration, 95
E
EBCDIC encoding, 488
echo, 667
echo server, 683
ECMAScript, 504
Edges (graph), 454
Effective Modern C++ (Meyer), xxxii, 50, 105, 159, 177, 416, 420
Electronic Freedom Foundation, 582
Elvis operator (:?), 186
The Empire Strikes Back, 152, 240
end (iterator), 467
ENOENT, 352
EndWith, 328
enum class, 49
enumeration type, 49
environment variables, 698
EOF, 531
eofbit, 530
epoch, 387
erf, 392
errno, 352
error
codes, 102
handling, 113
EscapeCapsule, 378
escape sequences, 37
Euler’s number, 54
evaluation order, 196
event, 283
Exactly, 328
exception, lii, 98
alternatives to, 114
and the object life cycle, 89
performance of, 113
rethrowing, 103
user-defined, 104
execution order, 211
exit code, 4
exp, 392
exp2, 392
expectation, 325
EXPECT_CALL, 326
explicit, 204
explicit type conversion, 201
exploit, 69
extended precision, 35
external linkage, 92
extractor, 527
extreme-value algorithms, 626
F
factorization, 643
Fahller, Björn, 337
FAIL, 308
failbit, 530
FakeIt, 337
fclose, 352
FibonacciRange, 235
file, 552
FILE, 353
file stream classes, 541
filesystem library, 551
fill constructor, 416
final, 245
finder (string), 514
finfisher, 445
Firefly, 594
Flintstone, Fred, 34
float, 35
FloatEq, 328
floating-point
literals, 35
promotion rules, 183
types, 35
floor, 393
flushing, 532
fma, 392
fmod, 392
fold
expression, 253
operation, 630
fopen, 352
for loop
a nickel tour of, 43
description of, 232
format specifiers, 18
Boolean, 38
character, 38
floating point, 36
integer, 32
pointer, 68
size_t, 41
format strings, 18
formatted stream operations, 525
forward-linked list, 78
forward range, 511
Foundation (Asimov), liv
fprintf, 352
free functions, 214
ftp (file transfer protocol), 667
function
absolute value, 28
anonymous, xlix
call operator, 255
declaration vs. definition, 63
definition, 214
free, 214
inlining, 245
invocation, 18
main, 4
modifier, 244
namespace scope, 214
non-member, 214
object, 255
parameter pack, 252
pointer declaration, 254
prefix modifier, 244
specifier, 244
step, 17
suffix modifier, 244
sum, 29
templates, 248
functional programming, 254
fundamental types, 31
G
Galaxy Quest, 539
garbage collector, 90
GCC, 9–13
gcd, 392
gdb, 25
Ge, 328
generator (string), 512
generic lambda, 261
generic programming, l, 156, 248
get, 175
get_copy, 172
Gettysburg Address, 69
global
namespace, 217
scope, 91
stream objects, 525
glvalue, 124
Gt, 328
gmock_gen.py, 325
GNU, 9
Compiler Collection (GCC), 13
debugger, 25
GnuPG, 11
Netcat, 685
goat grass, 612
Godbolt, Matt, 6
The Golden Ratio, 540
Goldmember, 64
goodbit, 530
Google Mock, 324–332
matchers, 327–329
Google Test, 310
assertions, 312
goto statement, 239–240
graph, 454
group (regex), 505
GTEST_FLAG, 310
gtest_main, 310
Guardians of the Galaxy, 539
Gunteroth, Kurt, 113
H
half-open range, 413
Hall, Sir Robert Bryson II, 102
handle, 353
hard link, 552
Harry Potter and the Sorcerer’s Stone (Rowling), 534
hashes, 442
HasSubstr, 328
header-only library, 304
heap, 189–190
data structure, 430
memory region, 365
HeapAlloc, 189–190
hexadecimal integers, 33
HippoMocks, 332–336
The Hitchhiker’s Guide to the Galaxy (Adams), liv, 64, 118, 217, 229, 378, 452, 543
hours, 388
hue-saturation-value (HSV)representation, 205
hypot, 392
I
IANA (Internet Assigned Numbers Authority), 667
ICMP (Internet Control Message Protocol), 666
IDE (interactive development environment), 3, 6
identifiers, 246
Illustrative Shorthand (Bronson), 276
imag, 394
imaginary number, 393
imap, 667
implementation vs. interface, 297
implicit-type conversion, 198
include guard, 710
increment operator (++), 185
indirection operator (*), 186
inheritance, 100
vs. implementation, 137
init capture (lambda), 267
InitGoogleMock, 324–325
expression, 232
statement, 226
init statements (for loop), 43
inline, 244
inner product, 632
input operator, 527
input string streams, 539
input validation, 56
inserter, 464
instrumentation, 282
int, 14. See also integer
integer, 14
Boolean conversion, 38
description of, 32
factorization, 643
literal, 33–34
integration test, 282
interactive development environment (IDE), 3, 6
internal linkage, 92
Internet Assigned Numbers Authority (IANA), 667
Internet Control Message Protocol (ICMP), 666
internet protocol (IP), 666
the internet’s first transmission, 708
intrusive container, 434
invocable type, 255
invoke (a function), 18
iostream, xlix
vs. printf, 19
IP (internet protocol), 666
irc, 667
IServiceBus, 297
isfinite, 393
IsNull, 328
isinf, 393
isqrt, xxxviii
iterator, xlviii, 407, 412, 463
bidirectional, 468
categories, 471
contiguous, 471
expression, 232
forward, 467
input stream buffer, 547
input, 466
insert, 464
range expression, 235
variables, 44
itoa, xxxix
J
Jabberwocky, xliii
Javascript object notation, 457
Jay and Silent Bob Strike Back, 240
Josuttis, Nicolai, 164, 415, 444, 535
jump statement, 238
junit, 310
K
keyboard interrupt, 699
knuckleball, 224
L
label, 239
Labyris Books, 641
constexpr, 268
initializer expression, 266
this capture, 267
LambdaFactory, 267
language support errors, 102
launch policy, 640
lazy evaluation, 640
lcm, 392
leaking memory, 342
leap years, 383
Le, 328
left shift operator <<, 182
lexicographical comparison, 488
library, 5
Life of Brian, 672
linear congruential generator, 214
linkage, 92
linker, 5
Linux, 9
development environment, 9
integer size on, 32
list, 425
listdir, 566
string, 46
LLDB (low level debugger), 25
load factor, 445
local
static variable, 92
variable, 91
locale, 521
lock-free concurrent programming, 653
log, 392
log2, 392
log10, 392
Logger, 138
LoggerType, 136
logical operators, 182
long double, 35
long int, 32
long long int, 32
The Lord of the Rings (Tolkien), 343, 345
Lt, 328
Low Level Debugger (LLDB), 25
ltoa, xxxix
lvalue, 124
M
macOS
development environment, 8
integer size on, 32
macro, 708
magic values, 205
main, 272
make_simple_unique, 177
malloc, 189
manipulators, 533
Marx, Groucho, 99
match condition (Boost Asio), 675
matchers (Google Mock), 327–329
match (regex), 506
The Matrix, 601
max, 392
max heap, 635
maximum load factor, 445
mean (genericizing), 155–158
member, 52
access operator, 185
destruction order, 111
inheritance, 139–140
initialization, 57
initialization order, 111
initializer lists, 83
static, 93
member-of-object operator, 185
member-of-pointer operator, 185
memory fragmentation, 189
memory leaks, 96
merging (algorithm), 625
Mersenne Twister, 398
metaprogramming, 178
methods, 55
Meyers, Scott, xxxii, 50, 105, 159, 177, 416, 661–662
mgrep, 707
microseconds, 388
Microsoft Visual C++ Compiler (MSVC), 6
Microsoft Windows, 6
milliseconds, 388
min, 392
minutes, 388
mock, 297
Mock, 332–336
MOCK_CONST_METHOD, 325
mocking, 323
MOCK_METHOD, 325
MockRepository, 332–336
Modern C++ Design: Generic Programming and Design Patterns Applied (Alexandrescu), 178
Modest Mouse, 153
modifier methods (path), 554
modulo %, 183
The Moon is a Harsh Mistress (Heinlein), xl
most vexing parse, 63
move
construction, 160
iterator adaptor, 476
MoveDetector, 596
multicore processor, 640
multiplication (*), 183
mutable
iterator, 471
lambda, 265
mutex (mutual exclusion algorithm), 649
MyTemplateClass, 150
my_template_function, 151
N
naggy mock, 326
name binding, 178
named capture (lambda), 264
named conversion, 151
named element, 178
block, 217
global, 217
scope, 91
using directive, 218
nanoseconds, 388
narrow_cast, 154
NarrowCast, 222
NarrowCaster, 221
ncat, 685
nested initializer lists, 447
netcat, 685
Neuromancer (Gibson), 53
new, 95
new expression, 95
nice mock, 326
Nmap, 689
noexcept, 104
non-member functions, 214
non-type template parameters, 174
norm, 394
NotNull, 328
NOT (!), 182
ntp, 667
null pointer, 76
null-terminated strings, 45
nunit, 310
O
allocation, 90
automatic storage duration, 90
composition, 137
deallocation, 90
dynamic, 95
initialization, 59
lifetime, 90
scope, 90
static, 91
storage duration, 89
swap, 346
object-oriented programming, 13
octal integers, 33
one-definition rule, 710
The One True Morty, 212
AND, 40
associativity, 194
address of (&), 68
bracket, 75
dot (.), 54
logical, 40
member of pointer (arrow operator ->), 71
OR, 40
overloading, 187
precedence, 194
unary/binary/tertiary, 40
unary negation, 40
operator(), 255
operator*, 463
operator++, 463
operator<, 611
operator<<, 525
operator>>, 525
operator delete[], 189
operator new[], 189
optimization, 710
optional, 372
OR (|), 182
OR (||), 182
Ordered (concept), 171
order of execution, 211
output
file streams, 542
iterator, 464
operator, 526
stream buffer iterators, 546
string stream, 538
overflow, 231
overload resolution, 249
override 138
ownership, 342
transferring, 122
Oxford comma, 518
Oxford’s best colleges, 73
P
page (memory), 190
pair, 374
pangram, 276
parallel algorithms, 575
parameter pack type, 177
parameters, 16
partitioned sequence, 620
partition point, 620
passing an array to a function, 73
path, 552
path variable, 698
PDP-8, 34
Pe’er, Eran, 337
performance test, 282
permission_denied, 102
Pig Latin, 485
ping, 666
plain-old-data classes, 52
pointer/array conversion, 72–74
pointers, 67–76
Boolean conversion, 76
null, 76
vs. references, 77
this, 80
void, 76
polar, 394
polymorphism, 149
compile time, 149
runtime, 133
pop3, 667
port (TCP/UDP), 666
positional arguments, 703
position (stream), 548
POSIX time, 387
pow, 392
pragma, 712
Pratchett, Terry, 412, 447–448
precision, 35
predicate, 164
prefix modifier, 244
PrimeNumberRange, 241
primitive types, 31
printf, 525
format specifiers, 18
format strings, 18
vs. iostream, 19
priority queue, 430
private (access control), 56
private ports, 684
Professional Assembly Language (Blum), xxxix
program
options, 700
support, 692
proj (std::complex), 394
promotion rules, 198
floating-point, 183
property injection, 146
property tree, 454
prototype, 213
prvalue, 124
pseudo-random number engines, 396
public (access control), 56
Pulp Fiction, 540
pure-virtual
classes, 142
method/interfaces, 138
Python, 163
Q
quantifier (regex), 504
queue, 428
R
race condition, 647
RAII (resource acquisition is initialization), liii, 108
and goto, 241
example, unique pointer, 159
random-access iterator, 469
random-access range, 511
randomize, 214
random number
distribution, 397
engine, 396
generator, 214
RandomNumberGenerator, 215
ranged-based for loop, 44, 234
declaration, 234
expressions, 234, 235, 466, 637
Rat Thing, 90
raw string literals, 506
ReadOnlyInt, 203
read-only methods, 82
real (std::complex), 394
red, green, refactor, 286
redundant load, 208
Ref, 328
register (on a CPU), 69
regular expression (regex), 503
rehashing, 445
relative path, 552
relative velocity, 294
remainder, 392
replace (regex), 509
Replicant, 121
REQUIRE, 305
REQUIRE_NOTHROW, 307
REQUIRE_THROWS, 307
REQUIRE_THROWS_AS, 307
requirements, 166
requires expression, 166
ad hoc, 172–173
reseating references, 77
reserved characters, 37
resource acquisition is initialization. See RAII
resource leakage, 160
resource management, 241
rethrowing an exception, 103
return-oriented programs, 69
return statements, 17
reverse half-open range, 478
reverse iterator adaptor, 477
right shift >>, 182
Ripley, Brian D., 396
Roland TR-808, 350
root name, 552
round, 393
rule of five, 129
rule of zero, 130
runtime polymorphism, 133
rvalue, 124
S
sandbox, 697
scheduler (of threads), 640
Schrödinger, Erwin, 371
scope, 90
global, 91
namespace, 91
scoped enums, 50
ScopedOathbreakers, 350
scoped pointer, 342
search
algorithm, 590
regex, 509
std::string, 494
seconds, 388
SECTION, 308
security vulnerability, 76
selection statement, 225
sequence container, 408
sequence operation
mutating, 592
non-modifying, 576
server, 666
service, 283
service bus architecture, 283
SetUp, 314
Seveneves (Stephenson), 50
Shaltanac, 218
shared pointer, 355
shared state, 641
Shift5, 525
Short Circuit, 42
short int, 32
SIGABRT, 699
SIGFPE, 699
SIGILL, 699
SIGINT, 699
signature, 213
signed char, 37
sign function, 226
SIGSEGV, 699
SIGTERM, 699
SimpleString class, 107
with custom move and copy, 128
SimpleUniquePointer, 159
single-pass range, 511
single precision, 35
sinh, 393
sizeof..., 252
size_t, 41
skeleton class, 286
Skynet, 75
Slaughterhouse-Five (Vonnegut), 599, 605
small string optimization, 485
smtp, 667
Snow Crash (Stephenson), 90
socket, 666
sorting operation, 611
The Sound of Music, 599
source files, 4
SpeedUpdate, 283
spin lock, 651
sqrt, 392
square, 162
SquareMatrix, 458
ssh, 667
stable sort, 611
stack, 427
call, 105
container, 105
stack frame, 106
standard
exception classes, 101
stream operators, 525
template library, 407
Star Trek, 593
StartsWith, 328
StrCaseEq, 328
StrCaseNe, 328
StrEq, 328
StrNeq, 328
statement, 211
automatic storage duration, 212
break, 238
constexpr if, 227
compound, 15
conditional, 15
continue, 239
initialization, 226
iteration, 230
jump, 238
label, 239
return, 17
selection, 225
switch, 229
function, 244
members, 93
object, 91
storage duration, 91
variables, 91
static_assert, 173
std::
abort, 696
accumulate, 630
adjacent_difference, 633
adjacent_find, 585
advance, 472
all_of, 576
allocate, 366
any, 378
atexit, 693
atomic_bool, 653
atomic_char, 653
atomic_char16_t, 653
atomic_char32_t, 653
atomic_int, 653
atomic_llong, 653
atomic_long, 653
atomic_short, 653
atomic_uchar, 653
atomic_uint, 653
atomic_ullong, 653
atomic_ulong, 653
atomic_ushort, 653
atomic_wchar_t, 653
back_insert_iterator, 464
back_inserter, 464
bad_any_cast, 378
bad_function_call, 269
basic_iostream, 524
basic_istream, 524
basic_istringstream, 539
basic_ofstream, 542
basic_ostream, 524
basic_regex, 506
basic_string, 482
basic_string_view, 500
bernoulli_distribution, 400
binary_search, 620
binomial_distribution, 400
bitset, 432
boolalpha, 535
byte, 40
cauchy_distribution, 399
cerr, 525
char_traits, 482
chi_squared_distribution, 399
chrono_duration, 664
cin, 525
clamp, 628
clog, 525
complex, 393
condition_variable, 656
copy, 592
copy_backward, 594
count, 586
cout, 525
csub_match, 508
dec, 535
declaring, 269
destroy, 636
destroy_at, 636
destroy_n, 636
distance, 475
divides, 629
domain_error, 101
enable_shared_from_this, 685
ends, 533
equal, 588
equal_range, 619
errc, 102
exception, 101
exclusive_scan, 636
exit, 695
exponential_distribution, 400
extreme_value_distribution, 400
fill, 601
find, 581
find_end, 582
find_first_of, 584
find_if, 581
find_if_not, 581
fisher_f_distribution, 399
fixed, 535
flush, 533
for_each, 579
for_each_n, 580
forward, 177
forward_list, 467
front_insert_iterator, 464
front_inserter, 464
future, 641
future_status, 642
gamma_distribution, 400
generate, 602
geometric_distribution, 400
get, 376
get_if, 380
getenv, 698
hash, 443
hex, 535
imag, 393
includes, 636
inclusive_scan, 636
initializer_list, 457
inner_product, 632
insert_iterator, 464
inserter, 464
iota, 630
is_heap, 635
is_heap_until, 635
is_partitioned, 621
is_permutation, 589
is_sorted, 615
istream, 528
istringstream, 539
iter_swap, 475
length_error, 101
less, 430
locale, 521
lock_guard, 651
logic_error, 101
lognormal_distribution, 399
lower_bound, 617
make_heap, 635
make_move_iterator, 476
make_reverse_iterator, 478
make_shared, 356
make_unique, 350
map, 446
match_results, 507
max, 626
max_element, 627
merge, 625
min, 626
min_element, 627
minmax, 626
minus, 629
mismatch, 587
modulus, 629
mtt19937_64, 396
multimap, 452
multiplies, 629
multiset, 441
mutex, 649
next, 473
noboolalpha, 535
none_of, 578
normal_distribution, 399
nth_element, 616
nullopt, 372
oct, 535
optional, 372
ostream, 529
ostringstream, 538
overflow_error, 102
partial_sort, 614
partial_sum, 634
partition, 622
partition_copy, 622
plus, 629
poisson_distribution, 400
pop_heap, 635
prev, 473
priority_queue, 430
push_heap, 635
queue, 429
quick_exit, 696
quoted, 554
random_device, 396
ratio, 403
ratio_multiply, 403
real, 393
recursive_mutex, 649
recursive_timed_mutex, 649
reduce, 631
regex, 506
regex_replace, 509
remove, 603
replace, 600
reverse, 606
rvalue, 126
sample, 607
scientific, 535
scoped_lock, 651
search, 590
search_n, 591
set, 435
set_difference, 636
set_intersection, 636
set_symmetric_difference, 636
set_union, 636
setw, 535
shared_lock, 651
shared_mutex, 649
shared_ptr, 356
shared_timed_mutex, 649
shuffle, 609
signal, 699
size, 45
sort_heap, 635
stable_partition, 624
stable_sort, 612
stack, 427
string_literals, 484
strncpy, 109
student_t_distribution, 399
sub_match, 508
swap_ranges, 597
system, 697
system_error, 102
thread, 658
timed_mutex, 649
transform_exclusive_scan, 636
transform_inclusive_scan, 636
transform_reduce, 636
tuple, 376
type_traits, 188
u16string, 482
u16string_view, 500
u32string, 482
u32string_view, 500
underflow_error, 102
uniform_int_distribution, 398
uniform_real_distribution, 399
uninitialized_copy, 636
uninitialized_copy_n, 636
uninitialized_default_construct, 636
uninitialized_default_construct_n, 636
uninitialized_fill, 636
uninitialized_fill_n, 636
uninitialized_move, 636
uninitialized_move_n, 636
uninitialized_value_construct, 636
uninitialized_value_construct_n, 636
unique, 605
unique_lock, 651
unordered_map, 453
unordered_multimap, 453
unordered_multiset, 446
unordered_set, 442
upper_bound, 618
variant, 379
wait_for, 642
wait_until, 642
wcerr, 525
wcin, 525
wclog, 525
wcout, 525
wcsub_match, 508
weak_ptr, 361
weibull_distribution, 400
wistringstream, 539
wostringstream, 538
wregex, 506
ws, 533
wssub_match, 508
wstring, 482
wstring_view, 500
stderr, 525
stdin, 525
stdlib, i, xlviii, xxxii, xlviii–xlix
stdout, 525
step function, 17
storage type (any), 378
stormtroopers, 79
stream, 523
buffer classes, 546
state, 530
strict mock, 326
string, 45
as array, 46
conversion, 498
literal, 46
SimpleString class, 107
stream classes, 538
view, 500
strlen, 109
Stroustrup, Bjarne, xxv, xxxii xxxvii, 137, 159, 198, 415
struct, 52
vs. class, 57
structured binding, 222
declaration, 114
structured exception handling, lii
stub, 289
submatch (regex), 507
subscribe, 283
subscript operator [], 185
subtraction -, 183
suffix modifier, 244
sum, 29
Super C, xxxix
Sutton, Andrew, 170
symbolic link, 552
synchronization primitive, 649
syntactic requirements, 166
system ports, 684
T
The Taming of the Shrew (Shakespeare), 82
tanh, 393
Taxonomist, 62
TCP (Transmission Control Protocol), 666
TearDown, 314
tebibyte, 498
telnet, 667
declaring, 150
function, 151
instantiating, 151
instantiation, 150
metaprogramming, 178
parameter pack, 251
partial parameter application, 221
specialization, 178
type alias, 221
type checking, 161
type deduction, 158
variadic, 177
tequila, 247
ternary conditional operator, 186
ternary operator, liii
Tesla, Nikola, 72
test
acceptance, 282
integration, 282
performance, 282
unit, 282
TEST, 311
test-driven development, 285
TEST_F, 314
test fixture classes, 314
test harness, 289
text editor, 13
this pointer, 80
thread, 94
thread-safe code, 94
throw, 98
throwable objects, 98
timed_out, 102
TimerClass class, 131
Times, 329
toa, xl
tokenizer, 520
Tommy Tutone, 330
Top Gun, 642
traceroute, 666
Trainor, Meghan, 139
Tralfamadore, 599
transferring ownership, 350
transitive, 611
Transmission Control Protocol (TCP), 666
traversal category, 511
treedir, 568
tribool, 370
Trompeloeil, 337
try-catch block, lii, 99
tuple, 376
built-in, 31
character, 36
conversion, 198
erasure, 76
function, 178
fundamental, 31
integer, 32
narrowing, 222
parameters, 178
primitive, 31
reference, 67
support library, 164
typename, 150
template parameter, 174
traits, 164
typedef, xliii
U
Ubuntu, 10
UDP (User Datagram Protocol), 666
ultoa, xxxix
unary minus -, 183
unary plus +, 183
undefined behavior, 75
unformatted stream operations, 525
uniform initialization, 64
United States Army Cyber Command, 678
United States Cyber Command Seal, 473
United States Naval Observatory, 383
unit test, 282
unit-test program, 289
universal character names, 38
Unix Epoch, 387
unscoped enums, 50
unsigned char, 37
User Datagram Protocol (UDP), 666
user-defined
conversion, 203
exceptions, 104
literal, 197
user ports, 684
using directive, 218
V
va_arg, 250
va_copy, 250
va_end, 250
va_list, 250
value category, 124
value_of, 228
value parameters, 178
Vandevoorde, David, 178
declaring, 14
local, 91
local static, 92
static, 91
signed/unsigned, 32
variadic
arguments, 250
functions, 250
variant, 379
va_start, 250
vectorized algorithm, 575
VirtualAllocEx, 190
virtual destructor, 138
virtual methods, 140–142
Visual Studio, 6–8
debugger, 21
void, 42
void pointer, 76
W
wait state, 651
wall clock, 387
Wandbox, 6
wchar_t, 37
weak pointer, 360
while loop, 230
White House phone number, 504
wide character, 37
Windows, 6
binaries, 38
carriage return, 13
Component Object Model, 363
development environment, 6
integer size on, 32
Windows epoch, 387
Wodehouse, P.G., 374
word boundaries, 53
wprintf, 46
X
Xcode, 8
debugger, 23
XOR ^, 182
xUnit, 310
xvalue, 124
Y
Z
Zalewski, Michał, 677
Zbikowski, Mark, 38
zero-overhead principle, xxxvii
Zero Wing, 139
ZIP codes, 34
Zork I, 34