COPYRIGHTED MATERIAL INDEX. Symbols

Transcription

1 INDEX Symbols 16-bit characters, bit characters, 10! operator, 11 %= operator, 12 & operator, 12 &= operator, 12 *= operator, 12 += operator, 12 << operator, 6, 12 <<= operator, 12 = operator, 11 >> operator, 12 >>= operator, 12 ^ operator, 12 ^= operator, 12 operator, 12 = operator, 12 + operator, string class, /= operator, 12 -= operator, 12 + addition operator, decrement operator, 11 ~ in destructors, 172 # in directives, 5 / division operator, increment operator, 11 % mod operator, 11 * multiplication operator, 11 - subtraction operator, 11 \* (quotation mark), 7 \ (backslash character), 7 \n (escape character), 6 7 \r (carriage return), 7 \t (tab), 7 A abstract base classes, abstract superclasses, 85 abstraction, 92, benefits, 54 classes, 100 design and, design success, 95 interface exposed, versus implementation, 93 reusable code, access-controlled singleton patterns, access specifiers, private, 136 protected, 136 public, 136 accumulate( ) function, , 486 ad hoc comments, 119 adapter design pattern, adapters containers priority_queue, 424 example, operations, 425 queue, 421 example, operations, 422 stack example, operations, 427 function objects bind2nd( ), std::bind( ), add( ) method, overloading, addition operator (+), 11 addone( ) function, 30 address sizes, 885 aggregation, reusable code, 102 Agile Methodology, 847 algorithms. See also functions binary_search( ), 484 C++ standard library, 361 callbacks, 457 comparison algorithms, count_if( ), 468 equal_range( ), 484 COPYRIGHTED MATERIAL examples, voter registration audits, extending STL, for_each( ), 469 generate( ), header files, 1048 interface, 370 iterator invalidation and, 406 iterators, 481 lower_bound( ), 484 modifying algorithms, copy( ), erase( ), 497 iota( ), 491 move( ), replace( ), 497 reverse( ), 499 transform( ), unique( ), move semantics, 462 non-modifying, search algorithms, numerical processing, 486 operational algorithms, overview, set algorithms, sorting algorithms, STL (standard template library), comparison, 380 modifying, non-modifying, numerical processing, 380 operational, 381 search algorithms, sorting, utility algorithms, 378 upper_bound( ), 484 utility, aliasing, 780 template aliases, type aliases, alignment, curly braces,

2 allocate( ) method buffered streams allocate( ) method, 596 allocation operators, Allocator parameter, 393 Allocator type, 596 allocators, 627 header files, 1048 alltrue( ) function, 472 alternation (ECMAScript), 525 alternative function syntax, , 739 ambiguity in naming, base classes, 242 analysis and design workflow, 846 anchors (ECMAScript), 525 angle brackets, C++11, anonymous namespaces, 290 API (application programming interface), 58 exposed interface, 94 applications description, platform and, 888 architecture address sizes, 885 binary compatibility, byte order, arguments iterator template arguments, 482 iterators, 458 superclass method, type-safe variable-length argument lists, types, operator overloading, 648 variable-length argument lists, arithmetic function objects, arithmetic operators, 470 increment/decrement, overloading, shorthand operators, unary minus and unary plus, array class, 418 array container, 371 arrays, associative arrays, constant expressions, 20 deleting, 26 dynamic memory, deleting, types, dynamically allocated, 764 heap, multi-dimensional, of objects, pointers, stack, multi-dimensional, 767 standard C-style arrays, 450 std::array, vector container and, 370 ASCII (American Standard Code for Information Interchange), assembly code, assert macro, static_assert, assign( ) method, 398 assigning object value to objects, assignment bitwise, 172 disallowing, 180 self-assignment, 178 shallow, 172 assignment compared to copying, assignment operator, 162 declaring, 163 defining, 164 helper routines, initializer-lists, 635 move assignment operator, Spreadsheet class, associative arrays, associative containers, 386, 428 hashmaps as, map constructing, element lookup, element remove, 435 example, insert( ) method, iterators, operator[ ], types, 430 method requirements, multimap element lookup, 438 example, multiset, 444 set, typedefs, unordered, unordered_map, unordered_multimap, 449 unordered_multiset, unordered_set, at( ) method, 363 atomic operations, library, 802 atomic types, attributes, C++11, 308 auditvoterrolls( ) function, auto keyword, 402, 570, 710, templates, auto variable, 10 auto_ptr, 780 B back references, 526, 529 back_insert_iterator class, bad( ) method, 550 bad_alloc exception, base classes abstract, ambiguity, 242 source code, 233 virtual base, 242 virtual base classes, 265 begin( ) method, 451 behaviors, 80 overriding, 85 bibliography, bidirectional I/O, big-endian ordering, 886 big-o notation, binary compatibility, binary logical operators, overloading, binary operators, 11 binary_search( ) function, 484 bind2nd( ) method, bitset, 452 bitwise operators, 453 example, bitset container, bitwise copying, 172 bitwise function objects, 473 bitwise operators, 453 overloading, black box testing, 905 bool, vector and, bool( ) conversion operator, 321 bool variable, 10 Boolean expressions, conversion operators, bounded repeats, 525 brackets for deleting arrays, 26 break keyword, 19 buffer overflow errors, 795 buffered streams, 546,

