Deciphering Object-Oriented Programming with C++

Cover
Title Page
Copyright and Credits
Dedication
Contributors
Table of Contents
Preface
Part 1: C++ Building Block Essentials
Chapter 1: Understanding Basic C++ Assumptions
	Technical requirements
	Reviewing basic C++ language syntax
		Comment styles
		Variable declarations and standard data types
		Variables and array basics
	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 and “using” alias declaration
		class
		enum and strongly-typed enum
	Recapping namespace basics
	Summary
	Questions
Chapter 2: Adding Language Necessities
	Technical requirements
	Using the const and constexpr qualifiers
		const and constexpr 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 excessive 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 operators new() and delete()
		Creating and using pointers to user defined types
	Allocating and deallocating arrays at runtime
		Dynamically allocating single dimension arrays
		Dynamically allocating 2-D arrays – an array 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
	Looking ahead to smart pointers for safety
	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
Part 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
		Constructors and in-class initializers
		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
		Specifying a class as final
	Understanding inherited constructors and destructors
		Implicit constructor and destructor invocations
		Usage of 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 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 multiple inheritance
		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 association
		Implementing association
		Utilizing backlink maintenance and reference counting
	Summary
	Questions
Part 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 the 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
Part 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 an 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 a simple implementation
		An alternate simple implementation
		Using a 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
Part 5: Considerations for Safer Programming in C++
Chapter 21: Making C++ Safer
	Technical requirements
	Revisiting smart pointers
		Using smart pointers – unique
		Using smart pointers – shared
		Using smart pointers – weak
		Exploring a complementary idea – RAII
	Embracing additional C++ features promoting safety
		Revisiting range for loops
		Using auto for type safety
		Preferring STL for simple containers
		Applying const as needed
	Considering thread safety
		Multithreaded programming overview
		Multithreaded programming scenarios
	Utilizing core programming guidelines
		Examining guideline essentials
		Adopting a programming guideline
		Understanding resources for programming safely in C++
	Summary
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
Index
About Packt
Other Books You May Enjoy