Hands-On Design Patterns with C++: Solve common C++ problems with modern design patterns and build robust applications

Cover
Title Page
Copyright and Credits
About Packt
Contributors
Table of Contents
Preface
Chapter 1: An Introduction to Inheritance and Polymorphism
	Classes and objects
	Inheritance and class hierarchies
	Polymorphism and virtual functions
	Multiple inheritance
	Summary
	Questions
	Further reading
Chapter 2: Class and Function Templates
	Templates in C++
		Function templates
		Class templates
		Variable template
		Non-type template parameters
	Template instantiations
		Function templates
		Class templates
	Template specializations
		Explicit specialization
		Partial specialization
	Template function overloading
	Variadic templates
	Lambda expressions
	Summary
	Questions
	Further reading
Chapter 3: Memory Ownership
	Technical requirements
	What is memory ownership?
		Well-designed memory ownership
		Poorly designed memory ownership
	Expressing memory ownership in C++
		Expressing non-ownership
		Expressing exclusive ownership
		Expressing transfer of exclusive ownership
		Expressing shared ownership
	Summary
	Questions
	Further reading
Chapter 4: Swap - From Simple to Subtle
	Technical requirements
	Swap and the standard template library 
		Swap and STL containers
		Non-member swap
		Swapping like the standard
	When and why to use swap
		Swap and exception safety
		Other common swap idioms
	How to implement and use swap correctly
		Implementing swap
		Using swap correctly
	Summary
	Questions
Chapter 5: A Comprehensive Look at RAII
	Technical requirements
	Resource management in C++
		Installing the microbenchmark library
		Installing Google Test
		Counting resources
	Dangers of manual resource management
		Manual resource management is error-prone
		Resource management and exception safety
	The RAII idiom
		RAII in a nutshell
		RAII for other resources
		Releasing early
		Careful implementation of  Resource Acquisition is Initialization objects
		Downsides of RAII
	Summary
	Questions
	Further reading
Chapter 6: Understanding Type Erasure
	Technical requirements
	What is type erasure?
		Type erasure by example
	How is type erasure implemented in C++?
		Very old type erasure
		Object-oriented type erasure
		The opposite of the type erasure
		Type erasure in C++
	When to use type erasure, and when to avoid it
		Type erasure and software design
		Installing the micro-benchmark library
		The overhead of type erasure
	Summary
	Questions
Chapter 7: SFINAE and Overload Resolution Management
	Technical requirements
	Overload resolution and overload sets
		C++ function overloading
		Template functions
	Type substitution in template functions
		Type deduction and substitution
		Substitution failure
		Substitution Failure Is Not An Error
	Taking control of overload resolution
		Basic SFINAE
		Advanced SFINAE
		Advanced SFINAE revisited
		The ultimate SFINAE
	Summary
	Questions
	Further reading
Chapter 8: The Curiously Recurring Template Pattern
	Technical requirements
	Wrapping your head around CRTP
		What is wrong with a virtual function?
		Introducing CRTP
	CRTP and static polymorphism
		Compile-time polymorphism
		The compile-time pure virtual function
		Destructors and polymorphic deletion
		CRTP and access control
	CRTP as a delegation pattern
		Expanding the interface
	Summary
	Questions
Chapter 9: Named Arguments and Method Chaining
	Technical requirements
	The problem with arguments
		What\'s wrong with many arguments
		Aggregate parameters
	Named arguments in C++
		Method chaining
		Method chaining and  named arguments
		Performance of the named arguments idiom
	General method chaining
		Method chaining versus method cascading
		General method chaining
		Method chaining in class hierarchies
	Summary
	Questions
Chapter 10: Local Buffer Optimization
	Technical requirements
	The overhead of small memory allocations
		The cost of memory allocations
	Introducing local buffer optimization
		The main idea
		Effect of local buffer optimization
		Additional optimizations
	Local buffer optimization beyond strings
		Small vector
		Type-erased and callable objects
		Local buffer optimization in the C++ library
	Downsides of local buffer optimization
	Summary
	Questions
	Further reading
Chapter 11: ScopeGuard
	Technical requirements
	Error handling and Resource Acquisition Is Initialization
		Error safety and exception safety
		Resource Acquisition Is Initialization 
	The ScopeGuard pattern
		ScopeGuard basics
		Generic ScopeGuard
	ScopeGuard and exceptions
		What must not throw an exception
		Exception-driven ScopeGuard
	Type-erased ScopeGuard
	Summary
	Questions
Chapter 12: Friend Factory
	Technical requirements
	Friends in C++
		How to grant friendship in C++
		Friends versus member functions
	Friends and templates
		Friends of template classes
	The template friend factory
		Generating friends on demand
	The friend factory and the Curiously Recurring Template Pattern 
	Summary
	Questions
Chapter 13: Virtual Constructors and Factories
	Technical requirements
	Why constructors cannot be virtual
		When does an object get its type?
	The Factory pattern
		The basics of the Factory method
		Arguments for factory methods
		Dynamic type registry
		Polymorphic factory
	Factory-like patterns in C++
		Polymorphic copy
		CRTP Factory and return types
		CRTP Factory with less copy-paste
	Summary
	Questions
Chapter 14: The Template Method Pattern and the Non-Virtual Idiom
	Technical requirements
	The Template Method pattern
		The Template Method in C++
		Applications of the Template Method
		Pre-and post-conditions and actions
	The Non-Virtual Interface
		Virtual functions and access
		The NVI idiom in C++
		A note about destructors
	Drawbacks of the Non-Virtual Interface
		Composability
		The Fragile Base Class problem
	Summary
	Questions
	Further reading
Chapter 15: Singleton - A Classic OOP Pattern
	Technical requirements
	The singleton pattern – what is it and what is it for?
		What is a singleton?
		When to use the singleton
	Types of singletons
		Static singleton
		Meyers\' Singleton
		Leaky singletons
	Summary
	Questions
Chapter 16: Policy-Based Design
	Technical requirements
	Strategy pattern and policy-based design
		Foundations of policy-based design
		Implementation of policies
		Use of policy objects
	Advanced policy-based design
		Policies for constructors
		Policies for test
		Policy adapters and aliases
		Using policies to control the public interface
		Rebinding policies
	Recommendations and guidelines
		Strengths of the policy-based design
		Disadvantages of policy-based design
		Guidelines for policy-based designs
	Almost policy-based approach
	Summary
	Questions
Chapter 17: Adapters and Decorators
	Technical requirements
	The decorator pattern
		Basic decorator pattern
		Decorators the C++ way
		Polymorphic decorators and their limitations
		Composable decorators
	The Adapter pattern
		Basic Adapter pattern
		Function adapters
		Compile-time adapters
	Adapter versus policy
	Summary
	Questions
Chapter 18: The Visitor Pattern and Multiple Dispatch
	Technical requirements
	The Visitor pattern
		What is the Visitor pattern?
		Basic Visitor in C++
		Visitor generalizations and limitations
	Visiting complex objects
		Visiting composite objects
		Serialization and deserialization with Visitor
	Acyclic Visitor
	Visitors in modern C++
		Generic Visitor
		Lambda Visitor
		Generic Acyclic Visitor
	Compile-time Visitor
	Summary
	Questions
Assessments
Other Books You May Enjoy
Index