Demystified Object-Oriented Programming with C++

Cover
Copyright
Contributors
Table of Contents
Preface
Section 1: C++ Building Block Essentials
Chapter 1: Understanding Basic C++ Assumptions
Technical requirements
Reviewing basic C++ language syntax
Variable declarations and standard data types
Variables and array basics
Comment styles
Recapping basic I/O
The iostream library
Basic iostream manipulators
Revisiting control structures, statements, and looping
Control structures: if, else if, and else
Looping constructs: while, do while, and for loops
Reviewing C++ operators
Revisiting function basics
Reviewing user-defined type basics
struct
typedef
class
enum
Recapping namespace basics
Summary
Questions
Chapter 2: Adding Language Necessities
Technical requirements
Using the const qualifier
Const variables
Const qualification with functions
Working with function prototypes
Defining function prototypes
Naming arguments in function prototypes
Adding default values to function prototypes
Prototyping with different default values in different scopes
Understanding function overloading
Learning the basics of function overloading
Eliminating excess overloading with standard type conversion
Ambiguities arising from function overloading and type conversion
Summary
Questions
Chapter 3: Indirect Addressing: Pointers
Technical requirements
Understanding pointer basics and memory allocation
Revisiting pointer basics
Using the address-of and dereference operators
Using the operators new() and delete()
Creating and using pointers to user defined types
Allocating and deallocating arrays at run time
Dynamically allocating single-dimension arrays
Dynamically allocating 2-D arrays: arrays of pointers
Dynamically allocating 2-D arrays: pointers to pointers
Dynamically allocating N-D arrays: pointers to pointers to pointers
Using pointers with functions
Passing pointers as arguments to functions
Using pointers as return values from functions
Using the const qualifier with pointers
Using pointers to constant objects
Using constant pointers to objects
Using constant pointers to constant objects
Using pointers to constant objects as function arguments and as return types from functions
Using pointers to objects of unspecified types
Creating void pointers
Summary
Questions
Chapter 4: Indirect Addressing: References
Technical requirements
Understanding reference basics
Declaring, initializing, and accessing references
Referencing existing objects of user defined types
Using references with functions
Passing references as arguments to functions
Using references as return values from functions
Using the const qualifier with references
Using references to constant objects
Using pointers to constant objects as function arguments and as return types from functions
Realizing underlying implementation and restrictions
Understanding when we must use pointers instead of references
Summary
Questions
Section 2: Implementing Object-Oriented Concepts in C++
Chapter 5: Exploring Classes in Detail
Technical requirements
Introducing object-oriented terminology and concepts
Understanding object-oriented terminology
Understanding object-oriented concepts
Understanding class and member function basics
Examining member function internals; the "this" pointer
Using access labels and access regions
Understanding constructors
Applying constructor basics and overloading constructors
Creating copy constructors
Creating conversion constructors
Understanding destructors
Applying destructor basics and proper usage
Applying qualifiers to data members and member functions
Adding inline functions for potential efficiency
Adding const data members and the member initialization list
Using const member functions
Utilizing static data members and static member functions
Summary
Questions
Chapter 6: Implementing Hierarchies with Single Inheritance
Technical requirements
Expanding object-oriented concepts and terminology
Deciphering generalization and specialization
Understanding single inheritance basics
Defining base and derived classes, and accessing inherited members
Examining inherited access regions
Understanding inherited constructors and destructors
Implicit constructor and destructor invocations
Usage of the member initialization list to select a base class constructor
Putting all the pieces together
Implementation inheritance – changing the purpose of inheritance
Modifying access labels in the base class list by using protected or private base classes
Creating a base class to illustrate implementation inheritance
Using a private base class to implement one class in terms of another
Using a protected base class to implement one class in terms of another
Summary
Questions
Chapter 7: Utilizing Dynamic Binding through Polymorphism
Technical requirements
Understanding the OO concept of polymorphism
Implementing polymorphism with virtual functions
Defining virtual functions and overriding base class methods
Generalizing derived class objects
Utilizing virtual destructors
Putting all the pieces together
Considering function hiding
Understanding dynamic binding
Comprehending runtime binding of methods to operations
Interpreting the virtual function table (v-table) in detail
Summary
Questions
Chapter 8: Mastering Abstract Classes
Technical requirements
Understanding the OO concept of an abstract class
Implementing abstract classes with pure virtual functions
Creating interfaces
Generalizing derived class objects as abstract types
Putting all the pieces together
Summary
Questions
Chapter 9: Exploring Multiple Inheritance
Technical requirements
Understanding multiple inheritance mechanics
Examining reasonable uses for MI
Supporting Is-A and mix-in relationships
Supporting Has-A relationships
Creating a diamond-shaped hierarchy
Utilizing virtual base classes to eliminate duplication
Considering discriminators and alternate designs
Summary
Questions
Chapter 10: Implementing Association, Aggregation, and Composition
Technical requirements
Understanding aggregation and composition
Defining and implementing composition
Defining and implementing a generalized aggregation
Understanding associations
Implementing association
Utilizing back-link maintenance and reference counting
Summary
Questions
Section 3: Expanding Your C++ Programming Repertoire
Chapter 11: Handling Exceptions
Technical requirements
Understanding exception handling
Utilizing exception handling with try, throw, and catch
Exploring exception handling mechanics with typical variations
Utilizing exception hierarchies
Using standard exception objects
Creating customized exception classes
Creating hierarchies of user-defined exception types
Summary
Questions
Chapter 12: Friends and Operator Overloading
Technical requirements
Understanding friend classes and friend functions
Using friend functions and friend classes
Making access safer when using friends
Deciphering operator overloading essentials
Implementing operator functions and knowing when friends might be necessary
Summary
Questions
Chapter 13: Working with Templates
Technical requirements
Exploring template basics to genericize code
Examining the motivation for templates
Understanding template functions and classes
Creating and using template functions
Creating and using template classes
Examining a full program example
Making templates more flexible and extensible
Adding operator overloading to further genericize template code
Summary
Questions
Chapter 14: Understanding STL Basics
Technical requirements
Surveying the contents and purpose of the STL
Understanding how to use essential STL containers
Using STL list
Using STL iterator
Using STL vector
Using STL deque
Using STL stack
Using STL queue
Using STL priority queue
Examining STL map
Examining STL map using a functor
Customizing STL containers
Summary
Questions
Chapter 15: Testing Classes and Components
Technical requirements
Contemplating OO testing
Understanding canonical class form
Default constructor
Copy constructor
Overloaded assignment operator
Virtual destructor
Move copy constructor
Move assignment operator
Bringing the components of canonical class form together
Ensuring a class is robust
Creating drivers to test classes
Testing related classes
Testing classes related through inheritance, association, or aggregation
Testing exception handling mechanisms
Embedding exception handling in constructors to create robust classes
Summary
Questions
Section 4: Design Patterns and Idioms in C++
Chapter 16: Using the Observer Pattern
Technical requirements
Utilizing design patterns
Understanding the Observer pattern
Implementing the Observer pattern
Creating Observer, Subject, and domain-specific derived classes
Summary
Questions
Chapter 17: Applying the Factory Pattern
Technical requirements
Understanding the Factory Method pattern
Implementing the Factory Method pattern
Including the Factory Method in the Product class
Creating an Object Factory class to encapsulate the Factory Method
Summary
Questions
Chapter 18: Applying the Adapter Pattern
Technical requirements
Understanding the Adapter pattern
Implementing the Adapter pattern
Using an Adapter to provide a necessary interface to an existing class
Using an Adapter as a wrapper
Summary
Questions
Chapter 19: Using the Singleton Pattern
Technical requirements
Understanding the Singleton pattern
Implementing the Singleton pattern
Using the simple implementation
Using the more robust paired-class implementation
Using a registry to allow many classes to utilize Singleton
Summary
Questions
Chapter 20: Removing Implementation Details Using the pImpl Pattern
Technical requirements
Understanding the pImpl pattern
Implementing the pImpl pattern
Organizing file and class contents to apply the pattern basics
Improving the pattern with a unique pointer
Understanding pImpl pattern trade-offs
Summary
Questions
Assessments
Chapter 1 – Understanding Basic C++ Assumptions
Chapter 2 – Adding Language Necessities
Chapter 3 – Indirect Addressing: Pointers
Chapter 4 – Indirect Addressing: References
Chapter 5 – Exploring Classes in Detail
Chapter 6 – Implementing Hierarchies with Single Inheritance
Chapter 7 – Utilizing Dynamic Binding through Polymorphism
Chapter 8 – Mastering Abstract Classes
Chapter 9 – Exploring Multiple Inheritance
Chapter 10 – Implementing Association, Aggregation, and Composition
Chapter 11 – Handling Exceptions
Chapter 12 – Friends and Operator Overloading
Chapter 13 – Working with Templates
Chapter 14 – Understanding STL Basics
Chapter 15 – Testing Classes and Components
Chapter 16 – Using the Observer Pattern
Chapter 17 – Applying the Factory Pattern
Chapter 18 – Applying the Adapter Pattern
Chapter 19 – Using the Singleton Pattern
Chapter 20 – Removing Implementation Details Using the pImpl Pattern
Why subscribe?
Other Books You May Enjoy
Index