3 buffers, packet buffers classes buffers, packet buffers, bugs avoiding, catastrophic bugs, 928 cosmetic bugs, 928 debug traces, error logging, inheritance, 212 noncatastrophic bugs, 928 planning for, reporting, reproducing, debugging nonreproducible, debugging reproduced, root cause, 928 tracking tools, Bugzilla, built-in classes, vectors, 396 business modeling workflow, 846 byte addressability, 886 byte order, C C linking with, porting to C++, 889 C#, C++ as object-oriented language, Stroustrup, Bjarne, 3 C++11, 301 angle brackets, attributes, 308 containers, changes, conversion operators, emplace operations, 392 function syntax, 304 initialization, uniform, initializer lists, 306 literals, user-defined, null pointers, C++ design abstraction, differences, reuse, C standard library, C++ Standard Library, 361 compile-time rational arithmetic, 369 exceptions, 367 header files, algorithms, 1048 allocators, 1048 containers, exceptions, 1049 general utilities, I/O streams, 1050 iterators, 1048 mathematical utilities, 1049 threading library, 1051 I/O streams, 366 localization, 367 mathematical utilities, 368 random numbers, 368 regular expressions, 369 smart pointers, 367 STL (standard template library), containers, strings, 366 time utilities, 368 tuples, 369 C-style arrays, 450 C-style comments, 4 C-style strings, 28, cache invalidation, 867 caching, design-level efficiency, callbacks, 457 predicate function callbacks, 460 calling copy constructors, explicitly, 155 calling methods, from methods, call_once( ), 819 capitalization in naming, 124 capture blocks, lambda expressions, 463, 465 capture groups, 526 capturing, 465 cascading if statement, 16 casting downcasting, 229 pointers, upcasting, 229 casting variables, 10 casts const_cast, 296 dynamic_cast, reinterpret_cast, 298 situations for use, 300 static_cast, catastrophic bugs, 928 catch statements, 338, 354 catching exceptions, 30 31, 318, , 970 multiple, stack unwinding and, cbegin( ) method, cend( ) method, chain of responsibility pattern, chaining constructors, 224 char exception, 325 char16_t variable, 10 char32_t variable, 10 char variable, 10 character classes, 527 character sets encodings, 519 matches, non-western, UCS (Universal Character Set), 519 wide characters, word boundaries, 528 characters, 10 code points, 519 chess program, Chrono library clocks, duration, time_point class, class templates, 684 friend function templates, grid classes, partial class specialization, writing, classes, abstraction, 100 access specifiers, array, 418 back_insert_iterator, base classes abstract, virtual, 242 built-in, vectors, 396 character classes, 527 condition_variable, 823 data members, 33 access, declaring, DefaultHash, 607 definitions, derived, 212 DoubleSpreadsheetCell, 233 duration, enumerated types, exception, writing, exending, friends, fstream, generic template class, 364 hash class defi nition, HashIterator, hierarchies, diamond-shaped,

4 classes constructors classes (continued) exceptions, reusable code and, 101 implementation, 207 insert_iterator, instantiation, 365 interface, 207 iterator_traits, lock classes, Matrix, members, 135 methods, 135 mix-in, 92, variadic templates, nested, nested_exception mix-in class, 342 opaque, 99 ostream_iterator, 598 pair, parent classes, 212 reverse_iterator, smart pointers, writing, Spreadsheet, 134 (See Spreadsheet class) SpreadsheetCell, 134 stand-alone, reuse and, 57 standard library, 36 static data members, 181 std::pair, std::vector, 36 string, 366, StringSpreadsheetCell, 233 stringstream, 567 subclassing, SubObject, templates subclassing writing, time_point, user-defined, vectors, 396 valarray, 368 WeatherPrediction, 219 WebHost, 891 writing, clear( ) method, 639 clients, inheritance and, extending classes, clocks, code compiling, 5 decomposing, 22 reusable advantages, 59 design, ease of use, generality, writing, 56 reusing C standard library, capabilities, categories of available code, 57 disadvantages, frameworks, 58 libraries, 58 licensing, 64 limitations, open source libraries, performance, platform limitations, 64 polymorphism and, 86 prototype, 65 stand-alone functions/ classes, 57 strategies, support, 64 third-party application bundles, code points, 519 Code::Blocks debugger, coding, templates, coding without, coercing variables, 10 comments, 4 C-style, 4 code reuse design, 108 reasons for complicated code explanation, metainformation conveyance, usage explanation, style ad hoc, 119 every line, fixed-format, prefix comments, self-documenting, comparison algorithms, 380, comparison function objects, comparison operators, overloading, comparisons, vectors, compile-time debug mode, compile-time rational arithmetic, 369 compiler, template processing, 693 compiler-generated constructors, 160 compiler-generated default constructors, compilers bugs, 887 language extensions, 887 compiling code, 5 components, 79 condition variables, conditional operators, conditionals conditional operators, if/else statements, 16 switch statements, 17 ternary operator, 17 condition_variable class, 823 configuration management workflow, 846 const characters, string literals and, 512 const data members, 181, const iterator, 625 const keyword, 31 32, 187, methods, 286 parameters, 32, pointers, , 771 references, variables, const methods, const reference data members, 181, 185 const reference parameters, constant expressions, arrays constants, 125 const keyword, 32 namespaced, 124 const_cast, 296 constexpr keyword, constructor inheritance, constructor initializers. See ctorinitializer constructors, 34 chaining, 224 compiler-generated, 160 copy constructors, calling explicitly, 155 subclasses, default, compiler-generated, explicity defaulted, 150 explicity deleted, delegating, 146 delegating constructors, 159 DoubleSpreadsheetCell constructor, 235 error handling, function-try-blocks, hashmap class, , 634 on heap, 145 initializer-list constructors, move constructors, multiple,

