Search the FAQ Archives

3 - 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
faqs.org - Internet FAQ Archives

C++ FAQ (part 01 of 14)

( Part1 - Part2 - Part3 - Part4 - Part5 - Part6 - Part7 - Part8 - Part9 - Part10 - Part11 - Part12 - Part13 - Part14 )
[ Usenet FAQs | Web FAQs | Documents | RFC Index | Sex offenders ]
Archive-name: C++-faq/part01
Posting-Frequency: monthly
Last-modified: Jun 17, 2002
URL: http://www.parashift.com/c++-faq-lite/

See reader questions & answers on this topic! - Help others by sharing your knowledge
AUTHOR: Marshall Cline / cline@parashift.com / 972-931-9470

COPYRIGHT: This posting is part of "C++ FAQ Lite."  The entire "C++ FAQ Lite"
document is Copyright(C)1991-2002 Marshall Cline, Ph.D., cline@parashift.com.
All rights reserved.  Copying is permitted only under designated situations.
For details, see section [1].

NO WARRANTY: THIS WORK IS PROVIDED ON AN "AS IS" BASIS.  THE AUTHOR PROVIDES NO
WARRANTY WHATSOEVER, EITHER EXPRESS OR IMPLIED, REGARDING THE WORK, INCLUDING
WARRANTIES WITH RESPECT TO ITS MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR
PURPOSE.

C++-FAQ-Lite != C++-FAQ-Book: This document, C++ FAQ Lite, is not the same as
the C++ FAQ Book.  The book (C++ FAQs, Cline and Lomow, Addison-Wesley) is 500%
larger than this document, and is available in bookstores.  For details, see
section [3].

==============================================================================

This "raw text" document was mechanically produced from the HTML version at:
    USA:	http://www.parashift.com/c++-faq-lite/
    Canada:	http://new-brunswick.net/workshop/c++/faq
    France:	http://caor.ensmp.fr/FAQ/c++-faq-lite/
    Germany:	http://www.informatik.uni-konstanz.de/~kuehl/cpp/cppfaq.htm
    Ireland:	http://snet.wit.ie/GreenSpirit/c++-faq-lite/
    the Netherlands:	http://home.wanadoo.nl/efx/c++-faq/
    Poland:	http://www.gderek.lolo.com.pl/c++-faq/
    Spain:	http://geneura.ugr.es/~jmerelo/c++-faq/
    Taiwan:	http://www.cis.nctu.edu.tw/c++/C++FAQ-English/

If you have a Web browser, you probably want to read one of the above HTML
sites instead of this document because:
 * The HTML version has many hyperlinked cross references.
 * The HTML version is MUCH easier to read than this "raw text" version.
 * The HTML version is updated more regularly than this "monthly posting".

==============================================================================

Improve network response:

 * Use the closest mirror site (see URLs above).
 * Browse the FAQ off-line: Use the one-click download feature to get your own
   local copy.

Available in several languages:

 * English <http://www.parashift.com/c++-faq-lite/>.
 * Chinese translation using GB encoding <http://www.sunistudio.com/cppfaq/>
   (typically used on the Chinese mainland).
 * Chinese translation using Big5 encoding
   <http://www.cis.nctu.edu.tw/c++/C++FAQ-Chinese/> (typically used in Taiwan).
 * French translation
   <http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index-fr.html>.
 * Russian translation <http://quirks.chat.ru/cpp/faq/>.
 * Portuguese translation <http://www.arnaut.eti.br/op/CPPFL00.htm>.  [updated]

Look up stuff:

 * Find a generic topic with the table of contents (37 coarse-grained topics).
 * Find a specific topic with the extensive subject index (1099 fine-grained
   topics).
 * Find the changed topics by following the chain of recent changes (48 changes
   for 5/02 and 6/02).
 * Find the changed topics by going to the table of recent changes.

Table of Contents:

 * [1] Copying permissions
 * [2] On-line sites that distribute this document
 * [3] C++-FAQ-Book versus C++-FAQ-Lite
 * [4] Recent changes to this document
 * [5] Netiquette when posting to comp.lang.c++
 * [6] Big Picture issues
 * [7] Classes and objects
 * [8] References
 * [9] Inline functions
 * [10] Constructors
 * [11] Destructors
 * [12] Assignment operators
 * [13] Operator overloading
 * [14] Friends
 * [15] Input/output via <iostream> and <cstdio>
 * [16] Freestore management
 * [17] Exceptions and error handling
 * [18] Const correctness
 * [19] Inheritance -- basics
 * [20] Inheritance -- virtual functions
 * [21] Inheritance -- proper inheritance and substitutability
 * [22] Inheritance -- abstract base classes (ABCs)
 * [23] Inheritance -- what your mother never told you
 * [24] Inheritance -- private and protected inheritance
 * [25] Built-in / intrinsic / primitive data types
 * [26] Coding standards
 * [27] Learning OO/C++
 * [28] Newbie Questions / Answers
 * [29] Learning C++ if you already know Smalltalk
 * [30] Reference and value semantics
 * [31] How to mix C and C++
 * [32] Pointers to member functions
 * [33] Container classes and templates
 * [34] Class libraries
 * [35] Compiler dependencies
 * [36] Miscellaneous technical issues
 * [37] Miscellaneous environmental issues

==============================================================================

Subject Index

"A"
 * A2PS (see Pretty printing) ... [37.2]
 * 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]
 * Advertised behavior, contracts ... [21.11]
 * AFAICS (Acronym) ... [5.1]
 * Aggregation (see also Composition) ... [24.2]
 * Aliasing
   - Aliasing of const and non-const pointers ... [18.9], [18.11], [18.12],
     [18.13]
   - References are aliases for objects ... [8.1], [8.6]
 * All Terrain Vehicle (ATV) ... [29.5]
 * ANSI ... [6.11]
   - ANSI C ... [6.10]
   - ANSI C++ ... [6.12]
   - ANSI C++ committee "X3J16" ... [6.11], [29.1]
 * Arenas, memory ... [11.14]
 * Arithmetic, floating point ... [36.14]
 * Arity ... [13.7]
 * Arrays, evilness of ... [21.5]
 * Arrays
   - Arrays are evil ... [16.16], [17.5], [33.1]
   - Specifying length at runtime ... [16.19]
 * Artistic Style (see Pretty printing) ... [37.2]
 * Assigning a reference ... [8.2]
 * Assignment operator ... [12]
   - Check for self-assignment ... [22.5], [26.9]
   - Return *this ... [26.9]
   - Self-assignment ... [12.1], [12.2], [12.3]
   - Use const in parameter ... [26.9]
 * Associative array (see also STL) ... [33.2]
 * Associativity ... [13.7]
 * Author (see also C++ FAQ Lite) ... [1.1]
 * auto_ptr ... [17.4]
 * Avoiding decision logic ... [20.4]

