COPYRIGHTED MATERIAL INDEX. Numbers & Symbols. 16-bit characters, bit characters, 10

Transcription

1 INDEX Numbers & Symbols = operator, 12 /\ (backslash character), 7 * (quotation mark), 7 n (escape character), 6, 7 r (carriage return), 7 t (tab), decrement operator, 12 + addition operator, 12 / division operator, 12 ~ in destructors, 180 # in directives, 5 ++ increment operator, 12 % mod operator, 12 * multiplication operator, 12! operator, 11 %= operator, 12 & operator, 12 &= operator, 12 *= operator, 12 += operator, 12 -= operator, 12 /= operator, 12 << operator, 6, 12 = operator, 11 >> operator, 12 >>= operator, 12 ^ operator, 12 ^= operator, 12 operator, 12 = operator, 12 + operator, string class, 51 - subtraction operator, bit characters, bit characters, 10 A abstract base classes, abstract superclasses, 115 abstraction, 122, 211, 212 benefits, 84 classes, 130 design and, 84, 85 design success, 125 interface exposed, 123, 125 versus implementation, 123 reusable code, 129, 130 access specifiers, 145, 146 private, 146 protected, 146 public, 146 accumulate function, , 570 ad hoc comments, 65 adapters containers example, operations, 499, priority_queue, queue, function objects bind2nd( ), 548 std::bind( ), add( ) method, overloading, addition operator (+), 12 addone( ) function, 30 COPYRIGHTED MATERIAL 903

2 aggregation arrays aggregation, reusable code, 132 Agile Methodology, 789 algorithms. See also functions binary_search( ), 566 C++ standard library, 443 callbacks, 544 comparison algorithms, count_if( ), 542 equal_range( ), 566 examples, voter registration audits, extending STL, for_each( ), 562 generate( ), 542 header files, 898 interface, 448 iterator invalidation and, 485 iterators, 551 lower_bound( ), 566 modifying algorithms, copy( ), erase( ), iota( ), 570 move( ), replace( ), reverse( ), 562 transform( ), unique( ), 562 move semantics, 536 non-modifying, search algorithms, numerical processing, 570 operational algorithms, overview, set algorithms, sorting algorithms, STL (standard template library), comparison, 459 heap, 463 modifying, non-modifying, numerical processing, 464 operational, 461 search algorithms, 458 sorting, 462 utility algorithms, 459 upper_bound( ), 566 utility, aliasing, 728 alias templates, 338 type aliases, 297 alignment, curly braces, allocate( ) method, 628 allocation operators, Allocator parameter, 473 Allocator type, 628 allocators, 657 header files, 898 alltrue( ) function, 545 alternation (ECMAScript), 582 alternative function syntax, 23, 338 ambiguity in naming, base classes, 248 analysis and design workflow, 788 anchors (ECMAScript), 582 angle brackets, C++11, 324 anonymous namespaces, 292 API (application programming interface), 88 exposed interface, 124 arguments iterator template arguments, 551 iterators, 532 superclass method, types, operator overloading, 414 type-safe variable-length argument lists, variable-length argument lists, arithmetic function objects, 543 arithmetic operators, 543 increment/decrement, overloading, shorthand operators, unary minus and unary plus, 420 array class, array container, 450 arrays, associative arrays, constant expressions,

3 ASCII (American Standard Code for Information Interchange) bind2nd( ) method deleting, 28 dynamic memory, deleting, types, dynamically allocated, 713 heap, multi-dimensional, of objects, pointers, stack, multi-dimensional, standard C-style arrays, 523 std::array, 20 vector container and, ASCII (American Standard Code for Information Interchange), 575 assert macro, static_assert, assign( ) method, assigning object value to objects, assignment bitwise, 180 disallowing, 188 self-assignment, 186 shallow, 180 assignment compared to copying, assignment operator, 170 declaring, 171 defining, helper routines, 187 initializer-lists, move assignment operator, Spreadsheet class, associative arrays, associative containers, 453, 468 hashmaps as, map constructing, 506 element lookup, 509 element remove, example, insert( ) method, 507 iterators, operator[ ], 508 types, method requirements, multimap element lookup, 512 example, multiset, 516 set, typedefs, unordered, unordered_map, unordered_multimap, 522 unordered_multiset, 522 unordered_set, 522 atomic operations, library, 755 atomic types, attributes, C++11, auditvoterrolls( ) function, 571 auto keyword, 23, 402, 480, 507, 570, 602, 617, 699 templates, auto_ptr, 728 B back references, 583, 587 back_insert_iterator class, bad( ) method, 350 bad_alloc exception, base classes abstract, ambiguity, 248 source code, 239 virtual base, 248 virtual base classes, begin( ) method, 523 behaviors, 110 overriding, 115 bibliography, bidirectional I/O, big-o notation, binary logical operators, overloading, binary operators, 11 binary_search( ) function, 566 bind2nd( ) method,

