Mirrors/cpp-design-patterns-for-humans
1
0
Fork 0
mirror of https://github.com/iandinwoodie/cpp-design-patterns-for-humans.git synced 2025-12-18 04:54:39 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity

Standardized markdown formatting with prettier.

Browse Source 
Used default prettier settings.
This commit is contained in:
Ian Dinwoodie
2022-04-07 14:40:54 -04:00
parent ef1f87b1aa
commit 5d8eb8deec
1 changed files with 240 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

477
README.md
View File

@@ -28,52 +28,52 @@ you can plug into your application and wait for the magic to happen. These are,
rather, guidelines on how to tackle certain problems in certain situations. rather, guidelines on how to tackle certain problems in certain situations.
> Design patterns are solutions to recurring problems; guidelines for how to > Design patterns are solutions to recurring problems; guidelines for how to
tackle certain problems. > tackle certain problems.
Wikipedia describes design patterns as: Wikipedia describes design patterns as:
> [...] a general reusable solution to a commonly occurring problem within a > [...] a general reusable solution to a commonly occurring problem within a
given context in software design. It is not a finished design that can be > given context in software design. It is not a finished design that can be
transformed directly into source or machine code. It is a description or > transformed directly into source or machine code. It is a description or
template for how to solve a problem that can be used in many different > template for how to solve a problem that can be used in many different
situations. > situations.
### ⚠️ Be Careful ### ⚠️ Be Careful
- Design patterns are not a silver bullet to all your problems. - Design patterns are not a silver bullet to all your problems.
- Do not try to force them; bad things are supposed to happen, if done so. - Do not try to force them; bad things are supposed to happen, if done so.
- Keep in mind that design patterns are solutions **to** problems, not solutions - Keep in mind that design patterns are solutions **to** problems, not solutions
**finding** problems; so don't overthink. **finding** problems; so don't overthink.
- If used in a correct place in a correct manner, they can prove to be a savior; - If used in a correct place in a correct manner, they can prove to be a savior;
or else they can result in a horrible mess of a code. or else they can result in a horrible mess of a code.
## Types of Design Patterns ## Types of Design Patterns
* [Creational](#creational-design-patterns) - [Creational](#creational-design-patterns)
* [Structural](#structural-design-patterns) - [Structural](#structural-design-patterns)
* [Behavioral](#behavioral-design-patterns) - [Behavioral](#behavioral-design-patterns)
## Creational Design Patterns ## Creational Design Patterns
In plain words: In plain words:
> Creational patterns are focused towards how to instantiate an object or group > Creational patterns are focused towards how to instantiate an object or group
of related objects. > of related objects.
Wikipedia says: Wikipedia says:
> In software engineering, creational design patterns are design patterns that > In software engineering, creational design patterns are design patterns that
deal with object creation mechanisms, trying to create objects in a manner > deal with object creation mechanisms, trying to create objects in a manner
suitable to the situation. The basic form of object creation could result in > suitable to the situation. The basic form of object creation could result in
design problems or added complexity to the design. Creational design patterns > design problems or added complexity to the design. Creational design patterns
solve this problem by somehow controlling this object creation. > solve this problem by somehow controlling this object creation.
* [Simple Factory](#-simple-factory) - [Simple Factory](#-simple-factory)
* [Factory Method](#-factory-method) - [Factory Method](#-factory-method)
* [Abstract Factory](#-abstract-factory) - [Abstract Factory](#-abstract-factory)
* [Builder](#-builder) - [Builder](#-builder)
* [Prototype](#-prototype) - [Prototype](#-prototype)
* [Singleton](#-singleton) - [Singleton](#-singleton)
### 🏠 Simple Factory ### 🏠 Simple Factory
@@ -82,23 +82,23 @@ solve this problem by somehow controlling this object creation.
Real world example: Real world example:
> Consider, you are building a house and you need doors. You can either put on > Consider, you are building a house and you need doors. You can either put on
your carpenter clothes, bring some wood, glue, nails and all the tools required > your carpenter clothes, bring some wood, glue, nails and all the tools required
to build the door and start building it in your house or you can simply call the > to build the door and start building it in your house or you can simply call the
factory and get the built door delivered to you so that you don't need to learn > factory and get the built door delivered to you so that you don't need to learn
anything about the door making or to deal with the mess that comes with making > anything about the door making or to deal with the mess that comes with making
it. > it.
In plain words: In plain words:
> Simple factory simply generates an instance for client without exposing any > Simple factory simply generates an instance for client without exposing any
instantiation logic to the client. > instantiation logic to the client.
Wikipedia says: Wikipedia says:
> In object-oriented programming (OOP), a factory is an object for creating > In object-oriented programming (OOP), a factory is an object for creating
other objects – formally a factory is a function or method that returns objects > other objects – formally a factory is a function or method that returns objects
of a varying prototype or class from some method call, which is assumed to be > of a varying prototype or class from some method call, which is assumed to be
"new". > "new".
#### Programmatic Example #### Programmatic Example
@@ -171,7 +171,7 @@ std::cout << "height = " << door2->getHeight() << std::endl;
#### When To Use #### When To Use
When creating an object is not just a few assignments and involves some logic, When creating an object is not just a few assignments and involves some logic,
it makes sense to put it in a dedicated factory instead of repeating the same it makes sense to put it in a dedicated factory instead of repeating the same
code everywhere. code everywhere.
@@ -181,9 +181,9 @@ code everywhere.
Real world example: Real world example:
> Consider the case of a hiring manager. It is impossible for one person to > Consider the case of a hiring manager. It is impossible for one person to
interview for each of the positions. Based on the job opening, she has to decide > interview for each of the positions. Based on the job opening, she has to decide
and delegate the interview steps to different people. > and delegate the interview steps to different people.
In plain words: In plain words:
@@ -192,11 +192,11 @@ In plain words:
Wikipedia says: Wikipedia says:
> In class-based programming, the factory method pattern is a creational pattern > In class-based programming, the factory method pattern is a creational pattern
that uses factory methods to deal with the problem of creating objects without > that uses factory methods to deal with the problem of creating objects without
having to specify the exact class of the object that will be created. This is > having to specify the exact class of the object that will be created. This is
done by creating objects by calling a factory method—either specified in an > done by creating objects by calling a factory method—either specified in an
interface and implemented by child classes, or implemented in a base class and > interface and implemented by child classes, or implemented in a base class and
optionally overridden by derived classes—rather than by calling a constructor. > optionally overridden by derived classes—rather than by calling a constructor.
#### Programmatic Example #### Programmatic Example
@@ -291,22 +291,22 @@ the client doesn't know what exact sub-class it might need.
Real world example: Real world example:
> Extending our door example from Simple Factory. Based on your needs you might > Extending our door example from Simple Factory. Based on your needs you might
get a wooden door from a wooden door shop, iron door from an iron shop or a PVC > get a wooden door from a wooden door shop, iron door from an iron shop or a PVC
door from the relevant shop. Plus you might need a guy with different kind of > door from the relevant shop. Plus you might need a guy with different kind of
specialities to fit the door, for example a carpenter for wooden door, welder > specialities to fit the door, for example a carpenter for wooden door, welder
for iron door etc. As you can see there is a dependency between the doors now, > for iron door etc. As you can see there is a dependency between the doors now,
wooden door needs carpenter, iron door needs a welder etc. > wooden door needs carpenter, iron door needs a welder etc.
In plain words: In plain words:
> A factory of factories; a factory that groups the individual but > A factory of factories; a factory that groups the individual but
related/dependent factories together without specifying their concrete classes. > related/dependent factories together without specifying their concrete classes.
Wikipedia says: Wikipedia says:
> The abstract factory pattern provides a way to encapsulate a group of > The abstract factory pattern provides a way to encapsulate a group of
individual factories that have a common theme without specifying their concrete > individual factories that have a common theme without specifying their concrete
classes. > classes.
#### Programmatic Example #### Programmatic Example
@@ -445,23 +445,23 @@ involved.
Real world example: Real world example:
> Imagine you are at Hardee's and you order a specific deal, lets say, > Imagine you are at Hardee's and you order a specific deal, lets say,
"Big Hardee" and they hand it over to you without *any questions*; this is the > "Big Hardee" and they hand it over to you without _any questions_; this is the
example of simple factory. But there are cases when the creation logic might > example of simple factory. But there are cases when the creation logic might
involve more steps. For example you want a customized Subway deal, you have > involve more steps. For example you want a customized Subway deal, you have
several options in how your burger is made e.g what bread do you want? what > several options in how your burger is made e.g what bread do you want? what
types of sauces would you like? What cheese would you want? etc. In such cases > types of sauces would you like? What cheese would you want? etc. In such cases
builder pattern comes to the rescue. > builder pattern comes to the rescue.
In plain words: In plain words:
> Allows you to create different flavors of an object while avoiding constructor > Allows you to create different flavors of an object while avoiding constructor
pollution. Useful when there could be several flavors of an object. Or when > pollution. Useful when there could be several flavors of an object. Or when
there are a lot of steps involved in creation of an object. > there are a lot of steps involved in creation of an object.
Wikipedia says: Wikipedia says:
> The builder pattern is an object creation software design pattern with the > The builder pattern is an object creation software design pattern with the
intentions of finding a solution to the telescoping constructor anti-pattern. > intentions of finding a solution to the telescoping constructor anti-pattern.
Having said that let me add a bit about what telescoping constructor Having said that let me add a bit about what telescoping constructor
anti-pattern is. At one point or the other we have all seen a constructor like anti-pattern is. At one point or the other we have all seen a constructor like
@@ -611,7 +611,7 @@ pattern is to be used when the creation is a multi step process.
Real world example: Real world example:
> Remember dolly? The sheep that was cloned! Lets not get into the details but > Remember dolly? The sheep that was cloned! Lets not get into the details but
the key point here is that it is all about cloning. > the key point here is that it is all about cloning.
In plain words: In plain words:
@@ -620,8 +620,8 @@ In plain words:
Wikipedia says: Wikipedia says:
> The prototype pattern is a creational design pattern in software development. > The prototype pattern is a creational design pattern in software development.
It is used when the type of objects to create is determined by a prototypical > It is used when the type of objects to create is determined by a prototypical
instance, which is cloned to produce new objects. > instance, which is cloned to produce new objects.
In short, it allows you to create a copy of an existing object and modify it to In short, it allows you to create a copy of an existing object and modify it to
your needs, instead of going through the trouble of creating an object from your needs, instead of going through the trouble of creating an object from
@@ -665,6 +665,7 @@ class Sheep
std::string category_; std::string category_;
}; };
``` ```
Here is how we can clone this object Here is how we can clone this object
```cpp ```cpp
@@ -690,7 +691,7 @@ creation would be expensive as compared to cloning.
Real world example: Real world example:
> There can only be one president of a country at a time. The same president has > There can only be one president of a country at a time. The same president has
to be brought to action, whenever duty calls. President here is singleton. > to be brought to action, whenever duty calls. President here is singleton.
In plain words: In plain words:
@@ -699,8 +700,8 @@ In plain words:
Wikipedia says: Wikipedia says:
> In software engineering, the singleton pattern is a software design pattern > In software engineering, the singleton pattern is a software design pattern
that restricts the instantiation of a class to one object. This is useful when > that restricts the instantiation of a class to one object. This is useful when
exactly one object is needed to coordinate actions across the system. > exactly one object is needed to coordinate actions across the system.
Singleton pattern is actually considered an anti-pattern and overuse of it Singleton pattern is actually considered an anti-pattern and overuse of it
should be avoided. It is not necessarily bad and could have some valid use-cases should be avoided. It is not necessarily bad and could have some valid use-cases
@@ -754,22 +755,22 @@ TODO
In plain words: In plain words:
> Structural patterns are mostly concerned with object composition or in other > Structural patterns are mostly concerned with object composition or in other
words how the entities can use each other. Or yet another explanation would be, > words how the entities can use each other. Or yet another explanation would be,
they help in answering "How to build a software component?" > they help in answering "How to build a software component?"
Wikipedia says: Wikipedia says:
> In software engineering, structural design patterns are design patterns that > In software engineering, structural design patterns are design patterns that
ease the design by identifying a simple way to realize relationships between > ease the design by identifying a simple way to realize relationships between
entities. > entities.
* [Adapter](#-adapter) - [Adapter](#-adapter)
* [Bridge](#-bridge) - [Bridge](#-bridge)
* [Composite](#-composite) - [Composite](#-composite)
* [Decorator](#-decorator) - [Decorator](#-decorator)
* [Facade](#-facade) - [Facade](#-facade)
* [Flyweight](#-flyweight) - [Flyweight](#-flyweight)
* [Proxy](#-proxy) - [Proxy](#-proxy)
### 🔌 Adapter ### 🔌 Adapter
@@ -778,32 +779,32 @@ entities.
Real world example: Real world example:
> Consider that you have some pictures in your memory card and you need to > Consider that you have some pictures in your memory card and you need to
transfer them to your computer. In order to transfer them you need some kind of > transfer them to your computer. In order to transfer them you need some kind of
adapter that is compatible with your computer ports so that you can attach > adapter that is compatible with your computer ports so that you can attach
memory card to your computer. In this case card reader is an adapter. > memory card to your computer. In this case card reader is an adapter.
Another real world example: Another real world example:
> Another example would be the famous power adapter; a three legged plug can't > Another example would be the famous power adapter; a three legged plug can't
be connected to a two pronged outlet, it needs to use a power adapter that makes > be connected to a two pronged outlet, it needs to use a power adapter that makes
it compatible with the two pronged outlet. > it compatible with the two pronged outlet.
And another: And another:
> Yet another example would be a translator translating words spoken by one > Yet another example would be a translator translating words spoken by one
person to another. > person to another.
In plain words: In plain words:
> Adapter pattern lets you wrap an otherwise incompatible object in an adapter > Adapter pattern lets you wrap an otherwise incompatible object in an adapter
to make it compatible with another class. > to make it compatible with another class.
Wikipedia says: Wikipedia says:
> In software engineering, the adapter pattern is a software design pattern that > In software engineering, the adapter pattern is a software design pattern that
allows the interface of an existing class to be used as another interface. It is > allows the interface of an existing class to be used as another interface. It is
often used to make existing classes work with others without modifying their > often used to make existing classes work with others without modifying their
source code. > source code.
#### Programmatic Example #### Programmatic Example
@@ -848,6 +849,7 @@ class Hunter
} }
}; };
``` ```
Now let's say we have to add a wild dog in our game so that hunter can hunt Now let's say we have to add a wild dog in our game so that hunter can hunt
that also (Note: I do not condone the hunting of any dogs). But we can't do that that also (Note: I do not condone the hunting of any dogs). But we can't do that
directly because dog has a different interface. To make it compatible for our directly because dog has a different interface. To make it compatible for our
@@ -902,24 +904,24 @@ TODO
Real world example: Real world example:
> Consider you have a website with different pages and you are supposed to allow > Consider you have a website with different pages and you are supposed to allow
the user to change the theme. What would you do? Create multiple copies of each > the user to change the theme. What would you do? Create multiple copies of each
of the pages for each of the themes or would you just create separate theme and > of the pages for each of the themes or would you just create separate theme and
load them based on the user's preferences? Bridge pattern allows you to do the > load them based on the user's preferences? Bridge pattern allows you to do the
second i.e. > second i.e.
![With and without the bridge pattern](https://cloud.githubusercontent.com/assets/11269635/23065293/33b7aea0-f515-11e6-983f-98823c9845ee.png) ![With and without the bridge pattern](https://cloud.githubusercontent.com/assets/11269635/23065293/33b7aea0-f515-11e6-983f-98823c9845ee.png)
In plain words: In plain words:
> Bridge pattern is about preferring composition over inheritance. > Bridge pattern is about preferring composition over inheritance.
Implementation details are pushed from a hierarchy to another object with a > Implementation details are pushed from a hierarchy to another object with a
separate hierarchy. > separate hierarchy.
Wikipedia says: Wikipedia says:
> The bridge pattern is a design pattern used in software engineering that is > The bridge pattern is a design pattern used in software engineering that is
meant to "decouple an abstraction from its implementation so that the two can > meant to "decouple an abstraction from its implementation so that the two can
vary independently." > vary independently."
#### Programmatic Example #### Programmatic Example
@@ -1046,22 +1048,22 @@ TODO
Real world example: Real world example:
> Every organization is composed of employees. Each of the employees has the > Every organization is composed of employees. Each of the employees has the
same features i.e. has a salary, has some responsibilities, may or may not > same features i.e. has a salary, has some responsibilities, may or may not
report to someone, may or may not have some subordinates etc. > report to someone, may or may not have some subordinates etc.
In plain words: In plain words:
> Composite pattern lets clients treat the individual objects in a uniform > Composite pattern lets clients treat the individual objects in a uniform
manner. > manner.
Wikipedia says: Wikipedia says:
> In software engineering, the composite pattern is a partitioning design > In software engineering, the composite pattern is a partitioning design
pattern. The composite pattern describes that a group of objects is to be > pattern. The composite pattern describes that a group of objects is to be
treated in the same way as a single instance of an object. The intent of a > treated in the same way as a single instance of an object. The intent of a
composite is to "compose" objects into tree structures to represent part-whole > composite is to "compose" objects into tree structures to represent part-whole
hierarchies. Implementing the composite pattern lets clients treat individual > hierarchies. Implementing the composite pattern lets clients treat individual
objects and compositions uniformly. > objects and compositions uniformly.
#### Programmatic Example #### Programmatic Example
@@ -1199,23 +1201,23 @@ TODO
Real world example: Real world example:
> Imagine you run a car service shop offering multiple services. Now how do you > Imagine you run a car service shop offering multiple services. Now how do you
calculate the bill to be charged? You pick one service and dynamically keep > calculate the bill to be charged? You pick one service and dynamically keep
adding to it the prices for the provided services till you get the final cost. > adding to it the prices for the provided services till you get the final cost.
Here each type of service is a decorator. > Here each type of service is a decorator.
In plain words: In plain words:
> Decorator pattern lets you dynamically change the behavior of an object at > Decorator pattern lets you dynamically change the behavior of an object at
run time by wrapping them in an object of a decorator class. > run time by wrapping them in an object of a decorator class.
Wikipedia says: Wikipedia says:
> In object-oriented programming, the decorator pattern is a design pattern that > In object-oriented programming, the decorator pattern is a design pattern that
allows behavior to be added to an individual object, either statically or > allows behavior to be added to an individual object, either statically or
dynamically, without affecting the behavior of other objects from the same > dynamically, without affecting the behavior of other objects from the same
class. The decorator pattern is often useful for adhering to the Single > class. The decorator pattern is often useful for adhering to the Single
Responsibility Principle, as it allows functionality to be divided between > Responsibility Principle, as it allows functionality to be divided between
classes with unique areas of concern. > classes with unique areas of concern.
#### Programmatic Example #### Programmatic Example
@@ -1355,9 +1357,9 @@ TODO
Real world example: Real world example:
> How do you turn on the computer? "Hit the power button" you say! That is what > How do you turn on the computer? "Hit the power button" you say! That is what
you believe because you are using a simple interface that computer provides on > you believe because you are using a simple interface that computer provides on
the outside, internally it has to do a lot of stuff to make it happen. This > the outside, internally it has to do a lot of stuff to make it happen. This
simple interface to the complex subsystem is a facade. > simple interface to the complex subsystem is a facade.
In plain words: In plain words:
@@ -1366,7 +1368,7 @@ In plain words:
Wikipedia says: Wikipedia says:
> A facade is an object that provides a simplified interface to a larger body of > A facade is an object that provides a simplified interface to a larger body of
code, such as a class library. > code, such as a class library.
#### Programmatic Example #### Programmatic Example
@@ -1460,20 +1462,20 @@ TODO
Real world example: Real world example:
> Did you ever have fresh tea from some stall? They often make more than one > Did you ever have fresh tea from some stall? They often make more than one
cup that you demanded and save the rest for any other customer so to save the > cup that you demanded and save the rest for any other customer so to save the
resources e.g. gas etc. Flyweight pattern is all about that i.e. sharing. > resources e.g. gas etc. Flyweight pattern is all about that i.e. sharing.
In plain words: In plain words:
> It is used to minimize memory usage or computational expenses by sharing as > It is used to minimize memory usage or computational expenses by sharing as
much as possible with similar objects. > much as possible with similar objects.
Wikipedia says: Wikipedia says:
> In computer programming, flyweight is a software design pattern. A flyweight > In computer programming, flyweight is a software design pattern. A flyweight
is an object that minimizes memory use by sharing as much data as possible with > is an object that minimizes memory use by sharing as much data as possible with
other similar objects; it is a way to use objects in large numbers when a simple > other similar objects; it is a way to use objects in large numbers when a simple
repeated representation would use an unacceptable amount of memory. > repeated representation would use an unacceptable amount of memory.
#### Programmatic Example #### Programmatic Example
@@ -1567,7 +1569,7 @@ shop.takeOrder("half sugar", 4);
std::cout << shop.getPreferenceCount() << std::endl; // Output: 3 std::cout << shop.getPreferenceCount() << std::endl; // Output: 3
// Serve the customers. // Serve the customers.
shop.serve(); shop.serve();
// Output: (Note: Since the map is unordered, the serving order may vary.) // Output: (Note: Since the map is unordered, the serving order may vary.)
// Serving tea to table 4 // Serving tea to table 4
// Serving tea to table 5 // Serving tea to table 5
@@ -1586,25 +1588,25 @@ TODO
Real world example: Real world example:
> Have you ever used an access card to go through a door? There are multiple > Have you ever used an access card to go through a door? There are multiple
options to open that door i.e. it can be opened either using access card or by > options to open that door i.e. it can be opened either using access card or by
pressing a button that bypasses the security. The door's main functionality is > pressing a button that bypasses the security. The door's main functionality is
to open but there is a proxy added on top of it to add some functionality. Let > to open but there is a proxy added on top of it to add some functionality. Let
me better explain it using the code example below. > me better explain it using the code example below.
In plain words: In plain words:
> Using the proxy pattern, a class represents the functionality of another > Using the proxy pattern, a class represents the functionality of another
class. > class.
Wikipedia says: Wikipedia says:
> A proxy, in its most general form, is a class functioning as an interface to > A proxy, in its most general form, is a class functioning as an interface to
something else. A proxy is a wrapper or agent object that is being called by the > something else. A proxy is a wrapper or agent object that is being called by the
client to access the real serving object behind the scenes. Use of the proxy can > client to access the real serving object behind the scenes. Use of the proxy can
simply be forwarding to the real object, or can provide additional logic. In the > simply be forwarding to the real object, or can provide additional logic. In the
proxy extra functionality can be provided, for example caching when operations > proxy extra functionality can be provided, for example caching when operations
on the real object are resource intensive, or checking preconditions before > on the real object are resource intensive, or checking preconditions before
operations on the real object are invoked. > operations on the real object are invoked.
#### Programmatic Example #### Programmatic Example
@@ -1689,28 +1691,28 @@ TODO
In plain words: In plain words:
> It is concerned with assignment of responsibilities between the objects. What > It is concerned with assignment of responsibilities between the objects. What
makes them different from structural patterns is they don't just specify the > makes them different from structural patterns is they don't just specify the
structure but also outline the patterns for message passing/communication > structure but also outline the patterns for message passing/communication
between them. Or in other words, they assist in answering "How to run a behavior > between them. Or in other words, they assist in answering "How to run a behavior
in software component?" > in software component?"
Wikipedia says: Wikipedia says:
> In software engineering, behavioral design patterns are design patterns that > In software engineering, behavioral design patterns are design patterns that
identify common communication patterns between objects and realize these > identify common communication patterns between objects and realize these
patterns. By doing so, these patterns increase flexibility in carrying out this > patterns. By doing so, these patterns increase flexibility in carrying out this
communication. > communication.
* [Chain of Responsibility](#-chain-of-responsibility) - [Chain of Responsibility](#-chain-of-responsibility)
* [Command](#-command) - [Command](#-command)
* [Iterator](#-iterator) - [Iterator](#-iterator)
* [Mediator](#-mediator) - [Mediator](#-mediator)
* [Memento](#-memento) - [Memento](#-memento)
* [Observer](#-observer) - [Observer](#-observer)
* [Visitor](#-visitor) - [Visitor](#-visitor)
* [Strategy](#-strategy) - [Strategy](#-strategy)
* [State](#-state) - [State](#-state)
* [Template Method](#-template-method) - [Template Method](#-template-method)
### 🔗 Chain of Responsibility ### 🔗 Chain of Responsibility
@@ -1719,28 +1721,28 @@ communication.
Real world example: Real world example:
> For example, you have three payment methods (`A`, `B` and `C`) setup in your > For example, you have three payment methods (`A`, `B` and `C`) setup in your
account; each having a different amount in it. `A` has 100 USD, `B` has 300 USD > account; each having a different amount in it. `A` has 100 USD, `B` has 300 USD
and `C` having 1000 USD and the preference for payments is chosen as `A` then > and `C` having 1000 USD and the preference for payments is chosen as `A` then
`B` then `C`. You try to purchase something that is worth 210 USD. Using Chain > `B` then `C`. You try to purchase something that is worth 210 USD. Using Chain
of Responsibility, first of all account `A` will be checked if it can make the > of Responsibility, first of all account `A` will be checked if it can make the
purchase, if yes purchase will be made and the chain will be broken. If not, > purchase, if yes purchase will be made and the chain will be broken. If not,
request will move forward to account `B` checking for amount if yes chain will > request will move forward to account `B` checking for amount if yes chain will
be broken otherwise the request will keep forwarding till it finds the suitable > be broken otherwise the request will keep forwarding till it finds the suitable
handler. Here `A`, `B` and `C` are links of the chain and the whole phenomenon > handler. Here `A`, `B` and `C` are links of the chain and the whole phenomenon
is Chain of Responsibility. > is Chain of Responsibility.
In plain words: In plain words:
> It helps building a chain of objects. Request enters from one end and keeps > It helps building a chain of objects. Request enters from one end and keeps
going from object to object till it finds the suitable handler. > going from object to object till it finds the suitable handler.
Wikipedia says: Wikipedia says:
> In object-oriented design, the chain-of-responsibility pattern is a design > In object-oriented design, the chain-of-responsibility pattern is a design
pattern consisting of a source of command objects and a series of processing > pattern consisting of a source of command objects and a series of processing
objects. Each processing object contains logic that defines the types of command > objects. Each processing object contains logic that defines the types of command
objects that it can handle; the rest are passed to the next processing object in > objects that it can handle; the rest are passed to the next processing object in
the chain. > the chain.
#### Programmatic Example #### Programmatic Example
@@ -1852,27 +1854,27 @@ TODO
Real world example: Real world example:
> A generic example would be you ordering food at a restaurant. You (i.e. > A generic example would be you ordering food at a restaurant. You (i.e.
`Client`) ask the waiter (i.e. `Invoker`) to bring some food (i.e. `Command`) > `Client`) ask the waiter (i.e. `Invoker`) to bring some food (i.e. `Command`)
and waiter simply forwards the request to Chef (i.e. `Receiver`) who has the > and waiter simply forwards the request to Chef (i.e. `Receiver`) who has the
knowledge of what and how to cook. > knowledge of what and how to cook.
Another example: Another example:
> Another example would be you (i.e. `Client`) switching on (i.e. `Command`) the > Another example would be you (i.e. `Client`) switching on (i.e. `Command`) the
television (i.e. `Receiver`) using a remote control (`Invoker`). > television (i.e. `Receiver`) using a remote control (`Invoker`).
In plain words: In plain words:
> Allows you to encapsulate actions in objects. The key idea behind this pattern > Allows you to encapsulate actions in objects. The key idea behind this pattern
is to provide the means to decouple client from receiver. > is to provide the means to decouple client from receiver.
Wikipedia says: Wikipedia says:
> In object-oriented programming, the command pattern is a behavioral design > In object-oriented programming, the command pattern is a behavioral design
pattern in which an object is used to encapsulate all information needed to > pattern in which an object is used to encapsulate all information needed to
perform an action or trigger an event at a later time. This information includes > perform an action or trigger an event at a later time. This information includes
the method name, the object that owns the method and values for the method > the method name, the object that owns the method and values for the method
parameters. > parameters.
#### Programmatic Example #### Programmatic Example
@@ -2012,24 +2014,24 @@ TODO
Real world example: Real world example:
> An old radio set will be a good example of iterator, where user could start at > An old radio set will be a good example of iterator, where user could start at
some channel and then use next or previous buttons to go through the respective > some channel and then use next or previous buttons to go through the respective
channels. Or take an example of MP3 player or a TV set where you could press the > channels. Or take an example of MP3 player or a TV set where you could press the
next and previous buttons to go through the consecutive channels or in other > next and previous buttons to go through the consecutive channels or in other
words they all provide an interface to iterate through the respective channels, > words they all provide an interface to iterate through the respective channels,
songs or radio stations. > songs or radio stations.
In plain words: In plain words:
> It presents a way to access the elements of an object without exposing the > It presents a way to access the elements of an object without exposing the
underlying presentation. > underlying presentation.
Wikipedia says: Wikipedia says:
> In object-oriented programming, the iterator pattern is a design pattern in > In object-oriented programming, the iterator pattern is a design pattern in
which an iterator is used to traverse a container and access the container's > which an iterator is used to traverse a container and access the container's
elements. The iterator pattern decouples algorithms from containers; in some > elements. The iterator pattern decouples algorithms from containers; in some
cases, algorithms are necessarily container-specific and thus cannot be > cases, algorithms are necessarily container-specific and thus cannot be
decoupled. > decoupled.
#### Programmatic Example #### Programmatic Example
@@ -2046,22 +2048,22 @@ TODO
Real world example: Real world example:
> A general example would be when you talk to someone on your mobile phone, > A general example would be when you talk to someone on your mobile phone,
there is a network provider sitting between you and them and your conversation > there is a network provider sitting between you and them and your conversation
goes through it instead of being directly sent. In this case network provider is > goes through it instead of being directly sent. In this case network provider is
mediator. > mediator.
In plain words: In plain words:
> Mediator pattern adds a third party object (called mediator) to control the > Mediator pattern adds a third party object (called mediator) to control the
interaction between two objects (called colleagues). It helps reduce the > interaction between two objects (called colleagues). It helps reduce the
coupling between the classes communicating with each other. Because now they > coupling between the classes communicating with each other. Because now they
don't need to have the knowledge of each other's implementation. > don't need to have the knowledge of each other's implementation.
Wikipedia says: Wikipedia says:
> In software engineering, the mediator pattern defines an object that > In software engineering, the mediator pattern defines an object that
encapsulates how a set of objects interact. This pattern is considered to be a > encapsulates how a set of objects interact. This pattern is considered to be a
behavioral pattern due to the way it can alter the program's running behavior. > behavioral pattern due to the way it can alter the program's running behavior.
#### Programmatic Example #### Programmatic Example
@@ -2078,19 +2080,19 @@ TODO
Real world example: Real world example:
> Take the example of calculator (i.e. originator), where whenever you perform > Take the example of calculator (i.e. originator), where whenever you perform
some calculation the last calculation is saved in memory (i.e. memento) so that > some calculation the last calculation is saved in memory (i.e. memento) so that
you can get back to it and maybe get it restored using some action buttons (i.e. > you can get back to it and maybe get it restored using some action buttons (i.e.
caretaker). > caretaker).
In plain words: In plain words:
> Memento pattern is about capturing and storing the current state of an object > Memento pattern is about capturing and storing the current state of an object
in a manner that it can be restored later on in a smooth manner. > in a manner that it can be restored later on in a smooth manner.
Wikipedia says: Wikipedia says:
> The memento pattern is a software design pattern that provides the ability to > The memento pattern is a software design pattern that provides the ability to
restore an object to its previous state (undo via rollback). > restore an object to its previous state (undo via rollback).
Usually useful when you need to provide some sort of undo functionality. Usually useful when you need to provide some sort of undo functionality.
@@ -2109,19 +2111,19 @@ TODO
Real world example: Real world example:
> A good example would be the job seekers where they subscribe to some job > A good example would be the job seekers where they subscribe to some job
posting site and they are notified whenever there is a matching job opportunity. > posting site and they are notified whenever there is a matching job opportunity.
In plain words: In plain words:
> Defines a dependency between objects so that whenever an object changes its > Defines a dependency between objects so that whenever an object changes its
state, all its dependents are notified. > state, all its dependents are notified.
Wikipedia says: Wikipedia says:
> The observer pattern is a software design pattern in which an object, called > The observer pattern is a software design pattern in which an object, called
the subject, maintains a list of its dependents, called observers, and notifies > the subject, maintains a list of its dependents, called observers, and notifies
them automatically of any state changes, usually by calling one of their > them automatically of any state changes, usually by calling one of their
methods. > methods.
#### Programmatic Example #### Programmatic Example
@@ -2138,24 +2140,24 @@ TODO
Real world example: Real world example:
> Consider someone visiting Dubai. They just need a way (i.e. visa) to enter > Consider someone visiting Dubai. They just need a way (i.e. visa) to enter
Dubai. After arrival, they can come and visit any place in Dubai on their own > Dubai. After arrival, they can come and visit any place in Dubai on their own
without having to ask for permission or to do some leg work in order to visit > without having to ask for permission or to do some leg work in order to visit
any place here; just let them know of a place and they can visit it. Visitor > any place here; just let them know of a place and they can visit it. Visitor
pattern lets you do just that, it helps you add places to visit so that they can > pattern lets you do just that, it helps you add places to visit so that they can
visit as much as they can without having to do any legwork. > visit as much as they can without having to do any legwork.
In plain words: In plain words:
> Visitor pattern lets you add further operations to objects without having to > Visitor pattern lets you add further operations to objects without having to
modify them. > modify them.
Wikipedia says: Wikipedia says:
> In object-oriented programming and software engineering, the visitor design > In object-oriented programming and software engineering, the visitor design
pattern is a way of separating an algorithm from an object structure on which it > pattern is a way of separating an algorithm from an object structure on which it
operates. A practical result of this separation is the ability to add new > operates. A practical result of this separation is the ability to add new
operations to existing object structures without modifying those structures. It > operations to existing object structures without modifying those structures. It
is one way to follow the open/closed principle. > is one way to follow the open/closed principle.
#### Programmatic Example #### Programmatic Example
@@ -2172,22 +2174,22 @@ TODO
Real world example: Real world example:
> Consider the example of sorting, we implemented bubble sort but the data > Consider the example of sorting, we implemented bubble sort but the data
started to grow and bubble sort started getting very slow. In order to tackle > started to grow and bubble sort started getting very slow. In order to tackle
this we implemented Quick sort. But now although the quick sort algorithm was > this we implemented Quick sort. But now although the quick sort algorithm was
doing better for large datasets, it was very slow for smaller datasets. In order > doing better for large datasets, it was very slow for smaller datasets. In order
to handle this we implemented a strategy where for small datasets, bubble sort > to handle this we implemented a strategy where for small datasets, bubble sort
will be used and for larger, quick sort. > will be used and for larger, quick sort.
In plain words: In plain words:
> Strategy pattern allows you to switch the algorithm or strategy based upon the > Strategy pattern allows you to switch the algorithm or strategy based upon the
situation. > situation.
Wikipedia says: Wikipedia says:
> In computer programming, the strategy pattern (also known as the policy > In computer programming, the strategy pattern (also known as the policy
pattern) is a behavioural software design pattern that enables an algorithm's > pattern) is a behavioural software design pattern that enables an algorithm's
behavior to be selected at runtime. > behavior to be selected at runtime.
#### Programmatic Example #### Programmatic Example
@@ -2204,8 +2206,8 @@ TODO
Real world example: Real world example:
> Imagine you are using some drawing application, you choose the paint brush to > Imagine you are using some drawing application, you choose the paint brush to
draw. Now the brush changes its behavior based on the selected color i.e. if you > draw. Now the brush changes its behavior based on the selected color i.e. if you
have chosen red color it will draw in red, if blue then it will be in blue etc. > have chosen red color it will draw in red, if blue then it will be in blue etc.
In plain words: In plain words:
@@ -2214,12 +2216,12 @@ In plain words:
Wikipedia says: Wikipedia says:
> The state pattern is a behavioral software design pattern that implements a > The state pattern is a behavioral software design pattern that implements a
state machine in an object-oriented way. With the state pattern, a state machine > state machine in an object-oriented way. With the state pattern, a state machine
is implemented by implementing each individual state as a derived class of the > is implemented by implementing each individual state as a derived class of the
state pattern interface, and implementing state transitions by invoking methods > state pattern interface, and implementing state transitions by invoking methods
defined by the pattern's superclass. The state pattern can be interpreted as a > defined by the pattern's superclass. The state pattern can be interpreted as a
strategy pattern which is able to switch the current strategy through > strategy pattern which is able to switch the current strategy through
invocations of methods defined in the pattern's interface. > invocations of methods defined in the pattern's interface.
#### Programmatic Example #### Programmatic Example
@@ -2236,27 +2238,28 @@ TODO
Real world example: Real world example:
> Suppose we are getting some house built. The steps for building might look > Suppose we are getting some house built. The steps for building might look
like: > like:
>
> - Prepare the base of house > - Prepare the base of house
> - Build the walls > - Build the walls
> - Add roof > - Add roof
> - Add other floors > - Add other floors
> >
> The order of these steps could never be changed i.e. you can't build the roof > The order of these steps could never be changed i.e. you can't build the roof
before building the walls etc but each of the steps could be modified for > before building the walls etc but each of the steps could be modified for
example walls can be made of wood or polyester or stone. > example walls can be made of wood or polyester or stone.
In plain words: In plain words:
> Template method defines the skeleton of how a certain algorithm could be > Template method defines the skeleton of how a certain algorithm could be
performed, but defers the implementation of those steps to the children classes. > performed, but defers the implementation of those steps to the children classes.
Wikipedia says: Wikipedia says:
> In software engineering, the template method pattern is a behavioral design > In software engineering, the template method pattern is a behavioral design
pattern that defines the program skeleton of an algorithm in an operation, > pattern that defines the program skeleton of an algorithm in an operation,
deferring some steps to subclasses. It lets one redefine certain steps of an > deferring some steps to subclasses. It lets one redefine certain steps of an
algorithm without changing the algorithm's structure. > algorithm without changing the algorithm's structure.
#### Programmatic Example #### Programmatic Example
@@ -2283,9 +2286,9 @@ about the architectural patterns, stay tuned for it.
All content of this file, unless otherwise noted, is licensed as follows: All content of this file, unless otherwise noted, is licensed as follows:
- All provided source code examples are covered by the - All provided source code examples are covered by the
[MIT License](https://github.com/idinwoodie/cpp-design-patterns-for-humans/blob/master/LICENSE). [MIT License](https://github.com/idinwoodie/cpp-design-patterns-for-humans/blob/master/LICENSE).
- The C++ badge that appears in the banner image was created by - The C++ badge that appears in the banner image was created by
[Jeremy Kratz](https://jeremykratz.com/) and is licensed by [Jeremy Kratz](https://jeremykratz.com/) and is licensed by
[The Standard C++ Foundation](https://isocpp.org/home/terms-of-use). [The Standard C++ Foundation](https://isocpp.org/home/terms-of-use).
- Other content, including images, is released under the - Other content, including images, is released under the
[Creative Common Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/). [Creative Common Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).