"B"
 * Backtracking ... [5.3]
 * bad_alloc (see also std::bad_alloc) ... [16.5], [16.6]
 * Bag of Apple vs. of Fruit ... [21.3]
 * Bang (!) operator ... [28.11]
 * Base class ... [19.3]
 * Beautifier, Code (see Pretty printing) ... [37.2]
 * Behavior: Advertised vs. implemented ... [21.11]
 * Big Picture issues (see Managerial issues) ... [6]
 * Big Three, Law of ... [16.16], [22.5], [26.9]
 * Big5-encoded Chinese translation of C++ FAQ ... [2.5]
 * Binary compatibility between vendors ... [35.9]
 * Binding: Static vs. dynamic ... [20.2], [20.3]
 * Bits per byte ... [25.4], [25.5], [25.6]
 * Bizarre syntax: use only when you must ... [26.13]
 * Book (see C++ FAQ Book) ... [3]
 * Books on C++ ... [27]
 * Books
   - Design ... [27.8]
   - Legality issues of C++ ... [27.4], [27.6]
   - Morality issues of C++ ... [27.4], [27.5]
   - Programming-by-example in C++ ... [27.4], [27.7]
 * BTW (Acronym) ... [5.1]
 * Built-in (intrinsic, primitive) data types ... [25]
   - Arrays ... [16.19]
   - Choosing between integer sizes ... [28.3]
   - Comparing with string literals ... [13.6]
   - Deleting an array of ... [16.12], [25.11]
   - Identities for operators ... [26.9]
   - Initializing in ctors ... [10.6], [25.8]
   - Initializing when static ... [10.11], [10.15], [25.9]
   - Operator overloading ... [13.1]
   - Operator overloading and ... [25.10]
   - POD types and ... [25.7]
   - Promoting to a class type ... [15.15]
 * Business criteria dominate technical criteria ... [6.4]
 * Byte
   - At least 8 bits ... [25.4]
   - Defined ... [25.4]
   - Some have many bits ... [25.5], [25.6]
   - Units of sizeof ... [25.2]

"C"
 * C++2LaTeX (see Pretty printing) ... [37.2]
 * C++ books ... [27]
 * C-Clearly (see Pretty printing) ... [37.2]
 * C++ compiler
   - Free ... [35.1]
   - List of vendors ... [35.5]
   - Yaccable grammar ... [35.11]
 * 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]
   - Author ... [1.1]
   - Availability on-line ... [2]
   - Book is much bigger ... [3.2]
   - Chinese translation ... [2.5]
   - Copy permissions ... [1]
   - Copying permissions ... [1.3]
   - Copyright notice ... [1.2]
   - Downloading ... [2.2], [2.3], [2.4]
   - French translation ... [2.6]
   - HTML version ... [2.2]
   - Mirror WWW sites ... [2.1]
   - No Warranty ... [1.4]
   - Not same as C++ FAQ Book ... [1.6], [3.2]
   - Plaintext version ... [2.3], [2.4]
   - Portuguese translation ... [2.7]
   - Recent changes ... [4]
   - Russian translation ... [2.8]
 * C language
   - Accessing C++ data members from C ... [31.9]
   - C++ backward compatibility ... [6.10]
   - C++ is higher level than C ... [31.10]
   - C++ requires different skills/insights ... [33.1]
   - C vs. C++ ... [6.4]
   - Calling C from C++ ... [31.5]
   - Calling C++ from C ... [31.6]
   - Coding standards different from C++ ... [26.3], [33.1]
   - Common linker errors ... [23.6], [31.7]
   - Converting C++ to C ... [35.13]
   - __cplusplus ... [31.4]
   - extern C ... [31.3]
   - Including C headers ... [31.2], [31.3], [31.4]
   - Linking must be directed by C++ ... [31.1]
   - main() must be compiled using C++ ... [31.1]
   - Mixing C and C++ code ... [31]
   - Newsgroup comp.lang.c ... [5.9]
   - Not an efficient way to learn OO/C++ ... [27.2], [33.1]
   - Passing C++ objects to C code ... [31.8], [31.9]
   - static at file-scope ... [7.5]
 * C++ Libraries FAQ ... [34.9]
 * C++ to C conversion ... [35.13]
 * Cache Misses
   - Avoiding with a Matrix class ... [13.9]
   - Striding the cache ... [13.9]
 * Car and Truck example ... [20.4]
 * Casting pointers, evilness of ... [16.24], [21.2], [23.8], [26.10], [29.2],
   [29.3], [34.5]
 * Chaining method calls ... [8.4], [10.17]
 * Changes to this document (see also C++ FAQ Lite) ... [4]
 * char: Defined ... [25.3], [25.4]
 * char: Not necessarily the same as "character" ... [25.3]
 * char: sizeof(char) is 1 ... [25.1]
 * char*: Use a string-like class instead ... [13.6], [17.5]
 * Character not necessarily the same as char ... [25.3], [25.4]
 * Chinese translation of this document ... [2.5]
 * Choosing between integer sizes ... [28.3]
 * Chopped copies: see Slicing ... [30.8]
 * Circles vs. Ellipses ... [21.6], [21.7], [21.8], [21.9], [21.10]
 * Circular dependencies ... [36.10]
 * class ... [7.1], [7.8]
 * Class templates ... [33.6], [33.11]
 * clone() methods ... [16.23], [20.6], [22.5]
 * Code bloat ... [9.7]
 * Coding standards ... [26]
   - Assignment operators check assignment-to-self ... [12.1], [26.9]
   - Assignment operators return *this ... [26.9]
   - Assignment operators use const ... [26.9]
   - Avoid arrays whenever possible ... [21.5], [33.1]
   - Avoid dynamically typed libraries ... [34.5]
   - Avoid global variables ... [36.6]
   - Avoid hiding nested identifiers ... [36.6]
   - Avoiding bizarre syntax ... [26.13]
   - Bloodshed, Jihads, and Heat vs. Light ... [26.1]
   - Coding standards are never sufficient ... [26.2]
   - Coding standards are sometimes necessary ... [26.2]
   - const_cast ... [18.10]
   - Copy constructors use const ... [26.9]
   - Declare near first use ... [26.6]
   - Design classes from the outside-in ... [13.10]
   - Don't base C++ standards on C standards ... [26.3], [33.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.5], [11.6], [11.9]
   - Explicitly calling destructors (OK sometimes) ... [11.10]
   - Header filename extensions ... [26.8]
   - Identifier naming conventions ... [26.11]
   - Initialization lists ... [10.6], [25.8], [26.9]
   - Law of the Big Three ... [16.16], [26.9]
   - Macros that contain if ... [36.2]
   - Macros that contain multiple lines ... [36.3]
   - Macros that contain token pasting ... [36.4]
   - Operator overloading ... [26.9]
   - Source filename extensions ... [26.7]
   - static at file-scope (Don't!) ... [7.5]
   - The Ellemtel coding guidelines ... [26.12]
   - Todd Hoff's coding guidelines ... [26.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 ... [26.5]
   - virtual destructors ... [20.5], [26.9]
   - Whitespace pseudo-standards ... [28.8]
 * 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]
 * Comparisons, floating point ... [36.14]
 * Compatibility, Binary ... [35.9]
 * Compilation model, separate ... [33.11]
 * Compiler dependencies ... [35], [35.5]
 * Compilers for C++ ... [35.1], [35.5], [35.11], [35.13]
 * Composition
   - Benefits compared to freestore ... [30.4], [30.5]
   - Compared with private inheritance ... [24.2]
   - Criteria for composition vs. private inheritance ... [24.3]
   - Inlining virtual functions ... [30.5], [30.6]
 * Conservative garbage collectors ... [16.26]
 * const_cast ... [18.10]
 * Const correctness ... [18], [18.1]
   - A form of type safety ... [18.2]
   - Aliasing of const and non-const pointers ... [18.12]
   - Basics ... [28.4]
   - Coding standards concerning ... [26.9], [26.9]
   - const_cast ... [18.10], [18.11]
   - const member functions ... [18.9]
   - Fred& const x is nonsense ... [18.7]
   - Fred const& x -- use const Fred& x instead ... [18.8]
   - Immutable (const) pointers ... [18.5]
   - mutable ... [18.10]
   - Pointer-to-const ... [18.4], [18.5]
   - Pointer-to-const aliasing ... [18.13]
   - Prefer const over #define ... [28.5]
   - Reference-to-const ... [18.6]
   - Retrofitting const correctness is hard ... [18.3]
 * Construct On First Use Idiom ... [10.12], [10.13], [10.14], [10.15], [25.9]
 * Constructors ... [10], [16.9]
   - Build objects from dust ... [10.1]
   - Calling a virtual from ... [23.3]
   - Calling another constructor ... [10.3]
   - Coding standards re. copy constructor ... [26.9]
   - Default constructors ... [10.4], [10.5]
   - Init methods ... [10.3]
   - Initialization coding standard ... [10.6], [25.8], [26.9]
   - 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]
   - Throwing exceptions ... [17.2]
   - Using this within ... [10.7]
   - Virtual Constructor Idiom ... [16.23], [20.6], [22.5]
 * Containers ... [33]
   - Container of Thing vs. of Anything ... [21.4]
   - Heterogeneous ... [33.3]
   - Iterators ... [33.4]
 * Contracts on methods ... [21.11]
 * Converting C++ to C ... [35.13]
 * Copy constructors
   - Should use const ... [26.9]
 * Copy on write (see Reference counting) ... [16.22], [16.23]
 * Copy semantics (see also Value semantics) ... [30.1]
 * Copying permissions (see also C++ FAQ Lite) ... [1], [1.3]
 * Copyright notice (see also C++ FAQ Lite) ... [1.2]
 * CORBA FAQ
   - HTML version ... [2.4]
 * 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], [25.11], [33.1],
   [36.6]
 * create() methods (see Named Constructor Idiom) ... [10.8], [16.20], [16.23]
 * cstdio header ... [15.1]
 * Ctor (see also Constructors) ... [10]
 * Cursors: moving them on the screen ... [15.13]