4 bitset capturing bitset, bitwise operators, example, bitset container, bitwise copying, 180 bitwise function objects, 546 bitwise operators, overloading, bool, vector and, bool( ) conversion operator, 373 bool variable, 10 Boolean expressions, conversion operators, bounded repeats, 583 brackets for deleting arrays, 28 break keyword, 21 buffer overflow errors, 736 buffered streams, 346, 349 buffers, packet buffers, bugs avoiding, catastrophic bugs, 828 cosmetic bugs, 828 debug traces, error logging, inheritance, 218 noncatastrophic bugs, 828 planning for, reproducing, debugging nonreproducible, debugging reproduced, 843 root cause, 828 built-in classes, vectors, 476 business modeling workflow, 788 C C++ as object-oriented language, Stroustrup, Bjarne, 4 C++ design abstraction, differences, reuse, C standard library, C++ Standard Library, 443 compile-time rational arithmetic, 446 exceptions, 446 header files, algorithms, 898 allocators, 898 containers, exceptions, 899 general utilities, I/O streams, 900 iterators, 898 mathematical utilities, 899 threading library, 901 I/O streams, 445 localization, 445 mathematical utilities, random numbers, 447 regular expressions, 445 smart pointers, 446 STL (standard template library), containers, strings, 445 time utilities, 447 tuples, 447 C++11, 303 angle brackets, 324 attributes, containers, changes, conversion operators, emplace operations, 484 function syntax, 303 initialization, uniform, initializer lists, 305 literals, user-defined, cache invalidation, 809 caching, design-level efficiency, callbacks, 531 predicate function callbacks, calling copy constructors, explicitly, 164 calling methods, from methods, call_once( ), 763 capitalization in naming, 70 capture blocks, lambda expressions, 537 capture groups, 583 capturing,

5 cascading if statement code cascading if statement, 16 casting downcasting, pointers, upcasting, 235 casting variables, 10 casts const_cast, 29 dynamic_cast, reinterpret_cast, situations for use, 301 static_cast, catastrophic bugs, 828 catch statements, , 404 catching exceptions, 30 31, 370, multiple, stack unwinding and, cbegin( ) method, cend( ) method, chaining constructors, 230 char exception, 377 char variable, 10 char16_t variable, 10 char32_t variable, 10 character classes, 584 character sets encodings, 577 matches, non-western, UCS (Universal Character Set), 77 wide characters, word boundaries, 586 characters, 10 code points, 577 chess program, Chrono library clocks, duration, time_point class, class templates, 317 friend function templates, grid classes, partial class specialization, writing, classes abstraction, 130 access specifiers, array, back_insert_iterator, base classes abstract, virtual, 248 built-in, vectors, 476 character classes, 584 condition_variable, data members, 34 access, 148 declaring, definitions, derived, 218 DoubleSpreadsheetCell, 239 duration, enumerated types, 201 exception, writing, exending, friends, fstream, generic template class, 133 hierarchies, diamond-shaped, 248 clear( ) method, 668 clients, inheritance and, extending classes, clocks, code compiling, 5 decomposing, 22 reusable advantages, 89 design, ease of use, generality, writing, 86 reusing C standard library, capabilities, categories of available code, 87 disadvantages, frameworks,

6 code constructors code (continued) libraries, 88 licensing, 94 limitations, open source libraries, performance, platform limitations, 94 polymorphism and, 116 prototype, 95 stand-alone functions/classes, 87 strategies, support, 94 third-party application bundles, code points, 577 coding, templates, coding without, coercing variables, 10 comments, 4 5 code reuse design, 138 C-style, 4 5 reasons for complicated code explanation, metainformation conveyance, usage explanation, style ad hoc, 65 every line, fixed-format, prefix comments, 64 self-documenting, 66 comparison algorithms, 459, comparison function objects, comparison operators, overloading, comparisons, vectors, 477 compiler, template processing, 322 compiler-generated constructors, compiler-generated default constructors, compile-time debug mode, compile-time rational arithmetic, 446 compiling code, 5 components, 109 condition variables, conditional operators, conditionals conditional operators, if/else statements, 16 switch statements, 16 ternary operator, 17 condition_variable class, configuration management workflow, 788 const characters, string literals and, 50 const data members, const iterator, 649 const keyword methods, 289 parameters, 32, 287 pointers, references, variables, 287 constants, 71 const keyword, 32 namespaced, 70 const_cast, 298 constexpr keyword, constructor inheritance, constructors, 35 chaining, 230 compiler-generated, copy constructors, calling explicitly, 164 subclasses, default, compiler-generated, explicity defaulted, 159 explicity deleted, 160 delegating, 156 delegating constructors, DoubleSpreadsheetCell constructor, 241 error handling, function-try-blocks, hashmap class, , on heap, initializer-list constructors, move constructors,

