[ 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.5], [33.6]
- Evil! ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Prefer const over #define ... [29.7]
- See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.5], [33.6]
- With if ... [38.4]
- With multiple lines ... [38.5]
- With token pasting ... [38.6]
- #include
- ?: operator ... [27.5]
- ! operator (bang!) ... [29.13]
- .tar.gz (see Downloading) ... [2.2], [2.3], [2.4]
- .tar.Z (see Downloading) ... [2.2], [2.3], [2.4]
- "Think" is not a four-letter word ... [6.15]
- ## = token pasting ... [38.6]
- .zip (see Downloading) ... [2.2], [2.3], [2.4]
"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) ... [39.3]
- ABC (see also Inheritance) ... [22.2], [22.3]
- Access rules
- protected and private inheritance ... [24.6]
- protected and private members ... [19.5], [19.6]
- Acronyms ... [5.1]
- Ada vs. C++ ... [6.4]
- Addition: operator+ ... [13.1]
- 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 ... [35.2]
- Aliasing of const and non-const pointers (Const correctness) ... [18.13]
- Aliasing
- All Terrain Vehicle (ATV) ... [30.5]
- All; One size does not fit all ... [6.15], [9.3], [18.8], [18.9], [19.8], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- Amphibious vehicle (example) ... [25.7]
- ANSI ... [6.11]
- Anything: Container of Thing vs. of Anything ... [21.3]
- Apple: Bag of Apple vs. of Fruit ... [21.3]
- Arenas, memory ... [11.14]
- Arithmetic, floating point ... [29.17]
- Arity ... [13.7]
- Arrays
- Artistic Style (see Pretty printing) ... [39.3]
- Assigning a reference ... [8.2]
- Assignment operator ... [12]
- Associative array ... [34.2]
- Associativity ... [13.7]
- atoi() ... [38.2]
- Attachments on postings: don't! ... [5.4]
- ATV ... [30.5]
- Author ... [1.1]
- auto_ptr ... [17.4], [23.4]
- Avoiding decision logic ... [20.4]
"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 programming practices ... [6.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- 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** → const Foo**, Casting ... [18.15]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Preprocessor ... [29.8]
- Unnecessary global variables ... [33.2], [38.8]
- bad_alloc ... [16.5], [16.6]
- Bag of Apple vs. of Fruit ... [21.3]
- Bang (!) operator ... [29.13]
- Base class ... [19.3]
- Basics (Const correctness) ... [29.6]
- Beautifier, Code (see Pretty printing) ... [39.3]
- Behavior: Advertised vs. implemented ... [21.11], [21.12]
- Beliefs, naive/wrong
- "Evil" things should never be used ... [6.14]
- 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 {...} ... [38.5]
- Never use #define ... [29.7]
- Never use multiple-inheritance ... [25.2], [25.3]
- protected data is evil ... [19.8]
- Software has rules that always apply ... [6.15]
- Token-pasting doesn't require two levels of macros ... [38.6]
- Big Picture issues (see Managerial issues) ... [6]
- Big Three, Law of ... [16.16], [22.5], [27.9]
- Big5-encoded Chinese translation of C++ FAQ ... [2.5]
- Binary compatibility between vendors ... [37.9]
- Binary format mechanics, Serialization and ... [35.6]
- Binary format tradeoffs, Serialization and ... [35.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.4]
- Binding: Static vs. dynamic ... [20.2], [20.3]
- Bits per byte ... [26.4], [26.5], [26.6]
- Bizarre syntax: use only when you must ... [27.13]
- Bloat of code ... [9.3]
- Book (see C++ FAQ Book) ... [3]
- Books ... [28]
- Braces: whitespace standards ... [29.10]
- Bridge pattern ... [25.5]
- BTW (Acronym) ... [5.1]
- Bugs, subtle ... [6.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- 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** → const Foo**, Casting ... [18.15]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Preprocessor ... [29.8]
- Unnecessary global variables ... [33.2], [38.8]
- Build objects: constructors ... [10.1]
- Built-in (intrinsic, primitive) data types ... [26]
- Business criteria dominate technical criteria ... [6.4]
- Byte
"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
- C++ books ... [28]
- C++ compiler
- C++ FAQ Book ... [3]
- Is much bigger than this Lite document ... [3.2]
- ISBN ... [3.1]
- Not same as the on-line ("Lite") document ... [3.2]
- URL for Amazon.com ... [3.1]
- C++ FAQ Lite ... [3]
- C++ Libraries FAQ ... [36.9]
- C++ to C conversion ... [37.13]
- C++2LaTeX (see Pretty printing) ... [39.3]
- C-Clearly (see Pretty printing) ... [39.3]
- Cache Misses
- Avoiding with a Matrix class ... [13.9]
- Striding the cache ... [13.9]
- Calling Virtuals During Initialization Idiom ... [23.4]
- Car and Truck example ... [20.4]
- Car: Parking lot of Car vs. of Vehicle ... [21.3]
- Casting Derived** → Base**, evilness of ... [21.2]
- Casting Foo** → const Foo**, evilness of ... [18.15]
- Casting pointers, evilness of ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Caveats, Serialization and ... [35.12]
- Chaining method calls ... [8.4], [10.17]
- Changes to this document ... [4]
- Changing the screen's colors ... [15.21]
- char* (use a string-like class instead), evilness of ... [13.6], [17.5]
- 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 translation of this document ... [2.5]
- Choosing between integer sizes ... [29.5]
- Choosing member-functions vs. friend-functions ... [14.5]
- Choosing the best Serialization technique ... [35.2]
- Chopped copies ... [20.6], [22.5], [31.8], [34.4]
- Circles vs. Ellipses ... [21.6], [21.7], [21.8], [21.9], [21.10], [21.11]
- Circular dependencies ... [38.11]
- class ... [7.1], [7.8]
- Class templates ... [34.7], [34.12], [34.14]
- clear() and std::istream (input/output) ... [15.3]
- Clearing the screen ... [15.20]
- clone() methods ... [16.23], [20.6], [22.5]
- clrscr() ... [15.20]
- Code bloat ... [9.3]
- Coding standards concerning (Const correctness) ... [27.9]
- Coding standards ... [27]
- Assignment operators check assignment-to-self ... [12.1], [27.9]
- Assignment operators return *this ... [27.9]
- Assignment operators use const ... [27.9]
- Avoid arrays ... [16.16], [17.5], [21.5], [34.1]
- Avoid bizarre syntax ... [27.13]
- Avoid casting Derived** → Base** ... [21.2]
- Avoid casting Foo** → const Foo** ... [18.15]
- Avoid casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid char* (use a string-like class instead) ... [13.6], [17.5]
- Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
- Avoid Derived** → Base**, Casting ... [21.2]
- Avoid dynamically typed libraries ... [36.5]
- Avoid explicitly calling destructors (sometimes okay) ... [11.10]
- Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
- Avoid Foo** → const Foo**, Casting ... [18.15]
- Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Avoid hiding nested identifiers ... [38.8]
- Avoid macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Avoid missing virtual on some base class dtors ... [20.5]
- Avoid mixing malloc() and delete ... [16.2]
- Avoid mixing new and free() ... [16.2]
- Avoid mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Avoid mixing realloc() and new ... [16.4]
- Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Avoid pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid preprocessor ... [29.8]
- Avoid unnecessary global variables ... [33.2], [38.8]
- Avoid zombie objects ... [17.2]
- 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.11]
- Constructors should throw exceptions on failure ... [17.2]
- Copy constructors use const ... [27.9]
- Declare near first use ... [27.6]
- Design classes from the outside-in ... [13.10]
- Don't base C++ standards on C standards ... [27.3], [34.1]
- Don't test for NULL after new ... [16.5]
- Don't test for NULL before delete ... [16.7]
- Explicitly calling destructors (don't!) ... [11.9]
- Header filename extensions ... [27.8]
- Identifier naming conventions ... [27.11]
- Initialization lists ... [10.6], [26.8], [27.9]
- Law of the Big Three ... [16.16], [27.9]
- Macros that contain if ... [38.4]
- Macros that contain multiple lines ... [38.5]
- Macros that perform token pasting ... [38.6]
- main() returns int, not void ... [5.8], [29.3]
- Multiple inheritance ... [25.4]
- Never throw exceptions from a dtor ... [17.3]
- Operator overloading ... [27.9]
- Prefer ++i over i++ ... [13.12]
- Source filename extensions ... [27.7]
- static at file-scope (don't!) ... [7.5]
- The Ellemtel coding guidelines ... [27.12]
- Todd Hoff's coding guidelines ... [27.12]
- Use a std::string object rather than a char* ... [13.6], [17.5]
- Use delete[] for arrays ... [16.11]
- Use of the ternary ?: operator ... [27.5]
- virtual destructors ... [20.5], [27.9]
- Whitespace pseudo-standards ... [29.10]
- Colors: changing the screen's ... [15.21]
- Column-major order ... [13.9]
- Combinations ... [5.3]
- Committee Draft (CD) for ANSI/ISO C++ ... [6.12]
- comp.lang.c++
- Acronyms ... [5.1]
- Don't answer FAQs ... [5.6]
- Don't post job ads ... [5.10]
- Don't post resumes ... [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]
- Comparison: operator!= ... [13.10]
- Comparisons, floating point ... [29.17]
- Compatibility, Binary ... [37.9]
- Compilation model, separate ... [34.12], [34.13], [34.14]
- Compiler dependencies ... [37], [37.5]
- Compilers for C++ ... [37.1], [37.5], [37.11], [37.13]
- 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]
- Conflicts; Reader/writer and writer/writer conflicts ... [35.12]
- Conservative garbage collectors ... [16.26]
- Const correctness ... [18], [18.1]
- A form of type safety ... [18.2]
- Aliasing of const and non-const pointers ... [18.13]
- Basics ... [29.6]
- Coding standards concerning ... [27.9]
- const Fred& x vs. Fred const& x ... [18.8]
- const member functions ... [18.10]
- const_cast ... [18.11], [18.12]
- Converting Foo** → const Foo**, evilness of ... [18.15]
- Fred const& x vs. const Fred& x ... [18.8]
- Fred const* x vs. const Fred* x ... [18.9]
- Fred& const x is nonsense ... [18.7]
- Immutable (const) pointers ... [18.5]
- mutable ... [18.11]
- Pointer-to-const ... [18.4], [18.5]
- Pointer-to-const aliasing ... [18.14]
- Prefer const over #define ... [29.7]
- Reference-to-const ... [18.6]
- Retrofitting const correctness is hard ... [18.3]
- const Fred& x vs. Fred const& x (Const correctness) ... [18.8]
- const member functions (Const correctness) ... [18.10]
- const_cast ... [18.11]
- const_cast (Const correctness) ... [18.11], [18.12]
- Construct On First Use Idiom ... [10.12], [10.13], [10.14], [10.15], [26.9]
- Constructors ... [10], [16.9]
- Build objects from dust ... [10.1]
- Calling a virtual from ... [10.7], [23.3]
- Calling a virtual from; idiom ... [23.4]
- Calling another constructor ... [10.3]
- Coding standards re. copy constructor ... [27.9]
- Copy, Should use const ... [27.9]
- Default constructors ... [10.4], [10.5]
- Init methods ... [10.3]
- Initialization lists, Coding standard ... [10.6], [26.8], [27.9]
- Initialization lists, Using this within ... [10.7]
- Initialization of static data ... [10.11], [10.12], [10.14]
- Member objects should be self-managing ... [17.4]
- Named Constructor Idiom ... [10.8], [16.20], [16.23]
- Order with inheritance ... [25.14]
- Throwing exceptions ... [17.2]
- Virtual Constructor Idiom ... [16.23], [20.6], [22.5]
- Container of Thing vs. of Anything ... [21.3]
- Containers ... [34]
- Container of Thing vs. of Anything ... [21.4]
- Heterogeneous ... [34.4]
- Iterators ... [34.5]
- Contiguous storage in std::vector<T> ... [34.3]
- Contracts on methods ... [21.11], [21.12]
- Conversions, invalid
- Array-of-Derived → array-of-Base ... [21.4]
- Derived** → Base** ... [21.2]
- Foo** → const Foo** ... [18.15]
- Convert from string ... [38.2], [38.3]
- Convert to string; stringify() ... [38.1], [38.3]
- Converting array-of-Derived → kind-of Array-of-Base, evilness of ... [21.4]
- Converting C++ to C ... [37.13]
- Converting Foo** → const Foo**, evilness of (Const correctness) ... [18.15]
- Copy constructors
- Copy on write (see Reference counting) ... [16.22], [16.23]
- Copy semantics ... [31.1]
- Copying permissions ... [1], [1.3]
- Copyright notice ... [1.2]
- CORBA FAQ
- Corruption of heap: bang, you're dead ... [16.11], [30.3], [37.7], [37.8]
- Covariant Return Types ... [20.6]
- Crash at runtime without any warning ... [11.5], [11.6], [16.2], [16.4], [16.11], [16.12], [17.5], [20.5], [21.1], [21.4], [21.5], [26.11], [34.1], [38.8]
- create() methods (see Named Constructor Idiom) ... [10.8], [16.20], [16.23]
- Creational pattern ... [35.8]
- 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 ... [35.13]
"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.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- 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** → const Foo**, Casting ... [18.15]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Preprocessor ... [29.8]
- Unnecessary global variables ... [33.2], [38.8]
- Dangling else problems ... [38.4]
- Dangling pointer ... [12.2], [16.24]
- Death by heap corruption ... [16.11], [30.3], [37.7], [37.8]
- Death: dtor called at object's ... [11.1]
- Decision logic, avoiding ... [20.4]
- Decision-making
- One size does not fit all ... [6.15], [9.3], [18.8], [18.9], [19.8], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- Software development is ... [6.15], [9.3], [19.8], [19.9], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- Declarations, forward ... [38.11]
- Declarations
- Declare near first use ... [27.6]
- Function declarations ... [29.4]
- List x(); declares a function, not an object ... [10.2]
- Decompiling executables back into C++ source code ... [37.4]
- Deducing template types ... [34.9]
- Default code, non-pure virtual function is ... [20.4]
- Default constructors ... [10.4], [10.5]
- Default parameters ... [10.3]
- define macros
- Evil but sometimes useful ... [32.4], [33.5], [33.6]
- Evil! ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Prefer const over #define ... [29.7]
- See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.5], [33.6]
- With if ... [38.4]
- With multiple lines ... [38.5]
- With token pasting ... [38.6]
- Definition of "evil" ... [6.14]
- Definition vs. declaration of templates ... [34.12], [34.13], [34.14]
- Deinitialization of a static member datum ... [10.13]
- Delegate to a sister class via virtual inheritance ... [25.10]
- delete ... [16.1]
- Demand-paged virtual-memory operating-systems ... [9.3]
- Dereference: operator* ... [8.7], [13.10], [16.21], [16.24]
- Dereference: operator-> ... [8.7], [16.21], [16.24]
- Derived classes ... [19.3]
- 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
- Destructors ... [11], [16.8], [16.13], [37.7], [37.8]
- Base class subobjects are automagically destructed ... [11.12]
- Calling a virtual from ... [23.3]
- Can't be overloaded ... [11.4]
- Coding standards concerning ... [27.9]
- 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]
- Throwing an exception from (beware!) ... [11.13], [17.3]
- virtual destructor coding standard ... [20.5]
- Determining if inheritance is proper ... [21.12]
- Development of software is decision-making ... [6.15], [9.3], [19.8], [19.9], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- Diamond, dreaded ... [25.8]
- Dijkstra ... [5.3]
- Directory separator: use "/", not "\" ... [15.16], [38.7]
- Disciplines ... [27]
- Assignment operators check assignment-to-self ... [12.1], [27.9]
- Assignment operators return *this ... [27.9]
- Assignment operators use const ... [27.9]
- Avoid arrays ... [16.16], [17.5], [21.5], [34.1]
- Avoid bizarre syntax ... [27.13]
- Avoid casting Derived** → Base** ... [21.2]
- Avoid casting Foo** → const Foo** ... [18.15]
- Avoid casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid char* (use a string-like class instead) ... [13.6], [17.5]
- Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
- Avoid Derived** → Base**, Casting ... [21.2]
- Avoid dynamically typed libraries ... [36.5]
- Avoid explicitly calling destructors (sometimes okay) ... [11.10]
- Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
- Avoid Foo** → const Foo**, Casting ... [18.15]
- Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Avoid hiding nested identifiers ... [38.8]
- Avoid macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Avoid missing virtual on some base class dtors ... [20.5]
- Avoid mixing malloc() and delete ... [16.2]
- Avoid mixing new and free() ... [16.2]
- Avoid mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Avoid mixing realloc() and new ... [16.4]
- Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Avoid pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid preprocessor ... [29.8]
- Avoid unnecessary global variables ... [33.2], [38.8]
- Avoid zombie objects ... [17.2]
- 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.11]
- Constructors should throw exceptions on failure ... [17.2]
- Copy constructors use const ... [27.9]
- Declare near first use ... [27.6]
- Design classes from the outside-in ... [13.10]
- Don't base C++ standards on C standards ... [27.3], [34.1]
- Don't test for NULL after new ... [16.5]
- Don't test for NULL before delete ... [16.7]
- Explicitly calling destructors (don't!) ... [11.9]
- Header filename extensions ... [27.8]
- Identifier naming conventions ... [27.11]
- Initialization lists ... [10.6], [26.8], [27.9]
- Law of the Big Three ... [16.16], [27.9]
- Macros that contain if ... [38.4]
- Macros that contain multiple lines ... [38.5]
- Macros that perform token pasting ... [38.6]
- main() returns int, not void ... [5.8], [29.3]
- Multiple inheritance ... [25.4]
- Never throw exceptions from a dtor ... [17.3]
- Operator overloading ... [27.9]
- Prefer ++i over i++ ... [13.12]
- Source filename extensions ... [27.7]
- static at file-scope (don't!) ... [7.5]
- The Ellemtel coding guidelines ... [27.12]
- Todd Hoff's coding guidelines ... [27.12]
- Use a std::string object rather than a char* ... [13.6], [17.5]
- Use delete[] for arrays ... [16.11]
- Use of the ternary ?: operator ... [27.5]
- virtual destructors ... [20.5], [27.9]
- Whitespace pseudo-standards ... [29.10]
- Documentation generated by tools, HTML ... [39.1]
- 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 ... [39.5]
- Double-precision arithmetic ... [29.17]
- Downloading
- HTML version of C++ FAQ Lite ... [2.2]
- HTML version of this document ... [2.1]
- Plaintext version of C++ FAQ Lite ... [2.3]
- Why it's done via email ... [2.4]
- Dreaded diamond ... [25.8]
- Dtor (see also Destructors) ... [11]
- Dubious programming practices ... [6.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- 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** → const Foo**, Casting ... [18.15]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Preprocessor ... [29.8]
- Unnecessary global variables ... [33.2], [38.8]
- Dust ... [10.1]
- Dynamic Binding During Initialization Idiom ... [23.4]
- Dynamic
"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]
- 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]
- Ellemtel coding guidelines ... [27.12]
- Ellipses vs. Circles ... [21.6], [21.7], [21.8], [21.9], [21.10], [21.11]
- Encapsulation ... [6.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.7]
- 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.18]
- eof and std::istream (input/output) ... [15.2], [15.5]
- Equation parsing in C++ ... [5.3]
- Erasing the screen ... [15.20]
- Error codes (AKA "Return codes") ... [17.1], [17.2]
- Etiquette ... [5]
- Evil things ... [6.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- Choose the "lesser of two evils" ... [29.8]
- Converting array-of-Derived → kind-of Array-of-Base ... [21.4]
- Definition of "evil" ... [6.14]
- Derived** → Base**, Casting ... [21.2]
- Does not mean "never use these"! ... [6.15]
- Explicitly calling destructors (sometimes okay) ... [11.10]
- Explicitly calling destructors on local objects ... [11.5], [11.6]
- Foo** → const Foo**, Casting ... [18.15]
- friend classes/functions are not evil ... [15.9]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Multiple inheritance is not evil ... [25.2]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.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.15]
- Sometimes "evil" things are useful ... [29.11]
- Unnecessary global variables ... [33.2], [38.8]
- Exceptions ... [17]
- Executables
- Decompiling back to C++ source code ... [37.4]
- inline functions and size ... [9.3]
- Size ... [36.8]
- Explicitly calling destructors (sometimes okay), evilness of ... [11.10]
- Explicitly calling destructors on local objects, evilness of ... [11.5], [11.6]
- extern "C" ... [32], [32.3]
"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]
- FAQs
- Don't answer them ... [5.6]
- What if others ask them ... [5.5]
- Features of C++ from a business perspective ... [6.7]
- File I/O; translations of end-of-line sequences ... [15.12], [15.13]
- Filenames
- Extensions for header files ... [27.8]
- Extensions for source code files ... [27.7]
- Using "/" rather than "\" for directories ... [15.16], [38.7]
- Final classes ... [23.8]
- Final methods ... [23.9]
- find_if ... [36.3]
- Fine-point markers ... [6.15]
- First operand: friend-functions allow promotion of ... [14.5]
- Fit; One size does not fit all ... [6.15], [9.3], [18.8], [18.9], [19.8], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- Floating point
- FOO machine (hypothetical) ... [26.6]
- Foo** → const Foo**, Casting, evilness of ... [18.15]
- for loop ... [38.8]
- Format for serialization: human-readable vs. non-human-readable ... [35.3]
- Format, Binary-format for serialization ... [35.6]
- Format, Text-format for serialization ... [35.5]
- FORTRAN vs. C++ ... [6.4]
- Forward declarations ... [38.11]
- Four-letter words, "Think" is not ... [6.15]
- Fred const& x vs. const Fred& x (Const correctness) ... [18.8]
- Fred const* x vs. const Fred* x (Const correctness) ... [18.9]
- Fred& const x is nonsense (Const correctness) ... [18.7]
- Free C++ compiler ... [37.1]
- free() ... [16.2]
- free(): might use different heap from delete ... [16.8]
- Freestore ... [16]
- Allocating an array with new T[n] ... [16.10]
- Automatically freed on program exit ... [10.13]
- Automating a NULL test ... [16.6]
- Breaking it into pools ... [11.14]
- Corruption — bang, you're dead ... [16.11], [30.3], [37.7], [37.8]
- delete and free() might use different heaps ... [16.8], [16.9]
- delete handles NULL automatically ... [16.7]
- delete has two steps ... [16.8]
- delete this ... [16.14]
- delete[] uses magic ... [16.13], [37.7], [37.8]
- delete[] vs. delete ... [16.11]
- delete[] vs. delete for built-in types ... [16.12], [26.11]
- Deleting an array with delete[] ... [16.10]
- Difference between delete and delete[] ... [13.8], [16.2], [16.10]
- Garbage collectors ... [16.25], [16.26], [16.27]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Multi-dimensional arrays ... [16.15], [16.16]
- new and malloc() might use different heaps ... [16.4]
- new has two steps ... [16.9]
- new never returns NULL ... [16.5]
- Placement new ... [16.9]
- Placement new doesn't allocate ... [11.10]
- Prohibiting local objects ... [16.20]
- realloc() ... [16.4]
- Reference counting ... [16.21], [16.22], [16.23], [16.24]
- Runtime costs of ... [31.2], [31.4], [31.5]
- std::bad_alloc ... [16.5], [16.6]
- std::set_new_handler ... [16.6]
- Use std::auto_ptr only when pointing into the heap ... [23.4]
- Why use new rather than malloc() ... [16.3]
- French translation of this document ... [2.6]
- Frequently-asked-questions
- Don't answer them ... [5.6]
- What if others ask them ... [5.5]
- 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]
- Virtual Friend Function Idiom ... [14.3], [15.11]
- from-string conversion ... [38.2], [38.3]
- From: line of a posting (see also Netiquette) ... [5.4]
- Fruit: Bag of Apple vs. of Fruit ... [21.3]
- FTP sites
- Funcall: operator() ... [13.8], [13.9]
- Function declarations ... [10.2]
- Function pointer, Member ... [33]
- Address of a C++ method ... [33.4]
- Array of pointer-to-member ... [33.6]
- Can't convert to void* ... [33.7]
- Contrast to pointer-to-function ... [33.1]
- Converting to pointer-to-function ... [33.2], [33.3]
- Passing as pointer-to-function ... [33.2]
- Function pointer
- Can't convert to void* ... [33.8]
- Contrast pointer-to-member-function ... [33.1]
- Converting from pointer-to-member-function ... [33.3]
- Function templates ... [34.8], [34.9], [34.12], [34.13]
- 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 ... [38.13]
- 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.7], [9.4]
- Functions: inline allows safety with speed ... [9.4]
- Functions: procedural integration via inline ... [9.2]
- 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.25]
- Gas powered engine (example) ... [25.5]
- GB-encoded Chinese translation of C++ FAQ ... [2.5]
- Generalization (see also Inheritance) ... [19.3]
- Generalization, Nested ... [25.5]
- Generalized pointers: Handles ... [8.7]
- Genericity (see also Templates) ... [34.11]
- getch() ... [15.17]
- Global variables: Just Say No! ... [33.2], [38.8]
- GNU indent (see Pretty printing) ... [39.3]
- GNU
- Grammar for C++, Yaccable ... [37.11]
- Graphics ... [5.9]
- Graphs of objects (definition), Serialization and ... [35.13]
- grind (see Pretty printing) ... [39.3]
- Guidelines ... [27]
- Assignment operators check assignment-to-self ... [12.1], [27.9]
- Assignment operators return *this ... [27.9]
- Assignment operators use const ... [27.9]
- Avoid arrays ... [16.16], [17.5], [21.5], [34.1]
- Avoid bizarre syntax ... [27.13]
- Avoid casting Derived** → Base** ... [21.2]
- Avoid casting Foo** → const Foo** ... [18.15]
- Avoid casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid char* (use a string-like class instead) ... [13.6], [17.5]
- Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
- Avoid Derived** → Base**, Casting ... [21.2]
- Avoid dynamically typed libraries ... [36.5]
- Avoid explicitly calling destructors (sometimes okay) ... [11.10]
- Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
- Avoid Foo** → const Foo**, Casting ... [18.15]
- Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Avoid hiding nested identifiers ... [38.8]
- Avoid macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Avoid missing virtual on some base class dtors ... [20.5]
- Avoid mixing malloc() and delete ... [16.2]
- Avoid mixing new and free() ... [16.2]
- Avoid mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Avoid mixing realloc() and new ... [16.4]
- Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Avoid pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid preprocessor ... [29.8]
- Avoid unnecessary global variables ... [33.2], [38.8]
- Avoid zombie objects ... [17.2]
- 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.11]
- Constructors should throw exceptions on failure ... [17.2]
- Copy constructors use const ... [27.9]
- Declare near first use ... [27.6]
- Design classes from the outside-in ... [13.10]
- Don't base C++ standards on C standards ... [27.3], [34.1]
- Don't test for NULL after new ... [16.5]
- Don't test for NULL before delete ... [16.7]
- Explicitly calling destructors (don't!) ... [11.9]
- Header filename extensions ... [27.8]
- Identifier naming conventions ... [27.11]
- Initialization lists ... [10.6], [26.8], [27.9]
- Law of the Big Three ... [16.16], [27.9]
- Macros that contain if ... [38.4]
- Macros that contain multiple lines ... [38.5]
- Macros that perform token pasting ... [38.6]
- main() returns int, not void ... [5.8], [29.3]
- Multiple inheritance ... [25.4]
- Never throw exceptions from a dtor ... [17.3]
- Operator overloading ... [27.9]
- Prefer ++i over i++ ... [13.12]
- Source filename extensions ... [27.7]
- static at file-scope (don't!) ... [7.5]
- The Ellemtel coding guidelines ... [27.12]
- Todd Hoff's coding guidelines ... [27.12]
- Use a std::string object rather than a char* ... [13.6], [17.5]
- Use delete[] for arrays ... [16.11]
- Use of the ternary ?: operator ... [27.5]
- virtual destructors ... [20.5], [27.9]
- vs. rules ... [6.15], [9.3], [18.8], [18.9], [19.8], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.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]
- Handles as generalized pointers ... [8.7]
- Has-a (see also Composition) ... [19.2], [24.2]
- Header files
- Heap-sort ... [5.3]
- Heap ... [16]
- Allocating an array with new T[n] ... [16.10]
- Automatically freed on program exit ... [10.13]
- Automating a NULL test ... [16.6]
- Breaking it into pools ... [11.14]
- Corruption — bang, you're dead ... [16.11], [30.3], [37.7], [37.8]
- delete and free() might use different heaps ... [16.8], [16.9]
- delete handles NULL automatically ... [16.7]
- delete has two steps ... [16.8]
- delete this ... [16.14]
- delete[] uses magic ... [16.13], [37.7], [37.8]
- delete[] vs. delete ... [16.11]
- delete[] vs. delete for built-in types ... [16.12], [26.11]
- Deleting an array with delete[] ... [16.10]
- Difference between delete and delete[] ... [13.8], [16.2], [16.10]
- Garbage collectors ... [16.25], [16.26], [16.27]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Multi-dimensional arrays ... [16.15], [16.16]
- new and malloc() might use different heaps ... [16.4]
- new has two steps ... [16.9]
- new never returns NULL ... [16.5]
- Placement new ... [16.9]
- Placement new doesn't allocate ... [11.10]
- Prohibiting local objects ... [16.20]
- realloc() ... [16.4]
- Reference counting ... [16.21], [16.22], [16.23], [16.24]
- Runtime costs of ... [31.2], [31.4], [31.5]
- std::bad_alloc ... [16.5], [16.6]
- std::set_new_handler ... [16.6]
- Use std::auto_ptr only when pointing into the heap ... [23.4]
- Why use new rather than malloc() ... [16.3]
- 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.6]
- Hiding rule ... [23.6]
- Homework problems ... [5.2], [5.3]
- Homogeneous containers ... [34.4]
- Hostility ... [32.10]
- How to learn OO/C++ ... [28]
- HPS Beauty (see Pretty printing) ... [39.3]
- HR (see Human Resources) ... [6.13]
- HTML documentation: tools that generate ... [39.1]
- HTML postings: don't! ... [5.4]
- HTML version of C++ FAQ Lite ... [2.2]
- HTML version of the CORBA FAQ ... [2.4]
- Human Resources: questions to ask in an interview ... [6.13]
- Human-readable format mechanics, Serialization and ... [35.5]
- Human-readable format tradeoffs, Serialization and ... [35.3]
- Hybrid garbage collectors ... [16.26]
- Hybrid OO programming languages ... [28.3]
- Hype ... [6.3]
- 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 ... [35.11]
- Idioms
- if (std::cin >> foo) and std::istream (input/output) ... [38.2], [38.3]
- if (std::cout << foo) and std::istream (input/output) ... [38.1]
- if
- Avoiding decision logic via virtual functions ... [20.4]
- Some are eliminated by try / catch / throw ... [17.1]
- Unnecessary ifs increase bugs, cost, time-to-market ... [17.1]
- Within macros ... [38.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
- Increment: operator++ ... [13.10]
- indent (see Pretty printing) ... [39.3]
- Indirection, Extra layers of ... [31.5]
- Infinite recursion, Serialization and ... [35.11]
- Infinity: floating point numbers ... [29.15]
- Infix operators ... [5.3]
- Inheritance but no pointers, Serialization and ... [35.8]
- Inheritance, Multiple ... [25]
- 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
- Access rules ... [24.6]
- protected vs. private inheritance ... [24.5]
- Inheritance, Virtual ... [25]
- Inheritance ... [6.7], [19], [20], [21], [22], [23]
- Abstract base classes (ABCs) ... [22], [22.2], [22.3]
- Access of private by derived ... [19.6]
- Access of protected and private ... [19.5]
- Access of protected by derived ... [19.7], [19.8]
- Array of Derived vs. of Base ... [21.4]
- Bag of Apple vs. of Fruit ... [21.3]
- Calling virtuals from constructors ... [10.7], [23.3]
- Calling virtuals from constructors: idiom ... [23.4]
- 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* → 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]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Hiding rule ... [23.6]
- 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]
- Multiple inheritance ... [25]
- Object layout in memory ... [32.9], [37.9]
- Old code calls new code ... [6.9]
- Parking-lot of Car vs. of Vehicle ... [21.3]
- Preventing inheritance (i.e., "final classes") ... [23.8]
- private inheritance ... [24], [24.1]
- private inheritance access rules ... [24.6]
- private inheritance vs. composition ... [24.2], [24.3]
- protected inheritance access rules ... [24.6]
- protected vs. private inheritance ... [24.5]
- Pure virtual functions ... [22.4]
- Redefining non-virtuals ... [23.5]
- Smalltalk differences ... [30.5]
- Specification device ... [19.2], [21.11], [21.12]
- virtual constructors ... [16.23], [20.6], [22.5]
- virtual data ... [31.2], [31.3]
- virtual destructor coding standard ... [20.5]
- virtual functions ... [20.1]
- virtual functions are central to OO ... [6.8]
- Virtual inheritance ... [25]
- What your Mother didn't tell you ... [23]
- When to use inheritance ... [19.2]
- init() functions ... [10.3]
- Initialization lists
- Initialization of a built-in/intrinsic type ... [10.15], [26.9]
- Initialization of a static member datum ... [10.9], [10.10], [10.11], [10.12], [10.14]
- 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 ... [38.13]
- 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.7], [9.4]
- 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 ... [38.2], [38.3]
- if (std::cout << foo) and std::istream ... [38.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) ... [38.2], [38.3]
- std::istream and if (std::cout << foo) ... [38.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]
- Inspector methods ... [18.10]
- Installed base of C++: size ... [6.5], [6.7]
- Instance initialized via constructors ... [10.1]
- Instance-data formats, Version numbers during serialization ... [35.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.10]
- 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]
- Interview questions ... [6.13]
- Intrinsic (built-in, primitive) data types ... [26]
- 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** ... [21.2]
- Foo** → const Foo** ... [18.15]
- Invalid input characters (see Input/output) ... [15.2]
- invalid input characters and std::istream (input/output) ... [15.2], [15.3]
- Inversion Principle ... [20.4]
- iostream header ... [15.1]
- iostream.h (see "iostream header") ... [15.1]
- Is-a-kind-of (see also Inheritance) ... [19.2], [21.12]
- ISO ... [6.11]
- istream and clear() (input/output) ... [15.3]
- istream and eof (input/output) ... [15.2], [15.5]
- istream and if (std::cin >> foo) (input/output) ... [38.2], [38.3]
- istream and if (std::cout << foo) (input/output) ... [38.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>> ... [15.4], [15.10], [38.2], [38.3]
- istream operator>> (input/output) ... [15.10]
- istringstream ... [38.2], [38.3]
- Iterators ... [34.5]
- itoa() ... [38.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.4]
- javadoc-like tools ... [39.1]
- Job ads ... [5.10]
- Joins within graphs (definition), Serialization and ... [35.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]
- kbhit() ... [15.17]
- Keep private things private; Friends ... [14.2]
- Keyboard echo: turning it off ... [15.18]
- Keyboard: get individual key presses ... [15.17]
- keypressed() ... [15.17]
- Kind-of (see also Inheritance) ... [19.2]
- 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.4]
- Large executables ... [36.8], [37.10]
- Last rites (see also Destructors) ... [11.1]
- LaTeX
- C++2LaTeX pretty printer ... [39.3]
- Macros for "C++" ... [39.2]
- Law of the Big Three ... [16.16], [22.5], [27.9]
- Layer of indirection ... [31.5]
- Layout of object in memory ... [32.9], [37.9]
- Leaf classes ... [23.8]
- Leaf methods ... [23.9]
- Leaks, memory
- Learning OO/C++ ... [28]
- Getting started ... [29.2]
- How long does it take ... [6.6]
- No need to learn C first ... [28.2]
- No need to learn Smalltalk first ... [28.3]
- Least bad; Sometimes "evil" things are ... [6.15]
- Left operand: friend-functions allow promotion of ... [14.5]
- Legal mumbo jumbo
- Legality books on C++ ... [28.4], [28.6]
- Length of time needed to learn OO/C++ ... [6.6]
- lgrind (see Pretty printing) ... [39.3]
- Libraries FAQ ... [36.9]
- Libraries ... [36]
- 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 ... [38.8]
- Using friend classes to achieve separate lifetimes ... [14.2]
- Line-breaks: whitespace standards ... [29.10]
- Linker errors ... [10.10], [23.7], [32.7], [34.13], [34.14], [39.6]
- Lists, initialization
- Literals: naming numeric literals ... [29.11]
- Literals: numeric literal suffixes ... [29.12]
- 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.9]
- 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 name2() for token pasting ... [38.6]
- Macros, #define
- Evil but sometimes useful ... [32.4], [33.5], [33.6]
- Evil! ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Prefer const over #define ... [29.7]
- See also Inline functions ... [9.1], [9.5], [28.2], [30.3], [32.4], [33.5], [33.6]
- With if ... [38.4]
- With multiple lines ... [38.5]
- With token pasting ... [38.6]
- Macros, evilness of ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- main() returns int, not void ... [5.8], [29.3]
- Making decisions; Software development is ... [6.15], [9.3], [19.8], [19.9], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- malloc()
- Might use different heap from new ... [16.4]
- Mixing malloc() and delete ... [16.2]
- Why new is preferred over malloc() ... [16.3]
- Managerial issues ... [6]
- Business-centricity vs. Techno-centricity ... [6.4]
- C++ is a practical tool ... [6.1]
- C++ is not a perfect tool ... [6.2]
- Length of time needed to learn OO/C++ ... [6.6]
- Size of the installed base ... [6.5]
- Some advantages of OO ... [6.3]
- Standardization of C++ ... [6.11], [6.12]
- map<Key,Value> ... [8.7], [34.2]
- Maseratti ... [30.5]
- Matrix subscript operator ... [13.8], [13.9]
- Member functions: inline ... [9.7], [9.8]
- Member object containment ... [38.12]
- Member-function pointer ... [33]
- Address of a C++ method ... [33.4]
- Array of pointer-to-member ... [33.6]
- Can't convert to void* ... [33.7]
- Contrast to pointer-to-function ... [33.1]
- Converting to pointer-to-function ... [33.2], [33.3]
- Passing as pointer-to-function ... [33.2]
- Member-functions vs. friend-functions: choosing ... [14.5]
- Memory leaks
- Memory pools ... [11.14]
- Mentoring ... [6.6], [28.1]
- Merge-sort ... [5.3]
- Method chaining ... [8.4], [10.17]
- MFC
- Microsoft Visual C++
- Microsoft Windows
- 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 ... [39.5]
- Minimize the ripple effect ... [8.7]
- Minimum Spanning Trees in C++ ... [5.3]
- Mirror sites ... [2]
- Missing virtual on some base class dtors, evilness of ... [20.5]
- Mixing malloc() and delete, evilness of ... [16.2]
- Mixing new and free(), evilness of ... [16.2]
- Mixing new T[n] with delete p, evilness of ... [16.11], [16.12], [26.11]
- Mixing realloc() and new, evilness of ... [16.4]
- Mixing
- Mixing C and C++ code ... [32]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Monolithic class hierarchies ... [36.5], [36.6]
- Morality books on C++ ... [28.4], [28.5]
- More than 8-bits/byte (on some machines) ... [26.5], [26.6]
- Moving the cursor on the screen ... [15.19]
- MS-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 ... [39.5]
- MSVC++
- Multi-dimensional arrays
- Multi-threading
- Performance tradeoffs ... [35.12]
- Reader/writer conflicts ... [35.12]
- Writer/writer conflicts ... [35.12]
- Multiple encapsulated instances ... [6.7], [7.5], [34.5]
- Multiple inheritance ... [25]
- Multiply: operator* ... [13.1]
- mutable ... [18.11]
- mutable (Const correctness) ... [18.11]
- Mutator methods ... [18.10]
- MYOB (Acronym) ... [5.1]
"N" [ 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]
- Naive/wrong beliefs
- "Evil" things should never be used ... [6.14]
- 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 {...} ... [38.5]
- Never use #define ... [29.7]
- Never use multiple-inheritance ... [25.2], [25.3]
- protected data is evil ... [19.8]
- Software has rules that always apply ... [6.15]
- Token-pasting doesn't require two levels of macros ... [38.6]
- Name hiding ... [23.6]
- name2() macro for token pasting ... [38.6]
- Named Constructor Idiom ... [10.8], [16.20], [16.23]
- Named Parameter Idiom ... [10.17]
- Naming numeric literals ... [29.11]
- NaN: comparisons ... [29.14]
- NaN: not a number ... [29.15]
- NCITS ... [6.12]
- Nested generalization ... [25.5]
- Netiquette ... [5]
- Acronyms ... [5.1]
- Attachments: don't! ... [5.4]
- From: line of a posting ... [5.4]
- General netiquette ... [5.4]
- Getting and reading other FAQs ... [5.14]
- HTML postings: don't! ... [5.4]
- Job ads ... [5.10]
- Posting code ... [5.8]
- Reply-To: line of a posting ... [5.4]
- Response to off-topic postings ... [5.12]
- Resume postings ... [5.11]
- Rich-text postings: don't! ... [5.4]
- Selecting an appropriate newsgroup ... [5.9]
- Spam ... [5.13]
- Subject: line of a posting ... [5.7]
- Top-post: don't! ... [5.4]
- New handler ... [16.6]
- new ... [16.1]
- Advantages over malloc() ... [16.3]
- Allocating an array with new T[n] ... [16.10]
- Might use different heap from malloc() ... [16.4]
- Mixing with free() ... [16.2]
- Newbie questions / answers ... [29]
- Newlines: whitespace standards ... [29.10]
- Newsgroups
- Comp.graphics ... [5.9]
- Comp.lang.c ... [5.9]
- Comp.lang.c++ ... [5.9]
- Comp.lang.c++.moderated ... [5.9]
- Comp.object ... [5.9]
- Comp.os.ms-windows.programmer.misc ... [5.9]
- Comp.os.ms-windows.programmer.tools.* ... [5.9]
- Comp.os.msdos.programmer ... [5.9], [39.5]
- Comp.os.msdos.programmer.turbovision ... [5.9]
- Comp.programming ... [5.9]
- Comp.sources.wanted ... [5.9]
- Comp.std.c++ ... [5.9]
- Comp.sys.mac.oop.* ... [5.9]
- Comp.sys.mac.programmer.* ... [5.9]
- Comp.unix.programmer ... [5.9], [39.5]
- Comp.unix.solaris ... [5.9]
- Comp.windows.ms.programmer ... [39.5]
- Gnu.g++.bug ... [5.9]
- Gnu.g++.help ... [5.9]
- NIHCL (National Institute of Heath Class Library) ... [36.6]
- No inheritance, no pointers, Serialization and ... [35.7]
- No Warranty ... [1.4]
- Nodes within graphs (definition), Serialization and ... [35.13]
- noecho() ... [15.18]
- Non-human-readable format mechanics, Serialization and ... [35.6]
- Non-human-readable format tradeoffs, Serialization and ... [35.3]
- Non-member functions: inline ... [9.6]
- Non-pure virtual functions ... [20.4]
- Non-virtual
- Normal syntax: use when you can ... [27.13]
- Nuclear submarine ... [21.2], [21.3]
- NULL ... [16.5], [16.6]
- Numeric literal suffixes: L, U and f ... [29.12]
- Numeric literals: naming them ... [29.11]
- Numerical Recepies code ... [36.7]
"O" [ 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]
- Obfuscated C Code Contest ... [27.13]
- Object ... [7.2]
- Object formats, Version numbers during serialization ... [35.7]
- Object identity, Serialization and ... [35.11]
- Object layout in memory ... [32.9], [37.9]
- Object lifetime
- 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 ... [38.8]
- Using friend classes to achieve separate lifetimes ... [14.2]
- Object-oriented: So what? ... [6.3]
- Off-topic postings ... [5.10], [5.11], [5.12]
- Old code calls new code ... [6.9]
- One size does not fit all ... [6.15], [9.3], [18.8], [18.9], [19.8], [25.2], [25.3], [29.7], [29.11], [35.2], [35.3], [35.5], [35.6]
- OO (Acronym) ... [5.1]
- OO design books ... [28.8]
- Operands: friend-functions allow promotion of first ... [14.5]
- Operator ?: ... [27.5]
- operator delete(void*) ... [16.8], [16.11]
- operator delete[](void*) ... [16.11]
- operator new(size_t) ... [16.9]
- Operator overloading ... [13]
- Assignment operator ... [12], [22.5]
- Can't invent new operators ... [13.7]
- Can't replace behavior on built-ins ... [13.6], [26.10]
- Coding standards ... [27.9]
- Decrement operators operator-- ... [13.11], [13.12]
- Does help the users of a class ... [13.2]
- Does not help the developer of a class ... [13.4]
- Examples ... [13.3]
- Exploits developer's intuition ... [6.7]
- Increment operators operator++ ... [13.11], [13.12]
- operator delete(void*) ... [16.8], [16.11]
- operator delete[](void*) ... [16.11]
- operator new(size_t) ... [16.9]
- operator!= (comparison) ... [13.10]
- operator() (funcall) ... [13.8], [13.9]
- operator* (dereference) ... [8.7], [13.10], [16.21], [16.24]
- operator* (multiply) ... [13.1]
- operator+ (addition) ... [13.1]
- operator++ (increment) ... [13.10]
- operator++ (prefix vs. postfix increment) ... [13.11]
- operator++ (prefix vs. postfix speed) ... [13.12]
- operator-- (prefix vs. postfix increment) ... [13.11]
- operator-- (prefix vs. postfix speed) ... [13.12]
- operator-> (dereference) ... [8.7], [16.21], [16.24]
- operator<< (std::ostream output) ... [8.4], [15.8], [15.9], [38.1]
- operator<< (std::ostream output; virtual) ... [15.11]
- operator= ... [12], [22.5]
- operator>> (std::istream input) ... [15.4], [15.10], [38.2], [38.3]
- operator[] (subscript) ... [13.8], [13.9]
- Purpose of operator overloading ... [13.1]
- Self-assignment ... [12.1], [12.2], [12.3]
- Which operators can be overloaded ... [13.5]
- operator!= (comparison) ... [13.10]
- operator() (funcall) ... [13.8], [13.9]
- operator* (dereference) ... [8.7], [13.10], [16.21], [16.24]
- operator* (multiply) ... [13.1]
- operator+ (addition) ... [13.1]
- operator++ (increment) ... [13.10]
- operator++ (prefix vs. postfix increment) ... [13.11]
- operator++ (prefix vs. postfix speed) ... [13.12]
- operator-- (prefix vs. postfix increment) ... [13.11]
- operator-- (prefix vs. postfix speed) ... [13.12]
- operator-> (dereference) ... [8.7], [16.21], [16.24]
- operator<< (std::ostream output) ... [8.4], [15.8], [15.9], [38.1]
- operator<< (std::ostream output; virtual) ... [15.11]
- operator<< (virtual) and std::ostream (input/output) ... [15.11]
- operator<< and std::ostream (input/output) ... [15.8], [15.9]
- operator= ... [12], [22.5]
- operator>> (std::istream input) ... [15.4], [15.10], [38.2], [38.3]
- operator>> and std::istream (input/output) ... [15.10]
- operator[] (subscript) ... [13.8], [13.9]
- Optimization
- Order of ctors with inheritance ... [25.14]
- Order of static constructors ... [10.11], [10.12], [10.14], [10.15], [26.9]
- Order of static destructors ... [10.13]
- OS/2
- Binary mode for opening streams ... [15.12]
- Binary mode for std::cin and std::cout ... [15.13]
- ostream operator<< (input/output) ... [15.8], [15.9]
- ostream operator<< (virtual) (input/output) ... [15.11]
- ostream output: operator<< ... [8.4], [15.8], [15.9], [38.1]
- ostream output; virtual: operator<< ... [15.11]
- ostringstream ... [38.1]
- OTOH (Acronym) ... [5.1]
- Output/input ... [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 ... [38.2], [38.3]
- if (std::cout << foo) and std::istream ... [38.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) ... [38.2], [38.3]
- std::istream and if (std::cout << foo) ... [38.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]
- Overloading ... [13]
- Assignment operator ... [12], [22.5]
- Can't invent new operators ... [13.7]
- Can't overload by return type ... [38.9]
- Can't replace behavior on built-ins ... [13.6], [26.10]
- Coding standards ... [27.9]
- Decrement operators operator-- ... [13.11], [13.12]
- Does help the users of a class ... [13.2]
- Does not help the developer of a class ... [13.4]
- Examples ... [13.3]
- Exploits developer's intuition ... [6.7]
- Increment operators operator++ ... [13.11], [13.12]
- operator delete(void*) ... [16.8], [16.11]
- operator delete[](void*) ... [16.11]
- operator new(size_t) ... [16.9]
- operator!= (comparison) ... [13.10]
- operator() (funcall) ... [13.8], [13.9]
- operator* (dereference) ... [8.7], [13.10], [16.21], [16.24]
- operator* (multiply) ... [13.1]
- operator+ (addition) ... [13.1]
- operator++ (increment) ... [13.10]
- operator++ (prefix vs. postfix increment) ... [13.11]
- operator++ (prefix vs. postfix speed) ... [13.12]
- operator-- (prefix vs. postfix increment) ... [13.11]
- operator-- (prefix vs. postfix speed) ... [13.12]
- operator-> (dereference) ... [8.7], [16.21], [16.24]
- operator<< (std::ostream output) ... [8.4], [15.8], [15.9], [38.1]
- operator<< (std::ostream output; virtual) ... [15.11]
- operator= ... [12], [22.5]
- operator>> (std::istream input) ... [15.4], [15.10], [38.2], [38.3]
- operator[] (subscript) ... [13.8], [13.9]
- Purpose of operator overloading ... [13.1]
- Self-assignment ... [12.1], [12.2], [12.3]
- Which operators can be overloaded ... [13.5]
"P" [ 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]
- Paging operating-systems: space-vs-speed issues ... [9.3]
- Paradigm shifts ... [6.6], [32.10]
- Parameterized types (see also Templates) ... [34.10]
- Parameters, named vs. positional ... [10.17]
- Parameters: passing by reference vs. pointer ... [8.1]
- Parking lot of Car vs. of Vehicle ... [21.3]
- Parser for C++ ... [37.11]
- Part-of (see also Composition) ... [19.2], [24.2]
- Pascal vs. C++ ... [6.4]
- Passing array-of-Derived as array-of-Base, evilness of ... [21.4], [21.5]
- Passing parameters
- Passwords: turning off keyboard "echo" ... [15.18]
- Pasting tokens via name2() macro ... [38.6]
- Patterns, design
- PEBCAC (Acronym) ... [5.1]
- PEBCAK (Acronym) ... [5.1]
- Perfect programming languages ... [6.2]
- Performance and inline ... [9.3]
- Performance tradeoffs; Multi-threading and ... [35.12]
- Permissions to copy this document ... [1]
- Permutations ... [5.3]
- Persistence ... [36.5], [36.6], [38.10]
- Physical Layout different from Logical Interface ... [13.9]
- Placement new ... [11.14], [16.9]
- Plain Old Data; see POD types ... [26.7]
- Plaintext version of C++ FAQ Lite ... [2.3], [2.4]
- PMFJI (Acronym) ... [5.1]
- POD types ... [26.7]
- Pointer casts, evilness of ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Pointer conversion, Invalid: Derived** → Base** ... [21.2]
- Pointer conversion, Invalid: Foo** → const Foo** ... [18.15]
- Pointer semantics ... [31.1]
- Pointer to function, Member ... [33]
- Address of a C++ method ... [33.4]
- Array of pointer-to-member ... [33.6]
- Can't convert to void* ... [33.7]
- Contrast to pointer-to-function ... [33.1]
- Converting to pointer-to-function ... [33.2], [33.3]
- Passing as pointer-to-function ... [33.2]
- Pointer to function
- Can't convert to void* ... [33.8]
- Contrast pointer-to-member-function ... [33.1]
- Converting from pointer-to-member-function ... [33.3]
- Pointer to member ... [33]
- Address of a C++ method ... [33.4]
- Array of pointer-to-member ... [33.6]
- Can't convert to void* ... [33.7]
- Contrast to pointer-to-function ... [33.1]
- Converting to pointer-to-function ... [33.2], [33.3]
- Passing as pointer-to-function ... [33.2]
- Pointer-to-const ... [18.4], [18.5], [18.14]
- Pointer-to-const (Const correctness) ... [18.4], [18.5]
- Pointer-to-const aliasing (Const correctness) ... [18.14]
- Pointers vs. references ... [8.6]
- Pointers with cycles or non-trivial joins, Serialization and ... [35.11]
- Pointers with no cycles and no joins, Serialization and ... [35.9]
- Pointers with no cycles and only "trivial" joins, Serialization and ... [35.10]
- Pointers, Dangling ... [12.2], [16.24]
- Pointers, polymorphic ... [35.8]
- Pointers: Generalized as Handles ... [8.7]
- Pointers: passing by ... [8.1]
- Polymorphic pointers ... [35.8]
- Polymorphism ... [6.7], [20.2]
- Pools, memory ... [11.14]
- Portuguese translation of this document ... [2.7]
- Posers: smoking out people who pretend to know C++ ... [6.13]
- Positional parameter vs. named parameters ... [10.17]
- Postfix operators ... [5.3]
- Posting code (see also Netiquette) ... [5.8]
- Posting guidelines for comp.lang.c++ ... [5.4]
- Power of 2 ... [26.12]
- Pragmatics ... [6.1]
- Precedence ... [13.7]
- Prefer const over #define (Const correctness) ... [29.7]
- Prefix vs. postfix increment: operator++ ... [13.11]
- Prefix vs. postfix increment: operator-- ... [13.11]
- Prefix vs. postfix speed: operator++ ... [13.12]
- Prefix vs. postfix speed: operator-- ... [13.12]
- Prepare to die! (see also Destructors) ... [11.1]
- Preprocessor is evil ... [29.8]
- Preprocessor, evilness of ... [29.8]
- Pretenders: smoking out people who pretend to know C++ ... [6.13]
- Pretty printing
- Preventing inheritance (i.e., "final classes") ... [23.8]
- Prim ... [5.3]
- Primitive (built-in, primitive) data types ... [26]
- printOn() method called by operator<< ... [15.9]
- private inheritance ... [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]
- private members ... [7.6], [19.5], [19.6]
- Problems for homework ... [5.2], [5.3]
- Procedural integration and inline functions ... [9.2]
- Proficiency in OO/C++: How long does it take ... [6.6]
- Programming practices, Bad ... [6.14]
- Arrays ... [16.16], [17.5], [21.5], [34.1]
- Casting Derived** → Base** ... [21.2]
- Casting Foo** → const Foo** ... [18.15]
- Casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- char* (use a string-like class instead) ... [13.6], [17.5]
- 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** → const Foo**, Casting ... [18.15]
- Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Missing virtual on some base class dtors ... [20.5]
- Mixing malloc() and delete ... [16.2]
- Mixing new and free() ... [16.2]
- Mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Mixing realloc() and new ... [16.4]
- Passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Preprocessor ... [29.8]
- Unnecessary global variables ... [33.2], [38.8]
- Programming-by-example books on C++ ... [28.4], [28.7]
- Promotion of left operand: friend-functions allow ... [14.5]
- Proper inheritance depends on behavior ... [21.12]
- protected inheritance
- Access rules ... [24.6]
- protected vs. private inheritance ... [24.5]
- protected members ... [19.5]
- protected data is not evil! ... [19.8]
- The protected interface ... [19.7]
- Prototype pattern ... [35.8]
- public inheritance ... [19], [20], [21], [22], [23]
- Public interface; not enough to determine inheritance ... [21.12]
- public members ... [19.5]
- Pure OO programming languages ... [28.3]
- Pure virtual functions ... [20.4], [22.3], [22.4]
"Q" [ 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]
- Questions to ask during an interview ... [6.13]
- Quick-sort ... [5.3]
"R" [ 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]
- Reader/writer conflicts; Multi-threading and ... [35.12]
- realloc(): reallocating memory; see also Freestore ... [16.4]
- Recent changes to this document ... [4]
- Reciprocal: Friendship privileges are not ... [14.4]
- Redefining non-virtuals ... [23.5], [23.6]
- Reference counting
- Reference semantics ... [31], [31.7], [31.8]
- Reference-to-const (Const correctness) ... [18.6]
- References ... [8]
- Referent ... [8.2], [8.5], [31.2]
- Rely on specification, not implementation ... [21.12]
- remembering bad state and std::istream (input/output) ... [15.6]
- renew: reallocating memory ... [16.4]
- Reply-To: line of a posting (see also Netiquette) ... [5.4]
- Reseating a reference ... [8.5], [18.7], [18.8]
- Resumes ... [5.11]
- Resurrecting objects from a stream of bits ... [35.1]
- Retrofitting const correctness is hard (Const correctness) ... [18.3]
- Return codes
- Can't be used from constructors ... [17.2]
- Using try / catch / throw instead ... [17.1]
- Return on investment ... [19.9]
- Return type ... [38.9]
- Returning a reference ... [8.3], [8.4], [10.17]
- Rich-text postings: don't! ... [5.4]
- Right/left: moving const as far to the right as possible ... [18.8], [18.9]
- Ripple effect: Minimize it! ... [8.7]
- ROI ... [19.9]
- Row-major order ... [13.9]
- RTFM (Acronym) ... [5.1]
- rtfm.mit.edu ... [5.14]
- Rules of thumb ... [27]
- Assignment operators check assignment-to-self ... [12.1], [27.9]
- Assignment operators return *this ... [27.9]
- Assignment operators use const ... [27.9]
- Avoid arrays ... [16.16], [17.5], [21.5], [34.1]
- Avoid bizarre syntax ... [27.13]
- Avoid casting Derived** → Base** ... [21.2]
- Avoid casting Foo** → const Foo** ... [18.15]
- Avoid casting pointers ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid char* (use a string-like class instead) ... [13.6], [17.5]
- Avoid converting array-of-Derived → kind-of Array-of-Base ... [21.4]
- Avoid Derived** → Base**, Casting ... [21.2]
- Avoid dynamically typed libraries ... [36.5]
- Avoid explicitly calling destructors (sometimes okay) ... [11.10]
- Avoid explicitly calling destructors on local objects ... [11.5], [11.6]
- Avoid Foo** → const Foo**, Casting ... [18.15]
- Avoid hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9], [23.6]
- Avoid hiding nested identifiers ... [38.8]
- Avoid macros ... [9.5], [29.11], [30.3], [38.4], [38.5], [38.6]
- Avoid missing virtual on some base class dtors ... [20.5]
- Avoid mixing malloc() and delete ... [16.2]
- Avoid mixing new and free() ... [16.2]
- Avoid mixing new T[n] with delete p ... [16.11], [16.12], [26.11]
- Avoid mixing realloc() and new ... [16.4]
- Avoid passing array-of-Derived as array-of-Base ... [21.4], [21.5]
- Avoid pointer casts ... [16.24], [18.15], [21.2], [23.9], [27.10], [30.2], [30.3], [36.5]
- Avoid preprocessor ... [29.8]
- Avoid unnecessary global variables ... [33.2], [38.8]
- Avoid zombie objects ... [17.2]
- 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.11]
- Constructors should throw exceptions on failure ... [17.2]
- Copy constructors use const ... [27.9]
- Declare near first use ... [27.6]
- Design classes from the outside-in ... [13.10]
- Don't base C++ standards on C standards ... [27.3], [34.1]
- Don't test for NULL after new ... [16.5]
- Don't test for NULL before delete ... [16.7]
- Explicitly calling destructors (don't!) ... [11.9]
- Header filename extensions ... [27.8]
- Identifier naming conventions ... [27.11]
- Initialization lists ... [10.6], [26.8], [27.9]
- Law of the Big Three ... [16.16], [27.9]
- Macros that contain if ... [38.4]
- Macros that co