"D"
 * Dangerous programming practices ... [11.5], [11.6], [11.10], [13.6], [16.2],
   [16.4], [16.11], [16.12], [16.16], [17.5], [20.5], [21.1], [21.4], [21.5],
   [23.5], [25.11], [33.1], [36.6]
 * Dangling else problems ... [36.2]
 * Decision logic, avoiding ... [20.4]
 * Declarations
   - Declare near first use ... [26.6]
   - List x(); declares a function, not an object ... [10.2]
 * Decompiling executables back into C++ source code ... [35.4]
 * Deducing template types ... [33.8]
 * Default code, non-pure virtual function is ... [20.4]
 * Default parameters ... [10.3]
 * #define macros
   - Evil! ... [9.3], [28.9], [29.3], [36.2], [36.3], [36.4]
   - Evil but sometimes useful ... [31.4], [32.5], [32.6]
   - Prefer const over #define ... [28.5]
   - See also Inline functions ... [9.1], [9.3], [27.2], [29.3], [31.4],
     [32.5], [32.6]
   - with if ... [36.2]
   - with multiple lines ... [36.3]
   - with token pasting ... [36.4]
 * Definition of "evil" ... [6.14], [28.9]
 * Definition vs. declaration of templates ... [33.11]
 * Deinitialization of a static member datum ... [10.13]
 * delete ... [16.1]
   - delete p actually deletes *p, not p ... [16.1]
   - delete this ... [16.14]
   - delete[] uses magic ... [16.13], [35.7], [35.8]
   - delete[] vs. delete ... [16.11]
   - delete[] vs. delete for built-in types ... [16.12], [25.11]
   - Deleting an array with delete[] ... [16.10]
   - Difference between delete and delete[] ... [13.8], [16.2], [16.10]
   - Mixing with malloc() ... [16.2]
 * Derived classes ... [19.3]
   - Can access protected parts of Base ... [19.7]
   - Can't access private parts of Base ... [19.6]
   - Derived* to Base* conversion ... [19.4], [21.2]
   - Derived** to Base** conversion (invalid) ... [21.2]
   - Derived* to private Base* conversion (invalid) ... [24.4]
 * Design books ... [27.8]
 * Destructors ... [11], [16.8], [16.13], [35.7], [35.8]
   - Base class subobjects are automagically destructed ... [11.12]
   - Calling a virtual from ... [23.3]
   - Can't be overloaded ... [11.4]
   - Coding standards concerning ... [26.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 (OK sometimes) ... [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.11]
 * Dijkstra ... [5.3]
 * Directory separator: use "/", not "\" ... [15.14], [36.5]
 * Documentation generated by tools, HTML ... [36.1]
 * Double-precision arithmetic ... [36.14]
 * 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]
 * Dtor (see also Destructors) ... [11]
 * Dynamic
   - Dynamic binding ... [6.7], [20.2], [20.3]
   - dynamic_cast ... [33.3]
   - Dynamic length arrays ... [16.19]
   - Dynamic typing ... [20.2], [29.2], [29.3], [34.5], [34.6]

"E"
 * Echo: turning off keyboard "echo" ... [15.12]
 * Eight bits: minimum size for a byte ... [25.4]
 * Ellemtel coding guidelines (see also Coding standards) ... [26.12]
 * Ellipses vs. Circles ... [21.6], [21.7], [21.8], [21.9], [21.10]
 * Encapsulation ... [6.7], [7]
   - Definition ... [7.4]
   - Hides stuff from code, not from people ... [7.6]
   - Not necessarily violated by friends ... [14.2]
   - Security vs. Encapsulation ... [7.7]
 * End-of-file (see Input/output) ... [15.2], [15.4]
 * Enumerations ... [28.14]
   - Compared with int ... [28.15]
   - Conversions and operators ... [28.15]
 * Equation parsing in C++ ... [5.3]
 * Error codes (AKA "Return codes") ... [17.1], [17.2]
 * Etiquette (see also Netiquette) ... [5]
 * Evil things ... [6.14]
   - Array-of-Derived is NOT a kind-of Array-of-Base ... [21.4]
   - Arrays ... [21.5]
   - Choose the "lesser of two evils" ... [28.6]
   - Definition of "evil" ... [28.9]
   - Macros ... [9.3], [28.9], [29.3], [36.2], [36.3], [36.4]
   - Pointer casts ... [16.24], [21.2], [23.8], [26.10], [29.2], [29.3], [34.5]
   - Preprocessor ... [28.6]
   - Sometimes "evil" things are useful ... [28.9]
 * Exceptions ... [17]
   - Compared to return-codes and if ... [17.1]
   - Constructors can throw exceptions ... [17.2]
   - Destructors ... [11.13], [17.3]
   - Eliminate some if statements ... [17.1]
   - Example of throw; to re-throw current exception ... [16.9], [17.5],
     [35.7], [35.8]
   - Example of try ... catch ... [16.9], [17.5], [35.7], [35.8]
   - Member objects should be self-managing ... [17.4]
   - Stack unwinding ... [11.13], [17.3]
 * Executable size and inline functions ... [9.7]
 * Executables -- decompiling back to C++ source code ... [35.4]
 * extern C (see also C language) ... [31], [31.3]