7 containers c_str( ) method multiple, parent constructors, on stack, 154 vectors, writing, zero-initialization, 476 containers, adapters, 468 queue, associative, 368, 504 map, multimap, multiset, 516 set, bitset, 524 bitwise operators, example, C++ standard library, 443 C++11 changes, forward_list, forward interators, 450 hash tables, 468 header files, 898 interface, 449 methods, reversible, 658 sequential, 468 array class, deque, 491 forward_list, hashmap, list, vector, standard C-style arrays, 524 STL (standard template library), array, 450 bitset, deque, 50 forward_list, 450 hash tables, 453 list container, 340 map, multimap, multiset, 452 priority_queue, 451 set, 452 stack, table listing, unordered associative containers, 453 vector, streams, 524 strings, 524 typedefs, 648 vector, writing, hashmap, continue keyword, 21 conversion implicit, numeric, operators C++, 11 conversion operators ambiguity, bool( ), 373 Boolean expressions, writing, copy( ) function, copy constructors, assignment comparison, calling explicitly, 164 ctor-initializers, 163 helper routines, 187 object members and, Spreadsheet class, declaration, 185 subclasses, copy_backward( ) function, 558 copying bitwise, 180 shallow, 180 copystring( ) function, core process workflows, 788 cosmetic bugs, 828 counters naming conventions, 69 static data members, 189 count_if( ) algorithm, 542, 602 cout stream, 348 covariant return types, 248 CPUs, 742 cruft, 67 c_str( ) method,

8 C-style arrays design C-style arrays, 524 C-style comments, 4 5 C-style strings, 30, 47 ctor-initializers, 144, copy constructors, 163 data member initialization, curly braces, alignment and, D dangling pointers, 182, 446, 739 data members, 34 access, 148 ambiguity, 247 const, const reference data members, const reference members, mutable, 95 reference data members, reference members, references, 276 static, , 291 accessing, methods, d-char-sequence, 55 deadlocks, deallocate( ) method, 628 deallocation operators, debug mode compile-time, ring buffers, run-time, 835 start-time, debugging article citation example, debug traces, debug mode, Fundamental Law of Debugging, 828 introduction, 827 Linux, GDB debugger, memory class-related errors, 848 error categories, general errors, object errors, 848 multithreaded programs, reproducing bugs, debugging nonreproducible, debugging reproduced, 843 symbolic debugger, 843 Visual C debugger, declarations, 5 assignment operators, 171 classes, forward declaration, 191 functions, 22 methods, order, pointers, 26 declaring variables, 9 decltype keyword, 689 decltype keyword, templates, decltype variable, 10 decomposing code, 22 decomposition, modular, 67 refactoring, 67 decrement( ) method, decrement operator ( ), 12 decrement operators, overloading, deduction rules, 684 default constructors, compiler-generated, explicity defaulted, 165 explicity deleted, 160 default parameters, 197 #define directive, 5 definitions, 5 classes, delegating constructors, 156, delete keyword, delete-expression, 436 demote( ) method, 39 deployment workflow, 788 deque container, 450, 491 dereferencing operators, dereferencing pointers, 26, 719 derived classes, 218 design. See also C++ design; programming design; software design 910

9 design patterns dynamic-length vectors abstraction and, chess program, reusable code, abstraction, aggregation, 132 checks and safeguards, 134 class hierarchies, 131 comments, 138 documentation, 138 interfaces, separate concepts, subsystems, templates, user interface dependencies, 132 threading, design patterns, 98 design techniques, 98 classes, template, writing, double dispatch, throwing/catching exceptions, 370 design-level efficiency, 802 caching, object pools, destination ranges, 556 destructors, error handling and, freeing memory, 180 ifstream, 362 ofstream, 362 vectors, virtual, 232 method templates, 330 diamond-shaped hierarchies, 248 directives preprocessor, 5 6 using, 8 distributions, random numbers, division operator (/), 12 DLL (Dynamic Link Libraries), 296 documentation code reuse design, 138 comments reasons for, styles, double deletion, 739 smart pointers, double precision numbers, 10 double variable, 10 double-checked locking algorithm, doubledelete( ) function, double-ended queue. See deque container double-freeing, 446 DoubleSpreadsheetCell class, 239 constructor, 241 DoubleSpreadsheetCell constructor, 241 doubletostring( ) method, 193 doubly linked list structures, 450 do/while loop, 21 downcasting, doworkinthread( ) function, 753 dumb pointers, memory allocation results, 739 duration class, dynamic arrays versus dynamically allocated arrays, 713 dynamic memory, 707 advantages, 708 allocation, delete keyword, failure, 711 malloc( ) function, new keyword, arrays, deleting, multi-dimensional, types, freeing, 180 mental model, pointers, dynamic strings C-style strings, raw string literals, string class, string literals, 50 dynamically allocated arrays, 713 dynamic_cast, dynamic-length vectors,

10 ease of use exception handling E ease of use, ECMAScript, 582 alternation, 582 anchors, 582 back references, 587 character sets, matches, grouping, 583 precedence, 584 raw string literals, regular expressions, repetition, 583 wildcards, 582 word boundaries, 586 efficiency, design-level, 802, 808 caching, object pools, language-level, 802, catching exceptions by reference, 806 move semantics, 806 pass-by-reference, return by reference, 805 temporary objects, elements list container, map associative container, multimap associative container, 512 objects, fields, 479 requirements, value semantics, vectors access methods, appending to, initial value, user-defined classes, 476 emplace( ) method, 499 emplace operations, hashmap class, employee records system sample program Database class Database.cpp file, Database.h file, DatabaseTest.cpp file, 44 Employee class Employee.cpp file, Employee.h file, EmployeeTest.cpp file, 41 user interface, UserInterface.cpp file, empty( ) function, 548 emulation, function partial specialization, enable_if, end( ) method, 524 #endif directive, 6 endl manipulator, 351 end-of-file, 357 end-of-line sequence, 6 enumerated types, in classes, 201 strongly typed enumerations, type-safe, eof( ) method, equal( ) function, equal_range( ) function, 566 erase( ) function, erase( ) method, 514 error categories, error checking, 470 error handling, 104 constructors, function-try-blocks, destructors, exceptions, input, memory allocation errors, new handler callback function, 399 output, 350 error level, debugging, 831 error logging, ErrorCorrelator, 503 escape character, n, 7 event objects, 767 exception classes, writing, exception handling, 376 unexpected_handler, 384 unhandled exceptions,

