00. Design Pattern

Introduction of Design Pattern

TOC

• Design Pattern for Software
• 5 Principles of OOP (SOLID)
• Overview
  • C++ Idioms
  • Design Pattern
    • Create
    • Structure
    • Execute
    • Classification

Design Pattern for Software

• In software engineering, a design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. Wiki

The goal of Design Pattern is to make software easy to maintain. In this concept, Design Pattern is tightly related to Refactoring. If Design Pattern is where the target is, Refactoring is how to go. So, "Design Pattern" reflects the output structure of Refactoring.

5 Principles of OOP (SOLID)

• "S"ingle Responsibility Principle(SRP)
  • One module has only own Responsibility
• "O"pen Close Responsibility Principle(OCP)
  • A module is closed to modify, but opened to extend
• "L"iskov Substitution Principle(LSP)
  • A child class can be replaced by a parent class
  • Common members of children are come from a parent class
• "I"nterface Segregation Principle(ISP)
  • A specified interface is better than a common interface
• "D"ependency Inversion Principle(DIP)
  • A client is not dependent on a concrete class, but an interface or an abstract class.

Overview

C++ Idioms

1. CRTP: Curiously Recurring Template Pattern
2. Thin Template: Fast and low memory consuming container
3. RAII: Resource Acquisition Is Initialization
4. Function Object: Overloaded () operation to use as a function
5. Smart pointer: Class acting as a pointer
6. NVI: Non Virtual Interface
7. RTTI: Run Time Type Information

Design Pattern

Create

1. Singleton: Have only one instance, and there is only one way to access the instance
2. Abstract Factory: Have an interface for a factory to create instances which are in the same group.
3. Factory Method: Determine which group is to create
4. Prototype: Create a new instance which is the same as the previous instance.
5. Builder: Different instances with the same procedure

Structure

1. Adapter: Adopt middle layer to avoid interface conflict
2. Proxy: Wraps sub system with middle layer class
3. Bridge: Divide implementation and abstracts
4. Facade: Replace complicated system with simple classes
5. Composite: Make complex object with recursive compound
6. Decorator: Add dynamic functionalities with recursive compound
7. Flyweight: Share an instance among sibling instances which has the same arguments.

Execute

1. Iterator: Enumerate elements in container and complex objects
2. Visitor: Execute function to elements in container and complex objects
3. Observer: Broadcast an event
4. Mediator: Handle one request in all instances
5. Chain of Responsibility: Send an event in order
6. Template Method: Changes algorithms or policies
7. Strategy: Capsulate algorithm
8. State: Change behavior with state
9. Command: Capsulate command
10. Memento: Store and restore the state of the instance
11. Interpreter:

Classification

1. Event and Callback: Observer, Mediator
2. Common & uncommon
   1. Virtual function: Template method, Factory method
   2. Interface: Strategy, State, Builder
3. Middle layers: Adapter, Proxy, Bridge, Facade, Mediator
4. Containers or Complex objects: Iterator, Visitor
5. State and command: Command, Memento
6. Event propagation: Observer, Chain of responsibility