book

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

by Fedor G. Pikus

July 2023

Intermediate to advanced

626 pages

16h 40m

English

Packt Publishing

Read now

Unlock full access

ContributorsAbout the authorAbout the reviewer
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
Classes and objectsInheritance and class hierarchiesPolymorphism and virtual functionsMultiple inheritanceSummaryQuestionsFurther reading
Templates in C++Function templatesClass templatesVariable templatesNon-type template parametersTemplate template parametersTemplate instantiationsFunction templatesClass templatesTemplate specializationsExplicit specializationPartial specializationTemplate function overloadingVariadic templatesLambda expressionsConceptsSummaryQuestionsFurther reading
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
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
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
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

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
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
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
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
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
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
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
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
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
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
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
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
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
Other Books You May EnjoyPackt is searching for authors like youShare your thoughtsDownload a free PDF copy of this book

Content preview from Hands-On Design Patterns with C++ - Second Edition

Part 2: Common C++ Idioms

This part describes some of the more common C++ idioms: established, universally recognized ways to express a specific idea or implement a frequently needed task. The boundary between “patterns” and “idioms” is fuzzy at best. In this book, we consider more complete design solutions to be patterns, while simpler techniques are idioms. In other words, choosing a pattern may influence the design of your entire application or its major component, while using an idiom is more of an implementation decision that has been learned from someone else’s mistakes.

This part has the following chapters: