diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6ab1c1..27acf4e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -109,6 +109,7 @@ set(APP_SOURCES
"src/patterns/behavioral/State.cpp"
"src/patterns/behavioral/Observer.cpp"
"src/patterns/creational/Singleton.cpp"
+ "src/patterns/creational/FactoryMethod.cpp"
)
# Test files
diff --git a/docs/uml/patterns_creational_factorymethod.drawio.svg b/docs/uml/patterns_creational_factorymethod.drawio.svg
new file mode 100644
index 0000000..37de042
--- /dev/null
+++ b/docs/uml/patterns_creational_factorymethod.drawio.svg
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/src/patterns/behavioral/README.md b/src/patterns/behavioral/README.md
new file mode 100644
index 0000000..47dcbb3
--- /dev/null
+++ b/src/patterns/behavioral/README.md
@@ -0,0 +1,103 @@
+# Behavioral Design Patterns
+
+Behavioral design patterns are concerned with algorithms and the assignment of responsibilities between objects.
+
+---
+
+## Chain of Responsibility
+
+**Chain of Responsibility**
+Lets you pass requests along a chain of handlers. Upon receiving a request, each handler decides either to process the request or to pass it to the next handler in the chain.
+
+**Real-time example:**
+Customer support tickets in a company. Simple requests go to the first-level support, more complex issues go to specialists, and only very complex issues reach managers.
+
+---
+
+## Command
+
+**Command**
+Turns a request into a stand-alone object that contains all information about the request. This lets you pass requests as arguments, delay or queue execution, and support undo operations.
+
+**Real-time example:**
+Using a remote control for smart home devices. Each button press represents a command: turn on lights, open curtains, or play music. You can even undo the last command.
+
+---
+
+## Iterator
+
+**Iterator**
+Lets you traverse elements of a collection without exposing its underlying representation (list, stack, tree, etc.).
+
+**Real-time example:**
+Browsing a photo gallery app. You can swipe left or right to view photos without knowing how the photos are stored internally.
+
+---
+
+## Mediator
+
+**Mediator**
+Reduces chaotic dependencies between objects by forcing them to communicate through a mediator.
+
+**Real-time example:**
+An air traffic control tower. Planes don’t communicate directly with each other; the tower coordinates landings and takeoffs.
+
+---
+
+## Memento
+
+**Memento**
+Lets you save and restore the previous state of an object without revealing its implementation details.
+
+**Real-time example:**
+The “Undo” feature in a text editor. You can revert to a previous version of your document without knowing the details of how the editor stores text internally.
+
+---
+
+## Observer
+
+**Observer**
+Defines a subscription mechanism to notify multiple objects about events happening to the object they’re observing.
+
+**Real-time example:**
+Social media notifications. When someone posts a new photo, all their followers are notified immediately.
+
+---
+
+## State
+
+**State**
+Lets an object alter its behavior when its internal state changes, making it appear as if the object changed its class.
+
+**Real-time example:**
+A traffic light. Its behavior (red, yellow, green) changes automatically depending on its current state.
+
+---
+
+## Strategy
+
+**Strategy**
+Defines a family of algorithms, puts each into a separate class, and makes them interchangeable.
+
+**Real-time example:**
+A navigation app lets you choose between driving, walking, or cycling routes. Each strategy calculates a different route but uses the same interface.
+
+---
+
+## Template Method
+
+**Template Method**
+Defines the skeleton of an algorithm in the superclass but lets subclasses override specific steps without changing its structure.
+
+**Real-time example:**
+Making coffee or tea in a café. The steps (boil water, pour, serve) are the same, but each drink has slightly different preparation steps.
+
+---
+
+## Visitor
+
+**Visitor**
+Lets you separate algorithms from the objects on which they operate.
+
+**Real-time example:**
+A tax calculator that processes different types of items (books, electronics, groceries) without changing the item classes. The calculator “visits” each item to compute tax.
diff --git a/src/patterns/creational/FactoryMethod.cpp b/src/patterns/creational/FactoryMethod.cpp
new file mode 100644
index 0000000..10766b3
--- /dev/null
+++ b/src/patterns/creational/FactoryMethod.cpp
@@ -0,0 +1,174 @@
+// cppcheck-suppress-file [functionStatic]
+
+// Factory Method is a creational design pattern that provides an interface for creating objects in a superclass,
+// but allows subclasses to alter the type of objects that will be created.
+// Appicability:
+// (*) when you don’t know beforehand the exact types and dependencies of the objects your code should work with.
+// (**) when you want to provide users of your library or framework with a way to extend its internal components.
+// (***)when you want to save system resources by reusing existing objects instead of rebuilding them each time.
+
+// UML: docs/uml/patterns_creational_factorymethod.drawio.svg
+
+#include
+#include
+namespace
+{
+ namespace FactoryMethod
+ {
+ /**
+ * The Product interface declares the operations that all concrete products must
+ * implement.
+ */
+ class IGdbProduct
+ {
+ public:
+ virtual ~IGdbProduct() = default;
+ virtual void launch() const = 0;
+ };
+
+ /**
+ * Concrete Products provide various implementations of the Product interface.
+ */
+ class LinuxGdbProduct : public IGdbProduct
+ {
+ public:
+ void launch() const override
+ {
+ std::cout
+ << "\tsudo apt update && sudo apt install -y gdb && gdb --version\n";
+ }
+ };
+
+ class WindowsGdbProduct : public IGdbProduct
+ {
+ public:
+ void launch() const override
+ {
+ std::cout << "\tpacman -Syu mingw-w64-x86_64-gdb && gdb --version\n";
+ }
+ };
+
+ class MacOsGdbProduct : public IGdbProduct
+ {
+ public:
+ void launch() const override
+ {
+ std::cout << "\tbrew install gdb && gdb --version\n";
+ }
+ };
+
+ /**
+ * The Creator class declares the factory method that is supposed to return an
+ * object of a Product class. The Creator's subclasses usually provide the
+ * implementation of this method.
+ */
+ class IGdbCreator
+ {
+ public:
+ virtual ~IGdbCreator() = default;
+ virtual IGdbProduct *factoryMethod() = 0;
+ virtual void launchGdb() = 0;
+ };
+
+ class AbstractGdbCreater : public IGdbCreator
+ {
+ public:
+ // Call the factory method to create a Product object.
+
+ void launchGdb() override final
+ {
+ IGdbProduct *gdb = this->factoryMethod();
+ gdb->launch();
+ delete gdb;
+ }
+ };
+
+ /**
+ * Concrete Creators override the factory method in order to change the
+ * resulting product's type.
+ */
+ class WindowsGdbCreator : public AbstractGdbCreater
+ {
+ public:
+ IGdbProduct *factoryMethod() override
+ {
+ return new WindowsGdbProduct();
+ }
+ };
+
+ class LinuxGdbCreator : public AbstractGdbCreater
+ {
+ public:
+ IGdbProduct *factoryMethod() override
+ {
+ return new LinuxGdbProduct();
+ }
+ };
+
+ class MacOsGdbCreator : public AbstractGdbCreater
+ {
+ public:
+ IGdbProduct *factoryMethod() override
+ {
+ return new MacOsGdbProduct();
+ }
+ };
+
+ /**
+ * The client code works with an instance of a concrete creator, albeit through its base interface.
+ * As long as the client keeps working with the creator via the base interface, you can pass it any creator's subclass.
+ */
+ namespace ClientCode
+ {
+ void clientCode(IGdbCreator *gdb)
+ {
+ if (gdb != nullptr)
+ gdb->launchGdb();
+ }
+ }
+
+ class GdbCreatorFactory
+ {
+ public:
+ static IGdbCreator *createGdbCreator(const std::string &os)
+ {
+ if (os == "linux")
+ {
+ return new LinuxGdbCreator();
+ }
+ else if (os == "windows")
+ {
+ return new WindowsGdbCreator();
+ }
+ else if (os == "macos")
+ {
+ return new MacOsGdbCreator();
+ }
+ else
+ {
+ std::cout << "OS not support yet - " << os << "\n";
+ return nullptr;
+ }
+ }
+ };
+
+ void run()
+ {
+ std::string os = "linux";
+ IGdbCreator *gdb = GdbCreatorFactory::createGdbCreator(os);
+ ClientCode::clientCode(gdb);
+ delete gdb;
+ }
+ }
+}
+
+struct FactoryMethodAutoRunner
+{
+ FactoryMethodAutoRunner()
+ {
+ std::cout << "\n--- FactoryMethod Pattern Example ---\n";
+ FactoryMethod::run();
+ }
+};
+
+static FactoryMethodAutoRunner instance;
\ No newline at end of file
diff --git a/src/patterns/creational/README.md b/src/patterns/creational/README.md
new file mode 100644
index 0000000..cc89aa1
--- /dev/null
+++ b/src/patterns/creational/README.md
@@ -0,0 +1,53 @@
+# Creational Design Patterns
+
+Creational design patterns provide various object creation mechanisms, which increase flexibility and reuse of existing code.
+
+---
+
+## Factory Method
+
+**Factory Method**
+Provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created.
+
+**Real-time example:**
+A ride-hailing app can create different types of rides: economy, premium, or SUV. The app defines a general interface for booking a ride, and the specific ride type is decided at runtime.
+
+---
+
+## Abstract Factory
+
+**Abstract Factory**
+Lets you produce families of related objects without specifying their concrete classes.
+
+**Real-time example:**
+A furniture store app that sells sets of furniture. If a customer chooses a "Modern" style, the app provides a matching chair, table, and sofa. If "Victorian" style is chosen, it provides a different matching set. The app doesn’t need to know the concrete classes of each furniture piece.
+
+---
+
+## Builder
+
+**Builder**
+Lets you construct complex objects step by step. The pattern allows you to produce different types and representations of an object using the same construction code.
+
+**Real-time example:**
+Ordering a custom pizza online. You can choose the dough, sauce, toppings, and size step by step, resulting in different pizzas, all using the same ordering process.
+
+---
+
+## Prototype
+
+**Prototype**
+Lets you copy existing objects without making your code dependent on their classes.
+
+**Real-time example:**
+Copying a template for a new document in Google Docs. Instead of creating a document from scratch, you duplicate an existing one and modify it.
+
+---
+
+## Singleton
+
+**Singleton**
+Lets you ensure that a class has only one instance, while providing a global access point to this instance.
+
+**Real-time example:**
+A system configuration manager in an app. All parts of the app access the same configuration instance, so settings are consistent across the application.
diff --git a/src/patterns/creational/Singleton.cpp b/src/patterns/creational/Singleton.cpp
index 2f15072..449c9fc 100644
--- a/src/patterns/creational/Singleton.cpp
+++ b/src/patterns/creational/Singleton.cpp
@@ -6,6 +6,8 @@
// (*) when a class in your program should have just a single instance available to all clients; for example, a single database object shared by different parts of the program.
// (**) when you need stricter control over global variables.
+// UML: docs/uml/patterns_creational_singleton.drawio.svg
+
#include
namespace
diff --git a/src/patterns/structural/README.md b/src/patterns/structural/README.md
new file mode 100644
index 0000000..a630b45
--- /dev/null
+++ b/src/patterns/structural/README.md
@@ -0,0 +1,73 @@
+# Structural Design Patterns
+
+Structural design patterns explain how to assemble objects and classes into larger structures, while keeping these structures flexible and efficient.
+
+---
+
+## Adapter
+
+**Adapter**
+Allows objects with incompatible interfaces to collaborate.
+
+**Real-time example:**
+A travel power adapter. You plug a device from one country into a socket in another country using an adapter to make it compatible.
+
+---
+
+## Bridge
+
+**Bridge**
+Lets you split a large class or a set of closely related classes into two separate hierarchies—abstraction and implementation—which can be developed independently.
+
+**Real-time example:**
+A remote control system. The remote (abstraction) can control different devices (TV, AC, music system) independently without changing the remote design.
+
+---
+
+## Composite
+
+**Composite**
+Lets you compose objects into tree structures and then work with these structures as if they were individual objects.
+
+**Real-time example:**
+A company organizational chart. Managers and employees are treated uniformly. A manager can have subordinates, who can also be managers or employees.
+
+---
+
+## Decorator
+
+**Decorator**
+Lets you attach new behaviors to objects by placing these objects inside special wrapper objects that contain the behaviors.
+
+**Real-time example:**
+Adding extra features to a coffee order. You start with a plain coffee and decorate it with milk, sugar, or flavors without changing the original coffee class.
+
+---
+
+## Facade
+
+**Facade**
+Provides a simplified interface to a library, a framework, or any other complex set of classes.
+
+**Real-time example:**
+A home automation app. Instead of controlling lights, thermostat, and security system separately, the app provides a single interface to manage everything easily.
+
+---
+
+## Flyweight
+
+**Flyweight**
+Lets you fit more objects into available memory by sharing common parts of state between multiple objects.
+
+**Real-time example:**
+In a word processor, the same font style and size is shared across multiple characters instead of storing them individually for every character.
+
+---
+
+## Proxy
+
+**Proxy**
+Lets you provide a substitute or placeholder for another object. A proxy controls access to the original object, allowing you to perform something before or after the request reaches the original object.
+
+**Real-time example:**
+A payment gateway proxy. Instead of paying directly to the bank, you use a payment service that validates, logs, and then forwards your request to the bank.