The goal of this course is to introduce the well-known system and design patterns (POSA, GOF) and then implement them using C++. We discuss the most important patterns that help you create flexible applications and we use the object-oriented (OOP) and generic programming (GP) to implement robust designs, quickly and efficiently.

The GOF patterns were published in 1995 and they used OOP techniques as the basis for constructing the patterns. These techniques are still valid but in some cases it is more advantageous to create these using GP techniques. Furthermore, C++ libraries like STL and Boost that directly implement a number of design patterns, thus increasing developer productivity even more.

This unique course has been specially developed by Datasim for designers and developers who create practical applications. Based on years of real application software and training experience, this course discusses all the essential features in C++ in combination with proven design patterns to allow developers to create robust and flexible applications.

What do you learn?

• Learn the GOF (Gamma) patterns in C++
• Critical POSA (Buschmann) patterns to structure your applications
• Meta Design Patterns and Reflection
• Integrating OOP and GP in pattern design
• Implementing GOF patterns using generics (developed by Datasim)

Part I: Structural Patterns and Infrastructure

Structuring a C++ Application

• Whole Part Pattern
• Model View Controller (MVC)
• Presentation Abstraction Control (PAC)

Interfacing in C++

• Interfaces and abstract classes
• Provides and requires interfaces
• Contracts and service-oriented programming
• Contracts in C++ 

Defining Structure

• Inheritance
• Aggregation and Composition
• Delegation: stateful and stateless variants

Short Overview of UML 2.0 Diagrams

• Class diagrams
• Component diagrams
• Assembly and connector components
• Sequence diagrams and statecharts

Part II: GOF Patterns in C++

Overview

• Background to design patterns
• GOF pattern classification
• 20-80% rule: essential and non-essential patterns
• Advantages of using design patterns

Creational Design patterns

• Applicability of creational patterns to C++
• The Builder pattern
• Factory Method and Abstract Factory patterns
• Prototype pattern

Structural Design Patterns

• Composite pattern and nested objects
• Proxy pattern
• Decorator pattern
• Class and object Adapter
• Bridge pattern

Behavioural Patterns I

• Command pattern
• Strategy pattern
• Using boost function for creating algorithms
• Using interfaces and inheritance for Template Method pattern
• Visitor pattern and service extension
• Iterator pattern and its implementation in STL

Behavioural Patterns II

• Observer (Publisher-Subscriber) pattern
• Mediator pattern and change control
• Using boost signals as an alternative to Observer

Other Behavioural Patterns

• State pattern
• Role pattern
• Propagator pattern

Part III: Patterns using C++ Templates

Policy-based Design in C++

• Implementing contracts with interfaces
• Combining behaviour and structure: interfaces and inheritance
• Moving GOF patterns to their generic forms

Generic Patterns

• Strategy pattern
• Bridge pattern
• Command pattern

Part IV: Patterns and C++ Extensions

Regular Expressions using Boost

• What is a regular expression?
• Matching
• Compiled regular expressions
• Regex options

Lambda Expressions in C++11

• Using lambda expressions
• Expression trees
• Generic lambda expressions

Serialisation using Boost

• Serialisation engines
• Explicit and implicit serialization
• Binary and XML serialization
• Integration with Builder and Visitor patterns

Multi-threaded patterns

• Master-Slave pattern
• Producer-Consumer pattern
• Thread pooling

Examples

• Command processor using boost function and signal

Developers and programmers who wish to apply the Gamma patterns to the creation of flexible, reusable and maintainable software systems in C++.

In short, this is the course that applies modern design patterns in combination with object-oriented and generic programming models to speed up development of real-life applications.