"F"
 * FAQs
   - Don't answer them ... [5.6]
   - What if others ask them ... [5.5]
 * Features of C++ from a business perspective ... [6.7]
 * Filenames
   - Extensions for header files ... [26.8]
   - Extensions for source code files ... [26.7]
   - Using "/" rather than "\" for directories ... [15.14], [36.5]
 * Final classes ... [23.7]
 * Final methods ... [23.8]
 * find_if (see also std::find_if) ... [34.3]
 * Floating point
   - Code not linked error ... [37.5]
   - Comparisons ... [36.14]
   - Comparisons with NaN ... [28.12]
   - Inaccuracies ... [36.9]
   - Infinity ... [28.13]
   - NaN ... [28.13]
   - Not-a-number ... [28.13]
 * FOO machine (hypothetical) ... [25.6]
 * for loop ... [36.6]
 * FORTRAN vs. C++ ... [6.4]
 * Forward declarations ... [36.10]
   - Inline functions ... [36.12]
   - Member object containment ... [36.11]
   - Templates ... [36.13]
 * Free C++ compiler ... [35.1]
 * free() (see also Freestore) ... [16.2]
 * Freestore ... [16]
   - Allocating an array with new T[n] ... [16.10]
   - Automating a NULL test ... [16.6]
   - delete handles NULL automatically ... [16.7]
   - delete has two steps ... [16.8]
   - delete this ... [16.14]
   - delete[] uses magic ... [16.13], [35.7], [35.8]
   - delete[] vs. delete ... [16.11]
   - delete[] vs. delete for built-in types ... [16.12], [25.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 has two steps ... [16.9]
   - new never returns NULL ... [16.5]
   - Placement new ... [11.10], [16.9]
   - Prohibiting local objects ... [16.20]
   - realloc() ... [16.4]
   - Reference counting ... [16.21], [16.22], [16.23], [16.24]
   - Runtime costs of heap ... [30.4], [30.5]
   - std::bad_alloc ... [16.5], [16.6]
   - std::set_new_handler ... [16.6]
   - 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.7]
   - 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.8]
   - std::ostream operator<< ... [15.6], [15.7]
   - std::ostream operator<< (virtual) ... [15.9]
   - Virtual Friend Function Idiom ... [14.3], [15.9]
 * From: line of a posting (see also Netiquette) ... [5.4]
 * FTP sites
   - 128.231.128.7 ... [34.6]
   - butler.hpl.hp.com ... [34.2]
   - ftp.cs.rpi.edu ... [34.2]
   - ftp.cygnus.com ... [6.12]
   - ftp.germany.eu.net ... [37.2]
   - ftp.maths.warwick.ac.uk ... [6.12]
   - ftp.netlab.cs.rpi.edu ... [37.4]
   - ftp.research.att.com ... [6.12]
   - ftp.tex.ac.uk ... [37.2]
   - garbo.uwasa.fi ... [5.9]
   - oak.oakland.edu ... [5.9]
   - rtfm.mit.edu ... [5.14]
   - venus.ycc.yale.edu ... [37.2]
   - www.cs.rpi.edu ... [34.2]
   - www.cygnus.com ... [37.2]
   - www.maths.warwick.ac.uk ... [34.2]
 * Function templates ... [33.7], [33.8], [33.11]
 * FWIW (Acronym) ... [5.1]
 * FYI (Acronym) ... [5.1]

"G"
 * Garbage collector ... [16.25]
   - Conservative ... [16.26]
   - Hybrid ... [16.26]
   - Web sites ... [16.27]
 * GB-encoded Chinese translation of C++ FAQ ... [2.5]
 * Generalization (see also Inheritance) ... [19.3]
 * Generalized pointers: Handles ... [8.7]
 * Genericity (see also Templates) ... [33.10]
 * getch() ... [15.11]
 * Global variables: Just Say No! ... [36.6]
 * GNU indent (see Pretty printing) ... [37.2]
 * GNU
   - emacs ... [37.3]
   - g++ ... [5.9]
 * Grammar for C++, Yaccable ... [35.11]
 * Graphics ... [5.9]
 * grind (see Pretty printing) ... [37.2]

"H"
 * Handles as generalized pointers ... [8.7]
 * Has-a (see also Composition) ... [19.2], [24.2]
 * Header files
   - Filename extensions ... [26.8]
   - Standard headers ... [26.4]
 * Heap-sort ... [5.3]
 * Heat vs. light ... [26.1]
 * Heterogeneous containers ... [33.3]
 * Hiding inherited public features ... [21.1], [21.6], [21.7], [21.8], [21.9]
 * Hiding rule ... [23.5]
 * Homework problems ... [5.2], [5.3]
 * Homogeneous containers ... [33.3]
 * Hostility ... [31.10]
 * How to learn OO/C++ ... [27]
 * HPS Beauty (see Pretty printing) ... [37.2]
 * HR (see Human Resources) ... [6.13]
 * HTML documentation: tools that generate ... [36.1]
 * 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]
 * Hybrid garbage collectors ... [16.26]
 * Hybrid OO programming languages ... [27.3]
 * Hype ... [6.3]
 * Hypothetical FOO machine ... [25.6]

"I"
 * Idioms
   - Construct On First Use Idiom ... [10.12], [10.13], [10.14], [10.15],
     [25.9]
   - Named Constructor Idiom ... [10.8], [16.20], [16.23]
   - Named Parameter Idiom ... [10.17]
   - Virtual Constructor Idiom ... [16.23], [20.6], [22.5]
   - Virtual Friend Function Idiom ... [15.9]
 * 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 ... [36.2]
 * IMAO (Acronym) ... [5.1]
 * IMHO (Acronym) ... [5.1]
 * Immutable (const) pointers ... [18.5]
 * IMNSHO (Acronym) ... [5.1]
 * IMO (Acronym) ... [5.1]
 * Imperfect programming languages ... [6.2]
 * Improper inheritance: behavior, not just interface ... [21.11]
 * #include
   - Including C headers ... [31.2], [31.3], [31.4]
   - Use forward slash "/", not backslash "\" ... [36.5]
 * indent (see Pretty printing) ... [37.2]
 * Indirection, Extra layers of ... [30.5]
 * Infinity: floating point numbers ... [28.13]
 * Infix operators ... [5.3]
 * 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]
   - Array of Derived vs. of Base ... [21.4]
   - Calling virtuals from constructors ... [23.3]
   - 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]
   - Derived* to Base* conversion ... [19.4], [21.2]
   - Derived** to Base** conversion (invalid) ... [21.2]
   - Derived* to private Base* conversion (invalid) ... [24.4]
   - Determining if it is proper ... [21.11]
   - Differences between C++ and Smalltalk inheritance ... [29.4]
   - Friendship privileges are not inherited ... [14.4]
   - Hiding inherited public features ... [21.1]
   - Hiding rule ... [23.5]
   - How to code inheritance ... [19.3]
   - Importance of inheritance ... [19.1]
   - Is-a-kind-of ... [19.2], [21.11]
   - Multiple inheritance ... [6.7], [11.12], [24.2], [31.8], [31.9], [35.9],
     [35.12]
   - Old code calls new code ... [6.9]
   - Parking-lot of Car vs. of Vehicle ... [21.3]
   - Preventing inheritance (i.e., "final classes") ... [23.7]
   - 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.4]
   - Smalltalk differences ... [29.5]
   - Specification device ... [19.2], [21.11]
   - virtual constructors ... [16.23], [20.6], [22.5]
   - virtual data ... [30.2], [30.3]
   - virtual destructor coding standard ... [20.5]
   - virtual functions ... [20.1]
   - virtual functions are central to OO ... [6.8]
   - virtual inheritance ... [11.12], [31.8], [31.9], [35.9], [35.12]
   - What your Mother didn't tell you ... [23]
   - When to use inheritance ... [19.2]
 * Initialization lists (see also Coding standards) ... [10.6], [25.8], [26.9]
 * Initialization of a built-in/intrinsic type ... [10.15], [25.9]
 * Initialization of a static member datum ... [10.9], [10.10], [10.11],
   [10.12], [10.14]
 * Inline functions ... [9]
   - Better than #define macros ... [9.3]
   - Can decrease executable size ... [9.7]
   - Can degrade performance ... [9.7]
   - Can increase executable size ... [9.7]
   - Defined outside class body ... [9.5]
   - Defined within class body ... [9.6]
   - Forward declarations ... [36.12]
   - Inlining virtual functions ... [30.5], [30.6]
   - Like a #define macro ... [9.1]
   - Member functions ... [9.5]
   - Non-member functions ... [9.4]
   - Safety without loss of speed ... [6.7], [9.2]
 * Input/output ... [15]
   - Binary mode on MS-DOS ... [15.10]
   - std::istream and eof ... [15.2], [15.4]
   - std::istream and if (std::cin >> foo) ... [15.16]
   - std::istream and if (std::cout << foo) ... [15.15]
   - std::istream and invalid input characters ... [15.2]
   - std::istream and while (std::cin >> foo) ... [15.3]
   - std::istream operator>> ... [15.8]
   - std::istream remembers bad state ... [15.5]
   - std::ostream operator<< ... [15.6], [15.7]
   - std::ostream operator<< (virtual) ... [15.9]
 * Inspector methods ... [18.9]
 * Installed base of C++: size ... [6.5], [6.7]
 * int: choosing between integer sizes ... [28.3]
 * 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]
   - Separate from implementation ... [22.2]
 * Interview questions ... [6.13]
 * Intrinsic (built-in, primitive) data types ... [25]
   - Arrays ... [16.19]
   - Choosing between integer sizes ... [28.3]
   - Comparing with string literals ... [13.6]
   - Deleting an array of ... [16.12], [25.11]
   - Identities for operators ... [26.9]
   - Initializing in ctors ... [10.6], [25.8]
   - Initializing when static ... [10.11], [10.15], [25.9]
   - Operator overloading ... [13.1]
   - Operator overloading and ... [25.10]
   - POD types and ... [25.7]
   - Promoting to a class type ... [15.15]
 * Intuition isn't always correct ... [21.3], [21.4], [21.6], [21.7], [21.8],
   [21.9]
 * Invalid input characters (see Input/output) ... [15.2]
 * Inversion Principle ... [20.4]
 * iostream.h (see "iostream header") ... [15.1]
 * iostream header ... [15.1]
 * Is-a-kind-of (see also Inheritance) ... [19.2], [21.11]
 * ISO ... [6.11]
   - ISO C ... [6.10]
   - ISO C++ ... [6.12]
   - ISO C++ committee "WG21" ... [6.11]
 * istringstream ... [15.16]
 * Iterators ... [33.4]