5 containers debugging parent constructors, on stack, 144 vectors, writing, zero-initialization, 396 containers, adapters, 386 queue, associative, 386, 428 map, multimap, multiset, 444 set, bitset, 452 bitwise operators, 453 example, C++11 changes, C++ standard library, 361 forward_list, forward interators, 458 hash tables, 386 header files, 1048 interface, 370 methods, reversible, 628 sequential, 386 array class, 418 deque, 413 forward_list, hashmap, 641 list, , vector, standard C-style arrays, 450 STL (standard template library), array, 371 bitset, deque, 371 forward_list, hash tables, 374 list container, map, 373 multimap, 373 multiset, priority_queue, 372 set, stack, 372 table listing, unordered associative containers, 374 vector, 370 streams, strings, 451 typedefs, 616 vector, 276 writing, hashmap, continue keyword, 19 conversion implicit, numeric, operators, C++11 conversion operators ambiguity, bool( ), 321 Boolean expressions, writing, copy( ) function, copy constructors, assignment comparison, calling explicitly, 155 ctor-initializers, 154 helper routines, object members and, 166 Spreadsheet class, declaration, 177 subclasses, copy_backward( ) function, copying bitwise, 172 shallow, 172 copystring( ) function, core process workflows, 846 cosmetic bugs, 928 counters naming conventions, 123 static data members, 181 count_if( ) algorithm, 468, 570 cout stream, 548 covariant return types, 243 cppunit, CPUs, 798 cross-compiling, 884 cross-language development, assembly code, C# and C++, JNI (Java Native Interface), linking with C-code, paradigm shifts, Perl, shell scripts, 899 cross-platform development architecture address sizes, 885 binary compatibility, byte order, implementation, 886 compiler and, 887 library implementations, 887 platform-specific features, 888 cruft, 121 c_str( ) method, 891 ctor-initializers, 133, copy constructors, 154 data member initialization, 153 curly braces, alignment and, D d-char-sequence, 516 dangling pointers, 174, 367, 794 data members, 33 access, ambiguity, 241 const, 181, const reference data members, 185 const reference members, 181 mutable, 188 reference data members, reference members, 181 references, 271 static, 181, 288 accessing, methods, deadlocks, deallocate( ) method, 596 deallocation operators, debug mode compile-time, ring buffers, run-time, 937 start-time, debugging article citation example, Code::Blocks, debug traces, debug mode, Fundamental Law of Debugging, 928 introduction, 927 Linux, GDB debugger, memory class-related errors, 952 error categories, general errors, 952 object errors, 952 multithreaded programs, reproducing bugs, debugging nonreproducible, debugging reproduced, symbolic debugger, 947 Visual C debugger,

6 decltype keyword efficiency decltype keyword, 739 declarations, 5 assignment operators, 163 classes, forward declaration, 184 functions, 23 methods, order, pointers, 25 declaring variables, 8 9 decltype keyword, templates, decltype variable, 10 decomposing code, 22 decomposition, 120 modular, 121 refactoring, 121 decorator design pattern, 109, decrement( ) method, decrement operator (--), 11 decrement operators, overloading, deduction rules, default constructors, compiler-generated, explicity defaulted, 150 explicity deleted, default parameters, DefaultHash class, 607 #define directive, 5 definitions, 5 classes, delegating constructors, 146, 159 delete-expression, 675 delete keyword, 761 demote( ) method, 38 deployment workflow, 846 deque container, 371, 413 dereferencing operators, dereferencing pointers, 27, 770 derived classes, 212 design. See also C++ design; programming design; software design abstraction and, chess program, reusable code, abstraction, aggregation, 102 checks and safeguards, 104 class hierarchies, 101 comments, 108 documentation, 108 interfaces, separate concepts, subsystems, templates, user interface dependencies, 102 threading, design-level efficiency, 860 caching, object pools, design patterns, 68, adapter pattern, chain of responsibility pattern, decorator pattern, 109, factory pattern, iterator pattern, observer pattern, proxy pattern, singleton pattern, design techniques, 68, classes subclassing, template, writing, writing, double dispatch, files reading from, 971 writing to, 971 mix-in classes, throwing/catching exceptions, 970 destination ranges, destructors, error handling and, freeing memory, 172 ifstream, 562 ofstream, 562 vectors, virtual, 225 method templates, 698 diamond-shaped hierarchies, 242 directives preprocessor, 5 6 using, 8 distributions, random numbers, division operator (/), 11 DLL (Dynamic Link Libraries), 294 do/while loop, 19 docfunction( ) method, 893 documentation code reuse design, 108 comments reasons for, styles, double-checked locking algorithm, double deletion, smart pointers, 785 double dispatch, double-ended queue. See deque container double-freeing, 367 double precision numbers, 10 double variable, 10 doubledelete( ) function, DoubleSpreadsheetCell class, 233 constructor, 235 DoubleSpreadsheetCell constructor, 235 doubletodouble( ) method, 186 doubly linked list structures, downcasting, 229 doworkinthread( ) function, 814 dumb pointers, memory allocation results, 782 duration class, dynamic arrays versus dynamically allocated arrays, 764 dynamic-length vectors, dynamic memory, 759 advantages, 760 allocation, delete keyword, 761 failure, malloc( ) function, 762 new keyword, 761 arrays, deleting, multi-dimensional, types, freeing, 172 mental model, pointers, dynamic strings C-style strings, raw string literals, string class, string literals, 512 dynamically allocated arrays, 764 dynamic_cast, E ease of use, ECMAScript, alternation, 525 anchors, 525 back references, 529 character sets, matches, grouping, 526 precedence, 526 raw string literals, 529 regular expressions, 529 repetition, 525 wildcards, 525 word boundaries, 528 efficiency, design-level, 860, caching, object pools,

