Subject Index
(Part of C++ FAQ, Copyright © 1991-2011, Marshall Cline, cline@parashift.com)

[ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• #define macros
  • Evil but sometimes useful ... [32.4], [33.6], [33.7]
  • Evil! ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Prefer const vs. #define ... [29.7]
  • See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.7]
  • Use them when declaring member-function pointers ... [33.6]
  • With if ... [39.4]
  • With multiple lines ... [39.5]
  • With token pasting ... [39.6]
• #include
  • Including C headers ... [32.2], [32.3], [32.4]
  • Use forward slash "/", not backslash "\" ... [39.7]
• ?: operator ... [27.6]
• ! operator (bang!) ... [29.13]
• ## = token pasting ... [39.6]

"A" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• A form of type safety (Const correctness) ... [18.2]
• A2PS (see Pretty printing) ... [40.3]
• ABC (see also Inheritance) ... [22.2], [22.3]
• Abomination: f(void) ... [29.4]
• Abstract (Meaningwise) state vs. Concrete (Bitwise) state ... [18.10], [18.11]
• Abstract functions ... [20.6], [22.3], [22.4]
• Access rules
  • Derived classes can access the protected base members of only their own objects ... [7.7]
  • protected and private inheritance ... [24.6]
  • protected and private members ... [19.5], [19.6]
• Accessing std::vector<T>-elements by pointers ... [34.3]
• Acronym "FAQ" ... [6.18]
• Acronyms ... [5.1]
• Ada vs. C++ ... [6.5]
• Addition operator: operator+ ... [13.1]
• Address-of operator: operator& ... [16.25]
• Advertised behavior, contracts ... [21.11], [21.12]
• AFAICS (Acronym) ... [5.1]
• Aggregation (see also Composition) ... [24.2]
• Air vehicle (example) ... [25.5]
• Algorithm selection, Serialization and ... [36.2]
• Aliasing of const and non-const pointers (Const correctness) ... [18.15]
• Aliasing
  • Aliasing of const and non-const pointers ... [18.10], [18.14], [18.15], [18.16]
  • References are aliases for objects ... [8.1], [8.6], [8.7]
• All Terrain Vehicle (ATV) ... [30.5]
• All; One size does not fit all ... [6.16], [6.17], [9.3], [17.5], [17.8], [18.8], [18.9], [19.8], [21.8], [23.3], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
• Amphibious vehicle (example) ... [25.7]
• ANSI ... [6.12]
  • ANSI C ... [6.11]
  • ANSI C++ ... [6.13]
  • ANSI C++ committee "X3J16" ... [6.12], [30.1]
• Answers, Not Just Questions (in the FAQ) ... [6.18]
• Anything: Container of Thing vs. of Anything ... [21.3]
• Apple: Bag of Apple vs. of Fruit ... [21.3]
• Arenas, memory ... [11.14]
• Arithmetic of pointers ... [8.8], [11.14], [13.9], [13.13], [21.4], [23.12], [31.7], [34.3]
• Arithmetic operators (see also Operator overloading) ... [13.9]
• Arithmetic, floating point ... [29.17], [29.18]
• Arity ... [13.7]
• Arrays
  • Elements init'd via the default ctor ... [10.5]
  • Evilness of ... [16.17], [17.11], [21.5], [34.1]
  • How to access the raw array stored inside a std::vector<T> ... [34.3]
  • Multi-dimensional, Using pointers ... [16.16]
  • Multi-dimensional, Using specific classes ... [16.17]
  • Multi-dimensional, Using templates ... [16.18], [16.19]
  • Specifying length at runtime ... [16.20]
• Artistic Style (see Pretty printing) ... [40.3]
• Ask the right questions
  • Don't trust an answer from someone who hasn't heard the real question ... [25.2]
  • On multiple inheritance ... [25.5], [25.7]
  • What should be used ... [18.8], [18.9]
  • When/where to invest your time ... [19.9]
  • Who will create them ... [19.8]
  • Why using a try block here ... [17.7]
• Assigning a reference ... [8.2]
• Assigning references ... [8.2]
• Assignment operator (see also Operator overloading) ... [12], [22.5]
• Assignment operator ... [12]
  • Calling the Base Class assignment operator ... [12.4]
  • Check for self-assignment ... [22.5], [27.10]
  • Return *this ... [27.10]
  • Self-assignment ... [12.1], [12.2], [12.3]
  • Use const in parameter ... [27.10]
• Associative array ... [34.2]
• Associativity ... [13.7]
• atoi() ... [39.2]
• Attachments on postings: don't! ... [5.4]
• ATV ... [30.5]
• Author ... [1.1]
• auto_ptr ... [17.10], [23.6], [26.13], [34.6]
• Avoid catch-by-pointer (usually) (see also under Exceptions) ... [17.13], [17.14]
• Avoid catch-by-value (see also under Exceptions) ... [17.13]
• Avoiding an overabundance of try/catch blocks (see also under Exceptions) ... [17.7]
• Avoiding code duplication ... [35.9]
• Avoiding decision logic ... [20.6]

"B" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Backtracking ... [5.3]
• Bad input, ignoring (input/output) ... [15.3]
• Bad path; see Exceptions ... [17.3], [17.4]
• Bad programming practices ... [6.15]
  • Arrays ... [16.17], [17.11], [21.5], [34.1]
  • Casting Derived** → Base** ... [21.2]
  • Casting Foo** → Foo const** ... [18.17]
  • Casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • char* (use a string-like class instead) ... [13.6], [17.11]
  • Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Derived** → Base**, Casting ... [21.2]
  • Explicitly calling destructors (sometimes okay) ... [11.10]
  • Explicitly calling destructors on local objects ... [11.5], [11.6]
  • Foo** → Foo const**, Casting ... [18.17]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Missing virtual on some base class dtors ... [20.7]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Mixing realloc() and new ... [16.5]
  • Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Preprocessor ... [29.8]
  • Unnecessary global variables ... [33.2], [39.8]
  • Unnecessary use of "dumb" pointers ... [34.6]
• bad_alloc (see also under Exceptions) ... [16.6], [16.7]
• Bag of Apple vs. of Fruit ... [21.3]
• Bang (!) operator ... [29.13]
• Base class ... [19.3]
• Basics (Const correctness) ... [29.6]
• Basics of templates (see also under Templates) ... [35.1]
• Beautifier, Code
  • A2PS ... [40.3]
  • Artistic Style ... [40.3]
  • C++2LaTeX ... [40.3]
  • C-Clearly ... [40.3]
  • GNU indent ... [40.3]
  • Grind ... [40.3]
  • HPS Beauty ... [40.3]
  • Lgrind ... [40.3]
  • ProFactor StyleManager ... [40.3]
  • Source Styler for C++ ... [40.3]
  • StyleManager, ProFactor ... [40.3]
  • Tgrind ... [40.3]
  • Uncrustify ... [40.3]
• Behavior: Advertised vs. implemented ... [21.11], [21.12]
• Behavioral equivalence (see also Operator overloading) ... [13.9]
• Beliefs, naive/wrong
  • "Always" and "Never" rules ... [23.3]
  • "Evil" things should never be used ... [6.15]
  • Always name numeric literals ... [29.11]
  • Friendship breaks encapsulation ... [14.2]
  • inline functions always improve performance ... [9.3]
  • Methods always better than friend-functions ... [15.9]
  • Multi-line macros simply use {...} ... [39.5]
  • Never use #define ... [29.7]
  • Never use multiple-inheritance ... [25.2], [25.3]
  • One size fits all ... [25.6]
  • protected data is evil ... [19.8]
  • Software has rules that always apply ... [6.16], [17.8], [21.8], [23.4], [25.5]
  • There exists a purely technical definition of "good" ... [6.17]
  • Token-pasting doesn't require two levels of macros ... [39.6]
• Belorussian translation of this document ... [2.3]
• Big Picture Issues ... [6]
  • Business-centricity vs. Techno-centricity ... [6.5]
  • C++ is a practical tool ... [6.1]
  • C++ is not a perfect tool ... [6.2]
  • Length of time needed to learn OO/C++ ... [6.7]
  • Size of the installed base ... [6.6]
  • Some advantages of Generic Programming ... [6.4]
  • Some advantages of OO ... [6.3]
  • Standardization of C++ ... [6.12], [6.13]
• Big Three, Law of ... [16.17], [22.5], [27.10]
• Binary compatibility between vendors ... [38.9]
• Binary format mechanics, Serialization and ... [36.6]
• Binary format tradeoffs, Serialization and ... [36.3]
• Binary mode (input/output) ... [15.13]
• Binary mode for opening streams ... [15.12]
• Binary mode for std::cin and std::cout ... [15.13]
• Binary mode on MS-DOS (input/output) ... [15.12]
• Bind Dynamically During Initialization Idiom ... [23.6]
• Binding: Static vs. dynamic ... [20.2], [20.3], [20.4]
• Bits per byte ... [26.4], [26.5], [26.6]
• Bitwise (Concrete) state vs. Meaningwise (Abstract) state ... [18.10], [18.11]
• Bizarre syntax: use only when you must ... [27.14]
• Bjarne Stroustrup's web site ... [29.4]
• Bloat of code ... [9.3]
• Book (see C++ FAQ Book) ... [3]
• Books ... [28]
  • C++ FAQ Book ... [3]
  • Coding-Standards in C++ ... [27.1], [27.13]
  • Design ... [28.8]
  • Legality issues of C++ ... [28.4], [28.6]
  • Morality issues of C++ ... [28.4], [28.5]
  • Programming-by-example in C++ ... [28.4], [28.7]
• boolalpha ... [35.8]
• Borland free C++ compiler ... [38.1]
• Bosnian translation of this document ... [2.4]
• Braces: whitespace standards ... [29.10]
• Bridge pattern ... [25.5]
• British Informatics Olympiad ... [29.2]
• Broken mindset (see also under Exceptions) ... [17.6], [17.7]
• BTW (Acronym) ... [5.1]
• Bugs, subtle ... [6.15]
  • Arrays ... [16.17], [17.11], [21.5], [34.1]
  • Casting Derived** → Base** ... [21.2]
  • Casting Foo** → Foo const** ... [18.17]
  • Casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • char* (use a string-like class instead) ... [13.6], [17.11]
  • Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Derived** → Base**, Casting ... [21.2]
  • Explicitly calling destructors (sometimes okay) ... [11.10]
  • Explicitly calling destructors on local objects ... [11.5], [11.6]
  • Foo** → Foo const**, Casting ... [18.17]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Missing virtual on some base class dtors ... [20.7]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Mixing realloc() and new ... [16.5]
  • Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Preprocessor ... [29.8]
  • Unnecessary global variables ... [33.2], [39.8]
  • Unnecessary use of "dumb" pointers ... [34.6]
• Build objects: constructors ... [10.1]
• Built-in (intrinsic, primitive) data types ... [26]
  • Arrays ... [16.20]
  • Choosing between integer sizes ... [29.5]
  • Comparing with string literals ... [13.6]
  • Deleting an array of ... [16.13], [26.11]
  • Identities for operators ... [27.10]
  • Initializing in ctors ... [10.6], [26.8]
  • Initializing when static ... [10.14], [10.18], [26.9]
  • Operator overloading ... [13.1]
  • Operator overloading and ... [26.10]
  • POD types and ... [26.7]
  • Promoting to a class type ... [39.1]
• Bulgarian translation of this document ... [2.5]
• Bulirsch, R. ... [29.17], [37.7]
• Business criteria dominate technical criteria ... [6.5]
• Business issues dominate technical issues ... [6.17]
• By value
  • Return-by-value optimization ... [10.9]
  • Return-by-value optimization extended to local variables ... [10.10]
• Byte
  • At least 8 bits ... [26.4]
  • Defined ... [26.4]
  • Some have many bits ... [26.5], [26.6]
  • Units of sizeof ... [26.2]