"J"
 * Java vs. C++ ... [6.4]
 * javadoc-like tools ... [36.1]
 * Job ads ... [5.10]

"K"
 * kbhit() ... [15.11]
 * Keyboard echo: turning it off ... [15.12]
 * Keyboard: get individual key presses ... [15.11]
 * keypressed() ... [15.11]
 * Kind-of (see also Inheritance) ... [19.2]
 * Kruskal ... [5.3]
 * KUTGW (Acronym) ... [5.1]

"L"
 * Language wars ... [6.4]
 * Large executables ... [34.8], [35.10]
 * Last rites (see also Destructors) ... [11.1]
 * LaTeX
   - C++2LaTeX pretty printer ... [37.2]
   - Macros for "C++" ... [37.1]
 * Law of the Big Three ... [16.16], [22.5], [26.9]
 * Layer of indirection ... [30.5]
 * Leaf classes ... [23.7]
 * Leaf methods ... [23.8]
 * Learning OO/C++ ... [27]
 * Learning OO/C++
   - Getting started ... [28.2]
   - How long does it take ... [6.6]
   - No need to learn C first ... [27.2]
   - No need to learn Smalltalk first ... [27.3]
 * Legal mumbo jumbo
   - Author ... [1.1]
   - Copying permissions ... [1.3]
   - Copyright notice ... [1.2]
   - No Warranty ... [1.4]
   - Trademarks ... [1.5]
 * Legality books on C++ ... [27.4], [27.6]
 * Length of time needed to learn OO/C++ ... [6.6]
 * lgrind (see Pretty printing) ... [37.2]
 * Libraries FAQ ... [34.9]
 * Libraries ... [34]
   - Dynamically typed C++ libraries ... [34.5], [34.6]
   - Large executables ... [34.8], [35.10]
   - Numerical Recepies ... [34.7]
   - Standard Library ... [28.7]
   - STL ... [34.1], [34.2], [34.4]
 * Lifetime of objects
   - Controlling lifetime of locals ... [11.6], [11.7], [11.8]
   - In heterogeneous containers ... [33.3]
   - Order of destruction for array elements ... [11.3]
   - Order of destruction for locals ... [11.2]
   - Register liveness ... [30.5]
   - Rule for for loop variables ... [36.6]
   - Using friend classes to achieve separate lifetimes ... [14.2]
 * Linker errors ... [10.10], [23.6], [31.7], [37.5]
 * Literals: naming numeric literals ... [28.9]
 * Literals: numeric literal suffixes ... [28.10]
 * Log base 2 ... [25.12]
 * Log of a negative number ... [28.13]
 * Logical Interface different from Physical Layout ... [13.9]
 * long: choosing between integer sizes ... [28.3]