7 elements flush( ) method language-level, 860, catching exceptions by reference, 864 move semantics, 864 pass-by-reference, return by reference, 863 temporary objects, elements list container, 414 map associative container, multimap associative container, 438 objects, fields, requirements, value semantics, 387 vectors access methods, appending to, initial value, user-defined classes, 396 emplace( ) method, 422 emplace operations, 392 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, user interface, UserInterface. cpp file, empty( ) function, 477 emulation, function partial specialization, enable_if, encryption, passwords, end( ) method, 451 end-of-file, 557 end-of-line sequence, 6 #endif directive, 5 endl manipulator, 551 enumerated types, in classes, strongly typed enumerations, type-safe, 15 eof( ) method, 558 equal( ) function, equal_range( ) function, 484 erase( ) function, 497 erase( ) method, 441 error categories, error checking, 388 error handling, 74 constructors, function-try-blocks, destructors, exceptions, input, memory allocation errors, new handler callback function, 348 output, error level, 930 error logging, ErrorCorrelator, 426 escape character, \n, 6 7 event objects, 823 events, platform and, 888 exception classes, writing, exception handling, 323 unexpected_handler, 333 unhandled exceptions, exception_ptr, 813 exceptions, 30 31, 388 bad_alloc, benefits, C++, 320 C++ standard library, 367 catching, 318, , 970 multiple, by reference, 864 stack unwinding and, char, 325 class hierarchy and, custom, 126 header files, 1049 hierarchy, introduction, 317 invalid_argument, 322 lambda expressions, 463 matching, multithreaded programming, nested, nested_exception mix-in class, 342 polymorphism and, runtime_error, 328 specifications, throw lists, throwing, 318, , 970 multiple, stack unwinding and, types, unexpected, 332 unhandled, execution order of operators, 13 explicitly calling copy constructors, 155 explicity defaulted constructors, 150 exposed interface, API (application programming interface), 94 audience considerations, 93 subsystem interface, 94 utility classes versus libraries, 94 expressions regular expressions, 369, short-circuit logic, 18 extending, 84 classes, inheritance and, extending classes, extern keyword, external linkage, 288, 723 extraction operators, overloading, F facets, factorials at compile time, factory design pattern, fail( ) method, 550 feature creep, 840 file streams, ifstream destructor, 562 ofstream destructor, 562 seek( ) method, tell( ) method, files header files, objects, linking, 5 reading from, 971 writing to, 971 FILO (first-in, last-out), 372 final keyword, 215 find( ) algorithm, find( ) function, , reverse_iterator, 597 Find( ) function, template, 710 find_all( ) algorithm, findelement( ) method, 612 find_if( ) function, , 475 fixed-format comments, fixed-length arrays, vectors, fixed-length vectors, float variable, 9 floating-point numbers, 9 flush( ) method, 549,

8 flush-on-access grouping (ECMAScript) flush-on-access, for loop, 19 range-based, 20, 401 for_each( ) function, 469, formatting alignment, curly braces, parentheses, 128 spaces, 128 tabs, 128 forward declaration, 184 forward_list container, , forward iterators, 458 frameworks code reuse, 58 object oriented, 981 MVC (Model-View- Controller), free software, 66 freeing memory, destructors and, 172 friend function templates to class templates, friend keyword, 196 friends, fstream class, func( ) method, 335 function adapters, binders bind2nd( ), std::bind( ), function-call operator, function objects, 457, 469, 665 adapters, binders, adapting functions, arithmetic function objects, bitwise function objects, 473 comparison function objects, logical function objects, member functions, negators, 476 threads, writing, function pointers, implementing, 570 threads, typedefs, function templates, overloading, specialization, function-try-blocks, functional relationships, functionality adding, 85 replacing, 85 required, user interface, functions, 22 23, 684. See also algorithms accumulate( ), 486 addone( ), 30 alltrue( ), 472 alternative function syntax, 709, 739 auditvoterrolls( ), binary_search( ), 486 C++11 syntax, 304 callbacks, predicate function callbacks, 460 copy_backward( ), copystring( ), as data, declarations, 23 doubledelete( ), doworkinthread( ), 814 empty( ), 477 equal( ), equal_range( ), 486 Find( ), 710 find( ), , find_all( ), find_if( ), for_each( ), friends, functwo( ), 345 getduplicates( ), hash functions, includes( ), 501 incr( ), 278 lexicographal_compare( ), lower_bound( ), 486 main( ), 6 make_move_iterator( ), 601 malloc( ), 762 malloc_int( ), 783 max( ), 482 mem_fn( ), min( ), 482 minmax( ), 482 mismatch( ), namespaces and, 7 operator( ), parameters, 23 partial specialization, overloading and, printvector( ), 405 procedures and, 78 process( ), 571 processvalues( ), prototypes, 22 ptr_fun( ), 479 random_shuffle( ), 501 readname( ), 554 realloc( ), 764 sizeof( ), 511 sort( ), stand-alone, reuse and, 57 static, 291 strcat( ), 29, 511 strcopy( ), 511 strlen( ), 511 swap( ), 482, 619 testcallback( ), 467 threadfunc( ), 813 throw_with_nested( ), 343 unexpected( ), 333 upper_bound( ), 486 functors, 665 functwo( ) function, 345 Fundamental Law of Debugging, 928 futures, G garbage collection, GDB debugger, generality, generate( ) algorithm, generating random numbers, , random number engines, predefined, generic programming, 362 reusable code and, 683 templates and, 683 generic template class, 364 get( ) method, getduplicates( ) function, getline( ) method, 557 getsize( ) method, 363 getstring( ) method, 234 renaming, 189 getters/setters, 124 getvalue( ) method, 135 renaming, 189 global functions, operators, GNU project, 66 good( ) method, 550, 558 GPL (GNU Public License), 66 gprof, granularity of testing, graphical user interface, 888 graphics cards, cores, 798 greedy repeats, 525 grouping (ECMAScript),

9 handles inline methods H handles, 99 has-a relationship, is-a relationship comparison, hash( ) function, implementation, hash functions, , 605 DefaultHash class, 607 hash class definition, hash tables, 374, 386, , 605. See also unordered associative containers unordered_map, HashIterator class, methods, hashmap, interface, hashmap class accessor operations, 640 as associative container, clear operation, 639 constructor, , 634 emplace operations, erase operations, implementation, 610 initializer list assignment operator, 635 initializer list constructor, insertion operations, sequential containers, 641 as STL container, template demonstration, 615 templates, typedefs, 609 header files, algorithms, 1048 allocators, 1048 containers, exceptions, 1049 general utilities, I/O streams, 1050 interators, 1048 mathematical utilities, 1049 template definitions, 694 threading library, 1051 heap, 24, 25 constructors on, 145 objects on, vector allocation, 397 heap arrays, multi-dimensional, Hello, World arrays, std::array, comments, 4 conditionals conditional operators, if/else statements, 16 switch statements, 17 ternary operator, 17 functions, I/O streams, 6 7 loops do/while, 19 for loop, while loop, 19 main( ) function, 6 namespaces, 7 8 operators, preprocessor directives, 5 6 types enumerated, structs, variables, 8 11 helper methods, 138 helper routines assignment operator, copy constructors, hierarchies, classes, exceptions, diamond shaped, 242 exceptions, parallel, 243 reusable code and, 101 high-order bytes, 886 homogenous elements, 369 Hungarian Notation, I I/O bidirectional, overview, streams, 6 7, 366 header files, 1050 user input, 7 if/else statements, 16 cascading if statement, 16 #ifdef directive, 5 #ifndef directive, 5 ifstream destructor, 562 ifstream object, bool( ) conversion operator, 321 implementation cross-platform development and, 886 compiler and, 887 library implementations, 887 implementation class, 207 implementation workflow, 846 versus interface, 93 implicit conversion, In-class member initializers, in-memory streams, #include directive, 5 includes, preprocessor directives, 6 includes( ) function, 501 incr( ) function, 278 increment( ) method, increment operator (++), 11 overloading, indexing, iterators and, 404 inheritance, 84, bug fixes and, 212 clients and, extending classes, constructors, derived classes, 212 functionality adding, 85 replacing, 85 multiple, 91 92, uses, non-public, 264 parent classes, 212 pointers, 214 polymorphism, spreadsheet, preventing, 215 properties, 85 replacing, 85 reuse subclasses and, WeatherPrediction class, 219 specialization comparison, 708 subclasses, superclasses, 212 templates comparison, initialization constructors, (See also ctor-initializers) lists (C++11), 306 n-class member initializers, nonlocal variables, 292 references, 268 uniform in C++, , 397 zero-initialization, template types, initializer-list constructors, assignment operators, 635 hashmap class, initializer_list, 397 inline keyword, inline methods,

