Creational Design Patterns in Modern C++

Creational Design Patterns in Modern C++

English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 7.5 Hours | 3.19 GB


Learn creational design patterns in depth & their implementation in Modern C++

Design Patterns are a way to solve common object oriented design problems. But understanding and learning design patterns is hard and takes time. Looking at a pattern is like looking at a solution without a problem, unless you’ve encountered the problem in the past.

This course aims to help you understand & implement Creational Design Patterns. Each pattern is explained with multiple examples and through modern C++. This helps you understand how the pattern can be implemented efficiently using language features. The examples do not involve cars, pizzas, ducks, coffee, etc. These topics are rarely used while building real-world software. Instead I provide real-world examples written in Modern C++. These examples will compile & execute on any platform that supports a C++ compiler.

This is how the course teaches creational patterns.

The intent, structure of the pattern is explained through UML class diagram.

Basic implementation details of the pattern are explained.

The pattern is implemented in a simple example.

You get familiar with the overall implementation of the pattern.

Another example is introduced that has design issues the pattern aims to resolve.

We examine the issues and refactor the code by applying the design pattern step by step.

Alternative scenarios & examples are explained along with differences between them. You also learn how to decide between different alternatives.

I discuss the pattern in context of C++ and how to tweak it for performance, reusability & maximum flexibility.

Finally, you’ll learn when to use the pattern and its pros & cons.

This is an intensive discussion that spans multiple lectures. At the end of each section, you’ll understand the pattern in depth and can apply it in your code or easily clear any design interview.

What you’ll learn

  • Understand what creational design patterns are
  • How creational design patterns solve object construction problems
  • Implement singleton correctly in C++ with thread-safety
  • Use factory method to encapsulate the construction process
  • Use object pool pattern to avoid repetitive construction & destruction of objects
  • Control construction process of an object through builder
  • Clone expensive objects through prototype
  • Use abstract factory to construct objects based on a context
+ Table of Contents

Introduction
1 Course Introduction
2 Introduction to Patterns
3 Overview of UML Class Diagram
4 S.O.L.I.D. Principles – I
5 S.O.L.I.D. Principles – II
6 S.O.L.I.D. Principles – III
7 Creational Patterns Overview
8 Course Material (Slide Deck)

Singleton
9 Code
10 Introduction
11 Basic Example
12 Logger Class – I
13 Logger Class – II
14 Lazy Instantiation
15 Destruction Policies
16 Multithreading Issues
17 Why DCLP Fails
18 Meyer’s Singleton
19 Using stdcall once
20 CRTP Idiom
21 Clock Class
22 Monostate Pattern
23 Singleton Vs Monostate
24 Singleton Issues
25 Registry Of Singletons – I
26 Registry Of Singletons – II
27 Pros & Cons

Factory Method
28 Code
29 Introduction
30 Basic Implementation – I
31 Basic Implementation – II
32 Application Framework Discussion
33 Application Framework Implementation
34 Application Framework with Factory Method
35 Parameterised Factory Method
36 stdunique ptr
37 stdshared ptr
38 Pros & Cons

Object Pool
39 Source Code
40 Introduction
41 Basic Example
42 Pooling Game Objects – I
43 Pooling Game Objects – II
44 Multiple Actors – I
45 Multiple Actors – II
46 Multiple Actors – III
47 Generic Pool – I
48 Generic Pool – II
49 Pros & Cons

Abstract Factory
50 Code
51 Introduction
52 Basic Example
53 Basic Implementation with Abstract Factory
54 Database Framework Introduction
55 Database Framework Implementation
56 SqlServer Database Classes
57 MySql Database Classes
58 Database Framework Usage
59 Using Factory Method
60 Using Abstract Factory
61 Pros & Cons

Prototype
62 Code
63 Introduction
64 Cloning Types
65 Basic Example
66 Game Introduction
67 Game implementation – I
68 Game implementation – II
69 Game implementation – III
70 Cloning Example
71 Prototype Implementation – I
72 Prototype Implementation – II
73 Prototype Implementation – III
74 Class Vs Object
75 Varying State
76 Prototype Manager – I
77 Prototype Manager – II
78 Memory Management
79 Pros & Cons

Builder
80 Code
81 Introduction
82 Basic Implementation
83 File Example Introduction
84 Issues
85 Builder Implementation
86 Construction Using Builder
87 Modern Implementation
88 Fluent Builder
89 Pros & Cons