Design Patterns in Modern C

Design Patterns in Modern C

What you’ll learn

Recognize and apply design patterns
Refactor existing designs to use design patterns
Reason about applicability and usability of design patterns
Learn how to use different aspects of Modern C++

Requirements

Good understanding of C++
Awareness of features of Modern C++ (11/14/17/…)
Understanding of OOP (encapsulation, polymorphism, inheritance)

Description

Course Overview
This course provides a comprehensive overview of Design Patterns in Modern C++ from a practical perspective. This course in particular covers patterns with the use of:
The latest versions of the C++ programming languageUse of modern programming approaches: dependency injection, use of coroutines, and more!Use of modern developer tools such as CLion and ReSharper C++Discussions of pattern variations and alternative approaches
This course provides an overview of all the Gang of Four (GoF) design patterns as outlined in their seminal book, together with modern-day variations, adjustments, discussions of intrinsic use of patterns in the language.
What are Design Patterns?
Design Patterns are reusable solutions to common programming problems. They were popularized with the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, John Vlissides, Ralph Johnson and Richard Helm (who are commonly known as a Gang of Four, hence the GoF acronym).
The original book was written using C++ and Smalltalk as examples, but since then, design patterns have been adapted to every programming language imaginable: Swift, C#, Java, PHP and even programming languages that aren’t strictly object-oriented, such as JavaScript.
The appeal of design patterns is immortal: we see them in libraries, some of them are intrinsic in programming languages, and you probably use them on a daily basis even if you don’t realize they are there.
What Patterns Does This Course Cover?
This course covers all the GoF design patterns. In fact, here’s the full list of what is covered:
SOLID Design Principles: Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle and Dependency Inversion PrincipleCreational Design Patterns: Builder, Factories (Factory Method and Abstract Factory), Prototype and SingletonStructrural Design Patterns: Adapter, Bridge, Composite, Decorator, Façade, Flyweight and ProxyBehavioral Design Patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Null Object, Observer, State, Strategy, Template Method and Visitor
Who Is the Course For?
This course is for C++ developers who want to see not just textbook examples of design patterns, but also the different variations and tricks that can be applied to implement design patterns in a modern way.
Presentation Style
This course is presented as a (very large) series of live demonstrations being done in JetBrains CLion. Most demos are single-file, so you can download the file attached to the lesson and run it in CLion, XCode or another IDE of your choice (or just on the command line).
This course does not use UML class diagrams; all of demos are live coding.

Overview

Section 1: Introduction

Lecture 1 Introduction

Section 2: SOLID Design Principles

Lecture 2 Overview

Lecture 3 Single Responsibility Principle

Lecture 4 Open-Closed Principle

Lecture 5 Liskov Substitution Principle

Lecture 6 Interface Segregation Principle

Lecture 7 Dependency Inversion Principle

Lecture 8 Summary

Section 3: Builder

Lecture 9 Gamma Categorization

Lecture 10 Overview

Lecture 11 Life Without Builders

Lecture 12 Builder

Lecture 13 Fluent Builder

Lecture 14 Groovy-Style Builder

Lecture 15 Builder Facets

Lecture 16 Summary

Section 4: Factories

Lecture 17 Overview

Lecture 18 Point Example

Lecture 19 Factory Method

Lecture 20 Factory

Lecture 21 Inner Factory

Lecture 22 Abstract Factory

Lecture 23 Functional Factory

Lecture 24 Summary

Section 5: Prototype

Lecture 25 Overview

Lecture 26 Record Keeping

Lecture 27 Prototype

Lecture 28 Prototype Factory

Lecture 29 Prototype via Serialization

Lecture 30 Summary

Section 6: Singleton

Lecture 31 Overview

Lecture 32 Singleton Implementation

Lecture 33 Testability Issues

Lecture 34 Singleton in Dependency Injection

Lecture 35 Singleton Lifetime in DI Container

Lecture 36 Monostate

Lecture 37 Multiton

Lecture 38 Summary

