Course info
Aug 12, 2016
2h 49m

The correct application and recognition of design patterns is an important skill for developers and architects. This course, Design Patterns in C++: Behavioral - Chain of Responsibility to Memento, introduces the viewer to Behavioral design patterns. It covers the Chain of Responsibility, Command, Interpreter, Iterator, Mediator, and Memento design patterns. You'll be shown different ways in which these patterns can be implemented in modern C++ (C++ 11 and beyond). By the end of this course, you'll be more familiar with Behavioral design patterns in C++. Software required: a C++ IDE (e.g., Visual Studio, CLion) or a text editor (e.g., VIM, EMACS) together with a C++ compiler (e.g., GCC, Clang).

About the author
About the author

Dmitri is a developer, speaker, podcaster, technical evangelist and wannabe quant.

More from the author
ReSharper Fundamentals
2h 54m
Apr 28, 2017
More courses by Dmitri Nesteruk
Section Introduction Transcripts
Section Introduction Transcripts

Course Overview
Hi there! My name is Dmitri Nesteruk, and I am happy to welcome you to my course on the behavioral patterns in the C++ programming language. Now a bit about myself. I am a quantitative analyst who enjoys programming in C++ and its applications in finance and high performance computing. So this course is all about the behavioral patterns. Now the original design patterns book was written using small token C++, so you can consider this course, as well as the other courses in this series, as a bit of an update taking the design patterns into the era of modern C++. So this course is the first half of the overview of structural design patterns and the way in which they're implemented in C++. Now this course covers the first six behavioral design patterns including chain of responsibility, command, interpreter, iterator, mediator, as well as memento. By the end of the course, you should know how to implement these behavioral patterns in C++ and how to leverage them in your development. Now before beginning this course, you should have a reasonably good knowledge of C++, but no specialized knowledge is required. So I hope you will join me on this journey to learn the design patterns with the C++ behavioral design patterns course here at Pluralsight.

Hello and welcome to this module on the command design pattern. Let's see what we've got in store. First of all, we'll talk about the motivation for using the command design pattern. And then we'll actually go ahead and implement it. Following that, we're going to see how you can leverage the command design pattern to implement undo and redo operations. And, finally, we'll take a look at the composite command.

Hi there. In this module, we're going to talk about the interpreter design pattern. So what are we going to see? As always, first of all, we'll talk about the motivation for using interpreter. And then we'll take a look at two rather large demos. The first demo will be one where we're going to have a handmade interpreter. Essentially we're going to parse textual input ourselves without the use of any frameworks. And the second half will involve us using Boost. Spirit, a framework specifically for building parsers, which is going to make our life a lot easier.

Hi there. In this module, we'll talk about the iterator design pattern. So what exactly are we going to discuss? Well, as always, we'll start with the motivation for using the iterators. And then we'll take a look at the use of iterators in the standard library. Then we'll talk about the requirements which are put upon an iterator. And then we'll actually implement some iterators by, first of all, building our own binary tree iterator and then using the Boost. iterator_façade to build an iterator for a singly linked list.

In this module, we're going to take a look at the mediator pattern. So after discussing what the mediator pattern is actually for, we're going to take a look at two examples. One example, a very popular example for demonstrating how the mediator works, is a chat room. And we're going to build one. And then we're going to take a look at an event broker, a component we've already seen when we talked about the chain of responsibility pattern, but we'll go through it again and see how to implement it and why it is, in fact, a mediator.

Hi there. This is the last module of the course, and in this module, we'll talk about the memento design pattern. So after we talk about the motivation for using the memento design pattern, we'll take a look at two examples. In the first example, we'll actually implement the memento design pattern. And in the second example, we'll implement undo and redo functionality using this pattern.