11 exception_ptr formatting exception_ptr, exceptions, 30 31, , 470 bad_alloc, benefits, C++, C++ standard library, 446 catching, 370, multiple, by reference, 806 stack unwinding and, char, 377 class hierarchy and, custom, 72 header files, 899 hierarchy, introduction, 369 invalid_argument, 374 lambda expressions, 536 matching, 380 multithreaded programming, nested, nested_exception mixin class, polymorphism and, runtime_error, 380 specifications, throw lists, throwing, 370, multiple, stack unwinding and, types, unexpected, 383 unhandled, execution order of operators, 13 explicitly calling copy constructors, 164 explicitly defaulted constructors, 159 exposed interface, API (application programming interface), 124 audience considerations, 123 subsystem interface, 124 utility classes versus libraries, 124 expressions regular expressions, 445, short-circuit logic, 18 extending, 114 classes, inheritance and, extending classes, extern keyword, external linkage, 291, extraction operators, overloading, F facets, factorials at compile time, 696 fail( ) method, 350 feature creep, 782 file streams, ifstream destructor, 362 ofstream destructor, 362 seek( ) method, tell( ) method, files header files, objects, linking, 5 FILO (first-in, last-out), 451 final keyword, 221 find( ) algorithm, find( ) function, , reverse_iterator, 629 Find( ) function, template, find_all( ) algorithm, findelement( ) method, 641 find_if( ) function, , 546 fixed-format comments, fixed-length arrays, vectors, fixed-length vectors, float variable, 10 floating-point numbers, 10 flush( ) method, 349, 366 flush-on-access, for loop, 21 range-based, 21 22, for_each( ) function, 562, formatting alignment, curly braces, parentheses, 74 spaces, 74 tabs,

12 forward declaration functions forward declaration, 191 forward_list container, 450, forward iterators, 450 frameworks code reuse, 88 free software, 96 freeing memory, destructors and, 180 friend function templates to class templates, friend keyword, friends, fstream class, func( ) method, 386 function adapters, binders bind2nd( ), 548 std::bind( ), function objects, 428, 531, 542 adapters, binders, adapting functions, 549 arithmetic function objects, 543 bitwise function objects, 546 comparison function objects, logical function objects, 545 member functions, negators, 548 threads, writing, function pointers, implementing, threads, typedefs, function templates, overloading, specialization, functional relationships, functionality adding, 115 replacing, 115 required, user interface, function-call operator, functions, 22 23, 316. See also algorithms accumulate, 570 addone( ), 30 alltrue( ), 545 alternative function syntax, 338, auditvoterrolls( ), 571 binary_search( ), 566 C++11 syntax, 303 callbacks, predicate function callbacks, copy_backward( ), 558 copystring( ), as data, declarations, 22 doubledelete( ), doworkinthread( ), 753 empty( ), 548 equal( ), equal_range( ), 566 Find( ), find( ), , find_all( ), find_if( ), for_each( ), friends, functwo( ), 395 getduplicates( ), hash functions, includes( ), incr( ), 281 lexicographal_compare( ), lower_bound( ), 566 main( ), 6 make_move_iterator( ), 633 malloc( ), malloc_int( ), 730 max( ), 482 mem_fn( ), min( ), 482 minmax( ), 482 mismatch( ), namespaces and, 7 8 operator( ), parameters, 22 partial specialization, overloading and, printvector( ), 482 procedures and,

13 function-try-blocks header files process( ), processvalues( ), 692 prototypes, 22 random_shuffle( ), 460 readname( ), 354 realloc( ), 713 sizeof( ), 49 sort( ), stand-alone, reuse and, 87 static, 292 strcat( ), 49 strcopy( ), 48 strlen( ), swap( ), 482, 647 testcallback( ), 541 threadfunc( ), 753 throw_with_nested( ), 393 unexpected( ), 384 upper_bound( ), 566 function-try-blocks, functors, 428 functwo( ) function, 395 Fundamental Law of Debugging, 828 futures, G garbage collection, 724 GDB debugger, generality, generate( ) algorithm, 542 generating random numbers, random number engines, predefined, 616 generic programming, 444 reusable code and, 316 templates and, 316 generic template class, 133 get( ) method, getduplicates( ) function, getline( ) method, 357 getsize( ) method, 359 getstring( ) method, 240 renaming, 195 getters/setters, 70 getvalue( ) method, 145 renaming, 195 global functions, operators, GNU project, 96 good( ) method, 350, GPL (GNU Public License), 96 gprof, graphics cards, cores, greedy repeats, 583 grouping (ECMAScript), 583 H handles, 129 has-a relationship, is-a relationship comparison, hash functions, , 636, hash tables, 68, 453, , 636. See also unordered associative containers unordered_map, hash_map, implementation, 637 hashmap class accessor operations, as associative container, clear operation, 668 constructor, , emplace operations, erase operations, implementation, initializer list assignment operator, initializer list constructor, 664 insertion operations, 665 interface, sequential containers, as STL container, template demonstration, templates, typedefs, header files, algorithms, 898 allocators, 898 containers, exceptions, 899 general utilities, interators,