Section 7: Adapter

Lecture 39 Overview

Lecture 40 Vector/Raster Demo

Lecture 41 Adapter Caching

Lecture 42 Summary

Section 8: Bridge

Lecture 43 Overview

Lecture 44 Pimpl Idiom

Lecture 45 Shrink-Wrapped Pimpl

Lecture 46 Bridge Implementation

Lecture 47 Summary

Section 9: Composite

Lecture 48 Overview

Lecture 49 Geometric Shapes

Lecture 50 Neural Networks

Lecture 51 Array-Backed Properties

Lecture 52 Summary

Section 10: Decorator

Lecture 53 Overview

Lecture 54 Dynamic Decorator

Lecture 55 Static Decorator

Lecture 56 Functional Decorator

Lecture 57 Summary

Section 11: Façade

Lecture 58 Overview

Lecture 59 Façade

Lecture 60 Summary

Section 12: Flyweight

Lecture 61 Overview

Lecture 62 Handmade Flyweight

Lecture 63 Boost.Flyweight

Lecture 64 Text Formatting

Lecture 65 Summary

Section 13: Proxy

Lecture 66 Overview

Lecture 67 Smart Pointers

Lecture 68 Property Proxy

Lecture 69 Virtual Proxy

Lecture 70 Communication Proxy

Lecture 71 Proxy vs Decorator

Lecture 72 Summary

Section 14: Chain of Responsibility

Lecture 73 Overview

Lecture 74 Pointer Chain

Lecture 75 Broker Chain

Lecture 76 Summary

Section 15: Command

Lecture 77 Overview

Lecture 78 Command

Lecture 79 Undo Operations

Lecture 80 Composite Command (Macro)

Lecture 81 Summary

Section 16: Interpreter

Lecture 82 Overview

Lecture 83 Handmade Interpreter: Lexing

Lecture 84 Handmade Interpreter: Parsing

Lecture 85 Building Parsers with Boost.Spirit

Lecture 86 Summary

Section 17: Iterator

Lecture 87 Overview

Lecture 88 Iterators in the Standard Library

Lecture 89 Binary Tree Iterator

Lecture 90 Tree Iterator with Coroutines

Lecture 91 Boost Iterator Façade

Lecture 92 Summary

Section 18: Mediator

Lecture 93 Overview

Lecture 94 Chat Room

Lecture 95 Event Broker

Lecture 96 Summary

Section 19: Memento

Lecture 97 Overview

Lecture 98 Memento

Lecture 99 Undo and Redo

Lecture 100 Automatic Memento

Lecture 101 Summary

Section 20: Observer

Lecture 102 Overview

Lecture 103 Observer

Lecture 104 Observable

Lecture 105 Observable with Boost.Signals

Lecture 106 The Problem of Dependencies

Lecture 107 Thread Safety and Reentrancy

Lecture 108 Summary

Section 21: State

Lecture 109 Overview

Lecture 110 Classic State Implementation

Lecture 111 Handmade State Machine

Lecture 112 State Machine with Boost.MSM

Lecture 113 Summary

Section 22: Strategy

Lecture 114 Overview

Lecture 115 Dynamic Strategy

Lecture 116 Static Strategy

Lecture 117 Summary

Section 23: Template Method

Lecture 118 Overview

Lecture 119 Template Method

Lecture 120 Summary

Section 24: Visitor

Lecture 121 Overview

Lecture 122 Intrusive Visitor

Lecture 123 Reflective Visitor

Lecture 124 Classic Visitor (Double Dispatch)

Lecture 125 Acyclic Visitor

Lecture 126 Multimethods

Lecture 127 Variant and std::visit

Lecture 128 Summary

Section 25: Course Summary

Lecture 129 End of Course

Beginner and experienced C++ software developers,Developers interested in implementations of design patterns,Computer scientists

Course Information:

Udemy | English | 12h 28m | 4.54 GB
Created by: Dmitri Nesteruk

You Can See More Courses in the Developer >> Greetings from CourseDown.com