Contents
FAQ 1.01: What is the purpose of this chapter?
FAQ 1.03: Who is the target audience for this book?
FAQ 1.04: Is this a book about C++ per se?
FAQ 1.05: Why do developers need a guidebook for C++ and OO technology?
FAQ 1.06: What kind of guidance is given in the answers to these FAQs?
FAQ 1.07: What is the electronic FAQ and why buy this book when the electronic FAQ is free?
FAQ 1.08: Why should you buy this edition if you already have a copy of the first edition?
FAQ 1.09: What conventions are used in this book?
Chapter 2 Basic C++ Syntax and Semantics
FAQ 2.01: What is the purpose of this chapter?
FAQ 2.02: What are the basics of main()?
FAQ 2.03: What are the basics of functions?
FAQ 2.04: What are the basics of default parameters?
FAQ 2.05: What are the basics of local (auto) objects?
FAQ 2.06: What are the basics of constructing objects using explicit parameters?
FAQ 2.07: What are the basics of dynamically allocated (new) objects?
FAQ 2.08: What are the basics of local objects within inner scopes?
FAQ 2.09: What are the basics of passing objects by reference?
FAQ 2.10: What are the basics of passing objects by value?
FAQ 2.11: What are the basics of passing objects by pointer?
FAQ 2.12: What are the basics of stream output?
FAQ 2.13: What are the basics of stream input?
FAQ 2.14: What are the basics of using classes that contain overloaded operators?
FAQ 2.15: What are the basics of using container classes?
FAQ 2.16: What are the basics of creating class header files?
FAQ 2.17: What are the basics of defining a class?
FAQ 2.18: What are the basics of defining member functions?
FAQ 2.19: What are the basics of adding a constructor to a class?
FAQ 2.20: What are the basics of adding a destructor to a class?
FAQ 2.22: What are the basics of global objects?
FAQ 2.23: What are the basics of throwing and catching exceptions?
FAQ 2.24: What are the basics of inheritance and dynamic binding?
Chapter 3 Understanding the Management Perspective
FAQ 3.01: What is the purpose of this chapter?
FAQ 3.02: What is the core message of this chapter (and this book)?
FAQ 3.03: Why are the managers in charge rather than the developers who understand technology?
FAQ 3.04: How can someone manage something they don't understand?
FAQ 3.05: What is the most common mistake on C++ and OO projects?
FAQ 3.06: What's the “Software Peter Principle”?
FAQ 3.07: Should an organization use OO on all its projects?
FAQ 3.08: Can OO be ignored until it goes away?
FAQ 3.09: What OO language is best?
FAQ 3.10: What is the right approach to processes and tools?
FAQ 3.11: What is the right approach with off-the-shelf class libraries and frameworks?
Chapter 4 The Architectural Perspective
FAQ 4.01: What is the purpose of this chapter?
FAQ 4.02: Why is software architecture important?
FAQ 4.03: What should the architecture be based on, the problem being solved or the problem domain?
FAQ 4.04: Should the software architecture be based on the policy of the problem?
FAQ 4.05: Do customers ever change their requirements?
FAQ 4.06: Are stable requirements desirable?
FAQ 4.07: What is the key to planning for change?
FAQ 4.08: What is a framework?
FAQ 4.09: What is the “inversion of control” exhibited by frameworks?
FAQ 4.10: What is an extensible, domain-specific framework?
FAQ 4.11: What characteristics make a framework extensible yet domain-specific?
FAQ 4.12: What happens if the domain analysis is incorrect?
FAQ 4.14: How does an architect make the software architecture flexible?
FAQ 4.15: What is the secret to achieving reuse?
Part II. Object-Oriented Design
Chapter 5 Object-Oriented Fundamentals
FAQ 5.01: What is the purpose of this chapter?
FAQ 5.02: Why is the world adopting OO technology?
FAQ 5.03: What are some of the benefits of using C++ for OO programming?
FAQ 5.04: What are the fundamental concepts of object-oriented technology?
FAQ 5.05: Why are classes important?
FAQ 5.07: What are the desirable qualities of an object?
FAQ 5.08: How are classes better than the three basic building blocks of procedural software?
FAQ 5.09: What is the purpose of composition?
FAQ 5.10: What is the purpose of inheritance?
FAQ 5.11: What are the advantages of polymorphism and dynamic binding?
FAQ 5.12: How does OO help produce flexible and extensible software?
FAQ 5.13: How can old code call new code?
FAQ 5.14: What is an abstraction and why is it important?
FAQ 5.15: Should abstractions be user-centric or developer-centric?
FAQ 5.16: What's the difference between encapsulation and abstraction?
FAQ 5.17: What are the consequences of encapsulating a bad abstraction?
FAQ 5.18: What's the value of separating interface from implementation?
FAQ 5.20: What is the best way to create a good interface to an abstraction?
FAQ 5.21: How are get/set member functions related to poorly designed interfaces?
FAQ 5.22: Should there be a get and a set member function for each member datum?
FAQ 5.23: Is the real purpose of a class to export data?
FAQ 5.24: Should OO be viewed as data-centric?
Chapter 6 Specification of Observable Behavior
FAQ 6.01: What is the purpose of this chapter?
FAQ 6.03: What are the advantages of relying on the specification rather than the implementation?
FAQ 6.04: What are advertised requirements and advertised promises?
FAQ 6.06: Why are changes feared in development organizations that don't use specification?
FAQ 6.07: How do developers determine if a proposed change will break existing code?
FAQ 6.10: Is it possible to keep the specification synchronized with the code?
FAQ 7.01: What is proper inheritance?
FAQ 7.02: What are the benefits of proper inheritance?
FAQ 7.03: What is improper inheritance?
FAQ 7.04: Isn't the difference between proper and improper inheritance obvious?
FAQ 7.06: Is it proper to revoke (hide) an inherited public: member function?
FAQ 7.07: What is specialization?
FAQ 7.08: What do subsets have to do with proper inheritance?
Chapter 8 Detecting and Correcting Improper Inheritance
FAQ 8.01: Can improper inheritance wreck a project?
FAQ 8.02: What's the best way to learn how to avoid improper inheritance?
FAQ 8.03: Is intuition a reliable guide to understanding proper inheritance?
FAQ 8.04: Is an Ostrich a kind-of Bird?
FAQ 8.05: Should an overridden virtual function throw an exception?
FAQ 8.06: Can an overridden virtual function be a no-op?
FAQ 8.07: Why does C++ make it so hard to fix the Ostrich/Bird dilemma?
FAQ 8.08: Should Circle inherit from Ellipse?
FAQ 8.09: What can be done about the asymmetric-circle dilemma?
FAQ 8.10: What is the one issue in these FAQs that doesn't seem to die?
FAQ 8.11: Should Stack inherit from List?
FAQ 8.12: Is code reuse the main purpose of inheritance?
FAQ 8.13: Is container-of-thing a kind-of container-of-anything?
FAQ 8.16: Is array-of Derived a kind-of array-of Base?
Chapter 9 Error Handling Strategies
FAQ 9.01: Is error handling a major source of fundamental mistakes?
FAQ 9.02: How should runtime errors be handled in C++?
FAQ 9.04: What is an exception specification?
FAQ 9.05: What are the disadvantages of using return codes for error handling?
FAQ 9.06: What are the advantages of throw...catch?
FAQ 9.07: Why is it helpful to separate normal logic from exception handling logic?
FAQ 9.08: What is the hardest part of using exception handling?
FAQ 9.09: When should a function throw an exception?
FAQ 9.10: What is the best approach for the hierarchy of exception objects?
FAQ 9.11: How should exception classes be named?
FAQ 9.12: Where do setjmp and longjmp belong in C++?
FAQ 10.01: What is the purpose of this chapter?
FAQ 10.02: What are the advantages of self-testing objects?
FAQ 10.03: What are some common excuses people use for not building self-testing into their objects?
FAQ 10.04: What will happen if techniques like those presented here are not used?
FAQ 10.05: When is a class correct?
FAQ 10.06: What is behavioral self-testing?
FAQ 10.07: What is a class invariant?
FAQ 10.08: Why should the invariant be captured explicitly?
FAQ 10.09: When should the testInvariant() member function be called?
FAQ 10.10: What can be done to ensure that an object doesn't get blown away by a wild pointer?
FAQ 11.01: What is a reference?
FAQ 11.02: What does “referent” mean?
FAQ 11.03: When can a reference be attached to its referent?
FAQ 11.04: What happens when a value is assigned to a reference?
FAQ 11.05: What is a local reference?
FAQ 11.06: What does it mean to return a reference?
FAQ 11.07: What is the result of taking the address of a reference?
FAQ 11.08: Can a reference be made to refer to a different referent?
FAQ 11.09: Why use references when pointers can do everything references can do?
FAQ 11.10: Aren't references just pointers in disguise?
FAQ 11.11: When are pointers needed?
FAQ 11.12: Why do some people hate references?
FAQ 11.13: Does int& const x make sense?
FAQ 12.01: Does new do more than allocate memory?
FAQ 12.02: Why is new better than good old trustworthy malloc()?
FAQ 12.03: Does C++ have a counterpart to realloc() that goes along with new and delete?
FAQ 12.05: Does delete p delete the pointer p or the referent *p?
FAQ 12.06: Should the pointer returned from new Fred() be checked to see if it is NULL?
FAQ 12.07: How can new be convinced to return NULL rather than throw an exception?
FAQ 12.09: What happens if delete p is called when p is NULL?
FAQ 12.10: What happens when a pointer is deleted twice?
FAQ 12.11: How can an array of things be allocated and deallocated?
FAQ 12.12: What if delete p (not delete[] p) is used to delete an array allocated via new Fred[n]?
FAQ 12.14: How is an object constructed at a predetermined position in memory?
FAQ 12.16: How are objects created by placement new destroyed?
FAQ 12.18: Is it legal (and moral) for a member function to say delete this?
FAQ 13.01: What is the purpose of inline functions?
FAQ 13.02: What is the connection between the keyword “inline” and “inlined” functions?
FAQ 13.03: Are there any special rules about inlining?
FAQ 13.04: What is the one-definition rule (ODR)?
FAQ 13.05: What are some performance considerations with inline functions?
FAQ 13.06: Do inlined functions improve performance?
FAQ 13.07: Do inlined functions increase the size of the executable code?
FAQ 13.08: Why shouldn't the inlining decision be made when the code is first written?
FAQ 13.09: What happens when a programmer uses an inlined function obtained from a third party?
FAQ 13.10: Is there an easy way to swap between inline and non-inline code?
FAQ 14.01: How should pointer declarations be read?
FAQ 14.02: How can C++ programmers avoid making unexpected changes to objects?
FAQ 14.03: Does const imply runtime overhead?
FAQ 14.04: Does const allow the compiler to generate more efficient code?
FAQ 14.05: Is const correctness tedious?
FAQ 14.06: Why should const correctness be done sooner rather than later?
FAQ 14.07: What's the difference between an inspector and a mutator?
FAQ 14.08: When should a member function be declared as const?
FAQ 14.09: Does const apply to the object's bitwise state or its abstract state?
FAQ 14.10: When should const not be used in declaring formal parameters?
FAQ 14.11: When should const not be used in declaring a function return type?
FAQ 14.12: How can a “nonobservable” data member be updated within a const member function?
FAQ 14.13: Can an object legally be changed even though there is a const reference (pointer) to it?
FAQ 14.14: Does const_cast mean lost optimization opportunities?
FAQ 15.01: What is the purpose of this chapter?
FAQ 15.02: What is a namespace?
FAQ 15.03: How can code outside a namespace use names declared within that namespace?
FAQ 15.04: What happens if two namespaces contain the same name?
FAQ 15.05: What are some of the rules for using namespaces?
FAQ 15.06: What is name lookup?
FAQ 15.08: Can namespaces break code?
FAQ 15.09: Do namespaces have any other applications?
FAQ 15.10: How do namespaces solve the problem of long identifiers?
FAQ 16.01: What is the purpose of this chapter?
FAQ 16.02: What are static class members?
FAQ 16.03: What is an analogy for static data members?
FAQ 16.04: Can inline functions safely access static data members?
FAQ 16.05: What is an analogy for static member functions?
FAQ 16.06: How is a static data member similar to a global variable?
FAQ 16.07: How is a static member function similar to a friend function?
FAQ 16.08: What is the named constructor idiom?
FAQ 16.09: How should static member functions be called?
FAQ 16.10: Why might a class with static data members get linker errors?
FAQ 16.11: How is a const static data member initialized?
FAQ 16.13: How can the function call operator help with functionoids?
FAQ 16.14: Is it safe to be ignorant of the static initialization order problem?
FAQ 16.15: What is a simple and robust solution to the static initialization order problem?
FAQ 16.18: What are some criteria for choosing between all these various techniques?
FAQ 17.01: What is the purpose of this chapter?
FAQ 17.02: How does C++ express inheritance?
FAQ 17.03: What is a concrete derived class?
FAQ 17.04: Why can't a derived class access the private: members of its base class?
FAQ 17.06: Can a derived class pointer be converted into a pointer to its public base class?
FAQ 17.07: How can a class Y be a kind-of another class X as well as getting the bits of X?
FAQ 17.08: How can a class Y get the bits of an existing class X without making Y a kind-of X?
FAQ 17.09: How can a class Y be a kind-of another class X without inheriting the bits of X?
FAQ 18.01: What is the purpose of this chapter?
FAQ 18.02: How are private:, protected:, and public: different?
FAQ 18.03: Why can't subclasses access the private: parts of their base class?
FAQ 18.04: What's the difference between the keywords struct and class?
FAQ 18.05: When should a data member be protected: rather than private:?
FAQ 18.06: Why is private: the default access level for a class?
Chapter 19 Friend Classes and Friend Functions
FAQ 19.02: What's a good mental model for friend classes?
FAQ 19.03: What are some advantages of using friend classes?
FAQ 19.04: Do friends violate the encapsulation barrier?
FAQ 19.05: What is a friend function?
FAQ 19.06: When should a function be implemented as a friend function rather than a member function?
FAQ 19.07: What are some guidelines to make sure friend functions are used properly?
FAQ 19.08: What does it mean that friendship isn't transitive?
FAQ 19.09: What does it mean that friendship isn't inherited?
FAQ 19.10: What does it mean that friends aren't virtual?
FAQ 19.11: What qualities suggest a friend function rather than a member function?
FAQ 19.13: What is a private class?
FAQ 19.14: How are objects of a class printed?
FAQ 19.15: How do objects of a class receive stream input?
Chapter 20 Constructors and Destructors
FAQ 20.01: What is the purpose of a constructor?
FAQ 20.02: What is C++'s constructor discipline?
FAQ 20.03: What is the purpose of a destructor?
FAQ 20.04: What is C++'s destructor discipline?
FAQ 20.05: What happens when a destructor is executed?
FAQ 20.06: What is the purpose of a copy constructor?
FAQ 20.07: When is a copy constructor invoked?
FAQ 20.08: What is the “default constructor”?
FAQ 20.09: Should one constructor call another constructor as a primitive?
FAQ 20.11: How can a local object be destructed before the end of its function?
FAQ 20.12: What is a good way to provide intuitive, multiple constructors for a class?
FAQ 20.14: When a base class destructor calls a virtual function, why isn't the override called?
FAQ 20.15: What is the purpose of placement new?
FAQ 21.01: What is the purpose of this chapter?
FAQ 21.02: What is a virtual member function?
FAQ 21.03: How much does it cost to call a virtual function compared to calling a normal function?
FAQ 21.04: How does C++ perform static typing while supporting dynamic binding?
FAQ 21.05: Can destructors be virtual?
FAQ 21.06: What is the purpose of a virtual destructor?
FAQ 21.07: What is a virtual constructor?
FAQ 21.09: Should the scope operator :: be used when invoking virtual member functions?
FAQ 21.10: What is a pure virtual member function?
FAQ 21.11: Can a pure virtual function be defined in the same class that declares it?
FAQ 21.12: How should a virtual destructor be defined when it has no code?
FAQ 21.13: Can an ABC have a pure virtual destructor?
FAQ 21.15: Should a class with virtual functions have at least one non-inline virtual function?
Chapter 22 Initialization Lists
FAQ 22.01: What are constructor initialization lists?
FAQ 22.02: What will happen if constructor initialization lists are not used?
FAQ 22.03: What's the guideline for using initialization lists in constructor definitions?
FAQ 22.04: Is it normal for constructors to have nothing inside their body?
FAQ 22.05: How is a const data member initialized?
FAQ 22.06: How is a reference data member initialized?
FAQ 22.08: How should initializers be ordered in a constructor's initialization list?
FAQ 22.10: What if one member object has to be initialized using another member object?
FAQ 22.12: How can an array of objects be initialized with specific initializers?
Chapter 23 Operator Overloading
FAQ 23.01: Are overloaded operators like normal functions?
FAQ 23.02: When should operator overloading be used?
FAQ 23.03: What operators can't be overloaded?
FAQ 23.04: Is the goal of operator overloading to make the class easier to understand?
FAQ 23.05: Why do subscript operators usually come in pairs?
FAQ 23.06: What is the most important consideration for operators such as +=, +, and =?
FAQ 23.07: How are the prefix and postfix versions of operator++ distinguished?
FAQ 23.08: What should the prefix and postfix versions of operator++ return?
FAQ 23.09: How can a Matrix-like class have a subscript operator that takes more than one subscript?
FAQ 23.10: Can a ** operator serve as an exponentiation operator?
Chapter 24 Assignment Operators
FAQ 24.01: What should assignment operators return?
FAQ 24.02: What is wrong with an object being assigned to itself?
FAQ 24.03: What should be done about self-assignment?
FAQ 24.04: Should an assignment operator throw an exception after partially assigning an object?
FAQ 24.05: How should the assignment operator be declared in an ABC?
FAQ 24.07: What should be returned by private: and protected: assignment operators?
FAQ 24.09: How should the assignment operator in a derived class behave?
FAQ 24.10: Can an ABC's assignment operator be virtual?
FAQ 24.11: What should a derived class do if a base class's assignment operator is virtual?
FAQ 25.01: What is the purpose of templates?
FAQ 25.02: What are the syntax and semantics for a class template?
FAQ 25.03: How can a template class be specialized to handle special cases?
FAQ 25.04: What are the syntax and semantics for a function template?
FAQ 25.05: Should a template use memcpy() to copy objects of its template argument?
FAQ 25.06: Why does the compiler complain about >> when one template is used inside another?
FAQ 26.01: What belongs in a try block?
FAQ 26.02: When should a function catch an exception?
FAQ 26.03: Should a catch block fully recover from an error?
FAQ 26.04: How should a constructor handle a failure?
FAQ 26.05: What are zombie objects (and why should they be avoided)?
FAQ 26.07: Should destructors throw exceptions when they fail?
FAQ 26.08: Should destructors call routines that may throw exceptions?
FAQ 26.09: Should resource deallocation primitives signal failure by throwing an exception?
FAQ 26.10: What should the terminate() function do?
FAQ 26.11: What should the unexpected() function do?
FAQ 26.13: How might the exception-handling mechanism cause a program to silently crash?
FAQ 27.01: What is the purpose of this chapter?
FAQ 27.02: What is static type checking?
FAQ 27.03: What is dynamic type checking?
FAQ 27.04: What is the basic problem with dynamic type checking?
FAQ 27.05: How can dynamic type checking be avoided?
FAQ 27.06: Are there better alternatives to dynamic type checking?
FAQ 27.07: What is a capability query?
FAQ 27.08: What is an alternative to dynamic type checking with containers?
FAQ 27.09: Are there cases where dynamic type checking is necessary?
FAQ 27.10: Given a pointer to an ABC, how can the class of the referent be found?
FAQ 27.11: What is a downcast?
FAQ 27.12: What is an alternative to using downcasts?
FAQ 27.13: Why are downcasts dangerous?
FAQ 27.14: Should the inheritance graph of C++ hierarchies be tall or short?
FAQ 27.15: Should the inheritance graph of C++ hierarchies be monolithic or a forest?
FAQ 27.16: What is Runtime Type Identification (RTTI)?
FAQ 27.17: What is the purpose of dynamic_cast<T>()?
FAQ 27.18: Is dynamic_cast<T>() a panacea?
FAQ 27.19: What does static_cast<T>() do?
FAQ 27.20: What does typeid() do?
FAQ 27.21: Are there any hidden costs for type-safe downcasts?
FAQ 28.02: Are arrays good or evil?
FAQ 28.03: Should application development organizations create their own container classes?
FAQ 28.04: What are some common mistakes with containers of pointers?
FAQ 28.05: Does this mean that containers of pointers should be avoided?
FAQ 28.06: Surely good old-fashioned char* is an exception, right?
FAQ 28.07: Can auto_ptr<T> simplify ownership problems with containers of pointers?
FAQ 28.08: Can a Java-like Object class simplify containers in C++?
FAQ 28.09: What's the difference between a homogeneous and a heterogeneous container?
FAQ 28.10: Is it a good idea to use a “best of breed” approach when selecting container classes?
FAQ 28.11: Should all projects use C++'s standardized containers?
FAQ 28.12: What are the C++ standardized container classes?
FAQ 28.13: What are the best applications for the standardized C++ sequence container classes?
FAQ 28.14: What are the best situations for the standardized C++ associative container classes?
Chapter 29 Mixing Overloading with Inheritance
FAQ 29.01: What is the difference between overloaded functions and overridden functions?
FAQ 29.02: What is the hiding rule?
FAQ 29.03: How should the hiding rule be handled?
FAQ 29.05: Can virtual functions be overloaded?
FAQ 30.01: What is the purpose of this chapter?
FAQ 30.02: What are the Big Three?
FAQ 30.03: What happens when an object is destroyed that doesn't have an explicit destructor?
FAQ 30.04: What happens if an object is copied but doesn't have an explicit copy constructor?
FAQ 30.06: What is the Law of the Big Three?
FAQ 30.07: Which of the Big Three usually shows up first?
FAQ 30.08: What is remote ownership?
FAQ 30.09: How is remote ownership special?
FAQ 30.10: What if a class owns a referent and doesn't have all of the Big Three?
FAQ 30.11: Are there any C++ classes that help manage remote ownership?
FAQ 30.13: Are there cases where one or two of the Big Three may be needed but not all three?
FAQ 30.14: Are there any other circumstances that might explicitly warrant the Big Three?
FAQ 30.15: Why does copying an object using memcpy() cause a program crash?
FAQ 30.16: Why do programs with variable-length argument lists crash?
FAQ 30.17: Why do programs that use realloc() to reallocate an array of objects crash?
Chapter 31 Using Objects to Prevent Memory Leaks
FAQ 31.01: When are memory leaks important?
FAQ 31.02: What is the easiest way to avoid memory leaks?
FAQ 31.03: What are the most important principles for resource management?
FAQ 31.05: Should an object manage two or more resources?
FAQ 31.07: How should a pointer variable be handled after being passed to delete?
FAQ 31.09: How easy is it to implement reference counting with pointer semantics?
FAQ 31.10: Is reference counting with copy-on-write semantics hard to implement?
FAQ 31.11: How can reference counting be implemented with copy-on-write semantics for a hierarchy of classes?
Chapter 32 Wild Pointers and Other Devilish Errors
FAQ 32.01: What is a wild pointer?
FAQ 32.02: What happens to a program that has even one wild pointer?
FAQ 32.03: What does the compiler mean by the warning “Returning a reference to a local object”?
FAQ 32.04: How should pointers across block boundaries be controlled?
FAQ 32.06: When should C-style pointer casts be used?
FAQ 32.07: Is it safe to bind a reference variable to a temporary object?
FAQ 32.08: Should a parameter passed by const reference be returned by const reference?
FAQ 32.09: Should template functions for things like min(x,y) or abs(x) return a const reference?
FAQ 32.10: When is zero not necessarily zero?
Chapter 33 High-Performance Software
FAQ 33.01: Is bad performance a result of bad design or bad coding?
FAQ 33.02: What are some techniques for improving performance?
FAQ 33.03: What is an advantage of using pointers and references?
FAQ 33.04: What is a disadvantage of lots of references and pointers?
FAQ 33.05: How else can member objects improve performance over pointers?
FAQ 33.06: Which is better, ++i or i++?
FAQ 33.08: What kinds of applications should consider using final classes and final member functions?
FAQ 33.09: What is a final class?
FAQ 33.10: What is a final member function?
FAQ 33.11: How can final classes and final member functions improve performance?
FAQ 33.12: When should a nonfinal virtual function be invoked with a fully qualified name?
FAQ 33.13: Should full qualification be used when calling another member function of the same class?
FAQ 33.14: Do final classes and final member functions cause a lot of code duplication?
FAQ 33.15: Why do some developers dislike final member functions and final classes?
FAQ 34.01: Who should read this chapter?
FAQ 34.02: What is the Component Object Model?
FAQ 34.03: What are ActiveX and OLE?
FAQ 34.04: What does the name Component Object Model mean?
FAQ 34.05: What is a “binary object model”?
FAQ 34.06: What are the key features of COM?
FAQ 34.08: Why does COM need GUIDs (and CLSIDs and IIDs)?
FAQ 34.09: What is an interface?
FAQ 34.10: What is the IUnknown interface?
FAQ 34.11: How many ways are there to specify COM interfaces?
FAQ 34.12: What are COM classes and COM objects?
FAQ 34.13: How hard is it for callers to create and use a COM object?
FAQ 34.14: How does COM provide language transparency?
FAQ 34.15: How does COM provide location transparency?
FAQ 34.16: What types of errors occur due to reference counting?
FAQ 34.17: What mechanism does COM define for error handling?
FAQ 34.18: How are interfaces versioned?
FAQ 34.19: Is COM object oriented?
FAQ 34.20: What is the biggest problem with COM?
FAQ 34.21: What are the major differences between COM and C++?
FAQ 34.22: When should a class be defined as a COM class?
FAQ 34.23: What is Automation?
FAQ 34.24: What are dispatch interfaces?
FAQ 34.25: When should a class expose a Dispatch interface?
FAQ 34.26: How does Automation work?
FAQ 34.27: How does Invoke accomplish all of this?
FAQ 34.28: What is a type library?
FAQ 34.29: What are the benefits of using type libraries?
FAQ 34.30: How do type libraries improve performance?
FAQ 34.31: What are dual interfaces?
FAQ 34.32: What limitations are there on dual interfaces?
FAQ 34.33: What are OLE custom controls and ActiveX controls?
FAQ 34.34: Why do ActiveX controls differ from OLE custom controls?
FAQ 34.35: What is a control container?
FAQ 34.36: What are component categories?
FAQ 34.39: How stable is DCOM's infrastructure?
Chapter 35 Transitioning to CORBA
FAQ 35.07: What is the purpose of this chapter?
FAQ 35.08: What is the most important message of this chapter?
FAQ 35.09: What are the important concepts behind CORBA?
FAQ 35.10: Isn't OMG IDL pretty much the same as C++?
FAQ 35.11: Is the lifecycle of a CORBA object the same as the life cycle of a C++ object?
FAQ 35.13: How do CORBA exceptions compare to C++ exceptions?
FAQ 35.14: Which CORBA implementation is best? Is CORBA better than COM?
Chapter 36 C Language Considerations
FAQ 36.01: What are the main issues when mixing C and C++ code in the same application?
FAQ 36.02: How can C++ code call C code?
FAQ 36.03: How can C code call C++ code?
FAQ 36.04: Why is the linker giving errors for C functions called from C++ functions and vice versa?
FAQ 36.05: How can an object of a C++ class be passed to or from a C function?
FAQ 36.06: Can a C function directly access data in an object of a C++ class?
FAQ 36.07: Can C++ I/O (<iostream>) be mixed with C I/O (<stdio.h>)?
FAQ 36.08: Which is safer: <iostream> or <stdio.h>?
FAQ 36.09: Which is more extensible: <iostream> or <stdio.h>?
FAQ 36.10: Which is more flexible: <iostream> or <stdio.h>?
FAQ 36.11: Why does it seem that C++ programming feels farther away from the machine than C?
FAQ 36.12: Why does C++ do more things behind your back than C does?
Chapter 37 Private and Protected Inheritance
FAQ 37.01: What are private inheritance and protected inheritance?
FAQ 37.02: What is the difference between private inheritance and protected inheritance?
FAQ 37.03: What is the syntax and semantics for private and protected inheritance?
FAQ 37.04: When should normal has-a be used, rather than private or protected inheritance?
FAQ 37.05: What are the access rules for public, protected, and private inheritance?
FAQ 37.07: Should a pointer be cast from a private or protected derived class to its base class?
Chapter 38 Pointers to Member Functions
FAQ 38.01: What is the type of a pointer to a nonstatic member function?
FAQ 38.03: What is one of the most common errors when using pointers to member functions?
FAQ 38.04: How is an array of pointers to nonstatic member functions declared?
Chapter 39 The Transition to OO and C++
FAQ 39.01: Who should read this chapter?
FAQ 39.02: What are the key messages of this chapter?
FAQ 39.03: How many stages of technical expertise are there in the transition?
FAQ 39.04: Why bother defining levels of expertise?
FAQ 39.05: Can OO/C++ be learned from a book?
FAQ 39.06: Can OO/C++ be learned from a course?
FAQ 39.07: What is the key to learning OO/C++?
FAQ 39.08: Are small projects a good way to get your feet wet?
FAQ 39.09: Does being a good C programmer help when learning OO/C++?