book

Hands-On Design Patterns with C++ - Second Edition

Name: Hands-On Design Patterns with C++ - Second Edition
Author: Fedor G. Pikus
ISBN: 9781804611555

by Fedor G. Pikus

July 2023

Intermediate to advanced

626 pages

16h 40m

English

Packt Publishing

Read now

Unlock full access

Hands-On Design Patterns with C++
ContributorsAbout the authorAbout the reviewer
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesConventions usedGet in touchShare Your ThoughtsDownload a free PDF copy of this book
Part 1: Getting Started with C++ Features and Concepts
Chapter 1: An Introduction to Inheritance and Polymorphism
Classes and objectsInheritance and class hierarchiesPolymorphism and virtual functionsMultiple inheritanceSummaryQuestionsFurther reading
Chapter 2: Class and Function Templates
Templates in C++Function templatesClass templatesVariable templatesNon-type template parametersTemplate template parametersTemplate instantiationsFunction templatesClass templatesTemplate specializationsExplicit specializationPartial specializationTemplate function overloadingVariadic templatesLambda expressionsConceptsSummaryQuestionsFurther reading
Chapter 3: Memory and Ownership
Technical requirementsWhat is memory ownership?Well-designed memory ownershipPoorly designed memory ownershipExpressing memory ownership in C++Expressing non-ownershipExpressing exclusive ownershipExpressing transfer of exclusive ownershipExpressing shared ownershipOwning objects and viewsResource-owning objectsNon-owning access to resource-owning objectsSummaryQuestionsFurther reading
Part 2: Common C++ Idioms
Chapter 4: Swap – from Simple to Subtle
Technical requirementsSwap and the standard template librarySwap and STL containersNon-member swapSwapping like the standardWhen and why to use swapSwap and exception safetyOther common swap idiomsHow to implement and use swap correctlyImplementing swapUsing swap correctlySummaryQuestions
Chapter 5: A Comprehensive Look at RAII
Technical requirementsResource management in C++Installing the microbenchmark libraryInstalling Google TestCounting resourcesDangers of manual resource managementManual resource management is error-proneResource management and exception safetyThe RAII idiomRAII in a nutshellRAII for other resourcesReleasing earlyCareful implementation of Resource Acquisition is Initialization objectsDownsides of RAIIVery modern RAIISummaryQuestionsFurther reading
Chapter 6: Understanding Type Erasure
Technical requirementsWhat is type erasure?Type erasure by exampleFrom example to generalizationType erasure as a design patternType erasure as an implementation techniqueHow is type erasure implemented in C++?Very old type erasureType erasure using inheritanceType erasure without memory allocationType erasure without inheritanceEfficient type erasurePerformance of type erasureInstalling the micro-benchmark libraryThe overhead of type erasureGuidelines for using type erasureSummaryQuestions