"M"
 * Macros (see also #define macros) ... [9.3]
 * malloc()
   - (See also Freestore) ... [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> (see also std::map<Key,Value>) ... [8.7], [33.2]
 * Maseratti ... [29.5]
 * Matrix subscript operator ... [13.8], [13.9]
 * Member object containment ... [36.11]
 * Memory leaks
   - Automatically avoided in some cases ... [16.9]
   - Construct-on-first-use can plug leaks ... [10.13]
   - Destructors can plug leaks ... [13.8], [16.16], [17.5], [33.1]
   - Garbage-collectors can plug leaks ... [16.25], [16.26]
   - Intentionally allowing a leak ... [10.12]
   - Placement-new needs special code to avoid leaks ... [11.14]
   - Raw arrays can cause leaks ... [33.1]
   - Raw pointers can cause leaks ... [17.5]
   - Reference-counting can plug leaks ... [16.21], [16.22], [16.23]
   - Reference-counting has limitations ... [16.24]
   - Smart-pointers can plug leaks ... [16.15], [16.25]
 * Memory pools ... [11.14]
 * Mentoring ... [6.6], [27.1]
 * Merge-sort ... [5.3]
 * Method chaining ... [8.4], [10.17]
 * MFC
   - FAQ ... [35.2]
   - Status bar ... [35.3]
 * Microsoft ... [35.6]
 * Microsoft Windows ... [5.9], [15.10], [37.4]
 * Minimize the ripple effect ... [8.7]
 * Minimum Spanning Trees in C++ ... [5.3]
 * Mirror sites (see also This document) ... [2]
 * Mixing
   - Mixing C and C++ code (see also C language) ... [31]
   - Mixing malloc() and delete ... [16.2]
   - Mixing new and free() ... [16.2]
 * Monolithic class hierarchies ... [34.5], [34.6]
 * Morality books on C++ ... [27.4], [27.5]
 * More than 8-bits/byte (on some machines) ... [25.5], [25.6]
 * MS-DOS ... [5.9], [15.10], [37.4]
 * Multi-dimensional arrays
   - Using pointers ... [16.15]
   - Using specific classes ... [16.16]
   - Using templates ... [16.17], [16.18]
 * Multiple
   - Multiple encapsulated instances ... [6.7], [7.5], [33.4]
   - Multiple inheritance ... [6.7], [11.12], [24.2], [31.8], [31.9], [35.9],
     [35.12]
 * mutable ... [18.10]
 * Mutator methods ... [18.9]
 * MYOB (Acronym) ... [5.1]

"N"
 * "name2()" macro for token pasting ... [36.4]
 * Named Constructor Idiom ... [10.8], [16.20], [16.23]
 * Named Parameter Idiom ... [10.17]
 * Naming numeric literals ... [28.9]
 * NaN: comparisons ... [28.12]
 * NaN: not a number ... [28.13]
 * NCITS ... [6.12]
 * Netiquette ... [5]
   - From: line of a posting ... [5.4]
   - General netiquette ... [5.4]
   - Getting and reading other FAQs ... [5.14]
   - 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]
   - Selecting an appropriate newsgroup ... [5.9]
   - Spam ... [5.13]
   - Subject: line of a posting ... [5.7]
 * new
   - Advantages over malloc() ... [16.3]
   - Allocating an array with new T[n] ... [16.10]
   - Mixing with free() ... [16.2]
   - (See also Freestore) ... [16.1]
 * New handler (see also Freestore) ... [16.6]
 * Newbie questions / answers ... [28]
 * Newlines in your code: whitespace standards ... [28.8]
 * 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], [37.4]
   - 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], [37.4]
   - comp.unix.solaris ... [5.9]
   - comp.windows.ms.programmer ... [37.4]
   - gnu.g++.bug ... [5.9]
   - gnu.g++.help ... [5.9]
 * NIHCL (National Institute of Heath Class Library) ... [34.6]
 * No Warranty (see also C++ FAQ Lite) ... [1.4]
 * Non-pure virtual functions ... [20.4]
 * Non-virtual
   - Calling a virtual ... [23.1], [23.2]
 * Normal syntax: use when you can ... [26.13]
 * Nuclear submarine ... [21.2]
 * NULL ... [16.5], [16.6]
 * Numeric literal suffixes: L, U and f ... [28.10]
 * Numeric literals: naming them ... [28.9]
 * Numerical Recepies code ... [34.7]

"O"
 * Obfuscated C Code Contest ... [26.13]
 * Object ... [7.2]
 * Object-oriented: So what? ... [6.3]
 * Off-topic postings ... [5.10], [5.11], [5.12]
 * Old code calls new code ... [6.9]
 * OO (Acronym) ... [5.1]
 * OO design books ... [27.8]
 * ?: operator ... [26.5]
 * operator<< ... [8.4], [15.15]
 * operator>> ... [15.3], [15.16]
 * Operator ?: ... [26.5]
 * ! operator (bang!) ... [28.11]
 * Operator overloading ... [6.7], [13]
   - Assignment operator ... [12], [22.5]
   - Can't invent new operators ... [13.7]
   - Can't replace behavior on built-ins ... [13.6], [25.10]
   - Coding standards ... [26.9]
   - Does help the users of a class ... [13.2]
   - Does not help the developer of a class ... [13.4]
   - Examples ... [13.3]
   - operator!= ... [13.10]
   - operator() ... [13.8], [13.9]
   - operator+ ... [13.1]
   - operator++ ... [13.10]
   - operator-> ... [8.7], [16.21], [16.24]
   - operator[] ... [13.8], [13.9]
   - operator delete(void*) ... [16.8], [16.11]
   - operator delete[](void*) ... [16.11]
   - operator* (dereference operator) ... [8.7], [13.10], [16.21], [16.24]
   - operator* (multiply operator) ... [13.1]
   - operator new(size_t) ... [16.9]
   - operator>> (std::istream input) ... [15.3], [15.8], [15.16]
   - operator<< (std::ostream output) ... [15.6], [15.7], [15.15]
   - operator<< (std::ostream output; virtual) ... [15.9]
   - Purpose of operator overloading ... [13.1]
   - Self-assignment ... [12.1], [12.2], [12.3]
   - Which operators can be overloaded ... [13.5]
 * Optimization
   - const_cast ... [18.11]
 * Order of static constructors ... [10.11], [10.12], [10.14], [10.15], [25.9]
 * Order of static destructors ... [10.13]
 * OS/2 ... [15.10]
 * ostringstream ... [15.15]
 * OTOH (Acronym) ... [5.1]
 * Overloading
   - Can't overload by return type ... [36.7]
   - Operators (see Operator overloading) ... [6.7]

"P"
 * Paradigm shifts ... [6.6], [31.10]
 * Parameterized types (see also Templates) ... [33.9]
 * Parameters, named vs. positional ... [10.17]
 * Parking lots ... [21.3]
 * Parser for C++ ... [35.11]
 * Part-of (see also Composition) ... [19.2], [24.2]
 * Pascal vs. C++ ... [6.4]
 * Passing parameters
   - By pointer ... [8.1]
   - By reference ... [8.1], [30.8]
   - By value ... [30.8]
 * Passwords: turning off keyboard "echo" ... [15.12]
 * Perfect programming languages ... [6.2]
 * Permissions to copy this document ... [1]
 * Permutations ... [5.3]
 * Persistence ... [34.5], [34.6], [36.8]
 * Physical Layout different from Logical Interface ... [13.9]
 * Placement new ... [11.14], [16.9]
 * Plain Old Data; see POD types ... [25.7]
 * Plaintext version of C++ FAQ Lite ... [2.3], [2.4]
 * POD types ... [25.7]
 * Pointer casts, evilness of ... [16.24], [21.2], [23.8], [26.10], [29.2],
   [29.3], [34.5]
 * Pointer semantics (see also Reference semantics) ... [30.1]
 * Pointer-to-const ... [18.4], [18.5], [18.13]
 * Pointer to function (see Pointer to member) ... [32.1]
 * Pointer to member ... [32]
   - Address of a C++ method ... [32.4]
   - Array of pointer-to-member ... [32.6]
   - Contrast to pointer-to-function ... [32.1]
   - Converting to pointer-to-function ... [32.2], [32.3]
   - Passing as pointer-to-function ... [32.2]
 * Pointers: Generalized as Handles ... [8.7]
 * Pointers vs. references ... [8.6]
 * 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]
 * Power of 2 ... [25.12]
 * Pragmatics ... [6.1]
 * Precedence ... [13.7]
 * Prepare to die! (see also Destructors) ... [11.1]
 * Preprocessor is evil ... [28.6]
 * Pretenders: smoking out people who pretend to know C++ ... [6.13]
 * Pretty printing
   - A2PS ... [37.2]
   - Artistic Style ... [37.2]
   - C++2LaTeX ... [37.2]
   - C-Clearly ... [37.2]
   - GNU indent ... [37.2]
   - HPS Beauty ... [37.2]
   - Source Styler for C++ ... [37.2]
   - tgrind ... [37.2]
 * Preventing inheritance (i.e., "final classes") ... [23.7]
 * Prim ... [5.3]
 * Primitive (built-in, primitive) data types ... [25]
   - Arrays ... [16.19]
   - Choosing between integer sizes ... [28.3]
   - Comparing with string literals ... [13.6]
   - Deleting an array of ... [16.12], [25.11]
   - Identities for operators ... [26.9]
   - Initializing in ctors ... [10.6], [25.8]
   - Initializing when static ... [10.11], [10.15], [25.9]
   - Operator overloading ... [13.1]
   - Operator overloading and ... [25.10]
   - POD types and ... [25.7]
   - Promoting to a class type ... [15.15]
 * printOn() method called by operator<< ... [15.7]
 * 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 ... [19.5], [19.6]
 * Proficiency in OO/C++: How long does it take ... [6.6]
 * Programming-by-example books on C++ ... [27.4], [27.7]
 * Proper inheritance depends on behavior ... [21.11]
 * protected inheritance
   - Access rules ... [24.6]
   - protected vs. private inheritance ... [24.5]
 * protected members ... [19.5]
   - The protected interface ... [19.7]
 * public inheritance ... [19], [20], [21], [22], [23]
 * Public interface; not enough to determine inheritance ... [21.11]
 * public members ... [19.5]
   - The public interface ... [19.7]
 * Pure OO programming languages ... [27.3]
 * Pure virtual functions ... [20.4], [22.3], [22.4]

"Q"
 * Questions to ask during an interview ... [6.13]
 * Quick-sort ... [5.3]

"R"
 * realloc() (see also Freestore) ... [16.4]
 * Recent changes to this document (see also C++ FAQ Lite) ... [4]
 * Reciprocal: Friendship privileges are not ... [14.4]
 * Redefining non-virtuals ... [23.4]
 * Reference counting
   - Can it be suverted? ... [16.24]
   - Copy on write ... [16.22], [16.23]
   - Pointer semantics ... [16.21]
   - Reference semantics ... [16.22]
   - Reference semantics for a hierarchy ... [16.23]
 * Reference semantics ... [30], [30.7], [30.8]
 * References ... [8]
   - Assigning a reference ... [8.2]
   - References to const ... [18.1], [18.6]
   - References vs. pointers ... [8.6]
   - Reseating a reference ... [8.5], [18.7], [18.8]
   - Returning a reference ... [8.3], [8.4], [10.17]
 * Referent ... [8.2], [8.5], [30.2]
 * Rely on specification, not implementation ... [21.11]
 * Reply-To: line of a posting (see also Netiquette) ... [5.4]
 * Reseating a reference ... [8.5], [18.7], [18.8]
 * Resumes ... [5.11]
 * Return codes
   - Can't be used from constructors ... [17.2]
   - Using try / catch / throw instead ... [17.1]
 * Return type ... [36.7]
 * Returning a reference ... [8.3], [8.4], [10.17]
 * Ripple effect: Minimize it! ... [8.7]
 * Row-major order ... [13.9]
 * RTFM (Acronym) ... [5.1]
 * rtfm.mit.edu ... [5.14]
 * Runtime crashes 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], [25.11], [33.1],
   [36.6]
 * Russian translation of this document ... [2.8]

"S"
 * Screen: moving cursors on ... [15.13]
 * Screen: turning off keyboard "echo" ... [15.12]
 * Security vs. Encapsulation (see also Encapsulation) ... [7.7]
 * Self-assignment ... [12.1], [12.2], [12.3], [26.9]
 * Self-cleaning member objects ... [17.4]
 * Separate compilation model ... [33.11]
 * Separation of specification from implementation ... [21.11]
 * set_new_handler (see also Freestore) ... [16.6]
 * short: choosing between integer sizes ... [28.3]
 * Short-courses (one 40 hour workweek) ... [6.6]
 * Shortest path in C++ ... [5.3]
 * Sixty-four bit bytes (on some machines) ... [25.5]
 * Size of the C++ installed base ... [6.5], [6.7]
 * sizeof
   - 32-bit bytes ... [25.6]
   - 64-bit bytes ... [25.5]
   - Bytes with many bits ... [25.5], [25.6]
   - sizeof(char) is 1 ... [25.1]
   - Units are bytes ... [25.2]
 * Slicing ... [30.8]
 * Smalltalk ... [29]
   - Differences with C++ ... [29.1]
   - Dynamic type checking ... [29.2]
   - Inheritance differences ... [29.4], [29.5]
   - Language wars vs. C++ ... [6.4]
   - Not an efficient way to learn OO/C++ ... [27.3]
 * Smart pointers ... [13.3], [16.21], [17.4]
 * Smoking out people who pretend to know C++ ... [6.13]
 * SO (Acronym) ... [5.1]
 * Solaris ... [5.9]
 * Sorting in C++ ... [5.3]
 * Source filename extensions ... [26.7]
 * Source Styler for C++ (see Pretty printing) ... [37.2]
 * Spaces in your code: whitespace standards ... [28.8]
 * Spam ... [5.13]
 * Spanning Trees in C++ ... [5.3]
 * Specialization (see also Inheritance) ... [19.3]
 * Specification vs. implementation with inheritance ... [21.11]
 * Square root of a negative number ... [28.13]
 * Stack unwinding during exception handling ... [11.13], [17.3]
 * Standard headers ... [26.4]
 * Standard library ... [28.7]
 * Standardization issues ... [5.9], [6.11], [6.12], [29.1]
 * Standards: whitespace pseudo-standards ... [28.8]
 * Static
   - Common linker errors due to static data members ... [10.10]
   - Define static data members explicitly ... [10.9], [10.10]
   - Deinitialization order fiasco ... [10.13]
   - Initialization order fiasco ... [10.11], [10.12], [10.14], [10.15], [25.9]
   - Named Constructor Idiom using static ... [10.8], [16.20], [16.23]
   - static at file-scope (Don't!) ... [7.5]
   - Static binding ... [20.2], [20.3]
   - static create() methods ... [10.8], [16.20], [16.23]
   - Static typing ... [20.2], [29.2], [29.3]
 * Status bar with MFC ... [35.3]
 * std::bad_alloc (see also Freestore) ... [16.5], [16.6]
 * std::find_if ... [34.3]
 * std::map<Key,Value> (see also STL) ... [8.7], [33.2]
 * std::set_new_handler (see also Freestore) ... [16.6]
 * std::string: Better than char* ... [13.6], [17.5]
 * std::vector<T> (see also STL) ... [10.5], [16.18], [16.19], [21.4], [21.5],
   [33.1], [34.3]
 * stdio.h (see "cstdio header") ... [15.1]
 * STL ... [34.3]
   - Access to on-line help ... [34.4]
   - FTP sites ... [34.2]
   - std::map<Key,Value> ... [33.2]
   - std::vector<T> ... [10.5], [16.18], [16.19], [21.4], [21.5], [33.1],
     [34.3]
 * Strange syntax: use only when you must ... [26.13]
 * Striding the cache (see Cache Misses) ... [13.9]
 * string (see also std::string) ... [13.6]
 * stringstream ... [15.15], [15.16]
 * struct ... [7.1], [7.8]
 * Style guidelines (see Coding standards) ... [26]
 * Subclass
   - Derived classes that aren't subtypes ... [29.5]
   - See also Derived classes ... [19.3]
 * Subject: line of a posting (see also Netiquette) ... [5.7]
 * Submarines, Nuclear ... [21.2]
 * Subscript operator for Matrix ... [13.8], [13.9]
 * Substitutability ... [21.3], [21.4], [21.6], [21.7], [21.8], [21.9]
 * Subtypes that aren't derived classes ... [29.5]
 * Suffixes: numeric literal suffixes ... [28.10]
 * Superclass (see also Inheritance) ... [19.3]
 * Syntactic sugar ... [13.1]

"T"
 * Tabs in your code: whitespace standards ... [28.8]
 * .tar.gz (see Downloading) ... [2.2], [2.3], [2.4]
 * .tar.Z (see Downloading) ... [2.2], [2.3], [2.4]
 * Templates ... [33]
   - Basics of templates ... [33.5]
   - Class template is a family of classes ... [33.6], [33.11]
   - Deducing template types ... [33.8]
   - Definition vs. declaration ... [33.11]
   - Forward declarations ... [36.13]
   - Function template is a family of functions ... [33.7], [33.8], [33.11]
   - Genericity ... [33.10]
   - Multi-dimensional arrays ... [16.17], [16.18]
   - Parameterized types ... [33.9]
   - Using with built-in/intrinsic types ... [13.1]
 * terminate() ... [17.3]
 * Ternary operator: ?: ... [26.5]
 * TeX macros for "C++" ... [37.1]
 * tgrind (see Pretty printing) ... [37.2]
 * Thirty-two bit bytes (on some machines) ... [25.6]
 * This document (see also C++ FAQ Lite) ... [3]
 * this used in constructors ... [10.7]
 * throw ... [16.5], [16.6]
 * To-the-power-of operator** (Can't!) ... [13.7]
 * Todd Hoff's coding guidelines (see also Coding standards) ... [26.12]
 * ## = token pasting ... [36.4]
 * Token pasting via ## ... [36.4]
 * Tools that generate HTML documentation ... [36.1]
 * Trademarks ... [1.5]
 * Training ... [6.6]
 * Transitivity: Friendship privileges are not ... [14.4]
 * Translation of the C++ FAQ
   - Chinese using Big5 encoding ... [2.5]
   - Chinese using GB encoding ... [2.5]
   - French ... [2.6]
   - Portuguese ... [2.7]
   - Russian ... [2.8]
 * Truck and Car example ... [20.4]
 * Type safety
   - Comparison with Smalltalk ... [29.2]
   - Const correctness ... [18.2]
   - Static vs. dynamic typing ... [20.2]
 * typeid() ... [33.3]

"U"
 * Uncompiling executables back into C++ source code ... [35.4]
 * Unix ... [5.9], [37.4]
 * Unresolved external (see also Linker errors) ... [23.6]
 * Unusual syntax: use only when you must ... [26.13]
 * Usenet newsgroups (see also Newsgroups) ... [5.9]

"V"
 * v-pointer (see also virtual) ... [20.3], [35.9]
 * v-table (see also virtual) ... [20.3], [21.4], [23.6], [35.9]
 * Value semantics ... [30], [30.7], [30.8]
 * VC++ ... [35.6]
 * vector<T> (see also std::vector<T>) ... [10.5], [16.18], [16.19], [21.4],
   [21.5], [33.1], [34.3]
 * Vehicle example ... [20.4]
 * Version numbers to the "language" ... [35.12]
 * virtual
   - Binary compatibility of virtual functions ... [35.9]
   - Calling virtual functions from constructors ... [23.3]
   - Calling virtual functions from destructors ... [23.3]
   - Calling virtual functions from non-virtuals in the base class ... [23.1],
     [23.2]
   - Inlining virtual functions ... [30.5], [30.6]
   - Non-pure virtual functions are like default code ... [20.4]
   - Pure virtual functions ... [22.3], [22.4]
   - Redefining non-virtual member functions ... [23.4]
   - v-pointer (virtual pointer) ... [20.3], [35.9]
   - v-table (virtual table) ... [20.3], [21.4], [23.6], [35.9]
   - Virtual Constructor Idiom ... [16.23], [20.6], [22.5]
   - virtual data ... [30.2], [30.3]
   - virtual destructor coding standard ... [20.5], [26.9]
   - Virtual Friend Function Idiom ... [14.3], [15.9]
   - virtual functions ... [20]
   - virtual functions are central to OO ... [6.8]
   - virtual functions, example of ... [20.4]
   - virtual functions let old code call new code ... [6.9]
   - virtual functions, purpose of ... [20.1]
   - virtual inheritance ... [11.12], [31.8], [31.9], [35.9], [35.12]
 * Visual Basic vs. C++ ... [6.4]
 * Visual C++ ... [35.6]
 * Visual C++
   - FAQ ... [35.2]

"W"
 * Wannabes: smoking out people who pretend to know C++ ... [6.13]
 * Wars ... [26.1]
 * Where do I start? ... [28.2]
 * Whitespace standards ... [28.8]
 * WWW sites of this document ... [2.1]

"X"
 * X3 Secretariat ... [6.12]

"Y"
 * Yaccable grammar ... [35.11]

"Z"
 * .zip (see Downloading) ... [2.2], [2.3], [2.4]
 * Zombie objects ... [17.2]

==============================================================================

SECTION [1]: Copying permissions


[1.1] Author

Marshall Cline
cline@parashift.com

==============================================================================

[1.2] Copyright Notice

The entire C++ FAQ Lite document is Copyright (C) 1991-2002 Marshall P. Cline,
Ph.D. <http://www.parashift.com/>, cline@parashift.com.  All rights reserved.
Copying is permitted only under designated situations[1.3].

==============================================================================

[1.3] Copying Permissions

If all you want to do is quote a small portion of C++ FAQ Lite (such as one or
two FAQs) in a larger document, simply attribute the quoted portion with
something vaguely similar to, "From Marshall Cline's C++ FAQ Lite document,
www.parashift.com/c++-faq-lite/".

If you want to make a copy of large portions and/or the entire C++ FAQ Lite
document for your own personal use, you may do so without restriction
(provided, of course, that you don't redistribute the document to others, or
allow others to copy the document).

If you want to redistribute large portions and/or the entire C++ FAQ Lite
document to others, whether or not for commercial use, you must get permission
from the author first (and that permission is normally granted; note however
that it's often easier for you to simply tell your recipients about the
one-click download option[2.2]).  In any event, all copies you make must retain
verbatim and display conspicuously all the following: all copyright notices,
the Author[1.1] section, the Copyright Notice[1.2] section, the No
Warranty[1.4] section, the C++-FAQ-Lite != C++-FAQ-Book[1.6] section, and the
Copy Permissions[1.3] section.

If you want more and/or different privileges than are outlined here, please
contact me, cline@parashift.com.  I'm a very reasonable man...

==============================================================================

[1.4] No Warranty

THIS WORK IS PROVIDED ON AN "AS IS" BASIS.  THE AUTHOR PROVIDES NO WARRANTY
WHATSOEVER, EITHER EXPRESS OR IMPLIED, REGARDING THE WORK, INCLUDING WARRANTIES
WITH RESPECT TO ITS MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE.

==============================================================================

[1.5] Trademarks

 * Java is a trademark of Sun Microsystems, Inc. in the United States and other
   countries.
 * All other trademarks are the property of their respective owners.

Note: We'd like to list all trademarks explicitly; please let us know about who
owns what trademark and we'll name them explicitly; thanks!

==============================================================================

[1.6] C++-FAQ-Lite != C++-FAQ-Book

This document, C++ FAQ Lite, is not the same as the C++ FAQ Book.  The book
(C++ FAQ, Second Edition, Cline, Lomow, and Girou, Addison-Wesley) is 500%
larger than this document, and is available in bookstores.  See [3] for
details.

==============================================================================

User Contributions:

Comment about this article, ask questions, or add new information about this topic:

CAPTCHA




Part1 - Part2 - Part3 - Part4 - Part5 - Part6 - Part7 - Part8 - Part9 - Part10 - Part11 - Part12 - Part13 - Part14

[ Usenet FAQs | Web FAQs | Documents | RFC Index ]

Send corrections/additions to the FAQ Maintainer:
cline@parashift.com (Marshall Cline)





Last Update March 27 2014 @ 02:11 PM