"C" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• C language
  • __cplusplus ... [32.4]
  • Accessing C++ data members from C ... [32.9]
  • C vs. C++ ... [6.5]
  • C++ backward compatibility ... [6.11]
  • C++ is higher level than C ... [32.10]
  • C++ requires different skills/insights ... [34.1]
  • Calling C from C++ ... [32.5]
  • Calling C++ from C ... [32.6]
  • Coding standards different from C++ ... [27.3], [34.1]
  • Common linker errors ... [23.10], [32.7]
  • Converting C++ to C ... [38.13]
  • extern "C" ... [32.3]
  • Including C headers ... [32.2], [32.3], [32.4]
  • Linking must be directed by C++ ... [32.1]
  • main() must be compiled using C++ ... [32.1]
  • Mixing C and C++ code ... [32]
  • Newsgroup comp.lang.c ... [5.9]
  • Not an efficient way to learn OO/C++ ... [28.2], [34.1]
  • Passing C++ objects to C code ... [32.8], [32.9]
  • static at file-scope ... [7.5]
• C++ books ... [28]
  • C++ FAQ Book ... [3]
  • Coding-Standards in C++ ... [27.1], [27.13]
  • Design ... [28.8]
  • Legality issues of C++ ... [28.4], [28.6]
  • Morality issues of C++ ... [28.4], [28.5]
  • Programming-by-example in C++ ... [28.4], [28.7]
• C++ compiler
  • List of vendors ... [38.5]
  • Yaccable grammar ... [38.11]
• C++ compilers
  • Free: Borland free C++ compiler ... [38.1]
  • Free: Digital Mars free C++ compiler ... [38.1]
  • Free: DJGPP free C++ compiler ... [38.1]
  • Free: Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • Free: MinGW free C++ compiler ... [38.1]
• C++ FAQ Book ... [3]
  • Covers different topics from this on-line document ... [3.2]
  • ISBN ... [3.1]
  • Not same as the on-line document ... [3.2]
  • URL for Amazon.com ... [3.1]
• C++ FAQ ... [3]
  • Author ... [1.1]
  • Availability on-line ... [2]
  • Belorussian translation ... [2.3]
  • Book covers different topics ... [3.2]
  • Bosnian translation ... [2.4]
  • Bulgarian translation ... [2.5]
  • Chinese (Mainland/GB encoding) translation ... [2.6]
  • Chinese (Taiwan/Big5 encoding) translation ... [2.6]
  • Copy permissions ... [1]
  • Copying permissions ... [1.3]
  • Copyright notice ... [1.2]
  • Croatian translation ... [2.4]
  • French translation ... [2.7]
  • German translation ... [2.8]
  • Greek translation ... [2.9]
  • How you can help ... [6.19]
  • Korean translation ... [2.10]
  • Mirror WWW sites ... [2.1]
  • No Warranty ... [1.4]
  • Not same as C++ FAQ Book ... [1.6], [3.2]
  • Polish translation ... [2.11]
  • Portuguese translation ... [2.12]
  • Recent changes ... [4]
  • Romanian translation ... [2.16]
  • Russian translation ... [2.13]
  • Serbian translation ... [2.4]
  • Spanish translation ... [2.14]
  • Turkish translation ... [2.15]
• C++ Keywords
  • catch ... [17.1]
  • class ... [7.1], [7.9]
  • const ... [13.9], [18.1]
  • const_cast ... [18.13]
  • delete ... [13.10], [16.9], [16.11], [16.12], [16.14], [16.15], [38.7]
  • explicit ... [10.22], [13.9], [20.7]
  • export ... [35.14], [35.15]
  • extern ... [32], [32.3]
  • for ... [39.8]
  • if ... [17.1]
  • inline ... [9.1], [9.6], [9.7], [9.9], [39.13]
  • mutable ... [18.13]
  • new ... [16.1], [16.4], [16.5], [16.11]
  • operator ... [13.4]
  • private ... [7.4], [7.6], [24]
  • protected ... [7.4], [24]
  • public ... [7.9]
  • sizeof ... [26.1], [26.2], [26.5], [26.6]
  • struct ... [7.1], [7.9]
  • template ... [35.14]
  • this ... [10.7]
  • throw ... [17.1], [17.15]
  • try ... [17.1]
  • typeid ... [34.4]
  • typename ... [16.18], [16.19], [35.2], [35.3], [35.4], [35.12], [35.13]
  • using ... [23.9], [27.5]
  • virtual ... [16.24], [17.16], [20.7], [25.9]
• C++ Libraries FAQ ... [37.9]
• C++ to C conversion ... [38.13]
• C++0x ... [15.22]
• C++2LaTeX (see Pretty printing) ... [40.3]
• C-Clearly (see Pretty printing) ... [40.3]
• Cache Misses
  • Avoiding with a Matrix class ... [13.11], [13.12]
  • Striding the cache ... [13.11], [13.12]
• Calling base-class member functions using :: ... [20.5]
• Calling member functions defined in my base class ... [20.5]
• Calling Virtuals During Initialization Idiom ... [23.6]
• Can randomly expose errors; Multi-threading and ... [16.2]
• Can't invent new operators (see also Operator overloading) ... [13.7]
• Can't replace behavior on built-in operators (see also Operator overloading) ... [13.6], [26.10]
• Car and Truck example ... [20.6]
• Car: Parking lot of Car vs. of Vehicle ... [21.3]
• Casting Derived** → Base**, evilness of ... [21.2]
• Casting Foo** → Foo const**, evilness of ... [18.17]
• Casting pointers, evilness of ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
• catch keyword ... [17.1]
• Catch-by-pointer, avoid (usually) (see also under Exceptions) ... [17.13], [17.14]
• Catch-by-value, avoid (see also under Exceptions) ... [17.13]
• catch ... [17]
  • Avoid catch-by-pointer (usually) ... [17.13], [17.14]
  • Avoid catch-by-value ... [17.13]
  • Avoiding an overabundance of try/catch blocks ... [17.7]
  • Broken mindset ... [17.6], [17.7]
  • Catch-by-pointer, avoid (usually) ... [17.13], [17.14]
  • Catch-by-value, avoid ... [17.13]
  • Compared to return-codes and if ... [17.1], [17.2]
  • Constructors can throw exceptions ... [17.8]
  • Copy ctor must be publicly accessible ... [17.17]
  • Destructors ... [11.13], [17.9]
  • DIRR (Destruction Is Resource Reclamation) ... [6.18]
  • Eliminate some if statements ... [17.1]
  • Example of throw; to re-throw current exception ... [16.10], [17.11], [38.7], [38.8]
  • Example of try ... catch ... [16.10], [17.11], [38.7], [38.8]
  • Free lunch...NOT! ... [17.5]
  • Inherit your own exception classes (ultimately) from std::exception ... [17.12]
  • Member objects should be self-managing ... [17.10]
  • Mindset, right and wrong ... [17.6], [17.7]
  • Not one-size-fits-all ... [17.5]
  • Number of copies made internally ... [17.17]
  • Panacea...NOT! ... [17.5]
  • Polymorphically throwing ... [17.16]
  • Publicly accessible copy constructor ... [17.17]
  • RAII (Resource Acquisition Is Initialization) ... [6.18], [17.6], [17.7]
  • Requires discipline and rigor ... [17.5]
  • RRID (Resource Reclamation Is Destruction) ... [6.18]
  • Separate the "good (happy) path" from the "bad path" ... [17.4]
  • Simplify function return types and parameter types ... [17.3]
  • Simplify propagating the error information up the stack ... [17.2]
  • Stack unwinding ... [11.13], [17.9]
  • std::bad_alloc ... [16.6], [16.7]
  • std::runtime_error ... [17.12]
  • throw ... [16.6], [16.7]
  • throw; (without an exception-object after the throw keyword) ... [17.15]
  • Throwing polymorphically ... [17.16]
  • What to catch ... [17.13]
  • What to throw ... [17.12]
  • Whipping boy for the weak ... [17.5]
  • Wrong mindset ... [17.6], [17.7]
• Caveats, Serialization and ... [36.12]
• Ccdoc ... [40.1]
• ccdoc: a javadoc-like tool ... [40.1]
• Cfront C++ compiler ... [38.13]
• Chaining method calls ... [8.4], [10.20]
• Changes to this document ... [4]
• Changing the screen's colors ... [15.21]
• char* (use a string-like class instead), evilness of ... [13.6], [17.11]
• char: Defined ... [26.3], [26.4]
• char: Not necessarily the same as "character" ... [26.3]
• char: sizeof(char) is 1 ... [26.1]
• Character not necessarily the same as char ... [26.3], [26.4]
• Chinese (Mainland/GB encoding) translation of this document ... [2.6]
• Chinese (Taiwan/Big5 encoding) translation of this document ... [2.6]
• CHM version of this document ... [2.1]
• Choosing between integer sizes ... [29.5]
• Choosing member-functions vs. friend-functions ... [14.5]
• Choosing the best Serialization technique ... [36.2]
• Chopped copies ... [17.13], [17.16], [20.8], [22.5], [31.8], [34.4]
• Circles vs. Ellipses ... [21.6], [21.7], [21.8], [21.9], [21.10], [21.11]
• Circular dependencies ... [39.11]
• class keyword ... [7.1], [7.9]
• Class template is a family of classes (see also under Templates) ... [35.2], [35.12]
• Class templates ... [35.2], [35.12], [35.15]
• clear() and std::istream (input/output) ... [15.3]
• Clearing the screen ... [15.20]
• clone() methods ... [16.24], [20.8], [22.5]
• clrscr() ... [15.20]
• Code beautifier
  • A2PS ... [40.3]
  • Artistic Style ... [40.3]
  • C++2LaTeX ... [40.3]
  • C-Clearly ... [40.3]
  • GNU indent ... [40.3]
  • Grind ... [40.3]
  • HPS Beauty ... [40.3]
  • Lgrind ... [40.3]
  • ProFactor StyleManager ... [40.3]
  • Source Styler for C++ ... [40.3]
  • StyleManager, ProFactor ... [40.3]
  • Tgrind ... [40.3]
  • Uncrustify ... [40.3]
