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

Description

Gain comprehensive insights into concepts such as object-oriented programming (OOP), functional programming, generic programming, and the Standard Template Library (STL), along with exploring the latest features of C++ Key FeaturesDelve into the core patterns and components of C++ to master application designLearn tricks, techniques, and best practices to tackle common design and architectural challengesUnderstand the limitations imposed by C++ and how to solve them using design patternsBook Description C++ is a general-purpose programming language designed to ensure optimal efficiency, performance, and flexibility, while design patterns are commonly accepted solutions to well-recognized design problems. In essence, they are a library of reusable components, designed only for software architecture, and not for concrete implementation. This book covers the design patterns that naturally lend themselves to the needs of a C++ programmer, focusing on essential C++ concepts and on the patterns that uniquely benefit from the features of C++, in particular, generic programming. You'll also get to grips with C++ idioms such as Resource Acquisition Is Initialization (RAII) and type erasure. 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. You'll then explore how design patterns can be used as a concise and an efficient way to communicate. Since a pattern is a familiar and instantly recognizable solution to a specific problem, by using it, sometimes with a single line of code, you can convey a considerable amount of information. In addition to this, you'll understand how each pattern is used for solving a specific problem, from interface design problems through to system architecture challenges. Toward the concluding chapters, the book will guide you through some advanced design patterns. You'll also discover how you can use some advanced patterns to address more complex design problems. By the end of this book, you will have gained a comprehensive understanding of design patterns to create robust, reusable, and maintainable code. What you will learnRecognize the most common design patterns used in C++Understand how to use C++ generic programming to solve common design problemsExplore the most powerful C++ idioms, along with their strengths and drawbacksDiscover how to use popular C++ idioms with generic programmingUnderstand the impact of design patterns on a program's performanceLearn the difference between dynamic and static polymorphismWho this book is for This book is for experienced C++ developers and programmers who want to learn about software design patterns and principles and apply them to create robust, reusable, and easily maintainable apps. Table of ContentsAn introduction to Inheritance and polymorphismClass and function templatesMemory ownership Swap - from simple to subtleA Comprehensive Look at Resource Acquisition is Initialization (RAII)Type ErasureSFINAE and Overload Resolution ManagementThe Curiously Recurring Template PatternNamed Arguments and Method ChainingLocal Buffer OptimizationScopeguard Friend FactoryVirtual Constructors and FactoriesThe Template Method Pattern and the Non-Virtual IdiomSingleton: a Classic OOP PatternPolicy-based designAdaptors and DecoratorsVisitor and multiple dispatch Preface An Introduction to Inheritance and Polymorphism Function Templates Class Templates Swap A Comprehensive Look at RAII Technical requirements Resource management in C++ Installing GoogleTest Counting resources Dangers of manual resource management Manual resource management is error-prone Resource management and exception safety Resource Acquisition is Initialization (RAII) idiom RAII in a nutshell RAII for other resources Releasing early Careful implementation of RAII objects Downsides of RAII Summary Questions Further Reading TBD - OOP Idiom Type Erasure SFINAE and Overload Resolution Management Classic Patterns for Object-Oriented Designs Local Buffer Optimization Technical requirements The overhead of small memory allocations  Installing the micro-benchmark library The cost of memory allocations Introducing the local buffer optimization The main idea Effect of the 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 the local buffer optimization Summary Questions Further reading Friend Factory Virtual Constructors and Factories 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 Template Method Pattern and Non-Virtual Idiom Curiously Recurring Template Pattern Mixin Scopeguard Serialization/Deserialization and Virtual Template Policy-Based Design Policy-Based Design, Inside-Out Typelist and Typemap Visitor and Multiple Dispatch