10 input libraries input error handling, locale awareness, 559 manipulators, objects, streams, get( ) method, getline( ), 557 peek( ), putback( ), 556 readname( ) function, 554 unget( ), input stream iterator, 599 inrange( ) method, 171 insert( ) method, map associative container, insert iterators, insertion operators, overloading, insert_iterator class, instantiation, 365 selective, 693 int variable, 9 integer non-type parameters, integers, 9 enumerated types, 13 integration tests, methods, interface, 206 algorithms, 370 API (Application Programming Interface), 94 containers, 370 exposed, audience considerations, 93 subsystem interface, 94 utility classes versus libraries, 94 versus implementation, 93 implementation class, 207 interface class, 207 usability, interface class, 207 internal linkage, 288 Interop services, 894 interviews, intvector, 398 invalid_argument exception, 322 invalidation of iterators, 406 ios_base::out, 562 iostream subclass, is-a relationship, has-a relationship comparison, polymorphism, 86 iterator adapters (STL) insert iterators, move iterators, reverse iterators, stream iterators, iterator design pattern, iterators, 377, arguments, 458 categories, 389 const, 625 generate( ) algorithm, header files, 1048 indexing and, 404 input stream iterator, 599 invalidation, 406 list container, 414 map associative container, methods, operations, output stream iterator, 598 regular expressions, 530 safety, template arguments, 482 traits, typedefs, , types, 481 vector, writing, iterator_traits class, J K JNI (Java Native Interface), keywords auto, 402, 570, 710, , break, 19 const, 31 32, 187, methods, 286 parameters, 32, pointers, , 771 references, variables, constexpr, continue, 19 decltype, delete, 761 extern, final, 215 friend, 196 inline, new, 761 noexcept, 331 override, 246 static functions, 291 variables, 291 L throw, 322 typename, 613 using, 246 virtual, 216 lambda expressions capture block, 465 as parameters, 467 return types, syntax, threading, 810 language extensions, 887 language-level efficiency, 860, catching exceptions by reference, 864 move semantics, 864 pass-by-reference, return by reference, temporary objects, 864 lexicographical_compare() function, libraries atomic operations, C standard library, C++ standard library (See C++ standard library) Chrono clocks, duration, time_point class, code reuse, 58 implementations, 887 library handles, 294 netwrklib, 890 open source, finding, using, procedural, object-oriented wrapper, Ratio, regex, regex_iterator( ), regex_match( ), regex_replace( ), regex_search( ), regex_token_iterator( ), regular expressions library, 509 standard library, 35 classes,

11 life cycles of objects methods life cycles of objects, 142 assigning to objects, creation, destruction, LIFO (last-in, first-out), 372 linear congruential engine, 583 linkage doubly linked list structures, external, 288, 723 internal, 288 static, 723 static keyword, linking object files, 5 streams, Linux, GDB debugger, list container, , elements accessing, 414 adding/removing, 414 enrollment, forward_list comparison, iterators, 414 merge( ) method, 416 remove( ) method, 416 remove_if( ) method, 416 reverse( ) method, 416 size, 414 sort( ) method, 416 special operations, unique( ) method, 416 literals literal pooling, 512 string literals, 512 localizing, 518 raw string literals, , 529 user-defined, C++11, little-endian ordering, 886 locales, 521 classic, 522 input and, 559 Windows, localization, 367, string literals, 518 locks double-checked locking algorithm, 822 multithreading, log( ) method, log level, 930 Logger::log( ) method, 933 logical function objects, long double variable, 10 long long variable, 9 long variable, 9 longjmp( ), 319 loops do/while loop, 19 for loop, 19 range-based, 20 loop unrolling, while loop, 19 low-level files, platform and, 888 low-order bytes, 886 lower_bound( ) function, 484 M macros, preprocessor macros, main( ) function, 6 make_move_iterator( ) function, 601 make_pair( ) template, 429 make_shared( ) method, 782 malloc( ) function, 762 malloc_int( ) function, 783 map associative container constructing, elements insert( ) method, lookup, removing, 435 example, iterators, operator[ ], types, 430 unordered_map comparison, map container, 373 mark and sweep garbage collection, 775 mathematical utilities, 368 header files, 1049 Matrix class, max( ) function, 482 member functions, threads, 811 members, 135 pointers to, mem_fn( ) function, memory aliasing, 780 allocation contiguous pieces, 763 dumb pointers, 782 failure behavior, null pointers, 348 vectors, allocation errors, class-related errors, 952 double deletion, dynamic, 759 advantages, 760 allocation, , arrays, mental model, multi-dimensional arrays, pointers, errors, categories, freeing, destructors and, 172 function pointers, garbage collection, general errors, 952 heap, 24, 25 object errors, 952 object pools, 776 orphaned, 176 out-of-bounds access, 795 pointer arithmetic, pointers, 769 smart pointers, stack, 24 strings, underallocating, memory access errors, memory freeing errors, memory leaks, 367, Linux, Valgrind, Windows, memory management, custom, 775 merge( ) method, 416 Mersenne twister, 583 metaprogramming. See template metaprogramming method calls, 106 method templates, non-type parameters, methods, 135 add( ), overloading, allocate( ), 596 assign( ), 398 associative containers, at( ), 363 bad( ), 550 begin( ), 451 bind2nd( ), calling from methods, cbegin( ), cend( ), clear( ), 639 const, const keyword, 286 constructors, 34 containers, c_str( ), 891 deallocate( ), 596 declarations, ordering, decrement( ),