14 header files inheritance header files (continued) I/O streams, 900 mathematical utilities, 899 template definitions, threading library, 901 heap, 25 constructors on, objects on, vector allocation, 476 heap algorithms, 463 heap arrays, multi-dimensional, Hello, World arrays, std::array, 20 comments, 4 5 conditionals conditional operators, if/else statements, 16 switch statements, ternary operator, 17 functions, I/O streams, 6 7 loops for, 21 do/while, 21 while, main( ) function, 6 namespaces, 7 8 operators, preprocessor directives, 5 6 types enumerated, structs, 15 variables, 9 10 helper methods, 149 helper routines assignment operator, 187 copy constructors, 187 hierarchies, classes, exceptions, diamond shaped, 242 exceptions, parallel, 249 reusable code and, 131 homogenous elements, 447 Hungarian Notation, I #ifdef directive, 6 if/else statements, 16 cascading if statement, 16 #ifndef directive, 6 ifstream destructor, 362 ifstream object, bool( ) conversion operator, 373 implementation, implementation class, implementation workflow, 788 versus interface, 1213 implicit conversion, In-class member initializers, 167 #include directive, 5 includes, preprocessor directives, 6 includes( ) function, incr( ) function, 281 increment( ) method, increment operator (++), 12 overloading, indexing, iterators and, 481 inheritance, 114, bug fixes and, 218 clients and, extending classes, constructors, derived classes, 218 functionality adding, 115 replacing, 115 multiple, , uses, non-public, 270 parent classes, 218 pointers, 225 polymorphism, spreadsheet, preventing, 221 properties, 115 replacing,

15 initialization iterators reuse subclasses and, WeatherPrediction class, specialization comparison, 337 subclasses, superclasses, 218 templates comparison, initialization constructors, (See also ctorinitializers) in-class member initializers, 167 lists (C++11), 305 nonlocal variables, 294 references, 274 uniform in C++, 303, , 476 zero-initialization, template types, initializer_list, 476 initializer-list constructors, assignment operators, hashmap class, 664 inline keyword, inline methods, in-memory streams, input error handling, locale awareness, 359 manipulators, objects, streams, get( ) method, getline( ), 357 peek( ), putback( ), 356 readname( ) function, 354 unget( ), input stream iterator, 630 inrange( ) method, 178 insert( ) method, map associative container, 507 insert iterators, insertion operators, overloading, insert_iterator class, 631, instantiation, 133, 321 selective, 325 int variable, 9 integer non-type parameters, integers, 9 enumerated types, interface, 211, 212 algorithms, 449 API (Application Programming Interface), 124 containers, 449 exposed, audience considerations, 123 subsystem interface, 124 utility classes versus libraries, 124 versus implementation, 123 implementation class, interface class, usability, interface class, internal linkage, interviews, intvector, 476 invalid_argument exception, 374 invalidation of iterators, 485 I/O bidirectional, overview, streams, 6 7, 445 header files, 900 user input, 7 ios_base::out, 362 iostream subclass, is-a relationship, has-a relationship comparison, polymorphism, 116 iterative processes, iterator adapters (STL) insert iterators, move iterators, reverse iterators, stream iterators, iterators, 457, arguments, 532 categories, 471 const, 649 generate( ) algorithm,

16 iterators libraries iterators (continued) header files, 898 indexing and, 481 input stream iterator, 630 invalidation, 485 list container, 492 map associative container, methods, operations, 481 output stream iterator, 630 regular expressions, 588 safety, template arguments, 551 traits, typedefs, , types, 551 vector, writing, iterator_traits class, K keywords auto, 23, 339, 402, 570, 602, , 699 break, 21 const, 32, 191, methods, 289 parameters, 32, 287 pointers, references, variables, 287 constexpr, continue, 21 decltype, delete, extern, final, 221 friend, inline, new, noexcept, override, static L functions, variables, throw, 374 typename, 641 using, 253 virtual, 222 lambda expressions capture block, 537 as parameters, 541 return types, syntax, threading, 750 language-level efficiency, 802, catching exceptions by reference, 806 move semantics, 806 pass-by-reference, return by reference, 805 temporary objects, lexicographical_compare( ) function, libraries. See also C++ standard library atomic operations, 755 C standard library, Chrono clocks, duration, time_point class, code reuse, 88 library handles, 296 open source, finding, using, Ratio, regex, regex_iterator( ), regex_match( ), regex_replace( ), regex_search( ), regex_token_iterator( ), regular expressions library, 75 standard library, 36 classes,

