Book Image

Hands-On Design Patterns with C++

By : Fedor G. Pikus
Book Image

Hands-On Design Patterns with C++

By: Fedor G. Pikus

Overview of this book

C++ is a general-purpose programming language designed with the goals of efficiency, performance, and flexibility in mind. Design patterns are commonly accepted solutions to well-recognized design problems. In essence, they are a library of reusable components, only for software architecture, and not for a concrete implementation. The focus of this book is on the design patterns that naturally lend themselves to the needs of a C++ programmer, and on the patterns that uniquely benefit from the features of C++, in particular, the generic programming. Armed with the knowledge of these patterns, you will spend less time searching for a solution to a common problem and be familiar with the solutions developed from experience, as well as their advantages and drawbacks. The other use of design patterns is as a concise and an efficient way to communicate. A pattern is a familiar and instantly recognizable solution to specific problem; through its use, sometimes with a single line of code, we can convey a considerable amount of information. The code conveys: "This is the problem we are facing, these are additional considerations that are most important in our case; hence, the following well-known solution was chosen." By the end of this book, you will have gained a comprehensive understanding of design patterns to create robust, reusable, and maintainable code.

Related Content you might be interested in

Current Title:

Small book image
Hands-On Design Patterns with C++
Fedor G. Pikus
Jan, 2019 | 512 pages
Small book image
Template Metaprogramming with C++
Marius Bancila
Aug, 2022 | 480 pages
Small book image
The Art of Writing Efficient Programs
Fedor G Pikus
Oct, 2021 | 464 pages
Small book image
Advanced C++ Programming Cookbook
Dr Rian Quinn
Jan, 2020 | 454 pages
Table of Contents (21 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
An Introduction to Inheritance and Polymorphism
An Introduction to Inheritance and Polymorphism
Classes and objects
Inheritance and class hierarchies
Polymorphism and virtual functions
Multiple inheritance
Summary
Questions
Further reading
2
Class and Function Templates
Class and Function Templates
Templates in C++
Template instantiations
Template specializations
Template function overloading
Variadic templates
Lambda expressions
Summary
Questions
Further reading
3
Memory Ownership
Memory Ownership
Technical requirements
What is memory ownership?
Expressing memory ownership in C++
Summary
Questions
Further reading
4
Swap - From Simple to Subtle
Swap - From Simple to Subtle
Technical requirements
Swap and the standard template library
When and why to use swap
How to implement and use swap correctly
Summary
Questions
5
A Comprehensive Look at RAII
A Comprehensive Look at RAII
Technical requirements
Resource management in C++
Dangers of manual resource management
The RAII idiom
Summary
Questions
Further reading
6
Understanding Type Erasure
Understanding Type Erasure
Technical requirements
What is type erasure?
How is type erasure implemented in C++?
When to use type erasure, and when to avoid it
Summary
Questions
7
SFINAE and Overload Resolution Management
SFINAE and Overload Resolution Management
Technical requirements
Overload resolution and overload sets
Type substitution in template functions
Taking control of overload resolution
Summary
Questions
Further reading
8
The Curiously Recurring Template Pattern
The Curiously Recurring Template Pattern
Technical requirements
Wrapping your head around CRTP
CRTP and static polymorphism
CRTP as a delegation pattern
Summary
Questions
9
Named Arguments and Method Chaining
Named Arguments and Method Chaining
Technical requirements
The problem with arguments
Named arguments in C++
General method chaining
Summary
Questions
10
Local Buffer Optimization
Local Buffer Optimization
Technical requirements
The overhead of small memory allocations
Introducing local buffer optimization
Local buffer optimization beyond strings
Downsides of local buffer optimization
Summary
Questions
Further reading
11
ScopeGuard
ScopeGuard
Technical requirements
Error handling and Resource Acquisition Is Initialization
The ScopeGuard pattern
ScopeGuard and exceptions
Type-erased ScopeGuard
Summary
Questions
12
Friend Factory
Friend Factory
Technical requirements
Friends in C++
Friends and templates
The template friend factory
The friend factory and the Curiously Recurring Template Pattern
Summary
Questions
13
Virtual Constructors and Factories
Virtual Constructors and Factories
Technical requirements
Why constructors cannot be virtual
The Factory pattern
Factory-like patterns in C++
Summary
Questions
14
The Template Method Pattern and the Non-Virtual Idiom
The Template Method Pattern and the Non-Virtual Idiom
Technical requirements
The Template Method pattern
The Non-Virtual Interface
Drawbacks of the Non-Virtual Interface
Summary
Questions
Further reading
15
Singleton - A Classic OOP Pattern
Singleton - A Classic OOP Pattern
Technical requirements
The singleton pattern – what is it and what is it for?
Types of singletons
Summary
Questions
16
Policy-Based Design
Policy-Based Design
Technical requirements
Strategy pattern and policy-based design
Advanced policy-based design
Recommendations and guidelines
Almost policy-based approach
Summary
Questions
17
Adapters and Decorators
Adapters and Decorators
Technical requirements
The decorator pattern
The Adapter pattern
Adapter versus policy
Summary
Questions
18
The Visitor Pattern and Multiple Dispatch
The Visitor Pattern and Multiple Dispatch
Technical requirements
The Visitor pattern
Visiting complex objects
Acyclic Visitor
Visitors in modern C++
Compile-time Visitor
Summary
Questions
19
Assessments
Assessments
Chapter 1
Chapter 2
Chapter 3
Chapter 4
Chapter 5
Chapter 6
Chapter 7
Chapter 8
Chapter 9
Chapter 10
Chapter 11
Chapter 12
Chapter 13
Chapter 14
Chapter 15
Chapter 16
Chapter 17
Chapter 18
20
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

SFINAE and Overload Resolution Management

The idiom we study in this chapter, Substitution Failure Is Not An Error (SFINAE), is one of the more complex in terms of the language features it uses. Thus, it tends to get inordinate amounts of attention from C++ programmers. There is something in this feature that appeals to the mindset of a typical C++ programmer—a normal person thinks that, if it isn't broken, don't mess with it. A programmer, especially one writing in C++, tends to think that, if it isn't broken, you're not using it to its full potential. Let's just say that SFINAE has a lot of potential.

We will cover the following topics in this chapter:

  • What are function overloading and overload resolution?
  • What are type deduction and substitution?
  • What is SFINAE, and why was it necessary in C++?
  • How can SFINAE be used to write insanely complex...
Previous Section
End of Section 1
Next Section