C++ Design Pattern: What is a Design Pattern?

Q: What is a Design Pattern?

A: Design Patterns represent solutions to problems what arise when developing software within a particular context.

Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.
C. Alexander, The Timeless Way of Building, 1979

Patterns help you learn from other's successes, instead of your own failures.
Mark Johnson (cited by Bruce Eckel)

Q: How many types of design patterns exist?

A: Basically, there are three categories:

• Creational Patterns: deal with initializing and configuring classes and objects
• Structural Patterns: deal with decoupling the interface and implementation of classes and objects
• Behavioral Patterns: deal with dynamic interactions among societies of classes and objects

Q: What are good books about design patterns.

A: Here are some must-have books:

• Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (also known as Gang of Four)
• Thinking in Patterns with Java, by Bruce Eckel
• Thinking in Patterns with C++, by Bruce Eckel

Q: How can I quickly find information about a design pattern?

A: Here are some links on the web:

General

• Design Patterns

Creational Patterns

• Abstract Factory: Creates an instance of several families of classes
  
  • resource 1
  • resource 2
• Builder: Separates object construction from its representation
  
  • resource 1
  • resource 2
• Factory Method: Creates an instance of several derived classes
  
  • resource 1
  • resource 2
  • resource 3
• Prototype: A fully initialized instance to be copied or cloned
  
  • resource 1
  • resource 2
• Singleton: A class of which only a single instance can exist
  
  • resource 1
  • resource 2

Structural Patterns

• Adapter: Match interfaces of different classes
  
  • resource 1
  • resource 2
  • resource 1
• Bridge: Separates an object’s interface from its implementation
  
  • resource 1
  • resource 2
• Composite: A tree structure of simple and composite objects
  
  • resource 1
  • resource 2
  • resource 3
• Decorator: Add responsibilities to objects dynamically
  
  • resource 1
  • resource 2
  • resource 3
• Façade: A single class that represents an entire subsystem
  
  • resource 1
  • resource 2
• Flyweight: A fine-grained instance used for efficient sharing
  
  • resource 1
  • resource 2
  • resource 3
• Proxy: An object representing another object
  
  • resource 1
  • resource 2

Behavioral Patterns

• 　　Chain of Responsibility: A way of passing a request between a chain of objects
  
  • resource 1
  • resource 2
• Command: Encapsulate a command request as an object
  
  • resource 1
  • resource 2
  • resource 3
• Interpreter: A way to include language elements in a program
  
  • resource 1
  • resource 2
• Iterator: Sequentially access the elements of a collection
  
  • resource 1
  • resource 2
• Mediator: Defines simplified communication between classes
  
  • resource 1
  • resource 2
• Memento: Capture and restore an object's internal state
  
  • resource 1
• Observer: A way of notifying change to a number of classes
  
  • resource 1
  • resource 2
  • resource 3
• State: Alter an object's behavior when its state changes
  
  • resource 1
  • resource 2
  • resource 3
• Strategy: Encapsulates an algorithm inside a class
  
  • resource 1
  • resource 2
  • resource 3
• Template Method: Defer the exact steps of an algorithm to a subclass
  
  • resource 1
  • resource 2
  • resource 3
• Visitor: Defines a new operation to a class without change
  
  • resource 1
  • resource 2
  • resource 3
    

and more resources on (www.oodesign.com). Make sure you read the design principles, it's very usefull for understanding the desing patterns:

OO Design Principles:
Open Close Principle
Dependency Inversion Principle
Interface Sergregation Principle
Single Responsibility Principle
Liskov's Substitution Principle


Creational Patterns:
Singleton
Factory
Factory Method
Abstract Factory
Builder
Prototype
Object Pool

Behavioral Patterns:
Chain of Responsibility
Command
Interpreter
Iterator
Strategy
Template Method
Visitor