12 methods naming methods (continued) defining, demote( ), 38 docfunction( ), 893 doubletodouble( ), 186 emplace( ), 422 end( ), 451 eof( ), 558 erase( ), 441 fail( ), 550 findelement( ), 612 flush( ), 549, 566 func( ), 335 get( ), getsize( ), 363 getstring( ), 189, 234 getvalue( ), 135, 189 good( ), 550, 558 helper methods, 138 increment( ), inline, inrange( ), 171 insert( ), iterators, log( ), Logger::log( ), 933 make_shared( ), 782 multi, 973 namespaces and, 7 output, raw output methods, overloaded add( ), deleting, 189 operator+ method, overloading, overriding, changing parameters, chaning return type, clients and, overloaded superclass method, preventing, 219 private superclass method, static methods, superclass method access level, superclass method arguments, throw list, virtual, pointers to, promote( ), 38 pure virtual methods, push( ), 422 push_back( ), 320 put( ), rbegin( ), 597, 628 refcall( ), 274 rend( ), 597, 628 set( ), 189 setvalue( ), 135 static, 186, 288 stringtodouble( ), 186 testacquire( ), 919 tie( ), virtual, 216 pure, wait( ), 824 what( ), 340, 550 write( ), MFC (Microsoft Foundation Classes), 982 min( ) function, 482 minmax( ) function, 482 mismatch( ) function, mix-in classes, 92, variadic templates, mod operator (%), 11 modifying algorithms, , copy( ), erase( ), 497 iota( ), 491 move( ), replace( ), 497 reverse( ), 499 transform( ), unique( ), modular decomposition, 121 move( ) function, move assignment operator, , 653 move constructor, move iterators, move semantics, algorithms, 462 language-level efficiency and, 864 move iterators, MoveableClass instances, 601 move_backward( ) function, moving ownership, 279 multi-dimensional arrays, dynamic memory, multi-methods, 973 multimap container, 373 element lookup, 438 example, multiple inheritance, 91 92, uses, multiplication operator (*), 11 multiset associative container, 444 multithreaded programming, 797 cancelling threads, 812 condition variables, deadlocks, debugging, exceptions, futures, introduction, lambda expression, 810 locks, logger class example, member functions, 811 mutual exclusion, mutex classes, race conditions, results retrieval, 812 std::call_once( ), thread local storage, thread pools, threading design, threads function object, function pointers, multithreading singleton design pattern and, threading models, 71 mutability, lambda expressions, 463 mutable data members, 188 mutex classes, timed, writing to streams, mutual exclusion, mutex classes, MVC (Model-View-Controller), 70 object-oriented frameworks, MyEnum, 15 N N-dimensional grids, template recursion and, name mangling, 892 namespaces, 7 8 anonymous, 290 functions, 7 methods, 7 namespaced constants, 124 naming ambiguity, base classes, 242 conventions capitalization, 124 counters,

13 narrowing, uniform initialization operators Hungarian Notation, namespaced constants, 124 prefixes, 123 getters, 124 selecting, setters, 124 narrowing, uniform initialization, 303 negative tests, 919 negators, 476 nested classes, nested exceptions, nested_exception mix-in class, 342 networking, platform and, 888 netwrklib library, 890 new-expression, 675 new keyword, 761 NGrid template class, noexcept keyword, 331 non-integral array indices, non-modifying alorigthms, search algorithms, non-public inheritance, 264 non-type template parameters, , method templates, pointers, 723 reference, 723 non-western character sets, noncatastrophic bugs, 928 nonlocal variables, order of initialization, 292 nonstandard strings, 29 nothrow, 348 null pointers C++11, dereferencing, 27 memory allocation routines, 348 numbers, rational, 572 numeric conversion, numerical processing algorithms, 380, 486 O object-oriented frameworks, 981 MVC (Model-View-Controller), object-oriented languages C++ as, philosophy behaviors, 80 classes, components, 79 properties, 79 object-oriented wrappers, object pools, 776 design-level efficiency, objects, 81 83, 684 aggregation, arrays of, constructors, writing, elements, fields, even objects, 823 files, linking, 5 function objects, 111, 457 adapters, adapting functions, arithmetic function objects, comparison function objects, logical function objects, member functions, negators, 476 writing, on heap, inheritance, multiple, input, life cycles, 142 assigning to objects, creation, destruction, memory, dynamic allocation, output, passing by reference, relationships has-a, 83 84, hierarchies, is-a, 84 86, mix-in classes, 92 not-a, as return values, on stack, 141 destruction, 161 out of scope, 161 temporary, observer design pattern, ofstream destructor, 562 OOP (object-oriented programming), 33 opaque classes, 99 open source libraries, finding, using, open source programs, operational algorithms, 381, operator*, operator->, operator->*, 669 operator[ ], map associative container, operator( ) function, operator delete, overloading, operator+ method, global, operator new, 676 overoading, operator overloading, 106, , 362 add( ) method, allocation/deallocation operators, argument types, 648 arithmetic, increment/decrement, shorthand operators, unary minus and unary plus, behavior choices, 649 binary logical operators, bitwise operators, comparison, dereferencing operators, extraction operators, function-call operator, implementing overloaded, 238 insertion operators, limitations, methods versus global functions, operator delete, operator+ method, global, operators not to overload, 649 overloadable operators, placement new, 676 reasons for, 646 return types, subscripting operator, non-integral array indices, read-only access, type building, 206 use, 366 operators %=, 12 &, 12 &=,

