Gain insights into software design patterns and architecture in C++. Learn about C++ idioms, concurrency patterns, and apply the right solutions to improve code quality and productivity.

Design Pattern and Architectural Pattern with C__.png

cpp.tar.gz

Thread_sanitizer

Thread_sanitizer-copy

Thread_sanitizer-copy-copy

reactor

Software engineering researchers and practitioners noticed that parts of software projects could often be solved using approaches that were discovered earlier to solve similar problems. This led to the documentation of software design and architectural patterns, which are known solution approaches to a class of problems. 

This course starts by putting software patterns into perspective by answering the question, “What is a software pattern, and how is it different from an algorithm?” You will then learn about the two classes of patterns—software design and architecture patterns. Next, you’ll learn common C++ idioms. Finally, you will learn about software patterns for concurrency. 

By the end of the course, you will have useful and practical tools to improve the quality of your code and productivity. You’ll also be able to analyze a given part of your software project, pick the right pattern for the job, and apply it.

Master Software Design Patterns and Architecture in C++

# Overview
We often have object structures in our programs. For example, we might have objects in an interface that's implemented by various concrete classes. Sometimes, we want to add functionality to this object structure. We might be tempted to add a method for each additional functionality to the interface. However, this could violate the single responsibility and the open-closed design principles. It isn't a good idea to modify the interface every time we need to add a functionality to the concrete objects.

Let's assume that we have a store with different types of products, such as laptops and smartphones. Also, we have different types of customers (such as new customers, gold-level customers, and platinum-level customers). The operation that the code needs to perform is the calculation of the bill for each customer-product pair.

The visitor pattern can solve this problem by creating a separate class, called the Visitor, that contains the algorithm for calculating the bill. This class is then passed to the elements of the object (products and customers).

For example, let's say we have a class called `Product`, with subclasses `Laptop` and `Smartphone`, and classes `NewCustomer`, `GoldCustomer`, and `PlatinumCustomer`, which represent different types of customers. We would create a class called `BillCalculatorVisitor`, which will implement the algorithm to calculate the bill. Then, we would add a method called Accept to each product and customer class, which calls the appropriate method in the `BillCalculatorVisitor` class, passing itself as an argument.

The advantage of this pattern is that if we want to add new types of products or customers, we can do so without changing the `BillCalculatorVisitor` class and hence following the open-closed principle. Moreover, if we want to change the algorithm for calculating the bill, we can do so without changing the product and customer classes. This makes the code more extendable, flexible, and maintainable.


# Definition

The visitor design pattern defines new operations without changing the object structure.

# Explanation
In the visitor design pattern, we add a single method named `accept(visitor)` to the interface defining the object structure. Each concrete class implementing this interface will need to implement this method. Additionally, we define a `Visitor` interface and implement it through concrete classes, one for each additional functionality we want to implement. In our example, these concrete classes will perform the `visit` operation on the objects. Likewise, other concrete visitor classes can be defined for other operations. Look at the UML diagram of the visitor design pattern under the "Structure" heading below.

We'll explain the pattern in greater detail through coding examples in the next lesson.


# Type

The visitor design pattern belongs to the behavioral design patterns.

# Purpose
The visitor design pattern:
- Encapsulates an operation executed on an object structure as an object.
- Allows us to define new operations without changing the object structure.



# Applicability

The visitor design pattern is applicable where the operation of the object changes more frequently. With the visitor pattern, we can add operations without changing the structure of the object.


# Structure

Get an overview of the visitor design pattern.

Introduction

Introduction to Design Patterns

Deep Dive into Design Patterns

More Design Patterns

Idioms

Architectural Patterns

Patterns for Concurrency

Conclusion

Visitor Design Pattern

Overview