\begin{theindex}

  \item !=, \hyperpage{334}
  \item %baseclass-preinclude, \hyperpage{1037}
  \item %debug, \hyperpage{1033}
  \item %filenames, \hyperpage{1033}, \hyperpage{1038}
  \item %left, \hyperpage{1039}
  \item %nonassoc, \hyperpage{1039}
  \item %option c++, \hyperpage{1031}
  \item %prec, \hyperpage{1039}
  \item %right, \hyperpage{1039}
  \item %scanner, \hyperpage{1038}
  \item %stype, \hyperpage{1038}
  \item %token, \hyperpage{1039}
  \item %type, \hyperpage{1039}
  \item %union, \hyperpage{1037, 1038}
  \item -O0, \hyperpage{192}
  \item -\textgreater{}, \hyperpage{460}
  \item -\textgreater{}*, \hyperpage{460}
  \item -fgnu-tm, \hyperpage{684}
  \item -fmodules-ts, \hyperpage{958}
  \item -ltbb, \hyperpage{551}
  \item -{}-{}std=c++26, \hyperpage{6}
  \item .*, \hyperpage{460}
  \item ..., \hyperpage{775}
  \item .h, \hyperpage{16}
  \item .ih extension, \hyperpage{186}
  \item .template, \hyperpage{839}
  \item //, \hyperpage{10}
  \item ::, \hyperpage{24}, \hyperpage{311}
  \item ::template, \hyperpage{839}
  \item = 0, \hyperpage{412}
  \item = default, \hyperpage{172}, \hyperpage{236}
  \item = delete, \hyperpage{172}
  \item ==, \hyperpage{334}
  \item [ExecPol,], \hyperpage{551}
  \item [begin, end), \hyperpage{339}
  \item [first, last), \hyperpage{550}
  \item [left, right), \hyperpage{489}
  \item \#define \_\_cplusplus, \hyperpage{15}
  \item \#error, \hyperpage{721}
  \item \#ifdef, \hyperpage{16}
  \item \#ifndef, \hyperpage{16}
  \item \#include, \hyperpage{1033}
  \item \&, \hyperpage{33}
  \item \_ variable name, \hyperpage{644}
  \item \_\_cplusplus, \hyperpage{15}
  \item \textgreater{}, \hyperpage{334}
  \item \textgreater{}=, \hyperpage{334}
  \item \textgreater{}\textgreater{}, \hyperpage{290}
  \item \textgreater{}\textgreater{}: with templates, \hyperpage{356}
  \item \textless{}, \hyperpage{334}
  \item \textless{}=, \hyperpage{334}
  \item \textless{}=\textgreater{}: priority, \hyperpage{52}
  \item \u, \hyperpage{54}
  \item 0-pointer, \hyperpage{202}
  \item 0b, \hyperpage{330}
  \item 0b, 0B, \hyperpage{49}
  \item 0x, \hyperpage{49}

  \indexspace

  \item 0, \hyperpage{49}

  \indexspace

  \item abort exception, \hyperpage{277}
  \item abs, \hyperpage{382}
  \item absolute, \hyperpage{89}
  \item absolute position, \hyperpage{430}
  \item abstract base class, \hyperpage{450}, \hyperpage{1002}
  \item abstract classes, \hyperpage{412}
  \item access, \hyperpage{54}
  \item access files, \hyperpage{128}, \hyperpage{139}
  \item access promotion, \hyperpage{390}
  \item access rights, \hyperpage{152}
  \item accessor, \hyperpage{152}, \hyperpage{155}, \hyperpage{291}
  \item accumulate, \hyperpage{552}
  \item actions, \hyperpage{1036}
  \item adapter: inserter, \hyperpage{492}
  \item adapter: object to iterator, \hyperpage{488}
  \item adapter: required types, \hyperpage{493}
  \item add\_const, \hyperpage{865}
  \item add\_cv, \hyperpage{865}
  \item add\_lvalue\_reference, \hyperpage{865}
  \item add\_pointer, \hyperpage{865}
  \item add\_rvalue\_reference, \hyperpage{865}
  \item add\_volatile, \hyperpage{865}
  \item addExceptFd, \hyperpage{1012}
  \item addReadFd, \hyperpage{1012}
  \item address, \hyperpage{927}
  \item address of objects, \hyperpage{219}
  \item address-of operator, \hyperpage{33}
  \item addWriteFd, \hyperpage{1012}
  \item adjacent\_difference, \hyperpage{553}
  \item adjacent\_find, \hyperpage{554}
  \item adjustfield, \hyperpage{121}
  \item aggregate, \hyperpage{168}, \hyperpage{245}, \hyperpage{867}
  \item aggregate initialization, \hyperpage{393}
  \item Aho, A.V., \hyperpage{342}
  \item Alexandrescu, A., \hyperpage{735}, \hyperpage{835}, 
		\hyperpage{841}, \hyperpage{876}, \hyperpage{879}, 
		\hyperpage{888, 889}
  \item algorithm: header file, \hyperpage{549}
  \item alias template, \hyperpage{858}
  \item all\_of, \hyperpage{555}
  \item allocate arrays, \hyperpage{203}
  \item allocate memory, \hyperpage{312}
  \item allocate objects, \hyperpage{202}
  \item allocate primitive types, \hyperpage{202}
  \item allocator, \hyperpage{851}
  \item allocator class, \hyperpage{481}
  \item allocator\_arg\_t, \hyperpage{675}
  \item ambiguity, \hyperpage{160}, \hyperpage{416, 417}
  \item amd, \hyperpage{55}
  \item and, \hyperpage{332}
  \item and\_eq, \hyperpage{332}
  \item angle bracket notation, \hyperpage{335, 336}, \hyperpage{481}
  \item angle brackets, \hyperpage{720}
  \item angle brackets: consecutive, \hyperpage{356}
  \item anonymous, \hyperpage{231}, \hyperpage{485}, \hyperpage{494}
  \item anonymous function object, \hyperpage{322}
  \item anonymous object, \hyperpage{175}, \hyperpage{320}
  \item anonymous object: lifetime, \hyperpage{176}
  \item anonymous pair, \hyperpage{336}
  \item anonymous type, \hyperpage{702}
  \item anonymous variable, \hyperpage{34}
  \item anonymous variable: generic form, \hyperpage{336}
  \item ANSI/ISO, \hyperpage{10}, \hyperpage{15}, \hyperpage{52}, 
		\hyperpage{112}, \hyperpage{115}, \hyperpage{119}
  \item any\_of, \hyperpage{555}
  \item app, \hyperpage{130}, \hyperpage{144}
  \item append, \hyperpage{103}
  \item arg, \hyperpage{382}
  \item argument\_type, \hyperpage{859}
  \item arithmetic function object, \hyperpage{483}
  \item arithmetic operations, \hyperpage{483}
  \item arithmetic type, \hyperpage{864}
  \item array, \hyperpage{337}
  \item array bounds, \hyperpage{337}, \hyperpage{339}
  \item array bounds overflow, \hyperpage{285}
  \item array constructors, \hyperpage{337}
  \item array-to-pointer transformation, \hyperpage{705}
  \item array: 0-sized, \hyperpage{204}
  \item array: dynamic, \hyperpage{203}
  \item array: enlarge, \hyperpage{204}
  \item array: expandable, \hyperpage{339}
  \item array: fixed size, \hyperpage{204, 205}, \hyperpage{337}
  \item array: header file, \hyperpage{337}
  \item array: local, \hyperpage{204}
  \item array: member functions, \hyperpage{337}
  \item ASCII, \hyperpage{126, 127}, \hyperpage{136}, \hyperpage{351}
  \item ascii-value, \hyperpage{997}
  \item assembly language, \hyperpage{7}
  \item assign, \hyperpage{92}, \hyperpage{103}, \hyperpage{339}, 
		\hyperpage{344}, \hyperpage{353}
  \item assignment, \hyperpage{399}
  \item assignment: pointer to member, \hyperpage{459}
  \item assignment: refused, \hyperpage{400}
  \item assignment: sequential, \hyperpage{220}
  \item associative array, \hyperpage{355}, \hyperpage{363}
  \item async, \hyperpage{669, 670}
  \item asynchronous alarm, \hyperpage{1010}
  \item asynchronous input, \hyperpage{1010}
  \item asynchronous provider, \hyperpage{663}
  \item asynchronous return object, \hyperpage{663}
  \item at, \hyperpage{102}, \hyperpage{337}, \hyperpage{340}, 
		\hyperpage{353}, \hyperpage{358}, \hyperpage{377}
  \item at: multiple arguments, \hyperpage{289}
  \item ate, \hyperpage{130}, \hyperpage{145}
  \item atoi, \hyperpage{140}
  \item atomic actions, \hyperpage{636}
  \item atomic data types, \hyperpage{656}
  \item atomic: header file, \hyperpage{656}
  \item atomic\_cancel, \hyperpage{685}
  \item atomic\_commit, \hyperpage{685}
  \item atomic\_compare\_exchange\_strong(\_explicit), \hyperpage{659}
  \item atomic\_compare\_exchange\_weak(\_explicit), \hyperpage{659}
  \item atomic\_exchange(\_explicit), \hyperpage{659}
  \item atomic\_fetch\_add(\_explicit), \hyperpage{659}
  \item atomic\_fetch\_and, \hyperpage{659}
  \item atomic\_fetch\_or, \hyperpage{659}
  \item atomic\_fetch\_sub(\_explicit), \hyperpage{659}
  \item atomic\_fetch\_xor, \hyperpage{659}
  \item atomic\_init, \hyperpage{659}
  \item atomic\_is\_lock\_free, \hyperpage{659}
  \item atomic\_load(\_explicit), \hyperpage{659}
  \item atomic\_noexcept, \hyperpage{685}
  \item atomic\_store(\_explicit), \hyperpage{659}
  \item atomic\textless{}Trivial\textgreater{}, \hyperpage{656}
  \item atomic\textless{}Type\textgreater{}, \hyperpage{656}
  \item attribute, \hyperpage{50}
  \item auto, \hyperpage{41}
  \item auto \&, auto \&\&, \hyperpage{42}
  \item automatic expansion, \hyperpage{339}
  \item available member functions, \hyperpage{401}
  \item available space, \hyperpage{94}
  \item avoid global variables, \hyperpage{17}
  \item await\_ready, \hyperpage{938}
  \item await\_resume, \hyperpage{938}
  \item await\_suspend, \hyperpage{938}
  \item await\_transform, \hyperpage{937}
  \item awaitable, \hyperpage{936}

  \indexspace

  \item b, \hyperpage{53}
  \item back, \hyperpage{103}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{344}, \hyperpage{349}, \hyperpage{353}
  \item back\_inserter, \hyperpage{492}
  \item backdoors, \hyperpage{155}
  \item background process, \hyperpage{1005}
  \item bad, \hyperpage{116}
  \item bad\_alloc, \hyperpage{214}, \hyperpage{262}, \hyperpage{272}, 
		\hyperpage{315}
  \item bad\_array\_new\_length, \hyperpage{262}
  \item bad\_cast, \hyperpage{262}, \hyperpage{424}
  \item bad\_exception, \hyperpage{262}
  \item bad\_function\_call, \hyperpage{725}
  \item bad\_typeid, \hyperpage{262}, \hyperpage{426}
  \item badbit, \hyperpage{116}
  \item base, \hyperpage{488, 489}
  \item base class, \hyperpage{383}, \hyperpage{400}, \hyperpage{993}, 
		\hyperpage{1002}
  \item base class destructor, \hyperpage{393}
  \item base class initializer, \hyperpage{391}
  \item base class initializers: calling order, \hyperpage{398}
  \item base class: converting to derived class, \hyperpage{422}
  \item base class: hiding members, \hyperpage{395}
  \item base class: prototype, \hyperpage{428}
  \item base class: virtual, \hyperpage{417}
  \item base(): reverse\_terator, \hyperpage{489}
  \item bash, \hyperpage{143}
  \item BASIC, \hyperpage{7}
  \item basic guarantee, \hyperpage{271}
  \item basic operators of containers, \hyperpage{334}
  \item basic\_, \hyperpage{111}
  \item basic\_ios.h, \hyperpage{115}
  \item basic\_regex, \hyperpage{516}
  \item beg, \hyperpage{128}, \hyperpage{138}, \hyperpage{435}
  \item begin, \hyperpage{103}, \hyperpage{172}, \hyperpage{338}, 
		\hyperpage{340}, \hyperpage{344}, \hyperpage{353}, 
		\hyperpage{358}, \hyperpage{366}, \hyperpage{374}, 
		\hyperpage{489}, \hyperpage{556}
  \item bernoulli\_distribution, \hyperpage{531}
  \item bidirectional\_iterator\_tag, \hyperpage{826}
  \item BidirectionalIterator, \hyperpage{491}, \hyperpage{826}
  \item binary, \hyperpage{130}, \hyperpage{145}
  \item binary constant, \hyperpage{49}, \hyperpage{53}
  \item binary file, \hyperpage{127}, \hyperpage{136}, 
		\hyperpage{145, 146}
  \item binary input, \hyperpage{136}
  \item binary output, \hyperpage{121}, \hyperpage{126}
  \item binary tree, \hyperpage{617}
  \item binary\_search, \hyperpage{556}
  \item binomial\_distribution\textless{}IntType = int\textgreater{}, 
		\hyperpage{531}
  \item bison, \hyperpage{1031}, \hyperpage{1036}
  \item bison++, \hyperpage{1031}, \hyperpage{1036}
  \item bisonc++, \hyperpage{1031}, \hyperpage{1036}
  \item bisonc++: grammar file, \hyperpage{1037}
  \item bit-field, \hyperpage{40}
  \item bit-flags, \hyperpage{49}
  \item bitand, \hyperpage{332}
  \item bitor, \hyperpage{332}
  \item bits/error\_constants.h: header file, \hyperpage{81}
  \item bitwise and, \hyperpage{118}
  \item bobcat, \hyperpage{1036}, \hyperpage{1044}
  \item Bobcat library, \hyperpage{269}, \hyperpage{987}, 
		\hyperpage{991}
  \item bool, \hyperpage{52}, \hyperpage{359}, \hyperpage{366}
  \item boolalpha, \hyperpage{122}
  \item Boost Filesystem, \hyperpage{81}
  \item bound friend, \hyperpage{792}, \hyperpage{795}, \hyperpage{822}
  \item bridge design pattern, \hyperpage{428}
  \item broken\_promise, \hyperpage{665}
  \item bucket, \hyperpage{374}
  \item bucket numbers, \hyperpage{372}
  \item bucket\_count, \hyperpage{374}
  \item bucket\_size, \hyperpage{374}
  \item buffer, \hyperpage{430}
  \item buffer overflow, \hyperpage{29}
  \item built-in, \hyperpage{52}
  \item byte, \hyperpage{55}

  \indexspace

  \item C strings, \hyperpage{48}
  \item C++11, \hyperpage{169}
  \item C++17, \hyperpage{60}
  \item C++: function prevalence rule, \hyperpage{696}
  \item c\_str, \hyperpage{104}
  \item call back, \hyperpage{198}
  \item call\_once, \hyperpage{637}
  \item callback, \hyperpage{634}
  \item calling order of base class initializers, \hyperpage{398}
  \item calloc, \hyperpage{201}
  \item candidate functions, \hyperpage{728}
  \item canonical, \hyperpage{89}
  \item capacity, \hyperpage{103}, \hyperpage{340}
  \item capacity: reduce, \hyperpage{221}
  \item carries\_dependency, \hyperpage{50}
  \item case-insensitive, \hyperpage{98}
  \item catch, \hyperpage{248}, \hyperpage{257}
  \item catch: empty enum, \hyperpage{478}
  \item cauchy\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{532}
  \item cbegin, \hyperpage{103}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{353}, \hyperpage{358}, \hyperpage{374}, 
		\hyperpage{556}
  \item ccbuild, \hyperpage{7}
  \item cend, \hyperpage{103}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{353}, \hyperpage{358}, \hyperpage{374}, 
		\hyperpage{556}
  \item cerr, \hyperpage{25}, \hyperpage{126}, \hyperpage{142}
  \item chain of command, \hyperpage{429}
  \item char, \hyperpage{111}
  \item char *, \hyperpage{291}
  \item chi\_squared\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{532}
  \item child process, \hyperpage{1001}, \hyperpage{1003}
  \item chrono, \hyperpage{73}
  \item chrono: header file, \hyperpage{74, 75}, \hyperpage{77, 78}
  \item cin, \hyperpage{25}, \hyperpage{114}, \hyperpage{135, 136}, 
		\hyperpage{142}
  \item circular queue, \hyperpage{742}
  \item class, \hyperpage{10}, \hyperpage{25}, \hyperpage{478}, 
		\hyperpage{693}, \hyperpage{854}
  \item class hierarchy, \hyperpage{383}, \hyperpage{409}
  \item class interface, \hyperpage{793}
  \item class name, \hyperpage{425}
  \item class scope, \hyperpage{458}
  \item class template, \hyperpage{706}, \hyperpage{735}, 
		\hyperpage{742}
  \item class template: adding functionality, \hyperpage{804}
  \item class template: as base class, \hyperpage{856}
  \item class template: conditional data organization, \hyperpage{845}
  \item class template: declaration, \hyperpage{754}, \hyperpage{790}
  \item class template: deducing parameters, \hyperpage{790}
  \item class template: default argument, \hyperpage{754}
  \item class template: default arguments, \hyperpage{753}
  \item class template: defining a type, \hyperpage{842}
  \item class template: derivation, \hyperpage{803}
  \item class template: derived from ordinary class, \hyperpage{808}
  \item class template: friend function template, \hyperpage{733}
  \item class template: generate types, \hyperpage{735}
  \item class template: identifying subtypes, \hyperpage{762}
  \item class template: instantiation, \hyperpage{790}
  \item class template: member instantiation, \hyperpage{790}
  \item class template: member template, \hyperpage{746}
  \item class template: nested, \hyperpage{822}
  \item class template: non-type parameter, \hyperpage{744}
  \item class template: partial specialization, \hyperpage{768}, 
		\hyperpage{771}
  \item class template: partially compiled, \hyperpage{803}
  \item class template: pointer to, \hyperpage{790}
  \item class template: reference to, \hyperpage{790}
  \item class template: shadowing parameters, \hyperpage{747}
  \item class template: static members, \hyperpage{761}
  \item class template: transformation to a base class, \hyperpage{707}
  \item class template: using friend, \hyperpage{792}
  \item class template: values without objects, \hyperpage{843}
  \item class template: wrapped in simpler template, \hyperpage{889}
  \item class templates: deducing parameters, \hyperpage{336}, 
		\hyperpage{339}
  \item class type, \hyperpage{864}
  \item class vs. typename, \hyperpage{693}
  \item class-type parameters, \hyperpage{185}
  \item class-type return values, \hyperpage{185}
  \item class: abstract, \hyperpage{412}
  \item class: definition, \hyperpage{453}
  \item class: enforcing constraints, \hyperpage{851}
  \item class: externally declared functions, \hyperpage{453}
  \item class: having pointers, \hyperpage{508}
  \item class: local, \hyperpage{181}, \hyperpage{402}
  \item class: move-aware, \hyperpage{227}
  \item class: ordinary, \hyperpage{706}
  \item class: policy, \hyperpage{851}
  \item class: trait, \hyperpage{859}
  \item class: without data members, \hyperpage{413}
  \item clear, \hyperpage{103}, \hyperpage{118}, \hyperpage{340}, 
		\hyperpage{344}, \hyperpage{353}, \hyperpage{358}, 
		\hyperpage{366}, \hyperpage{374}
  \item climits: header file, \hyperpage{722}
  \item Cline, M., \hyperpage{23}
  \item clock, \hyperpage{77}
  \item clock\_cast, \hyperpage{79}
  \item clog, \hyperpage{126}
  \item close, \hyperpage{128, 129}, \hyperpage{139}, \hyperpage{443}
  \item closure object, \hyperpage{322}
  \item closure type, \hyperpage{322}
  \item co\_await, \hyperpage{925, 926}
  \item co\_return, \hyperpage{925, 926}
  \item co\_yield, \hyperpage{925, 926}
  \item code, \hyperpage{667}
  \item code bloat, \hyperpage{813}, \hyperpage{816}, \hyperpage{857}
  \item Coetmeur, A., \hyperpage{1036}
  \item collating order, \hyperpage{426}
  \item collision, \hyperpage{372}
  \item command language, \hyperpage{1009}
  \item common data fields, \hyperpage{189}
  \item common pool, \hyperpage{202}
  \item compare, \hyperpage{103}
  \item compare: header file, \hyperpage{308}, \hyperpage{511, 512}
  \item compare\_exchange\_strong, \hyperpage{657}
  \item compare\_exchange\_weak, \hyperpage{657}
  \item comparison classes, \hyperpage{510}
  \item comparison-salient state, \hyperpage{511}
  \item compile-time, \hyperpage{13}, \hyperpage{405}, \hyperpage{407}, 
		\hyperpage{420}, \hyperpage{691}, \hyperpage{721}
  \item compiler, \hyperpage{5, 6}
  \item compiler firewall, \hyperpage{428}
  \item compl, \hyperpage{332}
  \item complex, \hyperpage{381}
  \item complex numbers, \hyperpage{381}
  \item complex: header file, \hyperpage{381}
  \item composition, \hyperpage{164}, \hyperpage{185}, \hyperpage{383}, 
		\hyperpage{396}
  \item compound type, \hyperpage{864}
  \item concept, \hyperpage{899}
  \item concept: constraints, \hyperpage{907}
  \item concept: declaration, \hyperpage{919}
  \item concept: specialization, \hyperpage{904}
  \item concept: used for function parameters, \hyperpage{916}
  \item concept: using 'ConceptName auto', \hyperpage{917}
  \item concept: variadic, \hyperpage{914}
  \item condition flags, \hyperpage{116}
  \item condition member functions, \hyperpage{116}
  \item condition state, \hyperpage{116}
  \item condition\_variable, \hyperpage{650, 651}
  \item condition\_variable: header file, \hyperpage{649}, 
		\hyperpage{651, 652}
  \item condition\_variable\_any, \hyperpage{650}, \hyperpage{652}
  \item conditional, \hyperpage{865}
  \item conj, \hyperpage{382}
  \item consecutive closing angle brackets, \hyperpage{356}
  \item const, \hyperpage{21}, \hyperpage{705}
  \item const data and containers, \hyperpage{335}
  \item const function attribute, \hyperpage{12}
  \item const functions, \hyperpage{22}
  \item const member, \hyperpage{155}
  \item const member functions, \hyperpage{172}, \hyperpage{413}
  \item const-qualification, \hyperpage{173}
  \item const: generalized expression, \hyperpage{192}
  \item const\_cast\textless{}type\textgreater{}(expression), 
		\hyperpage{58}
  \item const\_iterator, \hyperpage{338}, \hyperpage{374}, 
		\hyperpage{490}
  \item const\_pointer\_cast, \hyperpage{506}
  \item const\_reverse\_iterator, \hyperpage{338}
  \item constant expression, \hyperpage{695}
  \item constant-expression constructor, \hyperpage{195}
  \item constant-expression function, \hyperpage{193}
  \item constexpr, \hyperpage{192}, \hyperpage{638}
  \item construct\_at, \hyperpage{612}
  \item construction: delegate to base classes, \hyperpage{392}
  \item constructor, \hyperpage{320}, \hyperpage{398}, \hyperpage{482}
  \item constructor notation, \hyperpage{57}
  \item constructor: and exceptions, \hyperpage{277}
  \item constructor: calling order, \hyperpage{393}
  \item constructor: default, \hyperpage{153, 154}
  \item constructor: delegation, \hyperpage{169}
  \item constructor: of derived classes, \hyperpage{390}
  \item constructor: primitive type, \hyperpage{696}
  \item container, \hyperpage{333}
  \item container without angle brackets, \hyperpage{335}
  \item container: basic operators, \hyperpage{334}
  \item container: data type requirements, \hyperpage{334}
  \item container: equality tests, \hyperpage{334}
  \item container: initialization, \hyperpage{337}
  \item container: nested, \hyperpage{356}
  \item container: ordering, \hyperpage{334}
  \item container: storing pointers, \hyperpage{335}
  \item contains, \hyperpage{104}
  \item containter: storing const data, \hyperpage{335}
  \item contiguous\_iterator\_tag, \hyperpage{826}
  \item ContiguousIterator, \hyperpage{491}, \hyperpage{826}
  \item conversion operator, \hyperpage{292}
  \item conversion operator: explicit, \hyperpage{297}
  \item conversion rules, \hyperpage{53}
  \item conversions, \hyperpage{745}
  \item conversions: binary to text, \hyperpage{131}
  \item conversions: text to binary, \hyperpage{140}
  \item cooperating routine, \hyperpage{926}
  \item cooperating routines, \hyperpage{926}
  \item copy, \hyperpage{89}, \hyperpage{104}, \hyperpage{558}, 
		\hyperpage{807}
  \item copy construction, \hyperpage{172}
  \item copy constructor, \hyperpage{176}, \hyperpage{221}, 
		\hyperpage{391}
  \item copy constructor: suppressed, \hyperpage{230}
  \item copy elision, \hyperpage{238}
  \item copy non-involved data, \hyperpage{343}
  \item copy\_backward, \hyperpage{559}
  \item copy\_file, \hyperpage{89}
  \item copy\_if, \hyperpage{558}
  \item copy\_options, \hyperpage{89}
  \item copy\_symlink, \hyperpage{89}
  \item copyfmt, \hyperpage{119}
  \item coroutine handle, \hyperpage{925}
  \item coroutine: essential characteristic, \hyperpage{945}
  \item coroutine: header file, \hyperpage{926}
  \item cos, \hyperpage{382}
  \item cosh, \hyperpage{382}
  \item count, \hyperpage{358}, \hyperpage{363}, \hyperpage{366, 367}, 
		\hyperpage{374}, \hyperpage{376}, \hyperpage{379}, 
		\hyperpage{559}
  \item count\_if, \hyperpage{559}
  \item coupling, \hyperpage{10}
  \item cout, \hyperpage{25}, \hyperpage{114}, \hyperpage{126}, 
		\hyperpage{142}, \hyperpage{1004}
  \item crbegin, \hyperpage{104}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{353}, \hyperpage{358}
  \item create files, \hyperpage{128}
  \item create\_directories, \hyperpage{89}
  \item create\_directory, \hyperpage{90}
  \item create\_directory\_symlink, \hyperpage{90}
  \item create\_hard\_link, \hyperpage{90}
  \item create\_symlink, \hyperpage{90}
  \item cref(arg), \hyperpage{702}
  \item crend, \hyperpage{104}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{353}
  \item CRTP, \hyperpage{813}
  \item cstddef, \hyperpage{55}
  \item cstddef: header file, \hyperpage{55}
  \item cstdint, \hyperpage{55}
  \item cstdio, \hyperpage{11}
  \item cstdlib: header file, \hyperpage{791}
  \item cumulative distribution function, \hyperpage{528}
  \item cur, \hyperpage{128}, \hyperpage{138}, \hyperpage{435}
  \item curiously recurring template pattern, \hyperpage{813, 814}
  \item current\_exception, \hyperpage{269}
  \item current\_path, \hyperpage{90}
  \item cv\_status, \hyperpage{650}
  \item Cygwin, \hyperpage{6}

  \indexspace

  \item daemon, \hyperpage{1004, 1005}, \hyperpage{1017}, 
		\hyperpage{1019}
  \item data, \hyperpage{104}, \hyperpage{338}, \hyperpage{340}
  \item data hiding, \hyperpage{7}, \hyperpage{27}, \hyperpage{152}, 
		\hyperpage{154}, \hyperpage{191}, \hyperpage{385}, 
		\hyperpage{388}, \hyperpage{431}, \hyperpage{453}
  \item data integrity, \hyperpage{453}
  \item data member, \hyperpage{152}, \hyperpage{431}
  \item data member: initialization, \hyperpage{167}, \hyperpage{169}
  \item data race, \hyperpage{552}
  \item Data Structures and Algorithms, \hyperpage{342}
  \item database applications, \hyperpage{138}
  \item deadlock, \hyperpage{552}
  \item deallocate memory, \hyperpage{312}
  \item Debian, \hyperpage{6}
  \item dec, \hyperpage{122}
  \item decay, \hyperpage{865}
  \item decay\_t, \hyperpage{865}
  \item decimal constant, \hyperpage{49}
  \item declaration section, \hyperpage{1037}
  \item declarative region, \hyperpage{63}
  \item declare iostream classes, \hyperpage{111}
  \item decltype, \hyperpage{700}
  \item decltype(auto), \hyperpage{697}
  \item declval, \hyperpage{699}
  \item decrement operator, \hyperpage{298}
  \item deduction rules, \hyperpage{741}
  \item default, \hyperpage{172}
  \item default arguments, \hyperpage{13}
  \item default constructor, \hyperpage{221}, \hyperpage{334}, 
		\hyperpage{390}
  \item default implementation, \hyperpage{434}
  \item default value, \hyperpage{341}, \hyperpage{347}
  \item default\_error\_condition, \hyperpage{266}
  \item deferred, \hyperpage{670}
  \item define members of namespaces, \hyperpage{72}
  \item delegating constructors, \hyperpage{169}
  \item delete, \hyperpage{172}, \hyperpage{201, 202}, \hyperpage{311}
  \item delete[], \hyperpage{204}, \hyperpage{211}
  \item deleter, \hyperpage{498}, \hyperpage{500}, \hyperpage{503, 504}
  \item deletions, \hyperpage{343}
  \item delimiter, \hyperpage{495}
  \item denorm\_min, \hyperpage{722}
  \item denorm\_style, \hyperpage{723}
  \item deprecated, \hyperpage{50}
  \item depth, \hyperpage{93}
  \item deque, \hyperpage{352}, \hyperpage{489}
  \item deque constructors, \hyperpage{352}
  \item deque: header file, \hyperpage{352}
  \item derivation, \hyperpage{383}
  \item derived class, \hyperpage{383}, \hyperpage{400}, 
		\hyperpage{422}
  \item derived class destructor, \hyperpage{393}
  \item derived class vs. base class size, \hyperpage{401}
  \item derived class: using declaration, \hyperpage{395}
  \item design pattern, \hyperpage{10}, \hyperpage{412}, 
		\hyperpage{1001}
  \item design pattern: Prototype, \hyperpage{450}
  \item design pattern: template method, \hyperpage{1002}
  \item Design Patterns, \hyperpage{1001}
  \item designated initialization, \hyperpage{40}
  \item destroy, \hyperpage{927}
  \item destructor, \hyperpage{153}, \hyperpage{209}, \hyperpage{411}
  \item destructor: and exceptions, \hyperpage{283}
  \item destructor: called at exit, \hyperpage{1004}
  \item destructor: calling order, \hyperpage{393}
  \item destructor: derived class, \hyperpage{393}
  \item destructor: empty, \hyperpage{411}
  \item destructor: explicit call, \hyperpage{208}, \hyperpage{211}
  \item destructor: for policy classes, \hyperpage{857}
  \item destructor: inline, \hyperpage{412}
  \item destructor: main task, \hyperpage{209}
  \item destructor: virtual, \hyperpage{411}
  \item detach, \hyperpage{627}, \hyperpage{633}
  \item device, \hyperpage{114}, \hyperpage{985}
  \item differenct\_type, \hyperpage{824}
  \item digit separator, \hyperpage{56}
  \item digits, \hyperpage{722}
  \item digits10, \hyperpage{723}
  \item digraphs, \hyperpage{3}
  \item direct base class, \hyperpage{386}
  \item directory\_entry, \hyperpage{91}
  \item directory\_options, \hyperpage{92}
  \item disable\_recursion\_pending, \hyperpage{93}
  \item display field width, \hyperpage{121}
  \item display floating point numbers, \hyperpage{120}, 
		\hyperpage{123}
  \item distance, \hyperpage{489}, \hyperpage{491}
  \item divides, \hyperpage{485}
  \item domain\_error, \hyperpage{262}
  \item done, \hyperpage{927}
  \item DOS, \hyperpage{145}
  \item double free, \hyperpage{506}
  \item double initialization, \hyperpage{401}
  \item double pointers, \hyperpage{198}
  \item doubly ended queue, \hyperpage{352}
  \item down-casting, \hyperpage{422}
  \item dup, \hyperpage{1005}
  \item dup2, \hyperpage{1005}, \hyperpage{1008}
  \item duration, \hyperpage{75}
  \item duration\_cast, \hyperpage{77}
  \item dynamic arrays, \hyperpage{203}
  \item dynamic binding, \hyperpage{407}
  \item dynamic cast, \hyperpage{422}
  \item dynamic growth, \hyperpage{343}
  \item dynamic polymorphism, \hyperpage{735}, \hyperpage{813}, 
		\hyperpage{856}
  \item dynamic\_cast, \hyperpage{422}, \hyperpage{425}
  \item dynamic\_pointer\_cast, \hyperpage{507}
  \item dynamically allocated variables, \hyperpage{745}

  \indexspace

  \item E, \hyperpage{53}
  \item early binding, \hyperpage{405}, \hyperpage{407}
  \item eback, \hyperpage{431}, \hyperpage{989}, \hyperpage{991}, 
		\hyperpage{995}
  \item ECHO, \hyperpage{1034}
  \item ECMAScript, \hyperpage{517}
  \item egptr, \hyperpage{431}, \hyperpage{989}, \hyperpage{991}, 
		\hyperpage{995}
  \item ellipsis, \hyperpage{38}, \hyperpage{292}, \hyperpage{775}, 
		\hyperpage{862}, \hyperpage{877}
  \item emit, \hyperpage{686, 687}
  \item emplace, \hyperpage{340}, \hyperpage{349}, \hyperpage{353}, 
		\hyperpage{358}, \hyperpage{366}, \hyperpage{370}, 
		\hyperpage{374}, \hyperpage{376, 377}, \hyperpage{380}
  \item emplace\_back, \hyperpage{340}, \hyperpage{344}, 
		\hyperpage{353}
  \item emplace\_front, \hyperpage{344}, \hyperpage{353}
  \item emplace\_hint, \hyperpage{358}, \hyperpage{374}, 
		\hyperpage{376}, \hyperpage{378}, \hyperpage{380}
  \item empty, \hyperpage{104}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{344}, \hyperpage{349}, \hyperpage{352}, 
		\hyperpage{354}, \hyperpage{358}, \hyperpage{366}, 
		\hyperpage{370}, \hyperpage{375}
  \item empty destructor, \hyperpage{411}
  \item empty enum, \hyperpage{478}
  \item empty list, \hyperpage{346}
  \item empty parameter list, \hyperpage{14}
  \item empty struct, \hyperpage{876}
  \item enable\_if, \hyperpage{865}
  \item encapsulation, \hyperpage{29}, \hyperpage{154}, \hyperpage{385}, 
		\hyperpage{453}
  \item end, \hyperpage{104}, \hyperpage{128}, \hyperpage{138}, 
		\hyperpage{172}, \hyperpage{338}, \hyperpage{340}, 
		\hyperpage{344}, \hyperpage{354}, \hyperpage{358}, 
		\hyperpage{366}, \hyperpage{375}, \hyperpage{435}, 
		\hyperpage{489}, \hyperpage{556}
  \item end of line comment, \hyperpage{10}
  \item end-of-stream, \hyperpage{494}
  \item endian, \hyperpage{127}
  \item endl, \hyperpage{26}, \hyperpage{124}
  \item endl: signature, \hyperpage{319}
  \item ends, \hyperpage{124}
  \item ends\_with, \hyperpage{104}
  \item enum, \hyperpage{18}
  \item enum class, \hyperpage{38}
  \item enum class errc, \hyperpage{264}
  \item enum values: and arithmetic operators, \hyperpage{329}
  \item enum values: evaluated at compile-time, \hyperpage{863}
  \item enumeration: nested, \hyperpage{476}, \hyperpage{823}
  \item environ, \hyperpage{10}
  \item eof, \hyperpage{117}
  \item eofbit, \hyperpage{116}
  \item epoch, \hyperpage{78}
  \item epptr, \hyperpage{987}
  \item epsilon, \hyperpage{723}
  \item equal, \hyperpage{560}
  \item equal\_range, \hyperpage{358}, \hyperpage{363}, 
		\hyperpage{366, 367}, \hyperpage{375, 376}, 
		\hyperpage{380}, \hyperpage{561}
  \item equal\_to, \hyperpage{486}
  \item equality operator, \hyperpage{334}
  \item equivalent, \hyperpage{90}, \hyperpage{266}
  \item erase, \hyperpage{104}, \hyperpage{340}, \hyperpage{345}, 
		\hyperpage{354}, \hyperpage{358}, \hyperpage{363}, 
		\hyperpage{366, 367}, \hyperpage{375}
  \item errc, \hyperpage{82}
  \item errc (enum), \hyperpage{264}
  \item errno, \hyperpage{81}
  \item error, \hyperpage{1037}
  \item error code, \hyperpage{247}
  \item error\_category: required header, \hyperpage{264}
  \item error\_code, \hyperpage{667}
  \item error\_code\_enum, \hyperpage{869}
  \item error\_condition, \hyperpage{267}
  \item error\_condition: required header, \hyperpage{264}
  \item error\_condition\_enum, \hyperpage{870}
  \item ErrorCodeEnum, \hyperpage{264}, \hyperpage{868}
  \item escape sequence, \hyperpage{48}
  \item exceptFd, \hyperpage{1012}
  \item exception, \hyperpage{119}, \hyperpage{423}
  \item Exception (Bobcat), \hyperpage{269}
  \item exception class, \hyperpage{261, 262}
  \item exception guarantees, \hyperpage{271}
  \item exception handler: order, \hyperpage{258}
  \item exception neutral, \hyperpage{273}
  \item exception safe, \hyperpage{270}
  \item exception: and constructors, \hyperpage{277}
  \item exception: and destructors, \hyperpage{283}
  \item exception: and new, \hyperpage{272}
  \item exception: and new[], \hyperpage{315}
  \item exception: and streambuf, \hyperpage{429}
  \item exception: bad\_alloc, \hyperpage{214}
  \item exception: header file, \hyperpage{262}
  \item exception: replace, \hyperpage{277}
  \item exception: standard, \hyperpage{262}
  \item exception\_ptr, \hyperpage{269}
  \item Exceptional C++, \hyperpage{272}
  \item exceptions, \hyperpage{247}
  \item exceptions (function), \hyperpage{261}
  \item exchange, \hyperpage{563}, \hyperpage{657}
  \item exclusive\_scan, \hyperpage{590, 591}
  \item exec..., \hyperpage{1004}
  \item execution policy, \hyperpage{551}
  \item execution: header file, \hyperpage{551}
  \item execution::par, \hyperpage{552}
  \item execution::par\_unseq, \hyperpage{552}
  \item execution::parallel\_policy: header file, \hyperpage{552}
  \item execution::parallel\_unsequenced\_policy: header file, 
		\hyperpage{552}
  \item execution::seq, \hyperpage{551}
  \item execution::sequenced\_policy: header file, \hyperpage{551}
  \item execution::unseq, \hyperpage{552}
  \item execution::unsequenced\_policy: header file, \hyperpage{552}
  \item exists, \hyperpage{90}
  \item exit, \hyperpage{247}, \hyperpage{252}, \hyperpage{1004, 1005}
  \item exit status, \hyperpage{1003}
  \item exit: avoid, \hyperpage{209}
  \item exit: calling destructors, \hyperpage{1004}
  \item exp, \hyperpage{382}
  \item expandable array, \hyperpage{339}
  \item expiring value, \hyperpage{37}
  \item explicit, \hyperpage{297}
  \item explicit conversions, \hyperpage{741}
  \item explicit instantiation declaration, \hyperpage{710}
  \item explicit template type arguments, \hyperpage{713}
  \item explicit type specification, \hyperpage{703}
  \item explicit: conversion operator, \hyperpage{297}
  \item exponential\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{534}
  \item exponentiation, \hyperpage{53}
  \item export compound, \hyperpage{960}
  \item export import Name:Partition;, \hyperpage{959}
  \item expression template, \hyperpage{895}
  \item expression: actual type, \hyperpage{422}
  \item expression: type of, \hyperpage{425}
  \item extended friend, \hyperpage{455}, \hyperpage{802}
  \item extensible literals, \hyperpage{330}
  \item extern, \hyperpage{6}, \hyperpage{790}
  \item extern C|hyperpage, 15
  \item extern template, \hyperpage{754, 755}
  \item extracting strings, \hyperpage{136}
  \item extraction operator, \hyperpage{25, 26}, \hyperpage{112}, 
		\hyperpage{135, 136}
  \item extreme\_value\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{533}

  \indexspace

  \item F, \hyperpage{53}
  \item factory function, \hyperpage{160}, \hyperpage{234}
  \item fail, \hyperpage{117}, \hyperpage{128}
  \item failbit, \hyperpage{116}, \hyperpage{138}
  \item failure class, \hyperpage{261}
  \item fallthrough, \hyperpage{51}
  \item false, \hyperpage{53}, \hyperpage{578}, \hyperpage{587}
  \item fetch\_, \hyperxindexformat{\=}{658}
  \item fetch\_\^=, \hyperpage{658}
  \item fetch\_add, \hyperpage{658}
  \item fetch\_and, \hyperpage{658}
  \item fetch\_sub, \hyperpage{658}
  \item field `...' has incomplete type, \hyperpage{795}
  \item field selector, \hyperpage{460}
  \item field width, \hyperpage{318}
  \item FIFO, \hyperpage{333}, \hyperpage{349}
  \item FILE, \hyperpage{111}
  \item file descriptor, \hyperpage{114}, \hyperpage{129}, 
		\hyperpage{143}, \hyperpage{985}, \hyperpage{993, 994}, 
		\hyperpage{1006}
  \item file flags, \hyperpage{130}
  \item file is rewritten, \hyperpage{130}
  \item file modes, \hyperpage{130}
  \item file rewriting: preventing, \hyperpage{130}
  \item file: binary mode, \hyperpage{130}
  \item file: copying, \hyperpage{140}
  \item file\_clock, \hyperpage{77}
  \item file\_size, \hyperpage{90}
  \item file\_type, \hyperpage{83}
  \item filebuf, \hyperpage{114}, \hyperpage{443}
  \item filesystem, \hyperpage{81}
  \item filesystem: header file, \hyperpage{74}, \hyperpage{81}
  \item filesystem\_error, \hyperpage{95}
  \item fill, \hyperpage{119}, \hyperpage{338}, \hyperpage{563}
  \item fill characters, \hyperpage{121}
  \item fill\_n, \hyperpage{563}
  \item FILO, \hyperpage{333}, \hyperpage{369}
  \item final, \hyperpage{414}
  \item find, \hyperpage{104}, \hyperpage{359}, \hyperpage{363}, 
		\hyperpage{366}, \hyperpage{368}, \hyperpage{375, 376}, 
		\hyperpage{380}, \hyperpage{564}
  \item find\_end, \hyperpage{565}
  \item find\_first\_not\_of, \hyperpage{105}
  \item find\_first\_of, \hyperpage{105}, \hyperpage{566}
  \item find\_if, \hyperpage{564}
  \item find\_if\_not, \hyperpage{564}
  \item find\_last\_not\_of, \hyperpage{105}
  \item find\_last\_of, \hyperpage{105}
  \item first, \hyperpage{335}
  \item first in, first out, \hyperpage{333}, \hyperpage{349}
  \item first in, last out, \hyperpage{333}, \hyperpage{369}
  \item first\_argument\_type, \hyperpage{859}
  \item fisher\_f\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{535}
  \item Fistream, \hyperpage{998}
  \item fixed, \hyperpage{123}
  \item fixed-size array, \hyperpage{337}
  \item flag\_type, \hyperpage{517}
  \item flags, \hyperpage{120}
  \item flags: of ios objects, \hyperpage{118}
  \item flex, \hyperpage{1031}
  \item flexc++, \hyperpage{1032--1036}, \hyperpage{1044}
  \item flexc++: debugging, \hyperpage{1033}
  \item float\_denorm\_style, \hyperpage{723}
  \item float\_round\_style, \hyperpage{724}
  \item floatfield, \hyperpage{123}
  \item flow-breaking methods, \hyperpage{247}
  \item flush, \hyperpage{124}, \hyperpage{128}
  \item fold expression: parentheses, \hyperpage{783}
  \item folding expression, \hyperpage{782}
  \item fopen, \hyperpage{126}, \hyperpage{135}
  \item for range declaration, \hyperpage{47}
  \item for-statement, \hyperpage{47}
  \item for\_each, \hyperpage{567}, \hyperpage{1019}
  \item for\_each: vs. transform, \hyperpage{609}
  \item fork, \hyperpage{621}, \hyperpage{1001, 1002}, \hyperpage{1005}
  \item formal type, \hyperpage{691}, \hyperpage{693}, \hyperpage{743}
  \item format, \hyperpage{525}
  \item format specifier, \hyperpage{525}
  \item format string, \hyperpage{132}, \hyperpage{525}
  \item format\_default, \hyperpage{522}
  \item format\_first\_only, \hyperpage{522}
  \item format\_no\_copy, \hyperpage{522}
  \item format\_sed, \hyperpage{522}
  \item formatted input, \hyperpage{136}
  \item formatted output, \hyperpage{121}, \hyperpage{126}
  \item formatting, \hyperpage{115}, \hyperpage{119}
  \item formatting commands, \hyperpage{112}
  \item formatting flags, \hyperpage{119}, \hyperpage{121}
  \item forward, \hyperpage{777, 778}
  \item forward class reference, \hyperpage{184}
  \item forward declaration, \hyperpage{111}, \hyperpage{185}
  \item forward declaration: enum class, \hyperpage{38}
  \item forward iterators, \hyperpage{101}
  \item forward: parameters, \hyperpage{780}
  \item forward\_iterator\_tag, \hyperpage{826}
  \item ForwardIterator, \hyperpage{491}, \hyperpage{826}
  \item fprintf, \hyperpage{112}
  \item free, \hyperpage{201}, \hyperpage{207}, \hyperpage{211}
  \item free compiler, \hyperpage{6}
  \item free function, \hyperpage{289}
  \item Free Software Foundation, \hyperpage{6}
  \item Friedl, J.E.F, \hyperpage{514}
  \item friend, \hyperpage{453}, \hyperpage{792, 793}
  \item friend: as forward declaration, \hyperpage{475}
  \item friend: bound, \hyperpage{792}, \hyperpage{795}
  \item friend: extended declaration, \hyperpage{455}
  \item friend: function declaration, \hyperpage{454}
  \item friend: in class templates, \hyperpage{792}
  \item friend: nested classes, \hyperpage{472}
  \item friend: unbound, \hyperpage{800}
  \item friend: using a template parameter, \hyperpage{1028}
  \item friendship among classes, \hyperpage{453}
  \item from\_address, \hyperpage{927}
  \item from\_time\_t, \hyperpage{78}
  \item front, \hyperpage{105}, \hyperpage{338}, \hyperpage{341}, 
		\hyperpage{345}, \hyperpage{349}, \hyperpage{354}
  \item front\_inserter, \hyperpage{493}
  \item FSF, \hyperpage{6}
  \item fstream, \hyperpage{144}
  \item fstream: header file, \hyperpage{115}, \hyperpage{128}, 
		\hyperpage{139}, \hyperpage{443}
  \item ftp::/prep.ai.mit.edu/pub/non-gnu, \hyperpage{1031}
  \item fully qualified name, \hyperpage{70}, \hyperpage{696}
  \item fully qualified name: nested class members, \hyperpage{471}
  \item function (std::), \hyperpage{725}
  \item function adapters, \hyperpage{482}
  \item function call operator, \hyperpage{316}
  \item function object, \hyperpage{316}
  \item function object: anonymous, \hyperpage{322}
  \item function object: arithmetic, \hyperpage{483}
  \item function object: logical, \hyperpage{486}
  \item function object: relational, \hyperpage{486}
  \item function overloading, \hyperpage{12}, \hyperpage{173}
  \item function pointer: polymorphic, \hyperpage{724}
  \item function prevalence rule, \hyperpage{696}
  \item function selection, \hyperpage{727}
  \item function template, \hyperpage{691}
  \item function template: overloading, \hyperpage{714}
  \item function template: partial specialization, \hyperpage{768}
  \item function template: specialization vs. overloading, 
		\hyperpage{720}
  \item function templates: multiply included, \hyperpage{709}
  \item function templates: specialized type parameters, 
		\hyperpage{717}
  \item function throw list, \hyperpage{262}
  \item function try block, \hyperpage{276}
  \item function-to-pointer transformation, \hyperpage{705}
  \item function: candidate, \hyperpage{728}
  \item function: constant-expression, \hyperpage{193}
  \item function: free, \hyperpage{301}
  \item function: returning rvalue reference, \hyperpage{228}
  \item function: variadic, \hyperpage{691}
  \item function: viable, \hyperpage{728}
  \item function:local, \hyperpage{326}
  \item functional: header file, \hyperpage{373}, \hyperpage{481}, 
		\hyperpage{487}, \hyperpage{670}, \hyperpage{701}, 
		\hyperpage{725}, \hyperpage{788}
  \item functionality, \hyperpage{337}
  \item functions as members of structs, \hyperpage{19}
  \item functions having identical names, \hyperpage{12}, 
		\hyperpage{19}
  \item functor, \hyperpage{316}
  \item fundamental type, \hyperpage{864}
  \item future, \hyperpage{664}
  \item future (coroutine), \hyperpage{926}
  \item future: header file, \hyperpage{664}, \hyperpage{667}, 
		\hyperpage{669}, \hyperpage{672}, \hyperpage{676}
  \item future\_already\_retrieved, \hyperpage{666}
  \item future\_category, \hyperpage{267}
  \item future\_errc, \hyperpage{665}
  \item future\_error, \hyperpage{663}, \hyperpage{665}, 
		\hyperpage{667}
  \item future\_status, \hyperpage{664}

  \indexspace

  \item g++, \hyperpage{5, 6}, \hyperpage{1035}
  \item Gamma, E., \hyperpage{412}, \hyperpage{450}, \hyperpage{1001}, 
		\hyperpage{1026}
  \item gamma\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{535}
  \item gbump, \hyperpage{431}, \hyperpage{991}
  \item gcm.cache, \hyperpage{960}, \hyperpage{962}
  \item gcount, \hyperpage{136}
  \item generalized const expression, \hyperpage{192}
  \item generalized lvalue, \hyperpage{37}
  \item generalized pair, \hyperpage{337}, \hyperpage{783}
  \item generate, \hyperpage{569}
  \item generate\_n, \hyperpage{569}
  \item generator: random number, \hyperpage{528}
  \item generic algorithm: categories, \hyperpage{550}
  \item generic algorithms, \hyperpage{334}, \hyperpage{549, 550}
  \item generic algorithms: required types, \hyperpage{859}
  \item generic data type, \hyperpage{550}
  \item generic software, \hyperpage{111}
  \item generic type, \hyperpage{335}
  \item generic\_category, \hyperpage{82}, \hyperpage{266}
  \item geometric\_distribution\textless{}IntType = int\textgreater{}, 
		\hyperpage{536}
  \item get, \hyperpage{136}, \hyperpage{499}, \hyperpage{502}, 
		\hyperpage{504, 505}, \hyperpage{784}
  \item get\_allocator, \hyperpage{105}, \hyperpage{341}, 
		\hyperpage{345}, \hyperpage{354}, \hyperpage{359}, 
		\hyperpage{366}, \hyperpage{375}
  \item get\_deleter, \hyperpage{502}, \hyperpage{505}
  \item get\_future, \hyperpage{675}
  \item get\_id, \hyperpage{623}, \hyperpage{628}, \hyperpage{633}
  \item get\_stop\_source, \hyperpage{633}
  \item get\_stop\_token, \hyperpage{633}
  \item get\_wrapped, \hyperpage{686, 687}
  \item getline, \hyperpage{106}, \hyperpage{117}, \hyperpage{137}
  \item global \texttt{try} block, \hyperpage{248}
  \item global function, \hyperpage{196}
  \item global namespace, \hyperpage{61}
  \item global scope, \hyperpage{458}
  \item global variable, \hyperpage{189}, \hyperpage{745}
  \item global variable: avoid, \hyperpage{17}
  \item glvalue, \hyperpage{37}
  \item gmtime, \hyperpage{132}
  \item GNU, \hyperpage{5, 6}, \hyperpage{214}, \hyperpage{476}, 
		\hyperpage{1035}
  \item good, \hyperpage{117}
  \item goodbit, \hyperpage{116}
  \item goto, \hyperpage{247}
  \item gptr, \hyperpage{431}, \hyperpage{989}, \hyperpage{991}, 
		\hyperpage{995}
  \item grammar, \hyperpage{985}, \hyperpage{1036}
  \item grammar specification file, \hyperpage{1036}
  \item grammatical rules, \hyperpage{1037}
  \item greater, \hyperpage{486}
  \item greater\_equal, \hyperpage{486}

  \indexspace

  \item handler (coroutine), \hyperpage{926}
  \item hard\_link\_count, \hyperpage{90}
  \item hardware\_concurrency, \hyperpage{628}, \hyperpage{633}
  \item has\_denorm, \hyperpage{723}
  \item has\_denorm\_loss, \hyperpage{723}
  \item has\_infinity, \hyperpage{723}
  \item has\_quiet\_NaN, \hyperpage{723}
  \item has\_signaling\_NaN, \hyperpage{723}
  \item hash, \hyperpage{371}
  \item hash function, \hyperpage{372}
  \item hash value, \hyperpage{377}
  \item hash\_function, \hyperpage{375}
  \item hashing, \hyperpage{371}
  \item hashing: default available, \hyperpage{371}
  \item header file, \hyperpage{114}, \hyperpage{183}, \hyperpage{187}
  \item header section, \hyperpage{1037}
  \item header: precompiled, \hyperpage{957}
  \item heap, \hyperpage{617}
  \item heterogeneous lookup, \hyperpage{380}
  \item hex, \hyperpage{122}
  \item hexadecimal constant, \hyperpage{49}
  \item hidden data member, \hyperpage{446}
  \item hiding: base class  members, \hyperpage{395}
  \item hierarchic sort, \hyperpage{806}
  \item hierarchy of code, \hyperpage{383}
  \item high\_resolution\_clock, \hyperpage{77}
  \item Hopcroft J.E., \hyperpage{342}
  \item http://cygwin.com, \hyperpage{6}
  \item http://fbb-git.gitlab.io/bisoncpp/, \hyperpage{1044}
  \item http://fbb-git.gitlab.io/bobcat/, \hyperpage{269}, 
		\hyperpage{987}, \hyperpage{991}
  \item http://gcc.gnu.org, \hyperpage{6}
  \item http://mingw-w64.org/doku.php, \hyperpage{6}
  \item http://oreilly.com/catalog/, \hyperpage{621}
  \item http://publications.gbdirect.co.uk/c\_book/, \hyperpage{3}
  \item http://www.debian.org, \hyperpage{6}
  \item http://www.gnu.org, \hyperpage{6}
  \item http://www.gnu.org/licenses/, \hyperpage{3}
  \item http://www.linux.org, \hyperpage{6}
  \item http://www.oreilly.com/catalog/lex, \hyperpage{1031}
  \item http://www.stroustrup.com/..., \hyperpage{22}
  \item http://www/parashift.com/c++-faq-lite/, \hyperpage{23}
  \item https://doc.qt.io, \hyperpage{153}
  \item https://fbb-git.gitlab.io/flexcpp/, \hyperpage{1036}
  \item https://fbb-git.gitlab.io/yodl/, \hyperpage{3}
  \item https://gitlab.com/fbb-git/cppannotations-zip, \hyperpage{i}
  \item human-readable, \hyperpage{121}

  \indexspace

  \item I/O, \hyperpage{111}
  \item I/O library, \hyperpage{111}
  \item I/O multiplexing, \hyperpage{1010}
  \item icase, \hyperpage{517}
  \item icmake, \hyperpage{7}
  \item id, \hyperpage{623}, \hyperpage{628}
  \item identically named member functions, \hyperpage{398}
  \item identifier: initial underscore, \hyperpage{330}
  \item identifiers starting with an underscore, \hyperpage{61}
  \item IEC-559, \hyperpage{723}
  \item IEEE-754, \hyperpage{723}
  \item if constexpr, \hyperpage{732}
  \item IFdNStreambuf, \hyperpage{990}
  \item IFdSeek, \hyperpage{992}
  \item IFdStreambuf, \hyperpage{988}, \hyperpage{1017}
  \item ifstream, \hyperpage{135}, \hyperpage{139}, \hyperpage{149}
  \item ifstream constructors, \hyperpage{139}
  \item ignore, \hyperpage{137}
  \item imag, \hyperpage{382}
  \item imaginary part, \hyperpage{381, 382}
  \item implementation, \hyperpage{151}
  \item implementation dependent, \hyperpage{453}
  \item implemented-in-terms-of, \hyperpage{405}
  \item implicit conversion, \hyperpage{400}
  \item import, \hyperpage{962}
  \item in, \hyperpage{130}, \hyperpage{144}
  \item in\_avail, \hyperpage{429}
  \item INCLUDE, \hyperpage{183}, \hyperpage{186}
  \item include guard, \hyperpage{16}
  \item includes, \hyperpage{570}
  \item inclusive\_scan, \hyperpage{590, 591}
  \item increment, \hyperpage{93}
  \item increment operator, \hyperpage{298}
  \item index operator, \hyperpage{285}, \hyperpage{337}, 
		\hyperpage{357}, \hyperpage{363}
  \item index operator: multiple arguments, \hyperpage{288}
  \item indirect base class, \hyperpage{386}
  \item inequality operator, \hyperpage{334}
  \item infinity, \hyperpage{723}
  \item inheritance, \hyperpage{181}, \hyperpage{383}, \hyperpage{385}
  \item inheritance: access to base class member, \hyperpage{390}
  \item inheritance: multiple, \hyperpage{396}
  \item inheritance: no derived class constructors, \hyperpage{392}
  \item inheritance: private derivation, \hyperpage{805}
  \item init, \hyperpage{1004, 1005}
  \item initialization, \hyperpage{169}, \hyperpage{202}, 
		\hyperpage{221}, \hyperpage{337}
  \item initialization: static data member, \hyperpage{190}
  \item initializer list, \hyperpage{39}, \hyperpage{169}
  \item initializer\_list, \hyperpage{171}
  \item initializer\_list: header file, \hyperpage{39}
  \item inline, \hyperpage{178, 179}, \hyperpage{318}, \hyperpage{412}, 
		\hyperpage{482}, \hyperpage{727}
  \item inline function, \hyperpage{179}
  \item inline member functions, \hyperpage{471}
  \item inline-inconsistency, \hyperpage{179}
  \item inline: avoid!, \hyperpage{180}
  \item inline: disadvantage, \hyperpage{180}
  \item inline: static members, \hyperpage{197}
  \item inner\_product, \hyperpage{572}
  \item inplace\_merge, \hyperpage{573}
  \item input, \hyperpage{135}, \hyperpage{142}
  \item input language, \hyperpage{1036}
  \item input\_iterator\_tag, \hyperpage{825}
  \item InputIterator, \hyperpage{490}, \hyperpage{825}
  \item insert, \hyperpage{106}, \hyperpage{341}, \hyperpage{345}, 
		\hyperpage{354}, \hyperpage{359}, \hyperpage{363}, 
		\hyperpage{366}, \hyperpage{368}, \hyperpage{375}, 
		\hyperpage{377}, \hyperpage{380}, \hyperpage{493}
  \item inserter, \hyperpage{492, 493}
  \item inserter: and non-STL classes, \hyperpage{493}
  \item inserter: required types, \hyperpage{493}
  \item inserting streambuf *, \hyperpage{141}
  \item insertion operator, \hyperpage{25}, \hyperpage{112}, 
		\hyperpage{126}, \hyperpage{289}
  \item insertions, \hyperpage{343}
  \item instantiation, \hyperpage{691}, \hyperpage{693}
  \item instantiation declaration, \hyperpage{710}, \hyperpage{755}
  \item instantiation function, \hyperpage{755}
  \item instantiation source, \hyperpage{755}
  \item int32\_t, \hyperpage{55}
  \item INT\_MAX, \hyperpage{722}
  \item integer division, \hyperpage{57}
  \item integral conversions, \hyperpage{745}
  \item integral type, \hyperpage{864}
  \item interface, \hyperpage{151}, \hyperpage{412}
  \item interface functions, \hyperpage{154}
  \item internal, \hyperpage{121}
  \item internal buffer, \hyperpage{128}
  \item internal header, \hyperpage{186}, \hyperpage{1004}
  \item invalid\_argument, \hyperpage{263}
  \item invoke\_result, \hyperpage{670}
  \item iomanip, \hyperpage{119}
  \item iomanip: header file, \hyperpage{115}, \hyperpage{132}
  \item ios, \hyperpage{112}, \hyperpage{115}, \hyperpage{142}, 
		\hyperpage{476}, \hyperpage{709}, \hyperpage{992}
  \item ios object: as bool value, \hyperpage{118}
  \item ios: header file, \hyperpage{114}, \hyperpage{992}
  \item ios::exceptions, \hyperpage{261}
  \item ios::fail, \hyperpage{129}, \hyperpage{139}
  \item ios\_base, \hyperpage{112}, \hyperpage{115}
  \item ios\_base.h, \hyperpage{115}
  \item iosfwd, \hyperpage{97}, \hyperpage{114}
  \item iosfwd: header file, \hyperpage{111}
  \item iostate, \hyperpage{261}
  \item iostream, \hyperpage{16}, \hyperpage{25}, \hyperpage{114}, 
		\hyperpage{128}, \hyperpage{139}, \hyperpage{144}
  \item iostream.h, \hyperpage{16}
  \item iostream: header file, \hyperpage{114}, \hyperpage{126}, 
		\hyperpage{136}
  \item iostream\_category, \hyperpage{267}
  \item iota, \hyperpage{574}
  \item is-a, \hyperpage{405}, \hyperpage{427, 428}
  \item is-implemented-in-terms-of, \hyperpage{427}
  \item is\_abstract, \hyperpage{865}
  \item is\_arithmetic, \hyperpage{865}
  \item is\_array, \hyperpage{865}
  \item is\_assignable, \hyperpage{865}
  \item is\_base\_of, \hyperpage{865}
  \item is\_bounded, \hyperpage{723}
  \item is\_class, \hyperpage{865}
  \item is\_compound, \hyperpage{865}
  \item is\_const, \hyperpage{866}
  \item is\_constructible, \hyperpage{866}
  \item is\_convertible, \hyperpage{866}
  \item is\_copy\_assignable, \hyperpage{866}
  \item is\_copy\_constructible, \hyperpage{866}
  \item is\_default\_constructible, \hyperpage{866}
  \item is\_destructible, \hyperpage{866}
  \item is\_empty, \hyperpage{866}
  \item is\_enum, \hyperpage{866}
  \item is\_error\_code\_enum, \hyperpage{869}
  \item is\_error\_condition\_enum, \hyperpage{870}
  \item is\_exact, \hyperpage{723}
  \item is\_floating\_point, \hyperpage{866}
  \item is\_function, \hyperpage{866}
  \item is\_fundamental, \hyperpage{866}
  \item is\_iec559, \hyperpage{723}
  \item is\_integer, \hyperpage{723}
  \item is\_integral, \hyperpage{866}
  \item is\_literal\_type, \hyperpage{866}
  \item is\_lock\_free, \hyperpage{657}
  \item is\_lvalue\_reference, \hyperpage{866}
  \item is\_member\_function\_pointer, \hyperpage{866}
  \item is\_member\_object\_pointer, \hyperpage{866}
  \item is\_member\_pointer, \hyperpage{866}
  \item is\_modulo, \hyperpage{723}
  \item is\_move\_assignable, \hyperpage{866}
  \item is\_move\_constructible, \hyperpage{866}
  \item is\_nothrow\_... type trait, \hyperpage{864}
  \item is\_nothrow\_assignable, \hyperpage{866}, \hyperpage{874}
  \item is\_nothrow\_constructible, \hyperpage{866}, \hyperpage{874}
  \item is\_nothrow\_copy\_assignable, \hyperpage{874}
  \item is\_nothrow\_copy\_constructible, \hyperpage{867}, 
		\hyperpage{874}
  \item is\_nothrow\_default\_constructible, \hyperpage{867}, 
		\hyperpage{874}
  \item is\_nothrow\_destructible, \hyperpage{867}, \hyperpage{874}
  \item is\_nothrow\_move\_assignable, \hyperpage{867}, \hyperpage{874}
  \item is\_nothrow\_move\_constructible, \hyperpage{867}, 
		\hyperpage{874}
  \item is\_object, \hyperpage{867}
  \item is\_open, \hyperpage{129}, \hyperpage{139}, \hyperpage{443}
  \item is\_partitioned, \hyperpage{574}
  \item is\_permutation, \hyperpage{575}
  \item is\_pod, \hyperpage{867}
  \item is\_pointer, \hyperpage{867}
  \item is\_polymorphic, \hyperpage{867}
  \item is\_reference, \hyperpage{867}
  \item is\_rvalue\_reference, \hyperpage{867}
  \item is\_same, \hyperpage{867}
  \item is\_scalar, \hyperpage{867}
  \item is\_signed, \hyperpage{723}, \hyperpage{867}
  \item is\_sorted, \hyperpage{576}
  \item is\_sorted\_until, \hyperpage{577}
  \item is\_specialized, \hyperpage{723}
  \item is\_standard\_layout, \hyperpage{867}
  \item is\_trivial, \hyperpage{867}
  \item is\_trivially\_assignable, \hyperpage{867}
  \item is\_trivially\_constructible, \hyperpage{867}
  \item is\_trivially\_copy\_assignable, \hyperpage{867}
  \item is\_trivially\_copy\_constructible, \hyperpage{867}
  \item is\_trivially\_copyable, \hyperpage{867}
  \item is\_trivially\_default\_constructible, \hyperpage{867}
  \item is\_trivially\_default\_destructible, \hyperpage{868}
  \item is\_trivially\_move\_assignable, \hyperpage{868}
  \item is\_trivially\_move\_constructible, \hyperpage{868}
  \item is\_union, \hyperpage{868}
  \item is\_unsigned, \hyperpage{868}
  \item is\_void, \hyperpage{868}
  \item is\_volatile, \hyperpage{868}
  \item istream, \hyperpage{112}, \hyperpage{135}, \hyperpage{150}
  \item istream constructor, \hyperpage{136}
  \item istream: header file, \hyperpage{114}, \hyperpage{136}
  \item istream: iterator, \hyperpage{493}
  \item istream\_iterator, \hyperpage{493}
  \item istreambuf\_iterator, \hyperpage{494, 495}
  \item istringstream, \hyperpage{112}, \hyperpage{135}, 
		\hyperpage{140}, \hyperpage{997}
  \item iter\_swap, \hyperpage{577}
  \item iterator, \hyperpage{42}, \hyperpage{335}, \hyperpage{338}, 
		\hyperpage{374}, \hyperpage{469}, \hyperpage{488, 489}
  \item iterator (std::) - deprecated, \hyperpage{488}
  \item iterator: 'using' declarations, \hyperpage{824}
  \item iterator: and generic algorithms, \hyperpage{825}
  \item iterator: as class template, \hyperpage{1028}
  \item iterator: common characteristics, \hyperpage{825}
  \item iterator: generic design, \hyperpage{824}
  \item iterator: header file, \hyperpage{488}, \hyperpage{492}, 
		\hyperpage{824}
  \item iterator: range, \hyperpage{489}
  \item iterator: requirements, \hyperpage{490}, \hyperpage{825}
  \item iterator: to const elements, \hyperpage{490}
  \item iterator: types, \hyperpage{490}
  \item iterator\_category, \hyperpage{824}
  \item iterator\_tag, \hyperpage{824}
  \item iterators: forward \textless{}-\textgreater{} reverse, 
		\hyperpage{489}

  \indexspace

  \item Java, \hyperpage{421}
  \item Java interface, \hyperpage{412}
  \item jmp\_buf, \hyperpage{250}
  \item join, \hyperpage{628}, \hyperpage{633}
  \item joinable, \hyperpage{628}, \hyperpage{633}
  \item Josutis, N., \hyperpage{835}
  \item jthread, \hyperpage{632}

  \indexspace

  \item Kendall's Advanced Theory of Statistics, \hyperpage{528}
  \item key, \hyperpage{355}
  \item Key type, \hyperpage{378}
  \item key, value, \hyperpage{355}
  \item key\_comp, \hyperpage{360}, \hyperpage{366}
  \item key\_equal, \hyperpage{375}
  \item keywords, \hyperpage{60}
  \item kludge, \hyperpage{299}
  \item Koenig lookup, \hyperpage{66}

  \indexspace

  \item L, \hyperpage{53}
  \item Lakos, J., \hyperpage{152}, \hyperpage{186}
  \item lambda expression, \hyperpage{322}
  \item lambda function, \hyperpage{569}
  \item lambda-declarator, \hyperpage{322}
  \item lambda-introducer, \hyperpage{322}
  \item lambda: access variables, \hyperpage{324}
  \item lambda: capture =, this, \hyperpage{325}
  \item lambda: generic, \hyperpage{758}
  \item lambda: mutable, \hyperpage{323}
  \item last\_write\_time, \hyperpage{90}
  \item late binding, \hyperpage{405}, \hyperpage{407}, \hyperpage{813}
  \item late-specified return type, \hyperpage{43}, \hyperpage{324}, 
		\hyperpage{700}
  \item launch, \hyperpage{670}
  \item left, \hyperpage{121}
  \item left hand side, \hyperpage{37}
  \item left-hand, \hyperpage{334}
  \item leftover, \hyperpage{595}, \hyperpage{613}
  \item length, \hyperpage{106}
  \item length\_error, \hyperpage{107}, \hyperpage{263}
  \item less, \hyperpage{486}
  \item less-than operator, \hyperpage{334}
  \item less\_equal, \hyperpage{486}
  \item letters in literal constants, \hyperpage{53}
  \item Lewis, P.A.W., \hyperpage{529}
  \item lex, \hyperpage{1031}, \hyperpage{1037}
  \item lexical scanner specification file, \hyperpage{1033}
  \item lexicographical\_compare, \hyperpage{578}
  \item lhs, \hyperpage{37}
  \item library, \hyperpage{187}
  \item lifetime: anonymous objects, \hyperpage{176}
  \item LIFO, \hyperpage{333}, \hyperpage{369}
  \item limits: header file, \hyperpage{722}
  \item linear chaining, \hyperpage{372}
  \item linear search, \hyperpage{316}, \hyperpage{318}
  \item linear\_congruential\_engine, \hyperpage{528}
  \item linker: removing identical template instantiations, 
		\hyperpage{712}
  \item Linux, \hyperpage{6}
  \item Liskov Substitution Principle, \hyperpage{405}, \hyperpage{427}
  \item Lisp, \hyperpage{7}
  \item list, \hyperpage{342}
  \item list constructors, \hyperpage{344}
  \item list container, \hyperpage{342}
  \item list: circular, \hyperpage{342}
  \item list: header file, \hyperpage{342}
  \item list: traversal, \hyperpage{342}
  \item literal constants, \hyperpage{53}
  \item literal float using F, \hyperpage{53}
  \item literal floating point value using E, \hyperpage{53}
  \item literal long int using L, \hyperpage{53}
  \item literal operator, \hyperpage{330}
  \item literal suffix, \hyperpage{100}
  \item literal type, \hyperpage{864}
  \item literal unsigned using U, \hyperpage{53}
  \item literal wchar\_t string L, \hyperpage{53}
  \item literals namespace, \hyperpage{100}
  \item load, \hyperpage{657}
  \item load\_factor, \hyperpage{375}
  \item local arrays, \hyperpage{204}
  \item local class, \hyperpage{181}, \hyperpage{402}
  \item local context, \hyperpage{626}
  \item local function, \hyperpage{326}
  \item local type, \hyperpage{703}
  \item local variables, \hyperpage{16}, \hyperpage{745}
  \item localtime, \hyperpage{132}
  \item lock, \hyperpage{637}, \hyperpage{643, 644}, \hyperpage{647}, 
		\hyperpage{653}
  \item lock (function), \hyperpage{643}
  \item lock count, \hyperpage{637}
  \item lock\_guard, \hyperpage{641}
  \item lock\_shared, \hyperpage{640}
  \item log, \hyperpage{382}
  \item logic\_error, \hyperpage{263}
  \item logical function object, \hyperpage{486}
  \item logical operators, \hyperpage{486}
  \item logical\_and, \hyperpage{487}
  \item logical\_not, \hyperpage{487}
  \item logical\_or, \hyperpage{487}
  \item lognormal\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{537}
  \item long double, \hyperpage{52}
  \item long long, \hyperpage{52}
  \item long long int, \hyperpage{55}
  \item longjmp, \hyperpage{247}, \hyperpage{250}
  \item lower\_bound, \hyperpage{360}, \hyperpage{367}, \hyperpage{579}
  \item lowest, \hyperpage{723}
  \item lsearch, \hyperpage{316}
  \item lseek, \hyperpage{993}
  \item LSP, \hyperpage{405}, \hyperpage{427}
  \item Ludlum, \hyperpage{66}
  \item lvalue, \hyperpage{34}, \hyperpage{36}, \hyperpage{285}, 
		\hyperpage{298}, \hyperpage{491}, \hyperpage{501}
  \item lvalue reference, \hyperpage{34}
  \item lvalue transformations, \hyperpage{704}, \hyperpage{745}
  \item lvalue-to-rvalue transformation, \hyperpage{704}
  \item lvalue: distinguish from rvalue, \hyperpage{1026}

  \indexspace

  \item macro, \hyperpage{14}, \hyperpage{192}, \hyperpage{320}
  \item main, \hyperpage{10, 11}
  \item make, \hyperpage{7}
  \item make\_error\_code, \hyperpage{83}
  \item make\_error\_condition, \hyperpage{267}
  \item make\_exception\_ptr, \hyperpage{269, 270}
  \item make\_heap, \hyperpage{618}
  \item make\_move\_iterator, \hyperpage{496}
  \item make\_shared, \hyperpage{508}
  \item make\_signed, \hyperpage{868}
  \item make\_unique, \hyperpage{508}
  \item make\_unsigned, \hyperpage{868}
  \item malloc, \hyperpage{201, 202}, \hyperpage{207}, \hyperpage{211}, 
		\hyperpage{215}
  \item manipulator, \hyperpage{112}, \hyperpage{152}, \hyperpage{318}
  \item manipulator: as objects, \hyperpage{320}
  \item map, \hyperpage{355}
  \item map constructors, \hyperpage{356}
  \item map: header file, \hyperpage{355}, \hyperpage{363}
  \item marked sub-expression, \hyperpage{515}, \hyperpage{519}
  \item Marshall Cline, \hyperpage{23}
  \item match\_any, \hyperpage{522}
  \item match\_continuous, \hyperpage{522}
  \item match\_default, \hyperpage{522}
  \item match\_flag\_type, \hyperpage{522}
  \item match\_not\_bol, \hyperpage{522}
  \item match\_not\_bow, \hyperpage{522}
  \item match\_not\_eol, \hyperpage{522}
  \item match\_not\_eow, \hyperpage{522}
  \item match\_not\_null, \hyperpage{522}
  \item match\_prev\_avail, \hyperpage{522}
  \item match\_results, \hyperpage{519}
  \item matched, \hyperpage{1038}
  \item mathematical functions, \hyperpage{382}
  \item max, \hyperpage{529}, \hyperpage{581}, \hyperpage{723}
  \item max-heap, \hyperpage{550}, \hyperpage{618}
  \item max\_bucket\_count, \hyperpage{375}
  \item max\_element, \hyperpage{582}
  \item max\_exponent, \hyperpage{724}
  \item max\_exponent10, \hyperpage{724}
  \item max\_load\_factor, \hyperpage{376}
  \item max\_size, \hyperpage{106}, \hyperpage{334}, \hyperpage{341}, 
		\hyperpage{345}, \hyperpage{354}, \hyperpage{360}, 
		\hyperpage{367}, \hyperpage{376}
  \item maybe\_unused, \hyperpage{51}
  \item member function, \hyperpage{27}, \hyperpage{97}, 
		\hyperpage{151}, \hyperpage{344}, \hyperpage{349}, 
		\hyperpage{431}, \hyperpage{502}, \hyperpage{505}
  \item member function: available, \hyperpage{401}
  \item member function: called explicitly, \hyperpage{395}
  \item member function: identically named, \hyperpage{398}
  \item member function: overloading, \hyperpage{13}
  \item member function: pure virtual implementation, \hyperpage{413}
  \item member functions, \hyperpage{352}
  \item member initializer, \hyperpage{164}
  \item member initializer: using { }, \hyperpage{165}
  \item member template, \hyperpage{746}
  \item member: const, \hyperpage{155}
  \item member: in-class, \hyperpage{178}
  \item member: overriding, \hyperpage{410}
  \item memcpy, \hyperpage{226}, \hyperpage{274}
  \item memory allocation, \hyperpage{201}
  \item memory buffers, \hyperpage{112}
  \item memory consumption, \hyperpage{446}
  \item memory leak, \hyperpage{201, 202}, \hyperpage{205}, 
		\hyperpage{212}, \hyperpage{255}, \hyperpage{258}, 
		\hyperpage{335}, \hyperpage{411}, \hyperpage{497}, 
		\hyperpage{508}
  \item memory: header file, \hyperpage{207}, \hyperpage{497}, 
		\hyperpage{502}, \hyperpage{508}, \hyperpage{611}, 
		\hyperpage{851}
  \item memory: initialization, \hyperpage{203}
  \item memory\_order, \hyperpage{658}
  \item merge, \hyperpage{345}, \hyperpage{583}
  \item merging, \hyperpage{551}
  \item mersenne\_twister\_engine, \hyperpage{528}
  \item message, \hyperpage{266}
  \item min, \hyperpage{529}, \hyperpage{581}, \hyperpage{724}
  \item min\_element, \hyperpage{582}
  \item min\_exponent, \hyperpage{724}
  \item min\_exponent10, \hyperpage{724}
  \item MinGW, \hyperpage{6}
  \item mini scanner, \hyperpage{1033}
  \item minmax, \hyperpage{584}
  \item minmax\_element, \hyperpage{582}, \hyperpage{584}
  \item minus, \hyperpage{485}
  \item mixing \textbf{C} and \textbf{C++} I/O, \hyperpage{114}
  \item modifier, \hyperpage{290}
  \item module compiled system header, \hyperpage{962}
  \item module flag, \hyperpage{958}
  \item module interface unit, \hyperpage{959}
  \item module mapper, \hyperpage{979}
  \item module partition interface unit, \hyperpage{959}
  \item module: frame, \hyperpage{960}
  \item module: system header, \hyperpage{963}
  \item modulus, \hyperpage{485}
  \item move, \hyperpage{231}, \hyperpage{586}
  \item move assignment, \hyperpage{232}
  \item move constructor, \hyperpage{229}, \hyperpage{391}
  \item move semantics, \hyperpage{35}, \hyperpage{227}
  \item move-aware, \hyperpage{36}, \hyperpage{233}
  \item move: design principle, \hyperpage{236}
  \item move\_backward, \hyperpage{586}
  \item MS-Windows, \hyperpage{6}, \hyperpage{130}, \hyperpage{145}
  \item mt19937, \hyperpage{529}, \hyperpage{600}
  \item Multi, \hyperpage{888}
  \item multimap, \hyperpage{363}
  \item multimap: no operator[], \hyperpage{363}
  \item multiple inheritance, \hyperpage{396}
  \item multiple inheritance: vtable, \hyperpage{447}
  \item multiplexing, \hyperpage{1010}
  \item multiplies, \hyperpage{485}
  \item multiset, \hyperpage{367}
  \item multiset::iterator, \hyperpage{368}
  \item mutable, \hyperpage{182}
  \item mutex, \hyperpage{635}, \hyperpage{643}, \hyperpage{647}
  \item mutex: header file, \hyperpage{635}, \hyperpage{637}, 
		\hyperpage{640}, \hyperpage{644}, \hyperpage{648}
  \item mutex\_type, \hyperpage{641}

  \indexspace

  \item name, \hyperpage{266}
  \item name conflicts, \hyperpage{24}
  \item name mangling, \hyperpage{12}
  \item name-independent declaration, \hyperpage{644}
  \item name-independent declarations, \hyperpage{18}
  \item name: fully qualified, \hyperpage{696}
  \item named constant expression, \hyperpage{193}
  \item namespace, \hyperpage{24}, \hyperpage{63}, \hyperpage{187}
  \item namespace alias, \hyperpage{71}
  \item namespace declarations, \hyperpage{64}
  \item namespace this\_thread, \hyperpage{622}
  \item namespace: anonymous, \hyperpage{64}
  \item namespace: closed, \hyperpage{64}
  \item namespace: import all names, \hyperpage{65}
  \item NaN, \hyperpage{723}
  \item narrowing conversion, \hyperpage{40}
  \item native\_handle, \hyperpage{628}, \hyperpage{633}
  \item negate, \hyperpage{485}
  \item negative\_binomial\_distribution\textless{}IntType = int\textgreater{}, 
		\hyperpage{539}
  \item negator, \hyperpage{487}
  \item nested blocks, \hyperpage{17}
  \item nested class, \hyperpage{469}
  \item nested class: declaration, \hyperpage{472}
  \item nested class: member access, \hyperpage{474}
  \item nested class: static members, \hyperpage{471}
  \item nested container, \hyperpage{356}
  \item nested derivation, \hyperpage{386}
  \item nested enumerations, \hyperpage{476}
  \item nested functions, \hyperpage{181}
  \item nested inheritance, \hyperpage{416}
  \item nested trait class, \hyperpage{860}
  \item nesting depth, \hyperpage{1032}
  \item new, \hyperpage{201, 202}, \hyperpage{309}
  \item new Type[0], \hyperpage{204}
  \item new-style casts, \hyperpage{57}
  \item new: and exceptions, \hyperpage{272}
  \item new: header file, \hyperpage{262}
  \item new: placement, \hyperpage{207}, \hyperpage{310}
  \item new[], \hyperpage{203--205}, \hyperpage{309}
  \item new[]: and exceptions, \hyperpage{315}
  \item new[]: and non-default constructors, \hyperpage{401}
  \item next\_permutation, \hyperpage{587}
  \item Nichols, B, \hyperpage{621}
  \item nm, \hyperpage{790}
  \item no arguments depending on a template parameter, \hyperpage{836}
  \item no buffering, \hyperpage{434}
  \item no\_state, \hyperpage{665, 666}
  \item noAlarm, \hyperpage{1012}
  \item noboolalpha, \hyperpage{122}
  \item nodiscard, \hyperpage{51}
  \item noexcept, \hyperpage{261}, \hyperpage{873}
  \item non-constant member functions, \hyperpage{413}
  \item non-local return, \hyperpage{247}
  \item none\_of, \hyperpage{555}
  \item noopt, \hyperpage{192}
  \item noreturn, \hyperpage{52}
  \item norm, \hyperpage{382}
  \item normal\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{538}
  \item noshowbase, \hyperpage{122}
  \item noshowpoint, \hyperpage{123}
  \item noshowpos, \hyperpage{123}
  \item not, \hyperpage{332}
  \item Not-a-Number, \hyperpage{723}
  \item not\_eq, \hyperpage{332}
  \item not\_equal\_to, \hyperpage{486}
  \item not\_fn, \hyperpage{487}
  \item nothrow guarantee, \hyperpage{274}
  \item notify\_all, \hyperpage{651}, \hyperpage{653}, \hyperpage{655}
  \item notify\_all\_at\_thread\_exit, \hyperpage{650}
  \item notify\_one, \hyperpage{651}, \hyperpage{653}
  \item nounitbuf, \hyperpage{124}
  \item nouppercase, \hyperpage{123}
  \item now, \hyperpage{77}
  \item npos, \hyperpage{98}
  \item nReady, \hyperpage{1011}
  \item NTBS, \hyperpage{48}
  \item nth\_element, \hyperpage{589}
  \item NULL, \hyperpage{14}, \hyperpage{192}, \hyperpage{201}
  \item null-bytes, \hyperpage{128}
  \item nullptr, \hyperpage{14}
  \item NullType, \hyperpage{876}
  \item numeric: header file, \hyperpage{549}
  \item numeric\_limits, \hyperpage{722}

  \indexspace

  \item O0, \hyperpage{192}
  \item object, \hyperpage{19}
  \item object hierarchy, \hyperpage{383}
  \item object oriented approach, \hyperpage{9}
  \item object: address, \hyperpage{219}
  \item object: allocation, \hyperpage{202}
  \item object: anonymous, \hyperpage{175}
  \item object: assign, \hyperpage{216}
  \item object: parameter, \hyperpage{222}
  \item object: static/global, \hyperpage{154}
  \item oct, \hyperpage{122}
  \item octal constant, \hyperpage{49}
  \item off\_type, \hyperpage{128}, \hyperpage{138}
  \item ofstream, \hyperpage{126}, \hyperpage{128}, \hyperpage{149}
  \item ofstream constructors, \hyperpage{128}
  \item once\_flag, \hyperpage{637}
  \item one definition rule, \hyperpage{151}, \hyperpage{709}
  \item open, \hyperpage{129}, \hyperpage{139}, \hyperpage{443}, 
		\hyperpage{987}
  \item openmode, \hyperpage{130}, \hyperpage{443}
  \item operator, \hyperpage{218}, \hyperpage{487}, 
		\hyperxindexformat{\=}{658}
  \item operator and, \hyperpage{332}
  \item operator and\_eq, \hyperpage{332}
  \item operator bitand, \hyperpage{332}
  \item operator bitor, \hyperpage{332}
  \item operator bool, \hyperpage{501}, \hyperpage{505}, 
		\hyperpage{647}
  \item operator bool [coroutine], \hyperpage{927}
  \item operator co\_await, \hyperpage{937}
  \item operator compl, \hyperpage{332}
  \item operator delete, \hyperpage{207}, \hyperpage{311}
  \item operator delete[], \hyperpage{313}
  \item operator new, \hyperpage{206}, \hyperpage{262}, \hyperpage{309}
  \item operator new(sizeInBytes), \hyperpage{203}
  \item operator new[], \hyperpage{312}
  \item operator not, \hyperpage{332}
  \item operator not\_eq, \hyperpage{332}
  \item operator or, \hyperpage{332}
  \item operator or\_eq, \hyperpage{332}
  \item operator overloading, \hyperpage{218}, \hyperpage{285}
  \item operator overloading: within classes only, \hyperpage{332}
  \item operator path const \&(), \hyperpage{92}
  \item operator xor, \hyperpage{332}
  \item operator xor\_eq, \hyperpage{332}
  \item operator!=, \hyperpage{317}, \hyperpage{486}, \hyperpage{490}
  \item operator"sv, \hyperpage{110}
  \item operator%, \hyperpage{485}
  \item operator(), \hyperpage{316}, \hyperpage{318}
  \item operator() [coroutine], \hyperpage{928}
  \item operator*, \hyperpage{382}, \hyperpage{485}, \hyperpage{490}, 
		\hyperpage{501}, \hyperpage{505}
  \item operator*=, \hyperpage{382}
  \item operator+, \hyperpage{300}, \hyperpage{382}, 
		\hyperpage{484, 485}, \hyperpage{552}, \hyperpage{594}
  \item operator++, \hyperpage{298}, \hyperpage{490}, \hyperpage{658}
  \item operator+=, \hyperpage{382}, \hyperpage{658}
  \item operator-, \hyperpage{382}, \hyperpage{485}
  \item operator-=, \hyperpage{382}, \hyperpage{658}
  \item operator-\textgreater{}, \hyperpage{501}, \hyperpage{505}
  \item operator-{}-{}, \hyperpage{298}, \hyperpage{658}
  \item operator/, \hyperpage{382}, \hyperpage{485}
  \item operator/=, \hyperpage{382}
  \item operator: free, \hyperpage{301}
  \item operator: keywords, \hyperpage{60}
  \item operator=, \hyperpage{501}, \hyperpage{505}
  \item operator==, \hyperpage{486}, \hyperpage{490}, \hyperpage{600}, 
		\hyperpage{613, 614}
  \item operator== (default), \hyperpage{371}
  \item operator[], \hyperpage{285}, \hyperpage{288}, \hyperpage{291}, 
		\hyperpage{851}, \hyperpage{1026}
  \item operator\&, \hyperpage{30}, \hyperpage{33}
  \item operator\&=, \hyperpage{658}
  \item operator\&\&, \hyperpage{487}
  \item operator\^=, \hyperpage{658}
  \item operator\textgreater{}, \hyperpage{486}
  \item operator\textgreater{}=, \hyperpage{486}
  \item operator\textgreater{}\textgreater{}, \hyperpage{136}, 
		\hyperpage{290}, \hyperpage{382}
  \item operator\textless{}, \hyperpage{355}, \hyperpage{377}, 
		\hyperpage{486}, \hyperpage{582, 583}, \hyperpage{587}, 
		\hyperpage{590}, \hyperpage{602--604}, \hyperpage{606}, 
		\hyperpage{615}, \hyperpage{618, 619}
  \item operator\textless{}=, \hyperpage{486}
  \item operator\textless{}\textless{}, \hyperpage{382}
  \item operators of containers, \hyperpage{334}
  \item operators: textual alternatives, \hyperpage{332}
  \item optional: header file, \hyperpage{544}
  \item options, \hyperpage{93}, \hyperpage{1033}
  \item or, \hyperpage{332}
  \item or\_eq, \hyperpage{332}
  \item ordered pair, \hyperpage{382}
  \item ordering: strict, \hyperpage{909}, \hyperpage{911}
  \item ordinary class, \hyperpage{691}, \hyperpage{706}
  \item ordinary function, \hyperpage{691}
  \item ostream, \hyperpage{112}, \hyperpage{114}, \hyperpage{116}, 
		\hyperpage{126}, \hyperpage{150}, \hyperpage{319}, 
		\hyperpage{412}
  \item ostream constructor, \hyperpage{126}
  \item ostream coupling, \hyperpage{142}
  \item ostream: define using 0-pointer, \hyperpage{126}, 
		\hyperpage{136}
  \item ostream: header file, \hyperpage{114}, \hyperpage{126}
  \item ostream\_iterator, \hyperpage{495}
  \item ostreambuf\_iterator, \hyperpage{495}
  \item ostringstream, \hyperpage{112}, \hyperpage{126}, 
		\hyperpage{130, 131}
  \item out, \hyperpage{130}, \hyperpage{144}
  \item out of memory, \hyperpage{215}
  \item out-of-line functions, \hyperpage{180}
  \item out\_of\_range, \hyperpage{263}
  \item output, \hyperpage{142}
  \item output formatting, \hyperpage{112}, \hyperpage{115}
  \item output\_iterator\_tag, \hyperpage{826}
  \item OutputIterator, \hyperpage{491}, \hyperpage{826}
  \item overflow, \hyperpage{430}, \hyperpage{434}, \hyperpage{985}, 
		\hyperpage{987}
  \item overflow\_error, \hyperpage{263}
  \item overloadable operators, \hyperpage{331}
  \item overloaded assignment, \hyperpage{334}
  \item overloading: by const attribute, \hyperpage{13}
  \item overloading: function template, \hyperpage{714}
  \item overpopulation, \hyperpage{621}, \hyperpage{660}
  \item override, \hyperpage{407}, \hyperpage{414}
  \item overriding members, \hyperpage{410}
  \item overview of generic algorithms, \hyperpage{334}
  \item owns\_lock, \hyperpage{643}

  \indexspace

  \item p, \hyperpage{53}
  \item packaged\_task, \hyperpage{672}
  \item padding, \hyperpage{119}
  \item pair, \hyperpage{335}, \hyperpage{356}
  \item pair container, \hyperpage{333}, \hyperpage{335}
  \item pair\textless{}map::iterator, bool\textgreater{}, 
		\hyperpage{359}
  \item pair\textless{}set::iterator, bool\textgreater{}, 
		\hyperpage{366}
  \item pair\textless{}type1, type2\textgreater{}, \hyperpage{336}
  \item parameter list, \hyperpage{12}
  \item parameter pack, \hyperpage{775}
  \item parameter pack: not expanded, \hyperpage{781}
  \item parameter pack: rvalue reference, \hyperpage{778}
  \item parameter: ellipsis, \hyperpage{862}
  \item parent process, \hyperpage{1001}, \hyperpage{1003}
  \item ParentSlurp, \hyperpage{1008}
  \item parse(), \hyperpage{1032}
  \item parse-tree, \hyperpage{985}
  \item parser, \hyperpage{985}, \hyperpage{1031}, \hyperpage{1036}
  \item parser generator, \hyperpage{1031, 1032}, \hyperpage{1036}
  \item partial class template specialization, \hyperpage{765}
  \item partial specialization, \hyperpage{768}
  \item partial\_ordering, \hyperpage{512}
  \item partial\_sort, \hyperpage{589}
  \item partial\_sort\_copy, \hyperpage{589}
  \item partial\_sum, \hyperpage{590}
  \item partition, \hyperpage{591}, \hyperpage{971}
  \item partition interface unit, \hyperpage{972}
  \item partition: syntax, \hyperpage{971}
  \item partition\_copy, \hyperpage{593}
  \item partition\_point, \hyperpage{591}
  \item Pascal, \hyperpage{181}
  \item path, \hyperpage{86}, \hyperpage{92}
  \item pbackfail, \hyperpage{431}
  \item pbase, \hyperpage{434}, \hyperpage{987}
  \item pbump, \hyperpage{434}, \hyperpage{987}
  \item peculiar syntax, \hyperpage{318}
  \item peek, \hyperpage{137}
  \item perfect forwarding, \hyperpage{35}, \hyperpage{708}, 
		\hyperpage{778}
  \item perfect forwarding: inheritance, \hyperpage{780}
  \item perfect forwarding: to data members, \hyperpage{784}
  \item perm\_options, \hyperpage{84}
  \item permissions, \hyperpage{84}, \hyperpage{90}
  \item perms, \hyperpage{83}
  \item permuting, \hyperpage{551}
  \item pimpl, \hyperpage{428}
  \item pipe, \hyperpage{985}, \hyperpage{1006}
  \item placement new, \hyperpage{207}, \hyperpage{310}, 
		\hyperpage{312, 313}, \hyperpage{852}
  \item placement new: generic algorithms, \hyperpage{611}
  \item plain old data, \hyperpage{245}, \hyperpage{867}
  \item plus, \hyperpage{483}, \hyperpage{485}
  \item pod, \hyperpage{245}
  \item point of instantiation, \hyperpage{711}, \hyperpage{726}, 
		\hyperpage{792}
  \item pointer, \hyperpage{824}
  \item pointer as iterator, \hyperpage{490}
  \item pointer in disguise, \hyperpage{400}
  \item pointer juggling, \hyperpage{857}
  \item pointer protection, \hyperpage{43}
  \item pointer: to an object, \hyperpage{401}
  \item pointer: to class template, \hyperpage{790}
  \item pointer: to data member, \hyperpage{459}
  \item pointer: to deleted memory, \hyperpage{216}
  \item pointer: to function, \hyperpage{198}, \hyperpage{316}, 
		\hyperpage{319}
  \item pointer: to member, \hyperpage{457}, \hyperpage{862}
  \item pointer: to member field selector, \hyperpage{460}
  \item pointer: to member: assignment, \hyperpage{459}
  \item pointer: to member: defining, \hyperpage{458}
  \item pointer: to member: size, \hyperpage{464}
  \item pointer: to object, \hyperpage{312}, \hyperpage{761}
  \item pointer: to policy base class, \hyperpage{856}
  \item pointer: to virtual member, \hyperpage{460}
  \item pointer: wild, \hyperpage{497}, \hyperpage{508}
  \item poisson\_distribution\textless{}IntType = int\textgreater{}, 
		\hyperpage{539}
  \item polar, \hyperpage{382}
  \item policy, \hyperpage{851}, \hyperpage{853}
  \item policy class: defining structure, \hyperpage{857}
  \item polymorphism, \hyperpage{405}, \hyperpage{443}
  \item polymorphism: bypassing, \hyperpage{838}
  \item polymorphism: dynamic, \hyperpage{735}
  \item polymorphism: how, \hyperpage{446}
  \item polymorphism: static, \hyperpage{735}
  \item polymorphous wrapper, \hyperpage{724}
  \item pop, \hyperpage{93}, \hyperpage{349}, \hyperpage{352}, 
		\hyperpage{370}
  \item pop\_back, \hyperpage{106}, \hyperpage{341}, \hyperpage{346}, 
		\hyperpage{354}
  \item pop\_front, \hyperpage{346}, \hyperpage{354}
  \item pop\_heap, \hyperpage{619}
  \item pos\_type, \hyperpage{138}
  \item POSIX, \hyperpage{55}
  \item postponing decisions, \hyperpage{247}
  \item pow, \hyperpage{382}
  \item power specification using p, \hyperpage{53}
  \item pptr, \hyperpage{434}, \hyperpage{987}
  \item precision, \hyperpage{120}
  \item precompiled header, \hyperpage{709}
  \item predefined function object, \hyperpage{482}
  \item predicate, \hyperpage{316}
  \item preprocessor, \hyperpage{192}, \hyperpage{320}
  \item preprocessor directive, \hyperpage{15}, \hyperpage{1033}
  \item preprocessor directive: error vs. static\_assert, 
		\hyperpage{721}
  \item prev\_permutation, \hyperpage{587}
  \item primitive types, \hyperpage{52}
  \item print, \hyperpage{127}
  \item printf, \hyperpage{11}, \hyperpage{26}, \hyperpage{775}
  \item priority queue data structure, \hyperpage{350}
  \item priority rules, \hyperpage{350}
  \item priority\_queue, \hyperpage{350, 351}
  \item private, \hyperpage{27}, \hyperpage{822}
  \item private backdoor, \hyperpage{288}
  \item private derivation, \hyperpage{398}
  \item private derivation: too restrictive, \hyperpage{389}
  \item private inheritance, \hyperpage{427}
  \item private members, \hyperpage{793}
  \item probability density function, \hyperpage{528}
  \item problem analysis, \hyperpage{383}
  \item procedural approach, \hyperpage{8}
  \item process ID, \hyperpage{1001}
  \item process id, \hyperpage{1002}
  \item profiler, \hyperpage{179}, \hyperpage{344}
  \item Prolog, \hyperpage{7}
  \item promise, \hyperpage{676}
  \item promise (coroutine), \hyperpage{936}
  \item promise [coroutine], \hyperpage{927}
  \item promise\_already\_satisfied, \hyperpage{666}
  \item promise\_type, \hyperpage{926}
  \item promise\_type (coroutine), \hyperpage{926}
  \item promotion, \hyperpage{297}
  \item promotions, \hyperpage{745}
  \item protected, \hyperpage{27}, \hyperpage{388}, \hyperpage{989}
  \item protected derivation: too restrictive, \hyperpage{389}
  \item protocol, \hyperpage{412}
  \item Prototype design pattern, \hyperpage{450}
  \item prototyping, \hyperpage{6}
  \item Proxy Design Pattern, \hyperpage{1026}
  \item Proxy: stream insertion and extraction, \hyperpage{1027}
  \item prvalue, \hyperpage{37}
  \item pthread\_getschedparam, \hyperpage{628}
  \item pthread\_setschedparam, \hyperpage{628}
  \item pthreads, \hyperpage{621}
  \item Pthreads Programming, \hyperpage{621}
  \item public, \hyperpage{27}, \hyperpage{191}, \hyperpage{398}
  \item pubseekoff, \hyperpage{430}, \hyperpage{435}
  \item pubseekpos, \hyperpage{430}
  \item pubsetbuf, \hyperpage{430}
  \item pubsync, \hyperpage{430}
  \item pure rvalue, \hyperpage{37}
  \item pure virtual functions, \hyperpage{412}
  \item pure virtual member: implementation, \hyperpage{413}
  \item push, \hyperpage{350}, \hyperpage{352}, \hyperpage{370}
  \item push\_back, \hyperpage{106}, \hyperpage{341}, \hyperpage{346}, 
		\hyperpage{354}, \hyperpage{492}
  \item push\_front, \hyperpage{346}, \hyperpage{354}, \hyperpage{493}
  \item push\_heap, \hyperpage{619}
  \item put, \hyperpage{127}
  \item put\_time, \hyperpage{132}
  \item putback, \hyperpage{137}, \hyperpage{994}

  \indexspace

  \item qsort, \hyperpage{791}
  \item qsort(), \hyperpage{198}
  \item Qt, \hyperpage{153}
  \item qualification conversions, \hyperpage{745}
  \item qualification transformation, \hyperpage{705}
  \item queue, \hyperpage{348, 349}
  \item queue data structure, \hyperpage{348}
  \item queue: header file, \hyperpage{348}, \hyperpage{350}
  \item quiet\_NaN, \hyperpage{724}
  \item quoted, \hyperpage{125}

  \indexspace

  \item radix, \hyperpage{119}, \hyperpage{724}
  \item rand, \hyperpage{528}
  \item random, \hyperpage{343}
  \item random access, \hyperpage{491}
  \item random: header file, \hyperpage{527}, \hyperpage{529}
  \item random\_access\_iterator\_tag, \hyperpage{826}
  \item RandomAccessIterator, \hyperpage{491}, \hyperpage{826}, 
		\hyperpage{828}
  \item RandomIterator, \hyperpage{1028}
  \item range, \hyperpage{46}
  \item range of values, \hyperpage{339}
  \item range-based for-loop, \hyperpage{46}
  \item range\_error, \hyperpage{263}
  \item ratio, \hyperpage{74}
  \item ratio: den, \hyperpage{74}
  \item ratio: header file, \hyperpage{74}
  \item ratio: num, \hyperpage{74}
  \item raw memory, \hyperpage{203}, \hyperpage{206}
  \item raw string literal, \hyperpage{48}
  \item rbegin, \hyperpage{106}, \hyperpage{338}, \hyperpage{341}, 
		\hyperpage{346}, \hyperpage{354}, \hyperpage{360}, 
		\hyperpage{367}, \hyperpage{489}, \hyperpage{831}
  \item rdbuf, \hyperpage{115}, \hyperpage{142, 143}, \hyperpage{1004}
  \item rdstate, \hyperpage{118}
  \item read, \hyperpage{137}
  \item read first, test later, \hyperpage{141}
  \item read\_symlink, \hyperpage{90}
  \item readFd, \hyperpage{1012}
  \item reading and writing, \hyperpage{114}
  \item readsome, \hyperpage{137}
  \item real, \hyperpage{382}
  \item real part, \hyperpage{381, 382}
  \item realloc, \hyperpage{215}
  \item recompilation, \hyperpage{386}
  \item recursion\_pending, \hyperpage{93}
  \item recursive\_mutex, \hyperpage{636}
  \item recursive\_timed\_mutex, \hyperpage{636}
  \item redirection, \hyperpage{143}, \hyperpage{1004}
  \item reduce, \hyperpage{593}
  \item ref(arg), \hyperpage{702}
  \item reference, \hyperpage{30}, \hyperpage{319}, \hyperpage{400}, 
		\hyperpage{824}
  \item reference binding, \hyperpage{305}
  \item reference operator, \hyperpage{30}
  \item reference parameter, \hyperpage{166}
  \item reference qualifier, \hyperpage{305}
  \item reference wrapper, \hyperpage{702}
  \item reference: to class template, \hyperpage{790}
  \item regcomp, \hyperpage{513}
  \item regex, \hyperpage{516}
  \item regex: header file, \hyperpage{513}, \hyperpage{516}, 
		\hyperpage{519}, \hyperpage{521}
  \item regex\_constants, \hyperpage{517}
  \item regex\_match, \hyperpage{521, 522}
  \item regex\_replace, \hyperpage{522}, \hyperpage{526}
  \item regex\_search, \hyperpage{521}, \hyperpage{523}
  \item regexec, \hyperpage{513}
  \item register, \hyperpage{60}
  \item regular expression, \hyperpage{1033}
  \item rehash, \hyperpage{376}
  \item reinterpret\_cast, \hyperpage{841}
  \item reinterpret\_to\_smaller\_cast, \hyperpage{841}
  \item relational function object, \hyperpage{486}
  \item relationship between code and data, \hyperpage{383}
  \item relative address, \hyperpage{459}
  \item release, \hyperpage{502}, \hyperpage{643}, \hyperpage{647}
  \item remove, \hyperpage{90}, \hyperpage{346}, \hyperpage{594}
  \item remove\_all, \hyperpage{90}
  \item remove\_all\_extents, \hyperpage{868}
  \item remove\_const, \hyperpage{868}
  \item remove\_copy, \hyperpage{594}
  \item remove\_copy\_if, \hyperpage{594}
  \item remove\_cv, \hyperpage{868}
  \item remove\_extent, \hyperpage{868}
  \item remove\_if, \hyperpage{346}, \hyperpage{594}
  \item remove\_pointer, \hyperpage{868}
  \item remove\_prefix, \hyperpage{110}
  \item remove\_reference, \hyperpage{868}
  \item remove\_suffix, \hyperpage{110}
  \item remove\_volatile, \hyperpage{868}
  \item rename, \hyperpage{91}
  \item rend, \hyperpage{106}, \hyperpage{338}, \hyperpage{341}, 
		\hyperpage{346}, \hyperpage{354}, \hyperpage{358}, 
		\hyperpage{360}, \hyperpage{367}, \hyperpage{489}, 
		\hyperpage{831}
  \item renew, \hyperpage{204, 205}
  \item replace, \hyperpage{106}, \hyperpage{596}
  \item replace\_copy, \hyperpage{596}
  \item replace\_copy\_if, \hyperpage{596}
  \item replace\_filename, \hyperpage{92}
  \item replace\_if, \hyperpage{596}
  \item repositioning, \hyperpage{127}, \hyperpage{138}
  \item request\_stop, \hyperpage{633}
  \item requires, \hyperpage{900}
  \item reserve, \hyperpage{107}, \hyperpage{341}, \hyperpage{376}
  \item reserved identifiers, \hyperpage{61}
  \item reset, \hyperpage{502}, \hyperpage{505}
  \item resetiosflags, \hyperpage{121}
  \item resize, \hyperpage{107}, \hyperpage{341}, \hyperpage{347}, 
		\hyperpage{354}
  \item resize\_file, \hyperpage{91}
  \item resource: stealing, \hyperpage{229}
  \item responsibility of the programmer, \hyperpage{338}, 
		\hyperpage{340}, \hyperpage{344}, \hyperpage{349}, 
		\hyperpage{353}, \hyperpage{370}, \hyperpage{502}
  \item restrictions, \hyperpage{7}
  \item result\_type, \hyperpage{859}
  \item resume, \hyperpage{928}
  \item rethrow\_exception, \hyperpage{270}
  \item return, \hyperpage{247}
  \item return by argument, \hyperpage{31}
  \item return type: implicit, \hyperpage{323}
  \item return type: late-specified, \hyperpage{324}
  \item return type: via invoke\_result, \hyperpage{788}
  \item return value, \hyperpage{11}, \hyperpage{319}
  \item return value optimization, \hyperpage{238}
  \item reusable software, \hyperpage{412}, \hyperpage{429}
  \item reverse, \hyperpage{347}, \hyperpage{597}
  \item reverse iterator, \hyperpage{831}
  \item Reverse Polish Notation, \hyperpage{369}
  \item reverse\_copy, \hyperpage{597}
  \item reverse\_iterator, \hyperpage{338}, \hyperpage{488}, 
		\hyperpage{831}
  \item reverse\_iterator.base(), \hyperpage{489}
  \item reverse\_iterator: initialized by iterator, \hyperpage{831}
  \item rfind, \hyperpage{107}
  \item rhs, \hyperpage{38}
  \item right, \hyperpage{122}
  \item right hand side, \hyperpage{38}
  \item right-hand, \hyperpage{334}, \hyperpage{336}
  \item rmExceptFd, \hyperpage{1013}
  \item rmReadFd, \hyperpage{1012}
  \item rmWriteFd, \hyperpage{1013}
  \item RNG, \hyperpage{529}
  \item rotate, \hyperpage{598}
  \item rotate\_copy, \hyperpage{598}
  \item round\_error, \hyperpage{724}
  \item round\_style, \hyperpage{724}
  \item RPN, \hyperpage{369}
  \item rule of thumb, \hyperpage{11}, \hyperpage{17}, \hyperpage{22}, 
		\hyperpage{59}, \hyperpage{69}, \hyperpage{164, 165}, 
		\hyperpage{179}, \hyperpage{183}, \hyperpage{187}, 
		\hyperpage{205}, \hyperpage{230}, \hyperpage{272}, 
		\hyperpage{274}, \hyperpage{292}, \hyperpage{297}, 
		\hyperpage{312}, \hyperpage{322}, \hyperpage{328}, 
		\hyperpage{343}, \hyperpage{385, 386}, \hyperpage{412}, 
		\hyperpage{459}, \hyperpage{510}, \hyperpage{514}, 
		\hyperpage{694}, \hyperpage{717}, \hyperpage{726}, 
		\hyperpage{737}, \hyperpage{754}, \hyperpage{772}, 
		\hyperpage{874}
  \item run-time, \hyperpage{405}, \hyperpage{422}, \hyperpage{721}
  \item run-time support system, \hyperpage{215}
  \item run-time vs. compile-time, \hyperpage{842}
  \item runtime\_error, \hyperpage{263}
  \item rvalue, \hyperpage{34}, \hyperpage{285}, \hyperpage{298}, 
		\hyperpage{490}, \hyperpage{501}
  \item rvalue reference, \hyperpage{34}
  \item rvalue reference return type, \hyperpage{228}
  \item rvalue: distinguish from lvalue, \hyperpage{1026}

  \indexspace

  \item s, \hyperpage{100}
  \item sample, \hyperpage{599}
  \item sbumpc, \hyperpage{429}, \hyperpage{991}
  \item scalar type, \hyperpage{381}
  \item scanf, \hyperpage{136}
  \item scanner, \hyperpage{985}, \hyperpage{1031}, \hyperpage{1033}, 
		\hyperpage{1036}
  \item scanner generator, \hyperpage{1031}
  \item ScannerBase, \hyperpage{1033}
  \item scientific, \hyperpage{123}
  \item scientific notation, \hyperpage{123}
  \item scope resolution operator, \hyperpage{24}, \hyperpage{64}, 
		\hyperpage{311}, \hyperpage{395}, \hyperpage{398}, 
		\hyperpage{417}
  \item scope: class, \hyperpage{458}
  \item scope: global, \hyperpage{458}
  \item scoped\_lock, \hyperpage{648}
  \item search, \hyperpage{600}
  \item search\_n, \hyperpage{600}
  \item second, \hyperpage{335}
  \item second\_argument\_type, \hyperpage{859}
  \item seek beyond file boundaries, \hyperpage{128}, \hyperpage{138}
  \item seek\_dir, \hyperpage{476}
  \item seek\_off, \hyperpage{993}
  \item seekdir, \hyperpage{128}, \hyperpage{138}, \hyperpage{430}
  \item seekg, \hyperpage{138}
  \item seekoff, \hyperpage{435}, \hyperpage{992}
  \item seekp, \hyperpage{128}
  \item seekpos, \hyperpage{435}, \hyperpage{992, 993}
  \item segmentation fault, \hyperpage{500}
  \item select, \hyperpage{1010}
  \item Selector, \hyperpage{1011}
  \item Semaphore, \hyperpage{654}
  \item set, \hyperpage{364}
  \item set: header file, \hyperpage{364}, \hyperpage{367}
  \item set\_difference, \hyperpage{601}
  \item set\_emit\_on\_sync, \hyperpage{687}
  \item set\_intersection, \hyperpage{602}
  \item set\_new\_handler, \hyperpage{214}
  \item set\_symmetric\_difference, \hyperpage{603}
  \item set\_union, \hyperpage{604}
  \item setAlarm, \hyperpage{1012}
  \item setbase, \hyperpage{122}
  \item setbuf, \hyperpage{435}
  \item setDebug, \hyperpage{1033}
  \item setf, \hyperpage{120}
  \item setfill, \hyperpage{120}
  \item setg, \hyperpage{433}, \hyperpage{988, 989}, \hyperpage{991}, 
		\hyperpage{993}
  \item setiosflags, \hyperpage{120}
  \item setjmp, \hyperpage{247}, \hyperpage{250}
  \item setp, \hyperpage{434}, \hyperpage{987}
  \item setprecision, \hyperpage{120}
  \item setstate, \hyperpage{119}
  \item setw, \hyperpage{121}
  \item SFINAE, \hyperpage{732}
  \item sgetc, \hyperpage{430}
  \item sgetn, \hyperpage{430}, \hyperpage{992}
  \item shadow member, \hyperpage{390}
  \item shared state, \hyperpage{663}
  \item shared state: abandon, \hyperpage{663}
  \item shared state: destruction, \hyperpage{663}
  \item shared state: releasing, \hyperpage{663}
  \item shared\_future, \hyperpage{667}
  \item shared\_lock, \hyperpage{646}
  \item shared\_mutex: header file, \hyperpage{639}, \hyperpage{646}
  \item shared\_ptr, \hyperpage{502}, \hyperpage{827}
  \item shared\_ptr: 0-pointer, \hyperpage{504}
  \item shared\_ptr: default, \hyperpage{503}
  \item shared\_ptr: defining, \hyperpage{503}
  \item shared\_ptr: initialization, \hyperpage{504}
  \item shared\_ptr: operators, \hyperpage{505}
  \item shared\_ptr: used type, \hyperpage{504}
  \item shift\_left, \hyperpage{586}
  \item shift\_right, \hyperpage{586}
  \item showbase, \hyperpage{122}
  \item showmanyc, \hyperpage{433}
  \item showpoint, \hyperpage{123}
  \item showpos, \hyperpage{123}
  \item shrink\_to\_fit, \hyperpage{107}, \hyperpage{341}, 
		\hyperpage{354}
  \item shuffle, \hyperpage{599, 600}
  \item signal, \hyperpage{1004}
  \item signaling\_NaN, \hyperpage{724}
  \item sin, \hyperpage{382}
  \item single inheritance, \hyperpage{396}
  \item sinh, \hyperpage{382}
  \item size, \hyperpage{107}, \hyperpage{171}, \hyperpage{338}, 
		\hyperpage{341}, \hyperpage{347}, \hyperpage{350}, 
		\hyperpage{352}, \hyperpage{355}, \hyperpage{361}, 
		\hyperpage{367}, \hyperpage{370}, \hyperpage{376}, 
		\hyperpage{492}
  \item size specification, \hyperpage{190}
  \item size: pointer to member, \hyperpage{464}
  \item size\_t, \hyperpage{55}, \hyperpage{309}
  \item size\_type, \hyperpage{98}
  \item sized deallocation function, \hyperpage{314}
  \item sizeof, \hyperpage{6}, \hyperpage{188}, \hyperpage{201}, 
		\hyperpage{207}, \hyperpage{775}, \hyperpage{863}
  \item sizeof derived vs base classes, \hyperpage{401}
  \item skipping leading blanks, \hyperpage{26}
  \item skipws, \hyperpage{124}, \hyperpage{495}
  \item sleep\_for, \hyperpage{623}
  \item sleep\_until, \hyperpage{623}
  \item slicing, \hyperpage{400}
  \item smart pointer, \hyperpage{497}
  \item snextc, \hyperpage{430}
  \item socket, \hyperpage{114}, \hyperpage{985}
  \item sort, \hyperpage{347}, \hyperpage{486}, \hyperpage{605}
  \item sort criteria: hierarchic sorting, \hyperpage{806}
  \item sort\_heap, \hyperpage{619}
  \item sorted collection of value, \hyperpage{367}
  \item sorted collection of values, \hyperpage{364}
  \item sorting, \hyperpage{551}
  \item space, \hyperpage{91}
  \item space(\_info), \hyperpage{94}
  \item spaceship, \hyperpage{307}
  \item splice, \hyperpage{347}
  \item split buffer, \hyperpage{433}
  \item sprintf, \hyperpage{126}
  \item sputbackc, \hyperpage{430}
  \item sputc, \hyperpage{430}
  \item sputn, \hyperpage{430}
  \item sqrt, \hyperpage{382}
  \item sscanf, \hyperpage{135}
  \item sstream: header file, \hyperpage{115}, \hyperpage{131}, 
		\hyperpage{140}, \hyperpage{150}
  \item stable\_partition, \hyperpage{591}
  \item stable\_sort, \hyperpage{605}, \hyperpage{806}
  \item stack, \hyperpage{369}
  \item stack constructors, \hyperpage{370}
  \item stack data structure, \hyperpage{369}
  \item stack operations, \hyperpage{318}
  \item stack: header file, \hyperpage{369}
  \item standard exceptions, \hyperpage{262}
  \item standard namespace, \hyperpage{24}
  \item standard namespace: and STL, \hyperpage{481}
  \item standard normal distribution, \hyperpage{538}
  \item Standard Template Library, \hyperpage{481}
  \item starts\_with, \hyperpage{108}
  \item stat, \hyperpage{54}, \hyperpage{168}
  \item state flags, \hyperpage{261}
  \item state of I/O streams, \hyperpage{112}, \hyperpage{115}
  \item static, \hyperpage{8}, \hyperpage{64}, \hyperpage{189}
  \item static binding, \hyperpage{405}, \hyperpage{407}
  \item static data members: initialization, \hyperpage{190}
  \item static data: const, \hyperpage{192}
  \item static inline member functions, \hyperpage{197}
  \item static member functions, \hyperpage{196}
  \item static member template, \hyperpage{840}
  \item static members, \hyperpage{189}, \hyperpage{761}
  \item static object, \hyperpage{154}
  \item static polymorphism, \hyperpage{735}, \hyperpage{813}, 
		\hyperpage{856}
  \item static polymorphism: downsides, \hyperpage{816}
  \item static type checking, \hyperpage{421}
  \item static type identification, \hyperpage{421}
  \item static variable: initialization, \hyperpage{639}
  \item static: data members, \hyperpage{189}
  \item static: members, \hyperpage{463}
  \item static\_assert, \hyperpage{721}
  \item static\_cast, \hyperpage{57}, \hyperpage{401}, \hyperpage{711}
  \item static\_pointer\_cast, \hyperpage{506}
  \item status, \hyperpage{91, 92}
  \item status\_known, \hyperpage{85}
  \item std, \hyperpage{111}
  \item std namespace: additions OK, \hyperpage{785}, \hyperpage{787}
  \item std::coroutine\_handle\textless{}State\textgreater{}, 
		\hyperpage{927}
  \item std::error\_code, \hyperpage{81}
  \item std::wstring, \hyperpage{109}
  \item stderr, \hyperpage{25}
  \item STDERR\_FILENO, \hyperpage{1007}
  \item stdexcept, \hyperpage{107}
  \item stdexcept: header file, \hyperpage{262}
  \item stdin, \hyperpage{25}
  \item STDIN\_FILENO, \hyperpage{1007}
  \item stdio.h, \hyperpage{11}, \hyperpage{16}
  \item stdout, \hyperpage{25}
  \item STDOUT\_FILENO, \hyperpage{988}, \hyperpage{1007}
  \item steady\_clock, \hyperpage{77}
  \item STL, \hyperpage{481}
  \item stod, \hyperpage{108}
  \item stof, \hyperpage{108}
  \item stoi, \hyperpage{109}
  \item stol, \hyperpage{109}
  \item stold, \hyperpage{108}
  \item stoll, \hyperpage{109}
  \item stop\_callback, \hyperpage{634}
  \item stop\_token, \hyperpage{633}
  \item stop\_token: header file, \hyperpage{634}
  \item storage class specifier, \hyperpage{60}
  \item store, \hyperpage{657}
  \item storing data, \hyperpage{342}
  \item stoul, \hyperpage{109}
  \item stoull, \hyperpage{109}
  \item str, \hyperpage{131}, \hyperpage{140}
  \item str..., \hyperpage{201}
  \item strcasecmp, \hyperpage{98}, \hyperpage{482}
  \item strdup, \hyperpage{201}, \hyperpage{215}
  \item strdupnew, \hyperpage{215}
  \item stream, \hyperpage{443}
  \item stream state flags, \hyperpage{118}
  \item stream: as bool value, \hyperpage{118}
  \item stream: associating, \hyperpage{149}
  \item stream: processing, \hyperpage{140}
  \item stream: read and write, \hyperpage{144}
  \item stream: reading to memory, \hyperpage{140}
  \item stream: writing to memory, \hyperpage{130}
  \item streambuf, \hyperpage{112}, \hyperpage{115}, \hyperpage{141}, 
		\hyperpage{429}, \hyperpage{494, 495}, \hyperpage{985}, 
		\hyperpage{988--990}, \hyperpage{992}, \hyperpage{994}
  \item streambuf: and exceptions, \hyperpage{429}
  \item streambuf: header file, \hyperpage{114}
  \item streamsize, \hyperpage{429}
  \item string, \hyperpage{97}
  \item string constructors, \hyperpage{100}
  \item string extraction, \hyperpage{136}
  \item string: as union member, \hyperpage{1038}
  \item string: declaring, \hyperpage{97}
  \item string: header file, \hyperpage{97}, \hyperpage{108}
  \item string: iterator types, \hyperpage{101}
  \item string::iterator, \hyperpage{469}
  \item string::size\_type, \hyperpage{98}
  \item string\_literals namespace, \hyperpage{100}
  \item string\_view: header file, \hyperpage{109}
  \item stringstream, \hyperpage{144}, \hyperpage{150}
  \item strong guarantee, \hyperpage{272}
  \item strong\_equality, \hyperpage{511}
  \item strong\_ordering, \hyperpage{513}
  \item Stroustrup, \hyperpage{22}
  \item struct, \hyperpage{18}
  \item struct: empty, \hyperpage{876}
  \item Structured Computer Organization, \hyperpage{654}
  \item Stuart, A. \& Ord, K, \hyperpage{528}
  \item student\_t\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{540}
  \item substitutability, \hyperpage{511}
  \item substitution failure, \hyperpage{732}
  \item substr, \hyperpage{108}
  \item subtract\_with\_carry\_engine, \hyperpage{528}
  \item sungetc, \hyperpage{430}
  \item suspend\_always (std::), \hyperpage{928}
  \item suspend\_never (std::), \hyperpage{928}
  \item Sutter, H., \hyperpage{272}, \hyperpage{735}
  \item swap, \hyperpage{108}, \hyperpage{224}, \hyperpage{274}, 
		\hyperpage{338}, \hyperpage{341}, \hyperpage{347}, 
		\hyperpage{355}, \hyperpage{361}, \hyperpage{367}, 
		\hyperpage{376}, \hyperpage{502}, \hyperpage{505}, 
		\hyperpage{607}, \hyperpage{628}, \hyperpage{633}, 
		\hyperpage{643}, \hyperpage{647}
  \item swap area, \hyperpage{214}
  \item swap\_ranges, \hyperpage{607}
  \item swapping, \hyperpage{551}
  \item Swiss army knife, \hyperpage{397}
  \item symbol area, \hyperpage{1033}
  \item symbolic constants, \hyperpage{26}
  \item symlink\_status, \hyperpage{91, 92}
  \item sync, \hyperpage{435}, \hyperpage{986, 987}
  \item synchronized, \hyperpage{684}
  \item syncstream: header file, \hyperpage{686, 687}
  \item syntactic elements, \hyperpage{248}
  \item sys/stat.h: header file, \hyperpage{83}
  \item system, \hyperpage{1001}, \hyperpage{1004}
  \item system\_category, \hyperpage{82}, \hyperpage{267}
  \item system\_clock, \hyperpage{77}
  \item system\_complete, \hyperpage{91}
  \item system\_error, \hyperpage{264}
  \item system\_error: header file, \hyperpage{81}, \hyperpage{264}

  \indexspace

  \item Tanenbaum, A.S., \hyperpage{654}
  \item task switching, \hyperpage{621}
  \item TCP/IP stack, \hyperpage{429}
  \item tellg, \hyperpage{138}
  \item tellp, \hyperpage{127}
  \item temp\_directory\_path, \hyperpage{91}
  \item template, \hyperpage{111}, \hyperpage{481}, \hyperpage{692}, 
		\hyperpage{743}
  \item template declaration, \hyperpage{709}
  \item template explicit specialization, \hyperpage{718}
  \item template explicit type specification: omitting, \hyperpage{720}
  \item template header, \hyperpage{693}
  \item template header: for member templates, \hyperpage{747}
  \item template instantiation declaration, \hyperpage{720}
  \item template mechanism, \hyperpage{691, 692}
  \item template members: without template type parameters, 
		\hyperpage{837}
  \item template meta programming, \hyperpage{709}, \hyperpage{813}, 
		\hyperpage{835}
  \item Template Method, \hyperpage{412}
  \item template method design pattern, \hyperpage{1002}
  \item template non-type parameter, \hyperpage{695}
  \item template pack: and template template parameters, 
		\hyperpage{888}
  \item template parameter deduction, \hyperpage{703}
  \item template parameter list, \hyperpage{693}, \hyperpage{695}, 
		\hyperpage{743}
  \item template parameter: default value, \hyperpage{745}
  \item template parameters: identical types, \hyperpage{707}
  \item template programming, \hyperpage{841}
  \item template template parameter, \hyperpage{835}, \hyperpage{853}
  \item template template parameter: and template packs, 
		\hyperpage{888}
  \item template type deduction, \hyperpage{707}
  \item template type parameter, \hyperpage{693}
  \item template type: initialization, \hyperpage{695}
  \item template: and the \textless{} token, \hyperpage{839}
  \item template: class, \hyperpage{742}
  \item template: class vs. typename, \hyperpage{853}
  \item template: embedded in using declarations, \hyperpage{764}
  \item template: embedding integral values, \hyperpage{842}
  \item template: explicit specialization, \hyperpage{719}
  \item template: expression template, \hyperpage{895}
  \item template: id-declaration mismatch, \hyperpage{719}
  \item template: identifying subtypes, \hyperpage{762}
  \item template: IfElse, \hyperpage{845}
  \item template: iteration by recursion, \hyperpage{847}
  \item template: overloading type parameter list, \hyperpage{714}
  \item template: parameter type transformation, \hyperpage{704}
  \item template: point of instantiation, \hyperpage{711}, 
		\hyperpage{726}
  \item template: preventing instantiation, \hyperpage{754}
  \item template: select type given bool, \hyperpage{845}
  \item template: specialization, \hyperpage{765}
  \item template: specified within template, \hyperpage{839}
  \item template: statements depending on type parameters, 
		\hyperpage{726}
  \item template: variadic, \hyperpage{774}
  \item template: when instantiated, \hyperpage{754}
  \item templates vs. using, \hyperpage{696}
  \item terminate, \hyperpage{444}
  \item text files, \hyperpage{145}
  \item textMsg, \hyperpage{256}
  \item this, \hyperpage{189}, \hyperpage{196, 197}, \hyperpage{219}, 
		\hyperpage{309}
  \item this\_thread, \hyperpage{622}
  \item thread, \hyperpage{621}, \hyperpage{623}
  \item thread of execution, \hyperpage{621}
  \item thread: header file, \hyperpage{622, 623}, \hyperpage{632}
  \item thread\_local, \hyperpage{629}
  \item throw, \hyperpage{248}, \hyperpage{253}
  \item throw list, \hyperpage{262}
  \item throw: empty, \hyperpage{256}
  \item throw: pointer, \hyperpage{255}
  \item tie, \hyperpage{116}, \hyperpage{142}
  \item time\_point, \hyperpage{78}
  \item time\_since\_epoch, \hyperpage{79}
  \item time\_t, \hyperpage{78}
  \item timed\_mutex, \hyperpage{636}
  \item timeval, \hyperpage{1010}
  \item tinyness\_before, \hyperpage{724}
  \item TMPDIR, \hyperpage{91}
  \item to\_string, \hyperpage{109}
  \item to\_sys, \hyperpage{91}
  \item to\_time\_t, \hyperpage{78}
  \item to\_wstring, \hyperpage{109}
  \item token, \hyperpage{369}, \hyperpage{1036}
  \item top, \hyperpage{352}, \hyperpage{370}
  \item trait class, \hyperpage{859}
  \item trait class: class detection, \hyperpage{862}
  \item trait class: nested, \hyperpage{860}
  \item transactional memory: -fgnu-tm, \hyperpage{684}
  \item transform, \hyperpage{485}, \hyperpage{487}, 
		\hyperpage{608, 609}
  \item transform: vs. for\_each, \hyperpage{609}
  \item transformation to a base class, \hyperpage{707}
  \item traps, \hyperpage{724}
  \item trigraphs, \hyperpage{3}
  \item trivial class type, \hyperpage{864}
  \item trivial copy constructor, \hyperpage{221}
  \item trivial default constructor, \hyperpage{172}
  \item trivial destructor, \hyperpage{212}
  \item trivial member function, \hyperpage{865}
  \item trivial type, \hyperpage{864}
  \item true, \hyperpage{53}, \hyperpage{129}, \hyperpage{139}, 
		\hyperpage{578}, \hyperpage{587}
  \item trunc, \hyperpage{130}, \hyperpage{145}
  \item try, \hyperpage{257}
  \item try\_lock, \hyperpage{637}, \hyperpage{643, 644}, 
		\hyperpage{647}
  \item try\_lock (function), \hyperpage{643}
  \item try\_lock\_for, \hyperpage{637}, \hyperpage{643}, 
		\hyperpage{648}
  \item try\_lock\_shared, \hyperpage{640}
  \item try\_lock\_shared\_for, \hyperpage{640}
  \item try\_lock\_shared\_until, \hyperpage{640}
  \item try\_lock\_until, \hyperpage{637}, \hyperpage{643}, 
		\hyperpage{648}
  \item tuple, \hyperpage{783}
  \item tuple: header file, \hyperpage{543}, \hyperpage{783}
  \item tuple\_element, \hyperpage{784}
  \item tuple\_size, \hyperpage{784}
  \item tuples: type based addressing, \hyperpage{784}
  \item tx\_exception, \hyperpage{263}
  \item Type, \hyperpage{335}
  \item type, \hyperpage{85}
  \item type checking, \hyperpage{11}
  \item type conversions, \hyperpage{728}
  \item type identification: run-time, \hyperpage{421}
  \item type of the pointer, \hyperpage{401}
  \item type safe, \hyperpage{26}, \hyperpage{136}, 
		\hyperpage{201, 202}
  \item type safety, \hyperpage{112}
  \item type specification: explicit, \hyperpage{703}
  \item type-safe, \hyperpage{26}
  \item type: anonymous, local, \hyperpage{702}
  \item type: primitive, \hyperpage{52}
  \item type: without values, \hyperpage{478}
  \item type\_traits: header file, \hyperpage{864}, \hyperpage{874}
  \item typedef, \hyperpage{18}
  \item typedefs: nested, \hyperpage{823}
  \item typeid, \hyperpage{422}, \hyperpage{425}
  \item typeid: argument, \hyperpage{426}
  \item typeinfo: header file, \hyperpage{262}, \hyperpage{425}
  \item typename, \hyperpage{836}
  \item typename ...Params, \hyperpage{775}
  \item typename \&\&, \hyperpage{34}
  \item typename: and template subtypes, \hyperpage{762}
  \item typename: disambiguating code, \hyperpage{762}

  \indexspace

  \item U, \hyperpage{53}
  \item u16string, \hyperpage{98}
  \item u32string, \hyperpage{98}
  \item uflow, \hyperpage{429}, \hyperpage{433}
  \item uint32\_t, \hyperpage{55}
  \item Ullman, J.D., \hyperpage{342}
  \item unary predicate, \hyperpage{560}
  \item unbound friend, \hyperpage{792}, \hyperpage{800}
  \item undefined reference to vtable, \hyperpage{448}
  \item underflow, \hyperpage{433}, \hyperpage{988}
  \item underflow\_error, \hyperpage{263}
  \item unget, \hyperpage{138}, \hyperpage{994}
  \item Unicode, \hyperpage{54}
  \item uniform initialization, \hyperpage{169}
  \item uniform\_int\_distribution\textless{}IntType = int\textgreater{}, 
		\hyperpage{541}
  \item uniform\_real\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{541}
  \item uninitialized... algorithms, \hyperpage{611}
  \item union, \hyperpage{18}, \hyperpage{1038}
  \item union: designated initialization, \hyperpage{40}
  \item unique, \hyperpage{347}, \hyperpage{505}, \hyperpage{613}
  \item unique\_copy, \hyperpage{614}
  \item unique\_lock, \hyperpage{641, 642}
  \item unique\_ptr, \hyperpage{497}, \hyperpage{827}
  \item unique\_ptr: 0-pointer, \hyperpage{499}
  \item unique\_ptr: assignment, \hyperpage{499}
  \item unique\_ptr: default, \hyperpage{499}
  \item unique\_ptr: defining, \hyperpage{498}
  \item unique\_ptr: initialization, \hyperpage{500}
  \item unique\_ptr: move constructor, \hyperpage{499}
  \item unique\_ptr: operators, \hyperpage{501}
  \item unique\_ptr: reaching members, \hyperpage{501}
  \item unique\_ptr: used type, \hyperpage{500}
  \item unistd.h: header file, \hyperpage{986}, \hyperpage{989, 990}, 
		\hyperpage{992}, \hyperpage{1006}
  \item unitbuf, \hyperpage{124}
  \item Unix, \hyperpage{143}, \hyperpage{145}, \hyperpage{1005}, 
		\hyperpage{1035}, \hyperpage{1044}
  \item unlock, \hyperpage{637}, \hyperpage{643}, \hyperpage{648}
  \item unlock\_shared, \hyperpage{640}
  \item unnamed type, \hyperpage{702}
  \item unordered\_map, \hyperpage{377, 378}
  \item unordered\_map: header file, \hyperpage{377}
  \item unordered\_map: sub-types, \hyperpage{378}
  \item unordered\_multimap, \hyperpage{379}
  \item unordered\_multiset, \hyperpage{376}
  \item unordered\_set, \hyperpage{373}
  \item unordered\_set: header file, \hyperpage{373}
  \item unordered\_set: member functions, \hyperpage{374}
  \item unordered\_set: sub-types, \hyperpage{373}
  \item unordered\_set::key\_equal, \hyperpage{373}
  \item unpack operator, \hyperpage{775}, \hyperpage{780}
  \item unrestricted union, \hyperpage{238}
  \item unsetf, \hyperpage{121}
  \item unsigned int, \hyperpage{55}
  \item upper\_bound, \hyperpage{361}, \hyperpage{367}, \hyperpage{615}
  \item uppercase, \hyperpage{123}
  \item URNG, \hyperpage{529}
  \item use\_count, \hyperpage{506}
  \item user interface, \hyperpage{407}
  \item user-defined literal, \hyperpage{196}
  \item user-defined literals, \hyperpage{330}
  \item using, \hyperpage{46}, \hyperpage{111}, \hyperpage{187}
  \item using declaration, \hyperpage{65}
  \item using directive, \hyperpage{65}
  \item using namespace std, \hyperpage{24}
  \item using vs. templates, \hyperpage{696}
  \item using: in derived classes, \hyperpage{395}
  \item using: nested, \hyperpage{823}
  \item using: restrictions, \hyperpage{69}
  \item UTF-16, \hyperpage{54}
  \item UTF-32, \hyperpage{54}
  \item utility, \hyperpage{231}
  \item utility: header file, \hyperpage{325}, \hyperpage{335}, 
		\hyperpage{699}, \hyperpage{778}
  \item uz, \hyperpage{55}

  \indexspace

  \item vague linkage, \hyperpage{180}
  \item valid state, \hyperpage{98}
  \item value, \hyperpage{355}
  \item value\_comp, \hyperpage{362}, \hyperpage{367}
  \item value\_type, \hyperpage{355}, \hyperpage{365}, \hyperpage{824}
  \item Vandevoorde, D., \hyperpage{835}
  \item variable: inline, \hyperpage{180}
  \item variadic concepts, \hyperpage{914}
  \item variadic function, \hyperpage{691}
  \item variadic functions, \hyperpage{774}
  \item variadic non-type parameters, \hyperpage{781}
  \item variadic template: number of arguments, \hyperpage{775}
  \item variadic templates, \hyperpage{774}
  \item vector, \hyperpage{339}, \hyperpage{489}
  \item vector constructors, \hyperpage{339}
  \item vector: header file, \hyperpage{339}
  \item vector: member functions, \hyperpage{339}
  \item vectorized execution, \hyperpage{552}
  \item viable functions, \hyperpage{728}
  \item virtual, \hyperpage{407}
  \item virtual base class, \hyperpage{417}
  \item virtual constructor, \hyperpage{449}
  \item virtual derivation, \hyperpage{417}
  \item virtual destructor, \hyperpage{411, 412}
  \item virtual member function, \hyperpage{407}
  \item virtual: vs static, \hyperpage{189}
  \item visibility: nested classes, \hyperpage{469}
  \item void, \hyperpage{15}
  \item void *, \hyperpage{258}, \hyperpage{309}, \hyperpage{311, 312}
  \item volatile, \hyperpage{705}
  \item vpointer, \hyperpage{446}
  \item vscanf, \hyperpage{136}
  \item vtable, \hyperpage{446}, \hyperpage{856}
  \item vtable: and multiple inheritance, \hyperpage{447}
  \item vtable: undefined reference, \hyperpage{448}

  \indexspace

  \item wait, \hyperpage{651}, \hyperpage{653}, \hyperpage{1011}
  \item wait\_for, \hyperpage{651}, \hyperpage{653}
  \item wait\_until, \hyperpage{652, 653}
  \item waitpid, \hyperpage{1003}
  \item wchar\_t, \hyperpage{52}, \hyperpage{54}, \hyperpage{111}
  \item weak\_equality, \hyperpage{511}
  \item weak\_ordering, \hyperpage{512}
  \item weibull\_distribution\textless{}RealType = double\textgreater{}, 
		\hyperpage{542}
  \item what, \hyperpage{261, 262}
  \item whitespace, \hyperpage{26}, \hyperpage{124, 125}
  \item width, \hyperpage{121}
  \item Wiebe-Marten Wijnja, \hyperpage{1024}
  \item wild pointer, \hyperpage{216}, \hyperpage{255}
  \item Williams, A., \hyperpage{621}
  \item wrapper, \hyperpage{213}, \hyperpage{998}
  \item wrapper class, \hyperpage{114}, \hyperpage{298}, 
		\hyperpage{399}
  \item wrapper functions, \hyperpage{198}
  \item wregex, \hyperpage{516}
  \item write, \hyperpage{127}
  \item write beyond end of file, \hyperpage{128}
  \item writeFd, \hyperpage{1012}
  \item ws, \hyperpage{125}
  \item wstring, \hyperpage{98}

  \indexspace

  \item X-windows, \hyperpage{55}
  \item xor, \hyperpage{332}
  \item xor\_eq, \hyperpage{332}
  \item XQueryPointer, \hyperpage{55}
  \item xsgetn, \hyperpage{430}, \hyperpage{433}, \hyperpage{990--992}
  \item xsputn, \hyperpage{430}, \hyperpage{435}
  \item xvalue, \hyperpage{37}

  \indexspace

  \item yacc, \hyperpage{1031}
  \item yield, \hyperpage{623}
  \item Yodl, \hyperpage{3}

  \indexspace

  \item zombie, \hyperpage{1004}, \hyperpage{1015}

\end{theindex}