• Code bloat ... [9.3]
• Code duplication, Avoiding ... [35.9]
• Coding standards (see also Operator overloading) ... [27.10]
• Coding standards concerning (Const correctness) ... [27.10]
• Coding standards ... [27]
  • Assignment operators check assignment-to-self ... [12.1], [27.10]
  • Assignment operators return *this ... [27.10]
  • Assignment operators use const ... [27.10]
  • Avoid arrays ... [16.17], [17.11], [21.5], [34.1]
  • Avoid bizarre syntax ... [27.14]
  • Avoid casting Derived** → Base** ... [21.2]
  • Avoid casting Foo** → Foo const** ... [18.17]
  • Avoid casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid char* (use a string-like class instead) ... [13.6], [17.11]
  • Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Avoid Derived** → Base**, Casting ... [21.2]
  • Avoid dynamically typed libraries ... [37.5]
  • Avoid explicitly calling destructors (sometimes okay) ... [11.10]
  • Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
  • Avoid Foo** → Foo const**, Casting ... [18.17]
  • Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Avoid hiding nested identifiers ... [39.8]
  • Avoid macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Avoid missing virtual on some base class dtors ... [20.7]
  • Avoid mixing malloc() and delete ... [16.3]
  • Avoid mixing new and free() ... [16.3]
  • Avoid mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Avoid mixing realloc() and new ... [16.5]
  • Avoid overabundance of try/catch blocks ... [17.7]
  • Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Avoid pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid preprocessor ... [29.8]
  • Avoid unnecessary global variables ... [33.2], [39.8]
  • Avoid unnecessary use of "dumb" pointers ... [34.6]
  • Avoid zombie objects ... [17.8]
  • Bloodshed, Jihads, and Heat vs. Light ... [27.1]
  • Coding standards are never sufficient ... [27.2]
  • Coding standards are sometimes necessary ... [27.2]
  • const_cast ... [18.13]
  • Constructors should throw exceptions on failure ... [17.8]
  • Copy constructors use const ... [27.10]
  • Declare near first use ... [27.7]
  • Design classes from the outside-in ... [13.13]
  • Don't base C++ standards on C standards ... [27.3], [34.1]
  • Don't test for NULL after new ... [16.6]
  • Don't test for NULL before delete ... [16.8]
  • Explicitly calling destructors (don't!) ... [11.9]
  • Header filename extensions ... [27.9]
  • Identifier naming conventions ... [27.12]
  • Initialization lists ... [10.6], [26.8], [27.10]
  • Law of the Big Three ... [16.17], [27.10]
  • Macros that contain if ... [39.4]
  • Macros that contain multiple lines ... [39.5]
  • Macros that perform token pasting ... [39.6]
  • main() returns int, not void ... [5.8], [29.3]
  • Multiple inheritance ... [25.4]
  • Never throw exceptions from a dtor ... [17.9]
  • Operator overloading ... [27.10]
  • Prefer ++i over i++ ... [13.15]
  • Source filename extensions ... [27.8]
  • static at file-scope (don't!) ... [7.5]
  • The Ellemtel coding guidelines ... [27.13]
  • Todd Hoff's coding guidelines ... [27.13]
  • Use a std::string object rather than a char* ... [13.6], [17.11]
  • Use delete[] for arrays ... [16.12]
  • Use of the ternary ?: operator ... [27.6]
  • virtual destructors ... [20.7], [27.10]
  • Whitespace pseudo-standards ... [29.10]
• Coding-Standard books on C++ ... [27.1], [27.13]
• Colors: changing the screen's ... [15.21]
• Column-major order ... [13.11], [13.12]
• Combinations ... [5.3]
• Comma operator (see also Operator overloading) ... [13.9]
• Committee Draft (CD) for ANSI/ISO C++ ... [6.13]
• comp.lang.c++
  • Acronyms ... [5.1]
  • Don't answer FAQs ... [5.6]
  • Don't post job ads ... [5.10]
  • Don't post resumés ... [5.11]
  • FAQs for other newgroups ... [5.14]
  • How to handle off-topic postings ... [5.12]
  • How to post code ... [5.8]
  • Netiquette ... [5.4]
  • Not for homework problems ... [5.2]
  • Spam ... [5.13]
  • Subject: lines ... [5.7]
  • What if others ask FAQs ... [5.5]
  • What if others ask homework problems ... [5.3]
  • Which newsgroup to use ... [5.9]
• Compared to return-codes and if (see also under Exceptions) ... [17.1], [17.2]
• Comparisons, floating point ... [29.17], [29.18]
• Compatibility, Binary ... [38.9]
• Compilation model, separate ... [35.12], [35.13], [35.14], [35.15]
• Compile-time (see also under Templates) ... [35.10]
• Compiler dependencies ... [38], [38.5]
• Compiler option -D ... [35.14]
• Compilers for C++ ... [38.5], [38.11], [38.13]
  • Free: Borland free C++ compiler ... [38.1]
  • Free: Digital Mars free C++ compiler ... [38.1]
  • Free: DJGPP free C++ compiler ... [38.1]
  • Free: Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • Free: MinGW free C++ compiler ... [38.1]
• Composition
  • Benefits compared to freestore ... [31.4], [31.5]
  • Compared with private inheritance ... [24.2]
  • Criteria for composition vs. private inheritance ... [24.3]
  • Inlining virtual functions ... [31.5], [31.6]
• Concrete (Bitwise) state vs. Abstract (Meaningwise) state ... [18.10], [18.11]
• Conflicts; Reader/writer and writer/writer conflicts ... [36.12]
• Confusion increases cost ... [23.4]
• Conservative garbage collectors ... [16.27]
• Consistency is good, but not the greatest good ... [23.3]
• Const correctness ... [18], [18.1]
  • A form of type safety ... [18.2]
  • Aliasing of const and non-const pointers ... [18.15]
  • Basics ... [29.6]
  • Coding standards concerning ... [27.10]
  • const member functions ... [18.10]
  • const X& x vs. X const& x ... [18.8]
  • const X* x vs. X const* x ... [18.9]
  • const-overloading ... [18.12]
  • const-reference returned from const member functions ... [18.11]
  • const_cast ... [18.13], [18.14]
  • Converting Foo** → Foo const**, evilness of ... [18.17]
  • Fred& const x is nonsense ... [18.7]
  • Immutable (const) pointers ... [18.5]
  • mutable ... [18.13]
  • Pointer to const member function ... [33.8]
  • Pointer-to-const ... [18.4], [18.5], [26.13]
  • Pointer-to-const aliasing ... [18.16]
  • Prefer const vs. #define ... [29.7]
  • Reference-to-const ... [18.6], [26.13]
  • Retrofitting const correctness is hard ... [18.3]
  • X const& x vs. const X& x ... [18.8]
  • X const* x vs. const X* x ... [18.9]
• const keyword ... [13.9], [18.1]
• const member functions (Const correctness) ... [18.10]
• const pointers ... [18.4], [18.5], [18.16]
• const references ... [18.1], [18.6]
• const X& x vs. X const& x (Const correctness) ... [18.8]
• const X* x vs. X const* x (Const correctness) ... [18.9]
• const-overloading (Const correctness) ... [18.12]
• Const-overloading of the subscript operator, operator[] ... [18.12]
• const-overloading of the subscript operator, operator[] ... [13.9]
• const-reference returned from const member functions (Const correctness) ... [18.11]
• const_cast (Const correctness) ... [18.13], [18.14]
• const_cast keyword ... [18.13]
• Construct On First Use Idiom ... [10.15], [10.16], [10.17], [10.18], [26.9]
• Constructive operators should return by value (see also Operator overloading) ... [13.9]
• Constructive operators shouldn't change their operands (see also Operator overloading) ... [13.9]
• Constructors can throw exceptions (see also under Exceptions) ... [17.8]
• Constructors ... [10], [16.10]
  • Build objects from dust ... [10.1]
  • Calling a virtual from ... [10.7], [23.5]
  • Calling a virtual from; idiom ... [23.6]
  • Calling another constructor ... [10.3]
  • Coding standards re. copy constructor ... [27.10]
  • Copy, Should use const ... [27.10]
  • Default constructors ... [10.4], [10.5]
  • Init methods ... [10.3]
  • Initialization lists, Coding standard ... [10.6], [26.8], [27.10]
  • Initialization lists, Using this within ... [10.7]
  • Initialization of static data ... [10.14], [10.15], [10.17]
  • Member objects should be self-managing ... [17.10]
  • Named Constructor Idiom ... [10.8], [16.21], [16.24]
  • Order with inheritance ... [25.14]
  • Throwing exceptions ... [17.8]
  • Virtual Constructor Idiom ... [16.24], [17.16], [20.8], [22.5]
• Containers ... [34]
  • Container of Thing vs. of Anything ... [21.3], [21.4]
  • Heterogeneous ... [34.4]
  • Iterators ... [34.5]
  • Of Smart Pointers ... [34.6]
• Contiguous storage in std::vector<T> ... [34.3]
• Contracts on methods ... [21.11], [21.12]
• Conversions, invalid: Derived** → Base** pointers ... [21.2]
• Conversions, invalid: Foo** → Foo const** pointers ... [18.17]
• Conversions, invalid
  • Array-of-Derived → array-of-Base ... [21.4]
• Convert from string ... [39.2], [39.3]
• Convert to string; stringify() ... [35.8], [39.1], [39.3]
• Converting array-of-Derived → kind-of Array-of-Base, evilness of ... [21.4]
• Converting C++ to C ... [38.13]
• Converting char-pointers to numbers ... [15.22]
• Converting chars to numbers ... [15.22]
• Converting Foo** → Foo const**, evilness of (Const correctness) ... [18.17]
• Copy constructors
  • Should use const ... [27.10]
• Copy ctor must be publicly accessible (see also under Exceptions) ... [17.17]
• Copy on write (see Reference counting) ... [16.23], [16.24]
• Copy on write in reference counting ... [16.23], [16.24]
• Copy semantics ... [31.1]
• Copying permissions ... [1], [1.3]
• Copyright notice ... [1.2]
• Corruption of heap: bang, you're dead ... [16.12], [30.3], [38.7], [38.8]
• Cost, schedule, risk ... [23.3]
• count ... [27.5]
• cout ... [27.5]
• Covariant Return Types ... [20.8]
• Crash at runtime without any warning ... [11.5], [11.6], [16.2], [16.3], [16.5], [16.12], [16.13], [17.11], [20.7], [21.1], [21.4], [21.5], [26.11], [34.1], [39.8]
• create() methods (see Named Constructor Idiom) ... [10.8], [16.21], [16.24]
• Creational pattern ... [36.8]
• Croatian translation of this document ... [2.4]
• Cross delegation with virtual inheritance ... [25.10]
• cstdio header ... [15.1]
• Ctor (see also Constructors) ... [10]
• Curley-braces: whitespace standards ... [29.10]
• Cursors: moving them on the screen ... [15.19]
• Cycles within graphs (definition), Serialization and ... [36.13]
• Cygwin ... [38.5]

"D" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Dangerous programming practices ... [6.15]
  • Arrays ... [16.17], [17.11], [21.5], [34.1]
  • Casting Derived** → Base** ... [21.2]
  • Casting Foo** → Foo const** ... [18.17]
  • Casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • char* (use a string-like class instead) ... [13.6], [17.11]
  • Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Derived** → Base**, Casting ... [21.2]
  • Explicitly calling destructors (sometimes okay) ... [11.10]
  • Explicitly calling destructors on local objects ... [11.5], [11.6]
  • Foo** → Foo const**, Casting ... [18.17]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Missing virtual on some base class dtors ... [20.7]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Mixing realloc() and new ... [16.5]
  • Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Preprocessor ... [29.8]
  • Unnecessary global variables ... [33.2], [39.8]
  • Unnecessary use of "dumb" pointers ... [34.6]
• Dangerous: pure technical definitions of "good" ... [6.17]
• Dangling else ... [39.4]
• Dangling pointer ... [12.2], [16.25], [34.6]
• Death by heap corruption ... [16.12], [30.3], [38.7], [38.8]
• Death: dtor called at object's ... [11.1]
• Deciding which operators should be overloaded ... [13.8]
• Decision logic, avoiding ... [20.6]
• Decision-making
  • Business issues dominate technical issues ... [6.17]
  • Must optimize important things: schedule + cost + risk ... [23.3]
  • One size does not fit all ... [6.16], [6.17], [9.3], [17.5], [17.8], [18.8], [18.9], [19.8], [21.8], [23.3], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
  • Software development is ... [6.16], [9.3], [17.8], [19.8], [19.9], [21.8], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
• Declaration: using-declaration ... [27.5]
• Declarations, forward ... [39.11]
  • Inline functions ... [39.13]
  • Member object containment ... [39.12]
  • Templates ... [39.14]
• Declarations
  • Declare near first use ... [27.7]
  • Forward (see also under Templates) ... [39.14]
  • Function declarations ... [29.4]
  • List x(); declares a function, not an object ... [10.2]
• Decompiling executables back into C++ source code ... [38.4]
• Decrement operators operator-- (see also Operator overloading) ... [13.14], [13.15]
• Deducing template types ... [35.4]
• Deducing template types (see also under Templates) ... [35.4]
• Default code, non-abstract function is ... [20.6]
• Default code, non-pure virtual function is ... [20.6]
• Default constructors ... [10.4], [10.5], [10.21]
• Default parameters ... [10.3]
• define macros
  • Evil but sometimes useful ... [32.4], [33.6], [33.7]
  • Evil! ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Prefer const vs. #define ... [29.7]
  • See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.7]
  • Use them when declaring member-function pointers ... [33.6]
  • With if ... [39.4]
  • With multiple lines ... [39.5]
  • With token pasting ... [39.6]
• Definition (vs. declaration) ... [9.9]
• Definition of "evil" ... [6.15]
• Definition of "FAQ" ... [6.18]
• Definition of "good" must not be purely technical ... [6.17]
• Definition vs. declaration (see also under Templates) ... [35.12], [35.13], [35.14], [35.15]
• Definition vs. declaration of templates ... [35.12], [35.13], [35.14], [35.15]
• Deinitialization of a static member datum ... [10.16]
• Delegate to a sister class via virtual inheritance ... [25.10]
• delete keyword ... [13.10], [16.9], [16.11], [16.12], [16.14], [16.15], [38.7]
• delete ... [16], [16.1]
  • Allocating an array with new T[n] ... [16.11]
  • Automatically freed on program exit ... [10.16]
  • Automating a NULL test ... [16.7]
  • Breaking it into pools ... [11.14]
  • Corruption — bang, you're dead ... [16.12], [30.3], [38.7], [38.8]
  • delete and free() might use different heaps ... [16.9], [16.10]
  • delete handles NULL automatically ... [16.8]
  • delete has two steps ... [16.9]
  • delete p actually deletes *p, not p ... [16.1]
  • delete this ... [16.15]
  • delete[] uses magic ... [16.14], [38.7], [38.8]
  • delete[] vs. delete ... [16.12]
  • delete[] vs. delete for built-in types ... [16.13], [26.11]
  • Deleting an array with delete[] ... [16.11]
  • Difference between delete and delete[] ... [13.10], [16.3], [16.11]
  • Double-delete-disaster ... [16.2]
  • Garbage collectors ... [16.26], [16.27], [16.28]
  • Might use different heap from free() ... [16.9]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing with malloc() ... [16.3]
  • Multi-dimensional arrays ... [16.16], [16.17]
  • new and malloc() might use different heaps ... [16.5]
  • new has two steps ... [16.10]
  • new never returns NULL ... [16.6]
  • Placement new ... [16.10]
  • Placement new doesn't allocate ... [11.10]
  • Prohibiting local objects ... [16.21]
  • realloc() ... [16.5]
  • Reference counting ... [16.22], [16.23], [16.24], [16.25]
  • Runtime costs of ... [31.2], [31.4], [31.5]
  • std::bad_alloc ... [16.6], [16.7]
  • std::set_new_handler ... [16.7]
  • Use std::auto_ptr only when pointing into the heap ... [23.6]
  • Why use new rather than malloc() ... [16.4]
• Demand-paged virtual-memory operating-systems ... [9.3]
• Dependent member-names (see also under Templates) ... [35.19], [35.20]
• Dependent type-names (see also under Templates) ... [35.18], [35.20]
• Dereference operator: operator* ... [8.8], [13.9], [13.13], [16.22], [16.25]
• Dereference operator: operator-> ... [8.8], [16.22], [16.25]
• Derived class' assignment operator (see also Operator overloading) ... [12.4]
• Derived classes ... [19.3]
  • Assignment operators ... [12.4]
  • Can access protected parts of Base ... [19.7]
  • Can't access private parts of Base ... [19.6]
  • Derived* → Base* conversion ... [19.4], [21.2]
  • Derived* → private Base* conversion (invalid) ... [24.4]
  • Derived** → Base** conversion (invalid) ... [21.2]
• Derived** → Base**, Casting, evilness of ... [21.2]
• Design books ... [28.8]
• Design patterns
  • Bridge ... [25.5]
  • Creational ... [36.8]
  • Prototype ... [36.8]
  • Visitor ... [36.11]
• Design: Decision process must include business criteria ... [6.17]
• Destructors (see also under Exceptions) ... [11.13], [17.9]
• Destructors ... [11], [16.9], [16.14], [38.7], [38.8]
  • Base class subobjects are automagically destructed ... [11.12]
  • Calling a virtual from ... [23.5], [23.7]
  • Can't be overloaded ... [11.4]
  • Coding standards concerning ... [27.10]
  • Controlling lifetimes of locals ... [11.6], [11.7], [11.8]
  • Explicitly calling them (don't!) ... [11.5], [11.6], [11.9]
  • Explicitly calling them (sometimes okay) ... [11.10]
  • Last rites ... [11.1]
  • Member objects are automagically destructed ... [11.11]
  • Order of destruction for array elements ... [11.3]
  • Order of destruction for locals ... [11.2]
  • Order with inheritance ... [25.15]
  • Throwing an exception from (beware!) ... [11.13], [17.9]
  • virtual ... [11.12], [16.24], [20.8], [21.2], [33.13]
  • virtual destructor coding standard ... [20.7]
• Determining if inheritance is proper ... [21.12]
• Development of software is decision-making ... [6.16], [9.3], [17.8], [19.8], [19.9], [21.8], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
• Diamond, dreaded ... [25.8]
• Dictionary of Algorithms and Data Structures ... [29.2]
• Difference between .* and ->* pointers ... [33.9]
• Digital Mars free C++ compiler ... [38.1]
• Dijkstra ... [5.3]
• Directive: using-directive ... [27.5]
• Directory separator: use "/", not "\" ... [15.16], [39.7]
• DIRR (Destruction Is Resource Reclamation) (see also under Exceptions) ... [6.18]
• Disaster of double-delete ... [16.2]
• Discipline and rigor: exception handling requires ... [17.5]
• Disciplines ... [27]
  • Assignment operators check assignment-to-self ... [12.1], [27.10]
  • Assignment operators return *this ... [27.10]
  • Assignment operators use const ... [27.10]
  • Avoid arrays ... [16.17], [17.11], [21.5], [34.1]
  • Avoid bizarre syntax ... [27.14]
  • Avoid casting Derived** → Base** ... [21.2]
  • Avoid casting Foo** → Foo const** ... [18.17]
  • Avoid casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid char* (use a string-like class instead) ... [13.6], [17.11]
  • Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Avoid Derived** → Base**, Casting ... [21.2]
  • Avoid dynamically typed libraries ... [37.5]
  • Avoid explicitly calling destructors (sometimes okay) ... [11.10]
  • Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
  • Avoid Foo** → Foo const**, Casting ... [18.17]
  • Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Avoid hiding nested identifiers ... [39.8]
  • Avoid macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Avoid missing virtual on some base class dtors ... [20.7]
  • Avoid mixing malloc() and delete ... [16.3]
  • Avoid mixing new and free() ... [16.3]
  • Avoid mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Avoid mixing realloc() and new ... [16.5]
  • Avoid overabundance of try/catch blocks ... [17.7]
  • Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Avoid pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid preprocessor ... [29.8]
  • Avoid unnecessary global variables ... [33.2], [39.8]
  • Avoid unnecessary use of "dumb" pointers ... [34.6]
  • Avoid zombie objects ... [17.8]
  • Bloodshed, Jihads, and Heat vs. Light ... [27.1]
  • Coding standards are never sufficient ... [27.2]
  • Coding standards are sometimes necessary ... [27.2]
  • const_cast ... [18.13]
  • Constructors should throw exceptions on failure ... [17.8]
  • Copy constructors use const ... [27.10]
  • Declare near first use ... [27.7]
  • Design classes from the outside-in ... [13.13]
  • Don't base C++ standards on C standards ... [27.3], [34.1]
  • Don't test for NULL after new ... [16.6]
  • Don't test for NULL before delete ... [16.8]
  • Explicitly calling destructors (don't!) ... [11.9]
  • Header filename extensions ... [27.9]
  • Identifier naming conventions ... [27.12]
  • Initialization lists ... [10.6], [26.8], [27.10]
  • Law of the Big Three ... [16.17], [27.10]
  • Macros that contain if ... [39.4]
  • Macros that contain multiple lines ... [39.5]
  • Macros that perform token pasting ... [39.6]
  • main() returns int, not void ... [5.8], [29.3]
  • Multiple inheritance ... [25.4]
  • Never throw exceptions from a dtor ... [17.9]
  • Operator overloading ... [27.10]
  • Prefer ++i over i++ ... [13.15]
  • Source filename extensions ... [27.8]
  • static at file-scope (don't!) ... [7.5]
  • The Ellemtel coding guidelines ... [27.13]
  • Todd Hoff's coding guidelines ... [27.13]
  • Use a std::string object rather than a char* ... [13.6], [17.11]
  • Use delete[] for arrays ... [16.12]
  • Use of the ternary ?: operator ... [27.6]
  • virtual destructors ... [20.7], [27.10]
  • Whitespace pseudo-standards ... [29.10]
• DJGPP free C++ compiler ... [38.1]
• Doc++ ... [40.1]
• doc++: a javadoc-like tool ... [40.1]
• Doctrine of Least Surprise (see also Operator overloading) ... [13.9]
• Documentation generated by tools, HTML ... [40.1]
• Does help the users of a class (see also Operator overloading) ... [13.2]
• Does not help the developer of a class (see also Operator overloading) ... [13.4]
• Dominate: Business criteria dominate technical criteria ... [6.5]
• Donald E. Knuth ... [29.17], [37.7]
• DOS
  • Binary mode for opening streams ... [15.12]
  • Binary mode for std::cin and std::cout ... [15.13]
  • Newsgroups specializing in ... [5.9]
  • OS-specific questions/answers ... [40.5]
• Double-delete-disaster ... [16.2]
• Double-precision arithmetic ... [29.17], [29.18]
• Downloading
  • CHM version of this document ... [2.1]
  • HTML version of this document ... [2.1]
• Downloads, free
  • Bjarne Stroustrup's web site ... [29.4]
  • Borland free C++ compiler ... [38.1]
  • British Informatics Olympiad ... [29.2]
  • C++ Libraries FAQ ... [37.9]
  • Ccdoc ... [40.1]
  • Cfront C++ compiler ... [38.13]
  • Cygwin ... [38.5]
  • Dictionary of Algorithms and Data Structures ... [29.2]
  • Digital Mars free C++ compiler ... [38.1]
  • DJGPP free C++ compiler ... [38.1]
  • Doc++ ... [40.1]
  • Doxygen ... [40.1]
  • Garbage collectors ... [16.27], [16.28]
  • Grammar for C++ ... [38.11]
  • Industrial Strength C++ ... [27.13]
  • International Obfuscated C Coding Contest ... [27.14]
  • Lgrind ... [40.3]
  • LLVM C++ compiler ... [38.13]
  • Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • MinGW ... [38.5]
  • MinGW free C++ compiler ... [38.1]
  • On floating point arithmetic ... [29.17]
  • PERCEPS ... [40.1]
  • STL Error-Message filter ... [35.17]
  • Techi-Warehouse ... [5.9]
  • The Correct C++ Tutorial ... [29.21]
  • University of Valladolid Programming Contest Site ... [29.2]
• Doxygen ... [40.1]
• doxygen: a javadoc-like tool ... [40.1]
• Dreaded diamond ... [25.8]
• Dtor (see also Destructors) ... [11]
• Dubious programming practices ... [6.15]
  • Arrays ... [16.17], [17.11], [21.5], [34.1]
  • Casting Derived** → Base** ... [21.2]
  • Casting Foo** → Foo const** ... [18.17]
  • Casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • char* (use a string-like class instead) ... [13.6], [17.11]
  • Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Derived** → Base**, Casting ... [21.2]
  • Explicitly calling destructors (sometimes okay) ... [11.10]
  • Explicitly calling destructors on local objects ... [11.5], [11.6]
  • Foo** → Foo const**, Casting ... [18.17]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Missing virtual on some base class dtors ... [20.7]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Mixing realloc() and new ... [16.5]
  • Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Preprocessor ... [29.8]
  • Unnecessary global variables ... [33.2], [39.8]
  • Unnecessary use of "dumb" pointers ... [34.6]
• Duplication of code, Avoiding ... [35.9]
• Dust ... [10.1]
• Dynamic Binding During Initialization Idiom ... [23.6]
• Dynamic
  • Dynamic binding ... [6.8], [20.2], [20.3], [20.4]
  • Dynamic length arrays ... [16.20]
  • Dynamic typing ... [20.2], [30.2], [30.3], [37.5], [37.6]
  • dynamic_cast ... [34.4]

"E" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Early Lifecycle Decisions ... [6]
  • Business-centricity vs. Techno-centricity ... [6.5]
  • C++ is a practical tool ... [6.1]
  • C++ is not a perfect tool ... [6.2]
  • Length of time needed to learn OO/C++ ... [6.7]
  • Size of the installed base ... [6.6]
  • Some advantages of Generic Programming ... [6.4]
  • Some advantages of OO ... [6.3]
  • Standardization of C++ ... [6.12], [6.13]
• Echo: turning off keyboard "echo" ... [15.18]
• Eight bits: minimum size for a byte ... [26.4]
• Elements of arrays init'd via the default ctor ... [10.5]
• Eliminate some if statements (see also under Exceptions) ... [17.1]
• Ellemtel coding guidelines ... [27.13]
• Ellipses vs. Circles ... [21.6], [21.7], [21.8], [21.9], [21.10], [21.11]
• Else, Dangling ... [39.4]
• Empty parameter list: f() vs. f(void) ... [29.4]
• Encapsulation ... [6.8], [7]
  • Allows changes to internal data structure ... [13.12]
  • Based on the class, not the instance (mostly) ... [7.7]
  • Definition ... [7.4]
  • Hides stuff from code, not from people ... [7.6]
  • Improved(!) by friends ... [14.2]
  • Not necessarily violated by friends ... [14.2]
  • Security vs. Encapsulation ... [7.8]
• End-of-file (see Input/output) ... [15.2], [15.5]
• End-of-line translations in text mode ... [15.12], [15.13]
• Ending lines: std::endl vs. '\n' (input/output) ... [15.7]
• Ending output lines: std::endl vs. '\n' ... [15.7]
• endl vs. '\n' for ending output lines ... [15.7]
• Enumerations ... [29.19]
  • Compared with int ... [29.20]
  • Conversions and operators ... [29.20]
• eof and std::istream (input/output) ... [15.2], [15.5]
• Equality test operator: operator== ... [13.9], [13.13]
• Equation parsing in C++ ... [5.3]
• Erasing the screen ... [15.20]
• Error codes
  • Avoiding using the return-code-mindset with real exceptions ... [17.7]
  • Can't be used from constructors ... [17.8]
  • Clutters code that needs to propagate error information up the stack ... [17.2]
  • Merges the control flow — "good (happy) path" vs. "bad path" ... [17.4]
  • Merges the return types — "successful result" vs. "error information" ... [17.3]
  • Using try / catch / throw instead ... [17.1]
• Error messages, Understanding ... [35.17]
• Etiquette ... [5]
• Etymology ... [6.18]
• Evil things ... [6.15]
  • Arrays ... [16.17], [17.11], [21.5], [34.1]
  • Casting Derived** → Base** ... [21.2]
  • Casting Foo** → Foo const** ... [18.17]
  • Casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • char* (use a string-like class instead) ... [13.6], [17.11]
  • Choose the "lesser of two evils" ... [29.8]
  • Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Definition of "evil" ... [6.15]
  • Derived** → Base**, Casting ... [21.2]
  • Does not mean "never use these"! ... [6.16]
  • Explicitly calling destructors (sometimes okay) ... [11.10]
  • Explicitly calling destructors on local objects ... [11.5], [11.6]
  • Foo** → Foo const**, Casting ... [18.17]
  • friend classes/functions are not evil ... [15.9]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Missing virtual on some base class dtors ... [20.7]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Mixing realloc() and new ... [16.5]
  • Multiple inheritance is not evil ... [25.2]
  • Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Preprocessor ... [29.8]
  • private inheritance is not evil ... [24.3]
  • protected data is not evil ... [19.8]
  • Sometimes "evil" things are the "least bad" alternative ... [6.16]
  • Sometimes "evil" things are useful ... [29.11]
  • Unnecessary global variables ... [33.2], [39.8]
  • Unnecessary use of "dumb" pointers ... [34.6]
• Example of throw; to re-throw current exception (see also under Exceptions) ... [16.10], [17.11], [38.7], [38.8]
• Example of try ... catch (see also under Exceptions) ... [16.10], [17.11], [38.7], [38.8]
• Examples (see also Operator overloading) ... [13.3]
• Exceptions ... [17]
  • Avoid catch-by-pointer (usually) ... [17.13], [17.14]
  • Avoid catch-by-value ... [17.13]
  • Avoiding an overabundance of try/catch blocks ... [17.7]
  • Broken mindset ... [17.6], [17.7]
  • Catch-by-pointer, avoid (usually) ... [17.13], [17.14]
  • Catch-by-value, avoid ... [17.13]
  • Compared to return-codes and if ... [17.1], [17.2]
  • Constructors can throw exceptions ... [17.8]
  • Copy ctor must be publicly accessible ... [17.17]
  • Destructors ... [11.13], [17.9]
  • DIRR (Destruction Is Resource Reclamation) ... [6.18]
  • Eliminate some if statements ... [17.1]
  • Example of throw; to re-throw current exception ... [16.10], [17.11], [38.7], [38.8]
  • Example of try ... catch ... [16.10], [17.11], [38.7], [38.8]
  • Free lunch...NOT! ... [17.5]
  • Inherit your own exception classes (ultimately) from std::exception ... [17.12]
  • Member objects should be self-managing ... [17.10]
  • Mindset, right and wrong ... [17.6], [17.7]
  • Not one-size-fits-all ... [17.5]
  • Number of copies made internally ... [17.17]
  • Panacea...NOT! ... [17.5]
  • Polymorphically throwing ... [17.16]
  • Publicly accessible copy constructor ... [17.17]
  • RAII (Resource Acquisition Is Initialization) ... [6.18], [17.6], [17.7]
  • Requires discipline and rigor ... [17.5]
  • RRID (Resource Reclamation Is Destruction) ... [6.18]
  • Separate the "good (happy) path" from the "bad path" ... [17.4]
  • Simplify function return types and parameter types ... [17.3]
  • Simplify propagating the error information up the stack ... [17.2]
  • Stack unwinding ... [11.13], [17.9]
  • std::bad_alloc ... [16.6], [16.7]
  • std::runtime_error ... [17.12]
  • throw ... [16.6], [16.7]
  • throw; (without an exception-object after the throw keyword) ... [17.15]
  • Throwing polymorphically ... [17.16]
  • What to catch ... [17.13]
  • What to throw ... [17.12]
  • Whipping boy for the weak ... [17.5]
  • Wrong mindset ... [17.6], [17.7]
• Executables
  • Decompiling back to C++ source code ... [38.4]
  • inline functions and size ... [9.3]
  • Size ... [37.8]
• explicit keyword ... [10.22], [13.9], [20.7]
• Explicitly calling destructors (sometimes okay), evilness of ... [11.10]
• Explicitly calling destructors on local objects, evilness of ... [11.5], [11.6]
• Exploits developer's intuition (see also Operator overloading) ... [6.8]
• export keyword ... [35.14], [35.15]
• export keyword (see also under Templates) ... [35.14], [35.15]
• extern "C" ... [32], [32.3]
• extern keyword ... [32], [32.3]
• External resources
  • Bjarne Stroustrup's web site ... [29.4]
  • Borland free C++ compiler ... [38.1]
  • British Informatics Olympiad ... [29.2]
  • C++ Libraries FAQ ... [37.9]
  • Ccdoc ... [40.1]
  • Cfront C++ compiler ... [38.13]
  • Cygwin ... [38.5]
  • Dictionary of Algorithms and Data Structures ... [29.2]
  • Digital Mars free C++ compiler ... [38.1]
  • DJGPP free C++ compiler ... [38.1]
  • Doc++ ... [40.1]
  • Doxygen ... [40.1]
  • Garbage collectors ... [16.27], [16.28]
  • Grammar for C++ ... [38.11]
  • Industrial Strength C++ ... [27.13]
  • International Obfuscated C Coding Contest ... [27.14]
  • Lgrind ... [40.3]
  • LLVM C++ compiler ... [38.13]
  • Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • MinGW ... [38.5]
  • MinGW free C++ compiler ... [38.1]
  • On floating point arithmetic ... [29.17]
  • PERCEPS ... [40.1]
  • STL Error-Message filter ... [35.17]
  • Techi-Warehouse ... [5.9]
  • The Correct C++ Tutorial ... [29.21]
  • University of Valladolid Programming Contest Site ... [29.2]

"F" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• f(void): an "abomination" ... [29.4]
• FAQs
  • Definition ... [6.18]
  • Don't answer them ... [5.6]
  • What if others ask them ... [5.5]
• Features of C++ from a business perspective ... [6.8]
• File I/O; translations of end-of-line sequences ... [15.12], [15.13]
• Filenames
  • Extensions for header files ... [27.9]
  • Extensions for source code files ... [27.8]
  • Using "/" rather than "\" for directories ... [15.16], [39.7]
• Final classes ... [23.11]
• Final methods ... [23.12]
• find_if ... [37.3]
• Fine-point markers ... [6.16]
• First operand: friend-functions allow promotion of ... [14.5]
• Fit; One size does not fit all ... [6.16], [6.17], [9.3], [17.5], [17.8], [18.8], [18.9], [19.8], [21.8], [23.3], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
• Floating point
  • Code not linked error ... [40.6]
  • Comparisons ... [29.17], [29.18]
  • Comparisons with NaN ... [29.14]
  • Hardware ... [29.18]
  • Inaccuracies ... [29.16]
  • Infinity ... [29.15]
  • NaN ... [29.15]
  • Not-a-number ... [29.15]
  • Register ... [29.18]
• FOO machine (hypothetical) ... [26.6]
• Foo** → Foo const**, Casting, evilness of ... [18.17]
• for keyword ... [39.8]
• for loop ... [39.8]
• Format for serialization: human-readable vs. non-human-readable ... [36.3]
• Format, Binary-format for serialization ... [36.6]
• Format, Text-format for serialization ... [36.5]
• FORTRAN vs. C++ ... [6.5]
• Forward declarations (see also under Templates) ... [39.14]
• Forward declarations ... [39.11]
  • Inline functions ... [39.13]
  • Member object containment ... [39.12]
  • Templates ... [39.14]
• Four-letter words, "Think" is not ... [6.16], [6.17], [17.8], [18.8], [18.9], [21.8], [23.4], [25.5], [25.6]
• Frameworks ... [17.14]
• Fred& const x is nonsense (Const correctness) ... [18.7]
• Free C++ compilers
  • Borland free C++ compiler ... [38.1]
  • Digital Mars free C++ compiler ... [38.1]
  • DJGPP free C++ compiler ... [38.1]
  • Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • MinGW free C++ compiler ... [38.1]
• Free downloads
  • Bjarne Stroustrup's web site ... [29.4]
  • Borland free C++ compiler ... [38.1]
  • British Informatics Olympiad ... [29.2]
  • C++ Libraries FAQ ... [37.9]
  • Ccdoc ... [40.1]
  • Cfront C++ compiler ... [38.13]
  • Cygwin ... [38.5]
  • Dictionary of Algorithms and Data Structures ... [29.2]
  • Digital Mars free C++ compiler ... [38.1]
  • DJGPP free C++ compiler ... [38.1]
  • Doc++ ... [40.1]
  • Doxygen ... [40.1]
  • Garbage collectors ... [16.27], [16.28]
  • Grammar for C++ ... [38.11]
  • Industrial Strength C++ ... [27.13]
  • International Obfuscated C Coding Contest ... [27.14]
  • Lgrind ... [40.3]
  • LLVM C++ compiler ... [38.13]
  • Microsoft C++ freely downloadable command-line compiler ... [38.1]
  • MinGW ... [38.5]
  • MinGW free C++ compiler ... [38.1]
  • On floating point arithmetic ... [29.17]
  • PERCEPS ... [40.1]
  • STL Error-Message filter ... [35.17]
  • Techi-Warehouse ... [5.9]
  • The Correct C++ Tutorial ... [29.21]
  • University of Valladolid Programming Contest Site ... [29.2]
• Free lunch...NOT! (see also under Exceptions) ... [17.5]
• free() ... [16], [16.3]
  • Allocating an array with new T[n] ... [16.11]
  • Automatically freed on program exit ... [10.16]
  • Automating a NULL test ... [16.7]
  • Breaking it into pools ... [11.14]
  • Corruption — bang, you're dead ... [16.12], [30.3], [38.7], [38.8]
  • delete and free() might use different heaps ... [16.9], [16.10]
  • delete handles NULL automatically ... [16.8]
  • delete has two steps ... [16.9]
  • delete this ... [16.15]
  • delete[] uses magic ... [16.14], [38.7], [38.8]
  • delete[] vs. delete ... [16.12]
  • delete[] vs. delete for built-in types ... [16.13], [26.11]
  • Deleting an array with delete[] ... [16.11]
  • Difference between delete and delete[] ... [13.10], [16.3], [16.11]
  • Garbage collectors ... [16.26], [16.27], [16.28]
  • Might use different heap from delete ... [16.9]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Multi-dimensional arrays ... [16.16], [16.17]
  • new and malloc() might use different heaps ... [16.5]
  • new has two steps ... [16.10]
  • new never returns NULL ... [16.6]
  • Placement new ... [16.10]
  • Placement new doesn't allocate ... [11.10]
  • Prohibiting local objects ... [16.21]
  • realloc() ... [16.5]
  • Reference counting ... [16.22], [16.23], [16.24], [16.25]
  • Runtime costs of ... [31.2], [31.4], [31.5]
  • std::bad_alloc ... [16.6], [16.7]
  • std::set_new_handler ... [16.7]
  • Use std::auto_ptr only when pointing into the heap ... [23.6]
  • Why use new rather than malloc() ... [16.4]
• Freestore ... [16]
  • Allocating an array with new T[n] ... [16.11]
  • Automatically freed on program exit ... [10.16]
  • Automating a NULL test ... [16.7]
  • Breaking it into pools ... [11.14]
  • Corruption — bang, you're dead ... [16.12], [30.3], [38.7], [38.8]
  • delete and free() might use different heaps ... [16.9], [16.10]
  • delete handles NULL automatically ... [16.8]
  • delete has two steps ... [16.9]
  • delete this ... [16.15]
  • delete[] uses magic ... [16.14], [38.7], [38.8]
  • delete[] vs. delete ... [16.12]
  • delete[] vs. delete for built-in types ... [16.13], [26.11]
  • Deleting an array with delete[] ... [16.11]
  • Difference between delete and delete[] ... [13.10], [16.3], [16.11]
  • Garbage collectors ... [16.26], [16.27], [16.28]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Multi-dimensional arrays ... [16.16], [16.17]
  • new and malloc() might use different heaps ... [16.5]
  • new has two steps ... [16.10]
  • new never returns NULL ... [16.6]
  • Placement new ... [16.10]
  • Placement new doesn't allocate ... [11.10]
  • Prohibiting local objects ... [16.21]
  • realloc() ... [16.5]
  • Reference counting ... [16.22], [16.23], [16.24], [16.25]
  • Runtime costs of ... [31.2], [31.4], [31.5]
  • std::bad_alloc ... [16.6], [16.7]
  • std::set_new_handler ... [16.7]
  • Use std::auto_ptr only when pointing into the heap ... [23.6]
  • Why use new rather than malloc() ... [16.4]
• French translation of this document ... [2.7]
• Frequently-asked-questions
  • Definition ... [6.18]
  • Don't answer them ... [5.6]
  • What if others ask them ... [5.5]
• Friend functions (see also under Templates) ... [35.16]
• Friends ... [14]
  • Are not evil ... [15.9]
  • Choosing between members and friends ... [14.5]
  • Definition of friend ... [14.1]
  • friend doesn't necessarily violate encapsulation ... [14.2]
  • Friendship privileges aren't inherited ... [14.4]
  • Friendship privileges aren't reciprocal ... [14.4]
  • Friendship privileges aren't transitive ... [14.4]
  • Pros and cons of friends ... [14.3]
  • std::istream operator>> ... [15.10]
  • std::ostream operator<< ... [15.8], [15.9]
  • std::ostream operator<< (virtual) ... [15.11]
  • Templates functions, issues ... [35.16]
  • Virtual Friend Function Idiom ... [14.3], [15.11]
• from-string conversion ... [39.2], [39.3]
• From: line of a posting (see also Netiquette) ... [5.4]
• Fruit: Bag of Apple vs. of Fruit ... [21.3]
• FTP sites
  • 128.231.128.7 ... [37.6]
  • Butler.hpl.hp.com ... [37.2]
  • Ftp.cs.rpi.edu ... [37.2]
  • Ftp.cygnus.com ... [6.13]
  • Ftp.germany.eu.net ... [40.3]
  • Ftp.maths.warwick.ac.uk ... [6.13]
  • Ftp.netlab.cs.rpi.edu ... [40.5]
  • Ftp.research.att.com ... [6.13]
  • Ftp.tex.ac.uk ... [40.3]
  • Garbo.uwasa.fi ... [5.9]
  • Oak.oakland.edu ... [5.9]
  • Rtfm.mit.edu ... [5.14]
  • Venus.ycc.yale.edu ... [40.3]
  • Www.cs.rpi.edu ... [37.2]
  • Www.cygnus.com ... [40.3]
  • Www.maths.warwick.ac.uk ... [37.2]
• Fully-qualified calls to base-class member functions ... [20.5]
• Funcall operator: operator() ... [13.10], [13.11], [13.12], [16.17], [16.18], [16.19]
• Function overloading and (see also under Templates) ... [35.11]
• Function pointer, Member ... [33]
  • Address of a C++ method ... [33.4]
  • Array of pointer-to-member ... [33.7]
  • Can't convert to void* ... [33.10]
  • Contrast to pointer-to-function ... [33.1]
  • Converting to pointer-to-function ... [33.2], [33.3]
  • Difference between .* and ->* ... [33.9]
  • Passing as pointer-to-function ... [33.2]
  • Pointer to const member function ... [33.8]
  • Use a #define macro to call them ... [33.6]
  • Use a typedef to declare them ... [33.5]
• Function pointer
  • Can't convert to void* ... [33.11]
  • Contrast pointer-to-member-function ... [33.1]
  • Converting from pointer-to-member-function ... [33.3]
  • Functionoids and... ... [33.13]
  • Members ... [33]
  • Sometimes you declare them unintentionally ... [10.21]
  • Weaknesses compared to functionoids ... [33.13]
• Function template is a family of functions (see also under Templates) ... [35.3], [35.4], [35.12]
• Function templates ... [35.3], [35.4], [35.7], [35.8], [35.9], [35.12], [35.13], [35.14]
• Functionoids ... [33.12]
  • Template-style ... [33.14]
  • Virtual-style ... [33.13]
  • Vs. functors ... [33.15]
• Functions, inline ... [9]
  • Better than #define macros ... [9.5]
  • Can make executables larger ... [9.3]
  • Can make executables smaller(!) ... [9.3]
  • Can make performance better ... [9.3]
  • Can make performance worse(!) ... [9.3]
  • Can make thrashing happen ... [9.3]
  • Can make thrashing not happen(!) ... [9.3]
  • Can make zero speed-difference(!) ... [9.3]
  • Defined outside class body ... [9.7]
  • Defined within class body ... [9.8]
  • Forward declarations ... [39.13]
  • Functionoids ... [33.14]
  • Inlining virtual functions ... [31.5], [31.6]
  • Like a #define macro ... [9.1]
  • Member functions ... [9.7]
  • Non-member functions ... [9.6]
  • Procedural integration ... [9.2]
  • Safety without loss of speed ... [6.8], [9.4]
• Functions
  • Declarations ... [10.2]
  • inline allows safety with speed ... [9.4]
  • Procedural integration via inline ... [9.2]
  • Return types ... [26.13]
• Functor ... [33.15]
• FWIW (Acronym) ... [5.1]
• FYI (Acronym) ... [5.1]

"G" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Garbage collector ... [16.26]
  • Conservative ... [16.27]
  • Hybrid ... [16.27]
  • Web sites ... [16.28]
• Garbage collectors ... [16.27], [16.28]
• Gas powered engine (example) ... [25.5]
• Generalization (see also Inheritance) ... [19.3]
• Generalization, Nested ... [25.5]
• Generalized pointers: Handles ... [8.8]
• Generic programming: So what? ... [6.4]
• Genericity (see also Templates) ... [35.6]
• Genericity (see also under Templates) ... [35.6]
• German translation of this document ... [2.8]
• getch() ... [15.17]
• Global variables: Just Say No! ... [33.2], [39.8]
• GNU indent (see Pretty printing) ... [40.3]
• GNU
  • Emacs ... [40.4]
  • G++ ... [5.9]
• Good ("happy") path; see Exceptions ... [17.3], [17.4]
• Good of the many outweighs the good of the few ... [23.3]
• Good, Must not be defined in purely technical terms ... [6.17]
• Grammar for C++ ... [38.11]
• Grammar for C++, Yaccable ... [38.11]
• Graphics ... [5.9]
• Graphs of objects (definition), Serialization and ... [36.13]
• Greater-than operator: operator> ... [13.9]
• Greater-than-or-equal-to operator: operator>= ... [13.9]
• Greek translation of this document ... [2.9]
• grind (see Pretty printing) ... [40.3]
• Guidelines for when and how (see also Operator overloading) ... [13.9]
• Guidelines ... [27]
  • Assignment operators check assignment-to-self ... [12.1], [27.10]
  • Assignment operators return *this ... [27.10]
  • Assignment operators use const ... [27.10]
  • Avoid arrays ... [16.17], [17.11], [21.5], [34.1]
  • Avoid bizarre syntax ... [27.14]
  • Avoid casting Derived** → Base** ... [21.2]
  • Avoid casting Foo** → Foo const** ... [18.17]
  • Avoid casting pointers ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid char* (use a string-like class instead) ... [13.6], [17.11]
  • Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
  • Avoid Derived** → Base**, Casting ... [21.2]
  • Avoid dynamically typed libraries ... [37.5]
  • Avoid explicitly calling destructors (sometimes okay) ... [11.10]
  • Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
  • Avoid Foo** → Foo const**, Casting ... [18.17]
  • Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Avoid hiding nested identifiers ... [39.8]
  • Avoid macros ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Avoid missing virtual on some base class dtors ... [20.7]
  • Avoid mixing malloc() and delete ... [16.3]
  • Avoid mixing new and free() ... [16.3]
  • Avoid mixing new T[n] with delete p ... [16.12], [16.13], [26.11]
  • Avoid mixing realloc() and new ... [16.5]
  • Avoid overabundance of try/catch blocks ... [17.7]
  • Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
  • Avoid pointer casts ... [16.25], [18.17], [21.2], [23.12], [27.11], [30.2], [30.3], [37.5]
  • Avoid preprocessor ... [29.8]
  • Avoid unnecessary global variables ... [33.2], [39.8]
  • Avoid unnecessary use of "dumb" pointers ... [34.6]
  • Avoid zombie objects ... [17.8]
  • Bloodshed, Jihads, and Heat vs. Light ... [27.1]
  • Coding standards are never sufficient ... [27.2]
  • Coding standards are sometimes necessary ... [27.2]
  • const_cast ... [18.13]
  • Constructors should throw exceptions on failure ... [17.8]
  • Copy constructors use const ... [27.10]
  • Declare near first use ... [27.7]
  • Design classes from the outside-in ... [13.13]
  • Don't base C++ standards on C standards ... [27.3], [34.1]
  • Don't test for NULL after new ... [16.6]
  • Don't test for NULL before delete ... [16.8]
  • Explicitly calling destructors (don't!) ... [11.9]
  • Header filename extensions ... [27.9]
  • Identifier naming conventions ... [27.12]
  • Initialization lists ... [10.6], [26.8], [27.10]
  • Law of the Big Three ... [16.17], [27.10]
  • Macros that contain if ... [39.4]
  • Macros that contain multiple lines ... [39.5]
  • Macros that perform token pasting ... [39.6]
  • main() returns int, not void ... [5.8], [29.3]
  • Multiple inheritance ... [25.4]
  • Never throw exceptions from a dtor ... [17.9]
  • Operator overloading ... [27.10]
  • Prefer ++i over i++ ... [13.15]
  • Source filename extensions ... [27.8]
  • static at file-scope (don't!) ... [7.5]
  • The Ellemtel coding guidelines ... [27.13]
  • Todd Hoff's coding guidelines ... [27.13]
  • Use a std::string object rather than a char* ... [13.6], [17.11]
  • Use delete[] for arrays ... [16.12]
  • Use of the ternary ?: operator ... [27.6]
  • virtual destructors ... [20.7], [27.10]
  • vs. rules ... [6.16], [6.17], [9.3], [17.5], [17.8], [18.8], [18.9], [19.8], [21.8], [23.3], [23.4], [25.2], [25.3], [25.5], [25.6], [29.7], [29.11], [36.2], [36.3], [36.5], [36.6]
  • Whitespace pseudo-standards ... [29.10]

"H" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• HAND (Acronym) ... [5.1]
• Handles as generalized pointers ... [8.8]
• Happy ("good") path; see Exceptions ... [17.3], [17.4]
• Hardware, floating point ... [29.18]
• Has-a (see also Composition) ... [19.2], [24.2]
• Header files
  • Filename extensions ... [27.9]
  • Standard headers ... [27.4]
• Heap-sort ... [5.3]
• Heap ... [16]
  • Allocating an array with new T[n] ... [16.11]
  • Automatically freed on program exit ... [10.16]
  • Automating a NULL test ... [16.7]
  • Breaking it into pools ... [11.14]
  • Corruption — bang, you're dead ... [16.12], [30.3], [38.7], [38.8]
  • delete and free() might use different heaps ... [16.9], [16.10]
  • delete handles NULL automatically ... [16.8]
  • delete has two steps ... [16.9]
  • delete this ... [16.15]
  • delete[] uses magic ... [16.14], [38.7], [38.8]
  • delete[] vs. delete ... [16.12]
  • delete[] vs. delete for built-in types ... [16.13], [26.11]
  • Deleting an array with delete[] ... [16.11]
  • Difference between delete and delete[] ... [13.10], [16.3], [16.11]
  • Garbage collectors ... [16.26], [16.27], [16.28]
  • Mixing malloc() and delete ... [16.3]
  • Mixing new and free() ... [16.3]
  • Multi-dimensional arrays ... [16.16], [16.17]
  • new and malloc() might use different heaps ... [16.5]
  • new has two steps ... [16.10]
  • new never returns NULL ... [16.6]
  • Placement new ... [16.10]
  • Placement new doesn't allocate ... [11.10]
  • Prohibiting local objects ... [16.21]
  • realloc() ... [16.5]
  • Reference counting ... [16.22], [16.23], [16.24], [16.25]
  • Runtime costs of ... [31.2], [31.4], [31.5]
  • std::bad_alloc ... [16.6], [16.7]
  • std::set_new_handler ... [16.7]
  • Use std::auto_ptr only when pointing into the heap ... [23.6]
  • Why use new rather than malloc() ... [16.4]
• Heat vs. light ... [27.1]
• Heterogeneous containers ... [34.4]
• Hiding inherited public features, evilness of ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
• Hiding rule ... [7.7], [23.9]
• Homework problems ... [5.2], [5.3]
• Homogeneous containers ... [34.4]
• Hostility ... [32.10]
• How to learn OO/C++ ... [28]
• How you can help with the C++ FAQ ... [6.19]
• HPS Beauty (see Pretty printing) ... [40.3]
• HR (see Human Resources) ... [6.14]
• HTML documentation: tools that generate ... [40.1]
• HTML postings: don't! ... [5.4]
• HTML version of this document ... [2.1]
• Human Resources: questions to ask in an interview ... [6.14]
• Human-readable format mechanics, Serialization and ... [36.5]
• Human-readable format tradeoffs, Serialization and ... [36.3]
• Hybrid garbage collectors ... [16.27]
• Hybrid OO programming languages ... [28.3]
• Hype ... [6.3], [6.4]
• Hypothetical FOO machine ... [26.6]

"I" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• I/O; translations of end-of-line sequences ... [15.12], [15.13]
• Identity of an object ... [36.11]
• Idioms
  • Calling Virtuals During Initialization Idiom ... [23.6]
  • Construct On First Use Idiom ... [10.15], [10.16], [10.17], [10.18], [26.9]
  • Dynamic Binding During Initialization Idiom ... [23.6]
  • Named Constructor Idiom ... [10.8], [16.21], [16.24]
  • Named Parameter Idiom ... [10.20]
  • Polymorphic Exception Idiom ... [17.16]
  • Public Overloaded Non-Virtuals Call Protected Non-Overloaded Virtuals Idiom ... [23.3]
  • Virtual Constructor Idiom ... [16.24], [17.16], [20.8], [22.5]
  • Virtual Friend Function Idiom ... [15.11]
• if (std::cin >> foo) and std::istream (input/output) ... [39.2], [39.3]
• if (std::cout << foo) and std::istream (input/output) ... [39.1]
• if keyword ... [17.1]
• if
  • Avoiding decision logic via virtual functions ... [20.6]
  • Some are eliminated by try / catch / throw ... [17.1]
  • Unnecessary ifs increase bugs, cost, time-to-market ... [17.1]
  • Within macros ... [39.4]
• ignore() and std::istream (input/output) ... [15.3]
• IMAO (Acronym) ... [5.1]
• IMHO (Acronym) ... [5.1]
• Immutable (const) pointers ... [18.5]
• Immutable (const) pointers (Const correctness) ... [18.5]
• IMNSHO (Acronym) ... [5.1]
• IMO (Acronym) ... [5.1]
• Imperfect programming languages ... [6.2]
• Improper inheritance: behavior, not just interface ... [21.12]
• include
  • Including C headers ... [32.2], [32.3], [32.4]
  • Use forward slash "/", not backslash "\" ... [39.7]
• Increment operator: operator++ ... [13.9], [13.13]
• Increment operators operator++ (see also Operator overloading) ... [13.14], [13.15]
• Indirection, Extra layers of ... [31.5]
• Industrial Strength C++ ... [27.13]
• Inequality test operator: operator!= ... [13.9], [13.13]
• Infinite recursion, Serialization and ... [36.11]
• Infinity: floating point numbers ... [29.15]
• Infix operators ... [5.3]
• Inherit your own exception classes (ultimately) from std::exception (see also under Exceptions) ... [17.12]
• Inheritance but no pointers, Serialization and ... [36.8]
• Inheritance, Multiple ... [25]
  • Alternate designs ... [25.5]
  • Constructor order ... [25.14]
  • Destructor order ... [11.12], [25.15]
  • Disciplines for using ... [25.4]
  • Is not evil! ... [25.2], [25.3]
  • Object layout in memory ... [32.9], [38.9]
  • Pointer conversions unknown to C compiler ... [32.8]
  • Sometimes unnecessary ... [24.2]
  • Strategy vs. tactics ... [25.1]
  • Tradeoff matrix ... [25.6]
  • Vehicle example ... [25.5], [25.7]
  • When introduced into C++ language ... [38.12]
• Inheritance, private ... [24], [24.1]
  • Access rules ... [24.6]
  • Compared with composition ... [24.2]
  • Criteria for private inheritance vs. composition ... [24.3]
  • Derived* to private Base* conversion (invalid) ... [24.4]
  • private vs. protected inheritance ... [24.5]
• Inheritance, protected ... [24]
  • Access rules ... [24.6]
  • protected vs. private inheritance ... [24.5]
• Inheritance, Virtual ... [25]
  • Avoid non-static data at/above it ... [25.11]
  • C-style casts and ... [25.13]
  • Constructor order ... [25.12], [25.14]
  • Cross delegation ... [25.10]
  • Delegate to a "sister class" ... [25.10]
  • Destructor order ... [11.12], [25.15]
  • Dreaded diamond ... [25.8]
  • Goes just above the diamond ... [25.9]
  • Object layout in memory ... [32.9], [38.9]
  • Pointer conversions unknown to C compiler ... [32.8]
  • Solves the "diamond" ... [25.5]
  • When introduced into C++ language ... [38.12]
• Inheritance ... [6.8], [19], [20], [21], [22], [23]
  • Abstract base classes (ABCs) ... [22], [22.2], [22.3]
  • Abstract functions ... [22.4]
  • Access of private by derived ... [19.6]
  • Access of protected and private ... [19.5]
  • Access of protected by derived ... [19.7], [19.8]
  • Accessing members inherited from a template base class ... [35.19], [35.20]
  • Accessing nested types inherited from a template base class ... [35.18], [35.20]
  • Array of Derived vs. of Base ... [21.4]
  • Assignment operators in the derived class ... [12.4]
  • Bag of Apple vs. of Fruit ... [21.3]
  • Calling virtuals from constructors ... [10.7], [23.5]
  • Calling virtuals from constructors: idiom ... [23.6]
  • Calling virtuals from destructors ... [23.5], [23.7]
  • Calling virtuals from non-virtuals in the base class ... [23.1], [23.2]
  • Circle vs. Ellipse ... [21.6], [21.7], [21.8], [21.9], [21.10], [21.11]
  • Container of Thing vs. of Anything ... [21.3]
  • Derived classes can access the protected base members of only their own objects ... [7.7]
  • Derived* → Base* conversion ... [19.4], [21.2]
  • Derived* → private Base* conversion (invalid) ... [24.4]
  • Derived** → Base** conversion (invalid) ... [21.2]
  • Destructor order ... [11.12]
  • Determining if it is proper ... [21.12]
  • Differences between C++ and Smalltalk inheritance ... [30.4]
  • Dynamic binding vs. switch statements ... [25.4]
  • Friendship privileges are not inherited ... [14.4]
  • Fully-qualified calls to base-class member functions ... [20.5]
  • Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.9]
  • Hiding rule ... [23.9]
  • How to code inheritance ... [19.3]
  • Importance of inheritance ... [19.1]
  • Intuition isn't always correct ... [21.3]
  • Is-a-kind-of ... [19.2], [21.11], [21.12]
  • Meaning is "is substitutable for" ... [21.8], [21.11]
  • Meaning is not "is a kind of" ... [21.8], [21.11]
  • Meaning is not "is a subset of" ... [21.8], [21.11]
  • Meaning is not "is a" ... [21.8], [21.11]
  • Members inherited from a template base class ... [35.19], [35.20]
  • Multiple inheritance ... [25]
  • Nested types inherited from a template base class ... [35.18], [35.20]
  • Object layout in memory ... [32.9], [38.9]
  • Old code calls new code ... [6.10]
  • Parking-lot of Car vs. of Vehicle ... [21.3]
  • Preventing inheritance (i.e., "final classes") ... [23.11]
  • private inheritance ... [24], [24.1]
  • private inheritance access rules ... [24.6]
  • private inheritance vs. composition ... [24.2], [24.3]
  • protected inheritance ... [24]
  • protected inheritance access rules ... [24.6]
  • protected vs. private inheritance ... [24.5]
  • Pure virtual functions ... [22.4]
  • Redefining non-virtuals ... [23.8]
  • Smalltalk differences ... [30.5]
  • Specification device ... [19.2], [21.11], [21.12]
  • Types nested in a template base class ... [35.18], [35.20]
  • virtual constructors ... [16.24], [17.16], [20.8], [22.5]
  • virtual data ... [31.2], [31.3]
  • virtual destructor coding standard ... [20.7]
  • virtual functions ... [20.1]
  • virtual functions are central to OO ... [6.9]
  • Virtual inheritance ... [25]
  • What your Mother didn't tell you ... [23]
  • When to use inheritance ... [19.2]
• init() functions ... [10.3]
• Initialization lists
  • Coding standard ... [10.6], [26.8], [27.10]
  • Using this within ... [10.7]
• Initialization of a built-in/intrinsic type ... [10.18], [26.9]
• Initialization of a static const member datum ... [10.13]
• Initialization of a static member datum ... [10.11], [10.12], [10.14], [10.15], [10.17]
• Initialization of instances via constructors ... [10.1]
• Inline functions ... [9]
  • Better than #define macros ... [9.5]
  • Can make executables larger ... [9.3]
  • Can make executables smaller(!) ... [9.3]
  • Can make performance better ... [9.3]
  • Can make performance worse(!) ... [9.3]
  • Can make thrashing happen ... [9.3]
  • Can make thrashing not happen(!) ... [9.3]
  • Can make zero speed-difference(!) ... [9.3]
  • Defined outside class body ... [9.7]
  • Defined within class body ... [9.8]
  • Forward declarations ... [39.13]
  • Functionoids ... [33.14]
  • Inlining virtual functions ... [31.5], [31.6]
  • Like a #define macro ... [9.1]
  • Member functions ... [9.7]
  • Non-member functions ... [9.6]
  • Procedural integration ... [9.2]
  • Safety without loss of speed ... [6.8], [9.4]
• inline keyword ... [9.1], [9.6], [9.7], [9.9], [39.13]
• Input/output ... [15]
  • Bad input, ignoring ... [15.3]
  • Binary mode ... [15.13]
  • Binary mode on MS-DOS ... [15.12]
  • clear() and std::istream ... [15.3]
  • Ending lines: std::endl vs. '\n' ... [15.7]
  • Eof and std::istream ... [15.2], [15.5]
  • if (std::cin >> foo) and std::istream ... [39.2], [39.3]
  • if (std::cout << foo) and std::istream ... [39.1]
  • ignore() and std::istream ... [15.3]
  • Invalid input characters and std::istream ... [15.2], [15.3]
  • operator<< (virtual) and std::ostream ... [15.11]
  • operator<< and std::ostream ... [15.8], [15.9]
  • operator>> and std::istream ... [15.10]
  • Remembering bad state and std::istream ... [15.6]
  • std::istream and clear() ... [15.3]
  • std::istream and eof ... [15.2], [15.5]
  • std::istream and if (std::cin >> foo) ... [39.2], [39.3]
  • std::istream and if (std::cout << foo) ... [39.1]
  • std::istream and ignore() ... [15.3]
  • std::istream and invalid input characters ... [15.2], [15.3]
  • std::istream and remembering bad state ... [15.6]
  • std::istream and while (std::cin >> foo) ... [15.4]
  • std::istream operator>> ... [15.10]
  • std::ostream operator<< ... [15.8], [15.9]
  • std::ostream operator<< (virtual) ... [15.11]
  • while (std::cin >> foo) and std::istream ... [15.4]
• Insecure, pathetic wannabes ... [9.9]
• Inspector methods ... [18.10], [18.11], [18.12]
• Installed base of C++: size ... [6.6], [6.8]
• Instance initialized via constructors ... [10.1]
• Instance-data formats, Version numbers during serialization ... [36.7]
• int main(), not void main() ... [5.8], [29.3]
• int: choosing between integer sizes ... [29.5]
• Integration, Procedural ... [9.2]
• Interfaces
  • A simplified view in the user's vocabulary ... [7.3]
  • Abstract base classes (ABCs) ... [22.2]
  • Design interfaces from the outside-in ... [13.13]
  • Goal of interface design ... [7.4]
  • More valuable than implementation ... [22.1]
  • protected interface ... [19.7], [19.8], [19.9]
  • Separate from implementation ... [22.2]
• International Obfuscated C Coding Contest ... [27.14]
• Interview questions ... [6.14]
• Intrinsic (built-in, primitive) data types ... [26]
  • Arrays ... [16.20]
  • Choosing between integer sizes ... [29.5]
  • Comparing with string literals ... [13.6]
  • Deleting an array of ... [16.13], [26.11]
  • Identities for operators ... [27.10]
  • Initializing in ctors ... [10.6], [26.8]
  • Initializing when static ... [10.14], [10.18], [26.9]
  • Operator overloading ... [13.1]
  • Operator overloading and ... [26.10]
  • POD types and ... [26.7]
  • Promoting to a class type ... [39.1]
• Intuition isn't always correct ... [21.3], [21.4], [21.6], [21.7], [21.8], [21.9], [21.11]
• Invalid conversion
  • Array-of-Derived → array-of-Base ... [21.4]
  • Derived** → Base** pointers ... [21.2]
  • Foo** → Foo const** pointers ... [18.17]
• Invalid input characters (see Input/output) ... [15.2]
• invalid input characters and std::istream (input/output) ... [15.2], [15.3]
• Inversion, Law of ... [20.6]
• iostream header ... [15.1]
• iostream.h (see "iostream header") ... [15.1]
• Is-a-kind-of (see also Inheritance) ... [19.2], [21.12]
• Isaacson, E. ... [29.17], [37.7]
• ISO ... [6.12]
  • ISO C ... [6.11]
  • ISO C++ ... [6.13]
  • ISO C++ committee "WG21" ... [6.12]
• istream and clear() (input/output) ... [15.3]
• istream and eof (input/output) ... [15.2], [15.5]
• istream and if (std::cin >> foo) (input/output) ... [39.2], [39.3]
• istream and if (std::cout << foo) (input/output) ... [39.1]
• istream and ignore() (input/output) ... [15.3]
• istream and invalid input characters (input/output) ... [15.2], [15.3]
• istream and remembering bad state (input/output) ... [15.6]
• istream and while (std::cin >> foo) (input/output) ... [15.4]
• istream input operator: operator>> ... [15.4], [15.10], [39.2], [39.3]
• istream operator>> (input/output) ... [15.10]
• istringstream ... [39.2], [39.3]
• Iterators ... [34.5]
• itoa() ... [39.1]

"J" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Java vs. C++ ... [6.5]
• javadoc-like tools ... [40.1]
• Job ads ... [5.10]
• Joins within graphs (definition), Serialization and ... [36.13]

"K" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Kahan, W. ... [29.17], [37.7]
• kbhit() ... [15.17]
• Keep private things private; Friends ... [14.2]
• Keller, H. ... [29.17], [37.7]
• Keyboard echo: turning it off ... [15.18]
• Keyboard: get individual key presses ... [15.17]
• keypressed() ... [15.17]
• Keywords
  • catch ... [17.1]
  • class ... [7.1], [7.9]
  • const ... [13.9], [18.1]
  • const_cast ... [18.13]
  • delete ... [13.10], [16.9], [16.11], [16.12], [16.14], [16.15], [38.7]
  • explicit ... [10.22], [13.9], [20.7]
  • export ... [35.14], [35.15]
  • extern ... [32], [32.3]
  • for ... [39.8]
  • if ... [17.1]
  • inline ... [9.1], [9.6], [9.7], [9.9], [39.13]
  • mutable ... [18.13]
  • new ... [16.1], [16.4], [16.5], [16.11]
  • operator ... [13.4]
  • private ... [7.4], [7.6], [24]
  • protected ... [7.4], [24]
  • public ... [7.9]
  • sizeof ... [26.1], [26.2], [26.5], [26.6]
  • struct ... [7.1], [7.9]
  • template ... [35.14]
  • this ... [10.7]
  • throw ... [17.1], [17.15]
  • try ... [17.1]
  • typeid ... [34.4]
  • typename ... [16.18], [16.19], [35.2], [35.3], [35.4], [35.12], [35.13]
  • using ... [23.9], [27.5]
  • virtual ... [16.24], [17.16], [20.7], [25.9]
• Kind-of (see also Inheritance) ... [19.2]
• Knuth, Donald E. ... [29.17], [37.7]
• Korean translation of this document ... [2.10]
• Kruskal ... [5.3]
• KUTGW (Acronym) ... [5.1]

"L" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Land vehicle (example) ... [25.5], [25.7]
• Language wars ... [6.5]
• LAPACK, Linear Algebra Subroutine Library ... [29.17], [37.7]
• Large executables ... [37.8], [38.10]
• Last rites (see also Destructors) ... [11.1]
• LaTeX
  • C++2LaTeX pretty printer ... [40.3]
  • Macros for "C++" ... [40.2]
• Law of Inversion ... [20.6]
• Law of the Big Three ... [16.17], [22.5], [27.10]
• Law, Murphy's ... [16.2]
• Layer of indirection ... [31.5]
• Layout of object in memory ... [32.9], [38.9]
• Leaf classes ... [23.11]
• Leaf methods ... [23.12]
• Leaks, memory ... [34.6]
  • Automatically avoided in some cases ... [16.10]
  • Construct-on-first-use can plug leaks ... [10.16]
  • Destructors can plug leaks ... [13.10], [16.17], [17.11], [34.1]
  • Garbage-collectors can plug leaks ... [16.26], [16.27]
  • Intentionally allowing a leak ... [10.15]
  • Placement-new needs special code to avoid leaks ... [11.14]
  • Raw arrays can cause leaks ... [34.1]
  • Raw pointers can cause leaks ... [17.11]
  • Reference-counting can plug leaks ... [16.22], [16.23], [16.24]
  • Reference-counting has limitations ... [16.25]
  • Smart-pointers can plug leaks ... [16.16], [16.26]
• Learning OO/C++ ... [28]
  • Getting started ... [29.2]
  • How long does it take ... [6.7]
  • No need to learn C first ... [28.2]
  • No need to learn Smalltalk first ... [28.3]
• Least bad; Sometimes "evil" things are ... [6.16]
• Left operand: friend-functions allow promotion of ... [14.5]
• Legal mumbo jumbo
  • Author ... [1.1]
  • Copying permissions ... [1.3]
  • Copyright notice ... [1.2]
  • No Warranty ... [1.4]
  • Trademarks ... [1.5]
• Legality books on C++ ... [28.4], [28.6]
• Length of time needed to learn OO/C++ ... [6.7]
• Less-than operator: operator< ... [13.9]
• Less-than-or-equal-to operator: operator<= ... [13.9]
• Lgrind ... [40.3]
• lgrind (see Pretty printing) ... [40.3]
• Libraries FAQ ... [37.9]
• Libraries ... [37]
  • Dynamically typed C++ libraries ... [37.5], [37.6]
  • LAPACK ... [29.17], [37.7]
  • Large executables ... [37.8], [38.10]
  • NETLIB ... [29.17], [37.7]
  • Numerical Recipes ... [37.7]
  • Standard Library ... [29.9]
  • STL ... [37.1], [37.2], [37.4]
• Lifetime of objects
  • Controlling lifetime of locals ... [11.6], [11.7], [11.8]
  • In heterogeneous containers ... [34.4]
  • Order of destruction for array elements ... [11.3]
  • Order of destruction for locals ... [11.2]
  • Register liveness ... [31.5]
  • Rule for for loop variables ... [39.8]
  • Using friend classes to achieve separate lifetimes ... [14.2]
• Line-breaks: whitespace standards ... [29.10]
• Linker errors ... [10.12], [10.13], [23.10], [32.7], [35.13], [35.14], [35.15], [35.16], [40.6]
• Lists, initialization
  • Coding standard ... [10.6], [26.8], [27.10]
  • Using this within ... [10.7]
• Literals: naming numeric literals ... [29.11]
• Literals: numeric literal suffixes ... [29.12]
• LLVM C++ compiler ... [38.13]
• Local objects, don't call dtor explicitly ... [11.5], [11.6]
• Log base 2 ... [26.12]
• Log of a negative number ... [29.15]
• Logical Interface different from Physical Layout ... [13.11], [13.12]
• long: choosing between integer sizes ... [29.5]

"M" [ Top | A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X | Y | Z | Bottom]

• Macro {TT{NAME2() for token pasting ... [39.6]
• Macros, #define
  • Evil but sometimes useful ... [32.4], [33.6], [33.7]
  • Evil! ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
  • Prefer const vs. #define ... [29.7]
  • See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.7]
  • Use them when declaring member-function pointers ... [33.6]
  • With if ... [39.4]
  • With multiple lines ... [39.5]
  • With token pasting ... [39.6]
• Macros, evilness of ... [9.5], [29.11], [30.3], [39.4], [39.5], [39.6]
• main() returns int, not void ... [5.8], [29.3]
• Makefile ... [35.14]
• Making decisions; Software development is ... [6.16], [