Either my name is Demitry and I'm very happy to walk you to this course on Design Patterns in modern
C++.
So what are design patterns.
Well quite simply the design patterns are common architectural approaches that people have observed
throughout the years and decided to catalog them and give them common names so that we can then talk
between one another and refer to the same patterns using the same words.
Now design patterns were popularized by the 1994 Design Patterns book written by four authors commonly
known as the Gang of Four.
And that book used Smalltalk and C++.
Nowadays Smalltalk isn't such a popular language and the kind of C++ that was used in the book is a
bit outdated we now have modern C++.
So the goal of this particular course you're watching right now is to actually take those design patterns
into the 21st century and use modern C++ to see where we can implement the patterns better faster and
make them look interesting as well.
So the design patterns have since 1994 been translated into lots of object oriented programming languages
so they suddenly exist in languages like C-Sharp and Java and plenty of languages which are not even
object oriented such as javascript for example.
Now Design Patterns are still universally relevant.
They haven't become outdated.
In fact they got so popular that they became internalized in some programming language.
So for example the observer pattern got internalized in the C-sharp language as the event key word.
Now this hasn't happened in C++.
Nobody internalized any patterns but we certainly can implement patterns ourselves.
We can also use libraries which provide implementations of certain patterns and I'm going to have lots
of that in this course in the sense of using different libraries for implementing various patterns and
finally even if you're not explicitly using patterns you might be already creating some of them in your
own code so if you're not aware of design patterns then after watching this course you might jump into
your code and you might say aha I've been using a design pattern there.
I didn't even realize it.
So in terms of the structure of this course it's fairly simple.
First of all we're going to talk about the solid design principles and these principles are relevant
because they are referenced quite a bit when talking about design patterns so I want to cover them before
we actually go through their creation or structure and behavior design patterns.
Now in terms of the patterns themselves I'm basically replicating what we have in the original gang
of four but because it's as relevant today as it was back in 1994.
Certainly the implementations have advanced since then but the actual categories Asians have not.
So we have the creational design patterns.
The only thing I've changed here is I put the abstract factory and factory method patterns under a single
core section called factories.
That's the only difference.
Then we're going to take a look at the structure design patterns again.
No change here from the book and the behavioral design patterns as well.
Again the similar scenario to what we have in the book.
So in terms of the way that the Course is organized it's 100 percent practical hands on which means
you're going to see me sit in front of the idea in this case I'm going to be using C line and I'm going
to be typing in the examples and explaining them now.
Most but not all of the demos in this course are single C++ files which means you can download them
you can open them in the ID of your choice and you can run them immediately.
Now the one interesting thing I have in the course is I have.
End of section coding exercises where you are asked to implement this particular pattern.
Now some of these exercises are particularly challenging because they reflect the difficulty inherent
in the original pattern.
Now what you're going to see me do as I do the demos you're going to see heavy use is off line editing
features particularly cogeneration which is going to be really all over the place.
I'm just going to be cutting a few corners where I can cut a few corners so for example I don't want
to waste your time as I try to get the access mortifies perfectly correct so sometimes I'd be liberally
using public members like public fields for example no other coding recommendation that's just me trying
to save you some time.
I'm also going to have a certain lack of virtual destructors where I should typically have them.
I'm going to be passing or returning by value in certain cases and I'm going to avoid implementing move
operations where they would make sense and so on and so forth so there's going to be a bit of simplification
in the course but it will never hurt the actual demonstration of the pattern so the pattern will always
be demonstrated that exactly as it's meant to be shown.
So in terms of the prerequisites for this course you have to have a really good understanding of object
oriented programming so if you are not solid on things like inheritance encapsulation polymorphism I
suggest you brush up with some of the basic C++ programming courses.
You need to have a good understanding of the C++ programming language as well.
I'm going to be using so many features of C++.
Then you need to be really comfortable with it.
You also need to be aware of the modern C++ features the latest stuff that's coming out in C++ because
I'm going to be using some things which are very cutting edge So for example I'm going to be using coroutines
and that's a very fresh and very interesting feature of the C++ programming language.
So finally I wanted to say a little bit about myself who I am so my name is Demitry and esoteric.
Here is a rather official looking picture of me and I work in an area called Quon finance a very C++
dominated area and it's a combination of math finance and computing including some really cool really
sophisticated applications of high performance computing.
And once again this is all C++ but I'm active as a conference speaker blogger.
I also lead a dot net use a group of all things I've been MVP for a number of years now and just in
case you forgot this is a course on Design Patterns in modern C++ So I've been doing work in other areas
as well but this is a C++ centric course.
So if you're interested then let's jump in and I will see you on the other side.