17 life cycles of objects mark and sweep garbage collection life cycles of objects, 152 assigning to objects, creation, destruction, LIFO (last-in, first-out), 451 linear_congruential_engine, 615 linkage doubly linked list structures, 350 external, 291, internal, static, 291 static keyword, linking object files, 5 streams, Linux, GDB debugger, list container, 450 forward_list comparison, list container, elements accessing, 492 adding/removing, 492 enrollment, iterators, 492 merge( ) method, 494 remove( ) method, 494 remove_if( ) method, 494 reverse( ) method, 494 size, 492 sort( ) method, 494 special operations, unique( ) method, 494 literals, 11 literal pooling, 50 string literals, 50 localizing, 576 raw string literals, 54 55, user-defined, C++11, locales, 579 classic, 580 input and, 359 Windows, 579 localization, 445, string literals, 576 lock classes, locks double-checked locking algorithm, multithreading, log( ) method, log level debugging, 831 Logger::log( ) method, 832 logical function objects, 545 long double variable, 10 long long variable, 9 long variable, 9 longjmp( ), 371 loops do/while loop, 21 for loop, 21 range-based, loop unrolling, while loop, lower_bound( ) function, 566 M macros, preprocessor macros, main( ) function, 6 make_move_iterator( ) function, 633 make_pair( ) template, 505 make_shared( ) method, 731 malloc( ) function, malloc_int( ) function, 730 map associative container constructing, 506 elements insert( ) method, 507 lookup, 509 removing, example, iterators, operator[ ], 508 types, 506 unordered_map comparison, map container, 452 mark and sweep garbage collection,

18 mathematical utilities methods mathematical utilities, header files, 899 Matrix class, max( ) function, 482 member functions, threads, 751 members, 145 pointers to, 727 mem_fn( ) function, memory aliasing, 728 allocation contiguous pieces, 712 dumb pointers, 729 failure behavior, null pointers, 398 vectors, allocation errors, class-related errors, 848 double deletion, 739 dynamic, 707 advantages, 708 allocation, , arrays, 713 mental model, multi-dimensional arrays, pointers, errors, categories, freeing, destructors and, 180 function pointers, garbage collection, 724 general errors, heap, 25 object errors, 848 object pools, 725 orphaned, 184 out-of-bounds access, pointer arithmetic, pointers, 718 smart pointers, stack, 25 strings, underallocating, memory access errors, memory freeing errors, memory leaks, 446, Linux, Valgrind, Windows, memory management, custom, merge( ) method, 494 Mersenne twister, 615 metaprogramming. See template metaprogramming method calls, 136 method templates, non-type parameters, methods, 145 add( ), overloading, allocate( ), 628 assign( ), associative containers, bad( ), 350 begin( ), 523 bind2nd( ), 548 calling from methods, cbegin( ), cend( ), clear( ), 668 const, const keyword, 289 constructors, 35 containers, c_str( ), deallocate( ), 628 declarations, ordering, decrement( ), defining, demote( ), 39 doubletostring( ), 193 emplace( ), 499 end( ), 523 eof( ), 358 erase( ), 514 fail( ), 350 findelement( ), 641 flush( ), 349, 366 func( ), 386 get( ),

19 MFC (Microsoft Foundation Classes) moving ownership getsize( ), 359 getstring( ), 195, 240 getvalue( ), 145, 195 good( ), 350, 358 helper methods, 149 increment( ), inline, inrange( ), 178 insert( ), 507 iterators, log( ), Logger::log( ), 832 make_shared( ), 731 multi, 973 namespaces and, 7 8 output, raw output methods, 349 overloaded add( ), deleting, 196 operator+ method, overloading, overriding, changing parameters, changing return type, clients and, overloaded superclass method, preventing, 225 private superclass method, static methods, superclass method access level, superclass method arguments, throw list, virtual, pointers to, 727 promote( ), 39 pure virtual methods, push( ), 4499 push_back( ), 475 put( ), 349 rbegin( ), 629, 658 refcall( ), rend( ), 629, 658 set( ), 196 setvalue( ), 145 static, 193, 291 stringtodouble( ), 193 tie( ), virtual, 222 pure, wait( ), 768 what( ), 340, 350 write( ), 349 MFC (Microsoft Foundation Classes), 88 min( ) function, 482 minmax( ) function, 482 mismatch( ) function, mixin, 122 variadic templates, mixin classes, 122 variadic templates, mod operator (%), 12 modifying algorithms, , copy( ), 558 erase( ), iota( ), 570 move( ), replace( ), reverse( ), 562 transform( ), unique( ), 562 modular decomposition, 67 move( ) function, move assignment operator, , 419 move constructor, move iterators, 632 move semantics, algorithms, 536 language-level efficiency and, 806 move iterators, MoveableClass instances, 633 move_backward( ) function, moving ownership,