Chapter 7: SFINAE, Concepts, and Overload Resolution Management
Technical requirementsOverload resolution and overload setsC++ function overloadingTemplate functionsType substitution in template functionsType deduction and substitutionSubstitution failureSubstitution Failure Is Not An ErrorWhen substitution failure is still an errorWhere and why does substitution failure happen?Concepts and constraints in C++20Constraints in C++20Concepts in C++20Concepts and type restrictionsSFINAE techniquesSFINAE in C++20SFINAE and type traitsConcepts before conceptsConstrained templates – the best practicesSummaryQuestions
Part 3: C++ Design Patterns
Chapter 8: The Curiously Recurring Template Pattern
Technical requirementsWhat is wrong with a virtual function?Introducing CRTPCRTP and static polymorphismCompile-time polymorphismThe compile-time pure virtual functionDestructors and polymorphic deletionCRTP and access controlCRTP as a delegation patternExpanding the interfaceCRTP and conceptsCRTP as an implementation techniqueCRTP for code reuseCRTP for generic interfacesCRTP and policy-based designSummaryQuestions
Chapter 9: Named Arguments, Method Chaining, and the Builder Pattern
Technical requirementsWhat’s wrong with many arguments?Aggregate parametersNamed arguments in C++Method chainingMethod chaining and named argumentsPerformance of the named arguments idiomGeneral method chainingMethod chaining versus method cascadingGeneral method chainingMethod chaining in class hierarchiesThe Builder patternBasics of the Builder patternThe fluent BuilderThe implicit builderSummaryQuestions
Chapter 10: Local Buffer Optimization
Technical requirementsThe overhead of small memory allocationsThe cost of memory allocationsIntroducing local buffer optimizationThe main ideaEffect of local buffer optimizationAdditional optimizationsLocal buffer optimization beyond stringsSmall vectorSmall queueType-erased and callable objectsLocal buffer optimization in the standard libraryLocal buffer optimization in detailDownsides of local buffer optimizationSummaryQuestions
Chapter 11: ScopeGuard
Technical requirementsError handling and resource acquisition is initializationError safety and exception safetyResource Acquisition Is InitializationThe ScopeGuard patternScopeGuard basicsGeneric ScopeGuardScopeGuard and exceptionsWhat must not throw an exceptionException-driven ScopeGuardType-erased ScopeGuardSummaryQuestions
Chapter 12: Friend Factory
Technical requirementsFriends in C++How to grant friendship in C++Friends versus member functionsSubtle details of friendshipFriends and templatesFriends of template classesThe template friend factoryGenerating friends on demandThe friend factory and the Curiously Recurring Template PatternSummaryQuestions
Chapter 13: Virtual Constructors and Factories
Technical requirementsWhy constructors cannot be virtualWhen does an object get its type?The Factory patternThe basics of the Factory methodFactory clarificationArguments for factory methodsDynamic type registryPolymorphic factoryFactory-like patterns in C++Polymorphic copyCRTP Factory and return typesCRTP for Factory implementationFactory and BuilderSummaryQuestions
Chapter 14: The Template Method Pattern and the Non-Virtual Idiom
Technical requirementsThe Template Method patternThe Template Method in C++Applications of the Template MethodPre-and post-conditions and actionsThe Non-Virtual InterfaceVirtual functions and accessThe NVI idiom in C++Template Method vs StrategyA note about destructorsDrawbacks of the Non-Virtual InterfaceComposabilityThe Fragile Base Class problemA cautionary note about template customization pointsSummaryQuestions
Part 4: Advanced C++ Design Patterns
Chapter 15: Policy-Based Design
Technical requirementsStrategy pattern and policy-based designFoundations of policy-based designImplementation of policiesUse of policy objectsAdvanced policy-based designPolicies for constructorsPolicies for testPolicy adapters and aliasesUsing policies to control the public interfaceRebinding policiesRecommendations and guidelinesStrengths of the policy-based designDisadvantages of policy-based designGuidelines for policy-based designsSummaryQuestions
Chapter 16: Adapters and Decorators
Technical requirementsThe decorator patternBasic decorator patternDecorators the C++ wayPolymorphic decorators and their limitationsComposable decoratorsThe Adapter patternBasic Adapter patternFunction adaptersAdapter or DecoratorCompile-time adaptersAdapter versus policyAdapter solutionPolicy solutionSummaryQuestions
Chapter 17: The Visitor Pattern and Multiple Dispatch
The Visitor patternWhat is the Visitor pattern?Basic Visitor in C++Visitor generalizations and limitationsVisiting complex objectsVisiting composite objectsSerialization and deserialization with VisitorAcyclic VisitorVisitors in modern C++Generic VisitorLambda VisitorGeneric Acyclic VisitorCompile-time VisitorVisitor in C++17SummaryQuestions
Chapter 18: Patterns for Concurrency
Technical requirementsC++ and concurrencySynchronization patternsMutex and locking patternsNo sharing is the best sharingWaiting patternsLock-free synchronization patternsConcurrent design patterns and guidelinesThread safety guaranteesTransactional interface designData structures with access limitationsConcurrent execution patternsActive objectReactor Object patternProactor Object patternMonitor patternCoroutine patterns in C++SummaryQuestions
Assessments
Chapter 1, An Introduction to Inheritance and PolymorphismChapter 2, Class and Function TemplatesChapter 3, Memory and OwnershipChapter 4, Swap - From Simple to SubtleChapter 5, Comprehensive Look at RAIIChapter 6, Understanding Type ErasureChapter 7, SFINAE, Concepts, and Overload Resolution ManagementChapter 8, The Curiously Recurring Template PatternChapter 9, Named Arguments, Method Chaining, and the Builder PatternChapter 10, Local Buffer OptimizationChapter 11, ScopeGuardChapter 12, Friend FactoryChapter 13, Virtual Constructors and FactoriesChapter 14, The Template Method Pattern and the  Non-Virtual IdiomChapter 15, Policy-Based DesignChapter 16, Adapters and DecoratorsChapter 17, The Visitor Pattern and Multiple DispatchChapter 18, Patterns for Concurrency
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare your thoughtsDownload a free PDF copy of this book

Overview

Master the art of software design with "Hands-On Design Patterns with C++." This comprehensive guide introduces you to the core design patterns and idioms in C++, focusing on modern applications and best practices. Learn how to build robust, maintainable, and scalable software solutions.

What this Book will help me do

Gain an in-depth understanding of core design patterns in C++ applicable to a variety of problems.
Learn how new features in C++17 and C++20 enable modern design approaches.
Develop proficiency in writing reusable and maintainable C++ code.
Master the use of templates, memory management, and type erasure in design patterns.
Understand the impact of design patterns on performance and how to optimize them.

Author(s)

Fedor G. Pikus is a leading expert in C++ programming and software design, with extensive professional experience. Authoritatively versed in C++ intricacies, Fedor brings clarity and practicality to complex topics. His approach combines real-world problem solving with deep theoretical insights.

Who is it for?

This book is ideal for professional software developers and engineers competent in C++ who seek to advance their design skills. If you have a good grasp of intermediate C++ and wish to utilize design patterns for improving software comprehensibility and robustness, this is for you. Enhance your architectural acumen with pragmatic knowledge and clear examples.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781804611555

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills