Structural Design Patterns in Modern C++

Structural Design Patterns in Modern C++

English | MP4 | AVC 1920×1080 | AAC 48KHz 2ch | 7h 53m | 4.38 GB


Uncover the secrets of structural design patterns and learn their implementation in modern C++

With design patterns, it is very easy to solve common object-oriented design problems. However, understanding and learning design patterns is tough and time-consuming. This course will help you to get acquainted with the design patterns and teach you some useful techniques to implement them in modern C++.

The course starts with an introduction to design patterns and explains the structure of a pattern with the help of a Unified Modeling Language (UML) class diagram. Then, you will understand how to implement a design pattern, how to examine the issues, and how to refactor the code by studying different types of design patterns such as adapter, façade, proxy, decorator, composite, bridge, and flyweight. In addition to this, you will also learn about the pros and cons of each pattern.

By the end of this course, you will be well-versed with various structural design patterns and will have developed the skills to implement them in modern C++.

Learn

  • Use the adapter pattern to convert an incompatible interface into a compatible one
  • Control access to the original object using the proxy pattern
  • Form larger structures through recursive composition using the composite pattern
  • Simplify complex interfaces of a system using the façade pattern
  • Enable sharing of large number of objects using the flyweight pattern
  • Use the decorator pattern to add more behaviors to an object at runtime
+ Table of Contents

Introduction
1 Course Overview
2 Introduction to Design Patterns
3 Overview of Unified Modeling Language (UML) Class Diagrams
4 Single-Responsibility, Open-d, Liskov Substitution, Interface Segregation, and Dependency Inversion (S.O.L.I.D.) Principles – Part I
5 Single-Responsibility, Open-d, Liskov Substitution, Interface Segregation, and Dependency Inversion (S.O.L.I.D.) Principles – Part II
6 Single-Responsibility, Open-d, Liskov Substitution, Interface Segregation, and Dependency Inversion (S.O.L.I.D.) Principles – Part III
7 Structural Design Patterns Overview

Adapter Design Pattern
8 Introduction to the Adapter Pattern
9 Basic Example
10 Game Input
11 Using the Adapter Pattern
12 Adapter Implementation
13 Class Adapter
14 Pros and Cons

Facade Design Pattern
15 Introduction to the Facade Pattern
16 Basic Example
17 Console Project – Part I
18 Console Project – Part II
19 Console Project – Part III
20 Console Project – Part IV
21 Console Facade for Linux
22 Pros and Cons

Proxy Design Pattern
23 Introduction to the Proxy Pattern
24 Basic Example
25 Introducing Virtual Proxy
26 Implementing Virtual Proxy
27 Applying Virtual Proxy
28 Introduction to Protection Proxy
29 Protection Proxy Example
30 Applying Protection Proxy
31 Remote Proxy Introduction
32 Example of the Remote Proxy
33 Using the Remote Proxy as a Component Object Model (COM) Component
34 Smart Proxy
35 Pros and Cons

Decorator Design Pattern
36 Introduction to the Decorator Pattern
37 Basic Example
38 Adding the Abstract Decorator Class
39 Implementing and Applying Streams
40 Adding Buffering to Streams
41 Adding the BufferedStream Class
42 Adding Encryption and Compression Support to Streams
43 Using Composition Instead of Inheritance
44 Adding the Abstract Decorator Class in Stream Class Hierarchies
45 Decorator Types
46 Static Decorator
47 Functional Decorator
48 Pros and Cons

Composite Design Pattern
49 Introduction to the Composite Pattern
50 Composite Intent and Implementation Overview
51 Basic Example
52 User Interface (UI) Example Overview
53 User Interface (UI) Example – Part I
54 User Interface (UI) Example – Part II
55 User Interface (UI) Example – Part III
56 Pros and Cons

Bridge Design Pattern
57 Introduction to the Bridge Pattern
58 Bridge Intent and Implementation Overview
59 Basic Example
60 Shapes Hierarchy and Implementing the Line Class
61 Adding the Shape Base Class
62 Adding Shapes
63 Adding Support for Rendering through OpenGL
64 Shapes Hierarchy Issues
65 Bridge Implementation
66 Handle-Body
67 Creating the String Class
68 Implementing Sharing for String Objects.
69 Pointer to IMPLementation (Plmpl) – Part I
70 Pointer to IMPLementation (Plmpl) – Part II
71 Static Bridge
72 Pros and Cons

Flyweight Design Pattern
73 Introduction to the Flyweight Pattern
74 Intent and Implementation Overview
75 Basic Implementation
76 Game Implementation – Part I
77 Game Implementation – Part II
78 Game Implementation – Part III
79 Creating String Class
80 Adding StringInfo for Sharing Internal Strings
81 Implementing String Interning
82 Boost.Flyweight
83 Pros and Cons