20 multi-dimensional arrays, dynamic memory nothrow multi-dimensional arrays, dynamic memory, multiline comments, 4 multimap container, 452 element lookup, 512 example, multiple inheritance, , uses, multiplication operator (*), 12 multiset associative container, 516 multithreaded programming, 741 cancelling threads, 752 condition variables, deadlocks, debugging, exceptions, futures, introduction, lambda expression, 750 locks, logger class example, member functions, 751 mutual exclusion, mutex classes, race conditions, results retrieval, 752 std::call_once( ), thread local storage, 751 thread pools, threading design, threads function object, function pointers, multithreading threading models, 101 mutability, lambda expressions, 537 mutable data members, 195 mutex classes, timed, writing to streams, mutual exclusion, mutex classes, MVC (Model-View-Controller), 99 object-oriented frameworks, 132 MyEnum, N namespaces, 7 8 anonymous, 292 functions, 7 8 methods, 7 8 namespaced constants, 70 naming ambiguity, base classes, 248 conventions capitalization, 70 counters, 69 Hungarian Notation, namespaced constants, 70 prefixes, 69 getters, 70 selecting, setters, 70 narrowing, uniform initialization, 304 N-dimensional grids, template recursion and, negators, 548 nested classes, nested exceptions, nested_exception mixin class, new keyword, new-expression, 436 NGrid template class, noexcept keyword, noncatastrophic bugs, 828 non-integral array indices, nonlocal variables, order of initialization, 294 non-modifying alorigthms, search algorithms, non-public inheritance, 270 nonstandard strings, 30 non-type template parameters, , method templates, pointers, 679 reference, 679 non-western character sets, nothrow,

21 null pointers operator overloading null pointers dereferencing, 26 memory allocation routines, 398 numbers, rational, 604 numeric conversion, numerical processing algorithms, 464, 570 O object pools, 725 design-level efficiency, object-oriented languages C++ as, philosophy behaviors, 110 classes, components, 109 properties, 109 objects, , 316 aggregation, arrays of, constructors, writing, elements, fields, 479 even objects, 767 files, linking, 5 function objects, 448, 531 adapters, adapting functions, 549 arithmetic function objects, 543 comparison function objects, logical function objects, 545 member functions, negators, 548 writing, on heap, inheritance, multiple, input, life cycles, 152 assigning to objects, creation, destruction, memory, dynamic allocation, output, passing by reference, relationships has-a, , hierarchies, is-a, mixin classes, 122 not-a, as return values, on stack, 151 destruction, 169 out of scope, 169 temporary, ofstream destructor, 362 OOP (object-oriented programming), 34 opaque classes, 129 open source libraries, finding, using, operational algorithms, 461, operator*, operator->, operator->*, 432 operator[ ], map associative container, 508 operator( ) function, operator delete, 437 overloading, operator+ method, global, operator new, 437 overoading, operator overloading, 136, , , 649 add( ) method, allocation/deallocation operators, argument types, 414 arithmetic, increment/decrement, shorthand operators, unary minus and unary plus, 420 behavior choices, 415 binary logical operators, bitwise operators, comparison,

22 operator overloading overloading operator overloading (continued) dereferencing operators, extraction operators, function-call operator, implementing overloaded, 243 insertion operators, limitations, methods versus global functions, operator delete, operator+ method, global, overloadable operators, placement new, 437 reasons for, 412 return types, subscripting operator, non-integral array indices, read-only access, type building, 211 use, 136 operators %=, 12 &, 12 &=, 12 *=, 12 +=, 12 -=, 12 /=, 12 <<, 12 <<=, 12 >>, 12 >>=, 12 ^, 12 ^=, 12, 12 =, 12 arithmetic, 543 arity, 412 assignment operator, 170 declaring, 171 defining, move assignment operator, Spreadsheet class, associativity, 413 binary, 11 bitwise, conditional, conversion ambiguity, bool( ), 373 Boolean expressions, C++11, writing, dereferencing, execution order, 13 function-call, global functions, overloading, placement new, 437 precedence, 413 relational, scope resolution, 147 sequencing operator, 415 string class, ternary, 11, 17 unary, 11 orphaned memory, 184 ostream_iterator class, 630 out scope (objects on stack), 169 output error handling, 350 manipulators, objects, overview, raw output methods, 349 standard output, 348 streams, buffered, 349 flush( ) method, 349 put( ) method, 349 write( ) method, 349 output stream iterator, 630 overload resolution, 196 overloading function partial specialization and, function templates, methods,

23 overloading operators parent destructors deleting overloaded, 196 operator+ method, operator+ method (global), operators arithmetic, implementing overloaded, 243 superclass method, overloading operators, 136, , allocation/deallocation operators, argument types, 414 arithmetic operators increment/decrement, unary minus and unary plus, 420 behavior choices, 415 binary logical operators, bitwise operators, comparison operators, dereferencing operators, extraction operators, function-call operator, insertion operators, limitations, operator delete, operators not to overload, 415 overloadable operators, placement new, 437 reasons for, 412 return types, subscripting operator, non-integral array indices, read-only access, type building, 211 use, 136 override keyword, 252 overriding behaviors, 115 methods, changing parameters, changing return type, clients and, overloaded superclass method, P preventing, 225 private superclass method, static methods, superclass method access level, superclass method arguments, syntax, 223 throw list, virtual, what( ), 340 packets, buffers, pair class, parallel hierarchies, 249 parameter packs, 694 parameters, 316 Allocator, 473 const keyword, 287 const keyword and, 32 const reference parameters, default, 197 functions, 22 lambda expressions, 536, 541 overridden methods, references, , template template parameters, templates, 316 integer non-type parameters, method templates, non-type parameters, , parameter packs, 694 type parameters, vector, 473 parent classes, 218 parent constructors, private, 270 protected, 270 references, parent constructors, parent destructors,

