[ 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]<