14 operators partial specialization operators (continued) *=, 12 +=, 12 <<, 12 <<=, 12 >>, 12 >>=, 12 ^, 12 ^=, 12, 12 =, 12 -=, 12 /=, 12 arithmetic, 470 arity, 646 assignment operator, 162 declaring, 163 defining, 164 move assignment operator, Spreadsheet class, associativity, 647 binary, 11 bitwise, 453 conditional, conversion ambiguity, bool( ), 321 Boolean expressions, C++11, writing, dereferencing, execution order, 13 function-call, global functions, 648 overloading, placement new, 676 precedence, 647 scope resolution, 137 sequencing operator, 649 string class, ternary, 11, 17 unary, 11 orphaned memory, 176 ostream_iterator class, 598 out scope (objects on stack), 161 output error handling, manipulators, objects, overview, raw output methods, standard output, 548 streams, buffered, 549 flush( ) method, 549 put( ) method, write( ) method, output stream iterator, 598 overload resolution, 189 overloading function partial specialization and, function templates, 712 methods, deleting overloaded, 189 operator+ method, operator+ method (global), operators arithmetic, implementing overloaded, 238 single polymorphism with, superclass method, overloading operators, 106, , allocation/deallocation operators, argument types, 648 arithmetic operators increment/decrement, unary minus and unary plus, behavior choices, 649 binary logical operators, bitwise operators, comparison operators, dereferencing operators, extraction operators, function-call operator, insertion operators, limitations, operator delete, operators not to overload, 649 overloadable operators, placement new, 676 reasons for, 646 return types, subscripting operator, non-integral array indices, read-only access, type building, 206 use, 366 override keyword, 246 overriding behaviors, 85 methods, changing parameters2, P changing return type, clients and, overloaded superclass method, preventing, 219 private superclass method, static methods, superclass method access level, superclass method arguments, syntax, throw list, virtual, what( ), 340 packets, buffers, pair class, parallel hierarchies, 243 parameter packs, 742 parameters, 684 Allocator, 393 const keyword, const keyword and, 32 const reference parameters, default, functions, 23, 806 lambda expressions, 463, 467 overridden methods, references, , 275 template template parameters, templates, 684 integer non-type parameters, method templates, non-type parameters, , parameter packs, 742 type parameters, vector, 393 parent classes, 212 parent constructors, private, 264 protected, 264 references, parent constructors, parent destructors, parenthese in code, 128 partial specialization classes, functions,

15 pass-by-reference, efficiency reference parameters pass-by-reference, efficiency, passing objects, by reference, by value, disallowing, 180 variables by reference, 28 by value, 28 passwords, encrypting, pattern-matching, 369 patterns. See design patterns subsitution pattern, 524 peek( ) method, performance, reuse and, Perl, password encryption, placement new operators, 676 platform, definition, 883 platform-specific features, 888 pointer arithmetic, pointers, 769 arrays, casting and, const keyword, , 771 dangling, 174, 367, 794 declaring, 25 dereferencing, 27, 770 dynamic memory, function pointers, threads, inheritance and, 214 to members, mental model, 770 to methods, non-type template parameters, 723 null, C++11, to references, 270 versus references, , references from, 272 references to, 270 smart pointers, 26, auto_ptr, 780 C++ standard library, 367 class writing, reference counting, 785 shared_ptr, stack unwinding and, 346 SuperSmartPointer, 786, unique_ptr, structures, 27 this, typedefs, variables, 27 polymorphism, 86 exceptions and, inheritance, spreadsheet, single, with overloading, SpreadsheetCell hierarchy, POSIX, initializing semaphores, 319 #pragma directive, 5 precedence, ECMAScript, 526 precision numbers, double precision numbers, 10 predicate function callbacks, 460 prefix comments, preprocessor directives, 5 6 #define, 5 #endif, 5 #ifdef, 5 #ifndef, 5 #include, 5 includes, 6 #pragma, 5 preprocessor macros, printf( ), 545 printing, tuples, printvector( ) function, 405 priority_queue container adapter, 424 example, operations, 425 private, superclasses, procedural library, object-oriented wrapper, procedures, 684 functions and, 78 process( ) function, 571 processvalues( ) function, profiling, gprof example, Visual C example, programming generic, 362 multithreaded (See multithreaded programming) scripting comparison, programming design, 50 importance of, programming languages, 899 programs, employee records sample program, promote( ) method, 38 properties, 79 inheritance and, 85 replacing, 85 protected methods, inheritance, 214 proxy design pattern, ptr_fun( ) function, 479 public extensions, public methods, inheritance, 214 pure virtual methods, push( ) method, 422 push_back( ) method, 320, 392 put( ) method, putback( ) method, 556 Q QA (quality assurance), 905 queue container adapter, 421 example, operations, 422 R r-char-sequence, 517 race conditions, random number engine adapter, 368, 584 random number engines, 368, linear congruential engine, 583 Mersenne twister, 583 predefined, subtract with carry engine, 583 random numbers C++ standard library, 368 distribution, 582, generating, , random_device engine, random_shuffle( ) function, 501 range-based for loop, 20 range specification, 527 ranges destination, source, Ratio library, rational numbers, 572 raw output methods, raw string literals, , 529 rbegin( ) method, 597, 628 read-only access, reading from files, 971 readname( ) function, 554 realloc( ) function, 764 recursion, templates, refactoring, decomposition and, 121 refcall( ) method, 274 reference counting smart pointers, reference data members, 181, const reference data members, 185 reference parameters, 275 const,