24 parenthese in code programming parenthese in code, 74 partial specialization classes, functions, pass-by-reference, efficiency, passing objects, by reference, by value, disallowing, 188 variables by reference, 27 by value, 27 pattern-matching, 445 patterns. See design patterns subsitution pattern, 582 peek( ) method, performance, reuse and, placement new operators, 437 pointer arithmetic, pointers, 718 arrays, casting and, const keyword, dangling, 182, 446, 739 declaring, 26 dereferencing, 26, 719 dynamic memory, function pointers, threads, inheritance and, 225 to members, 727 mental model, to methods, 727 non-type template parameters, 679 to references, versus references, 71 72, references from, 277 references to, smart pointers, 28 29, auto_ptr, 728 C++ standard library, 446 class writing, reference counting, shared_ptr, stack unwinding and, 396 unique_ptr, weak_ptr, 734 structures, 27 this, typedefs, variables, 27 polymorphism, 116 exceptions and, inheritance, spreadsheet, SpreadsheetCell hierarchy, POSIX, initializing semaphores, 371 #pragma directive, 6 precedence, ECMAScript, 584 precision numbers, double precision numbers, 10 predicate function callbacks, prefix comments, 64 preprocessor directives, 5 6 #define, 5 #endif, 6 #ifdef, 6 #ifndef, 6 #include, 5 includes, 6 #pragma, 6 preprocessor macros, printf( ), 345 printing, tuples, printvector( ) function, 482 priority_queue container adapter, example, operations, private, superclasses, procedures, 316 functions and, 108 process( ) function, processvalues( ) function, 692 profiling, gprof example, Visual C example, programming generic, 444 multithreaded (See multithreaded programming) 926

25 programming design regex library programming design, 80 importance of, programs, employee records sample program, promote( ) method, 39 properties, 109 inheritance and, 115 replacing, 115 protected methods, inheritance, 220 public methods, inheritance, 220 pure virtual methods, push( ) method, 499 push_back( ) method, 475, put( ) method, 349 putback( ) method, 356 Q queue container adapter example, operations, 499 queue container adapter, R race conditions, random number engine adapter, 447, random number engines, 447, linear_congruential_engine, 615 Mersenne twister, 615 predefined, 616 subtract_with_carry_engine, 615 random numbers C++ standard library, 447 distribution, generating, random_device engine, random_shuffle( ) function, 460 range specification, 584 range-based for loop, ranges destination, source, 556 Ratio library, rational numbers, 604 raw output methods, 349 raw string literals, rbegin( ) method, 629, 658 r-char-sequence, 55 readname( ) function, 354 read-only access, realloc( ) function, 713 recursion, templates, refactoring, decomposition and, 67 refcall( ) method, reference counting smart pointers, reference data members, const reference data members, reference parameters, const, 32 references, back references, 583, 587 const keyword, data members, 276 initializing, 274 modifying, 275 non-type template parameters, 679 parameters, parent classes, passing objects by, passing variables by, 27, 277 from pointers, 277 to pointers, versus pointers, 71 72, pointers to, reference variables, return values, 278 rvalue, unnamed values, 274 regex library, regex_iterator, regex_iterator( ), regex_match( ), regex_replace( ), regex_search( ), regex_token_iterator( ), typedefs,

26 regular expressions rvalue references regular expressions, 445, ECMAScript, iterators, 588 raw string literals, regex library, regular expressions library, 575 reinterpret_cast, relational operators, relationships functional, has-a, , hierarchies, inheritance, multiple, is-a, , 116=119 mixin classes, 122 not-a, remove( ) method, 494 remove-erase-idiom, 482, remove_if( ) method, 494 rend( ) method, 629, 658 repeats, greedy, 583 repetition (ECMAScript), 583 replace( ) function, replace operations, 583 required functionality, user interface, requirements on elements, requirements workflow, 788 return by reference, 805 return types lambda expressions, operator overloading, return values objects as, references, 278 returning values, reusable code abstraction, aggregation, 132 checks and safeguards, 134 class hierarchies, 131 comments, 138 design, documentation, 138 ease of use, generality, generic programming, 316 interfaces, usability, separate concepts, subsystems, templates, user interface dependencies, 132 reusable code and, 131 reuse advantages, C standard library, capabilities, categories of available code, 87 disadvantages, frameworks, 88 ideas, 87 inheritance and subclasses and, WeatherPrediction class, libraries, 88 open source, licensing, 94 limitations, performance and, philosophy, platform limitations, 94 prototype, 95 stand-alone functions/classes, 87 strategies, 90 95, 127 support, 94 third-party application bundles, writing reusable code, 86 reverse( ) functions, 62, 494 reverse iterators, reverse_iterator class, 629, reversible containers, 658 ring buffers, round-robin scheduling with vector, RTTI (Run Time Type Information), run-time debug mode, 835 runtime_error exception, 380 RUP (Rational Unified Process) of software development, rvalue references, move assignment operator,