Java Creational Factory

📁 File Structure

/FactoryMethodPattern
│── Product.java
│── ConcreteProductA.java
│── ConcreteProductB.java
│── Creator.java
│── ConcreteCreatorA.java
│── ConcreteCreatorB.java
│── Main.java
    

1. Product.java (Abstract Product Interface)

// Abstract Product interface
public interface Product {
    void use();
}
    

2. ConcreteProductA.java & ConcreteProductB.java (Concrete Products)

ConcreteProductA.java

// Concrete Product A
public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}
    

ConcreteProductB.java

// Concrete Product B
public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}
    

3. Creator.java (Abstract Factory Class)

// Abstract Creator class
public abstract class Creator {
    // Factory Method: Must be implemented by concrete creators
    public abstract Product factoryMethod();
}
    

4. ConcreteCreatorA.java & ConcreteCreatorB.java (Factory Implementations)

ConcreteCreatorA.java

// Concrete Creator A
public class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}
    

ConcreteCreatorB.java

// Concrete Creator B
public class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}
    

5. Main.java (Client Code)

public class Main {
    public static void main(String[] args) {
        // Create a factory for ProductA
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.factoryMethod();
        productA.use(); // Output: Using ConcreteProductA

        // Create a factory for ProductB
        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.factoryMethod();
        productB.use(); // Output: Using ConcreteProductB
    }
}
    

🎯 Key Takeaways

• ✅ Encapsulation: The client does not know which concrete product it gets.
• ✅ Scalability: Easily add new products and factories.
• ✅ Decoupling: The factory method isolates the creation logic.

C# Creational Factory

📁 File Structure

/FactoryMethodPattern
│── IProduct.cs
│── ConcreteProductA.cs
│── ConcreteProductB.cs
│── Creator.cs
│── ConcreteCreatorA.cs
│── ConcreteCreatorB.cs
│── Program.cs
    

1. IProduct.cs (Abstract Product Interface)

namespace FactoryMethodPattern
{
    // Abstract Product Interface
    public interface IProduct
    {
        void Use();
    }
}
    

2. ConcreteProductA.cs & ConcreteProductB.cs (Concrete Products)

ConcreteProductA.cs

using System;

namespace FactoryMethodPattern
{
    // Concrete Product A
    public class ConcreteProductA : IProduct
    {
        public void Use()
        {
            Console.WriteLine("Using ConcreteProductA");
        }
    }
}
    

ConcreteProductB.cs

using System;

namespace FactoryMethodPattern
{
    // Concrete Product B
    public class ConcreteProductB : IProduct
    {
        public void Use()
        {
            Console.WriteLine("Using ConcreteProductB");
        }
    }
}
    

3. Creator.cs (Abstract Factory Class)

namespace FactoryMethodPattern
{
    // Abstract Creator
    public abstract class Creator
    {
        // Factory Method: Must be implemented by concrete creators
        public abstract IProduct FactoryMethod();
    }
}
    

4. ConcreteCreatorA.cs & ConcreteCreatorB.cs (Factory Implementations)

ConcreteCreatorA.cs

namespace FactoryMethodPattern
{
    // Concrete Creator A
    public class ConcreteCreatorA : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ConcreteProductA();
        }
    }
}
    

ConcreteCreatorB.cs

namespace FactoryMethodPattern
{
    // Concrete Creator B
    public class ConcreteCreatorB : Creator
    {
        public override IProduct FactoryMethod()
        {
            return new ConcreteProductB();
        }
    }
}
    

5. Program.cs (Client Code)

using System;

namespace FactoryMethodPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a factory for ProductA
            Creator creatorA = new ConcreteCreatorA();
            IProduct productA = creatorA.FactoryMethod();
            productA.Use(); // Output: Using ConcreteProductA

            // Create a factory for ProductB
            Creator creatorB = new ConcreteCreatorB();
            IProduct productB = creatorB.FactoryMethod();
            productB.Use(); // Output: Using ConcreteProductB
        }
    }
}
    

🎯 Key Takeaways

• ✅ Encapsulation: The client does not know which concrete product it gets.
• ✅ Scalability: Easily add new products and factories.
• ✅ Decoupling: The factory method isolates the creation logic.

C++ Creational Factory

📁 File Structure

/ProjectFolder
│── Product.h
│── ConcreteProduct.h
│── ConcreteProduct.cpp
│── Creator.h
│── ConcreteCreator.h
│── ConcreteCreator.cpp
│── main.cpp
    

1. Product.h (Abstract Product)

#ifndef PRODUCT_H
#define PRODUCT_H

#include <iostream>

// Abstract Product class
class Product {
public:
    virtual void use() = 0; // Pure virtual function to be implemented by concrete products
    virtual ~Product() {} // Virtual destructor for proper cleanup
};

#endif // PRODUCT_H
    

2. ConcreteProduct.h & ConcreteProduct.cpp (Concrete Implementations)

ConcreteProduct.h

#ifndef CONCRETEPRODUCT_H
#define CONCRETEPRODUCT_H

#include "Product.h"

// Concrete Product class
class ConcreteProductA : public Product {
public:
    void use() override; // Implementation of abstract method
};

class ConcreteProductB : public Product {
public:
    void use() override;
};

#endif // CONCRETEPRODUCT_H
    

ConcreteProduct.cpp

#include "ConcreteProduct.h"

// Implement ConcreteProductA's behavior
void ConcreteProductA::use() {
    std::cout << "Using ConcreteProductA" << std::endl;
}

// Implement ConcreteProductB's behavior
void ConcreteProductB::use() {
    std::cout << "Using ConcreteProductB" << std::endl;
}
    

3. Creator.h (Abstract Factory Class)

#ifndef CREATOR_H
#define CREATOR_H

#include "Product.h"

// Abstract Factory class
class Creator {
public:
    virtual Product* factoryMethod() = 0; // Factory method to create objects
    virtual ~Creator() {} // Virtual destructor
};

#endif // CREATOR_H
    

4. ConcreteCreator.h & ConcreteCreator.cpp (Factory Implementations)

ConcreteCreator.h

#ifndef CONCRETECREATOR_H
#define CONCRETECREATOR_H

#include "Creator.h"
#include "ConcreteProduct.h"

// Concrete Creator for ProductA
class ConcreteCreatorA : public Creator {
public:
    Product* factoryMethod() override;
};

// Concrete Creator for ProductB
class ConcreteCreatorB : public Creator {
public:
    Product* factoryMethod() override;
};

#endif // CONCRETECREATOR_H
    

ConcreteCreator.cpp

#include "ConcreteCreator.h"

// Factory method returns an instance of ConcreteProductA
Product* ConcreteCreatorA::factoryMethod() {
    return new ConcreteProductA();
}

// Factory method returns an instance of ConcreteProductB
Product* ConcreteCreatorB::factoryMethod() {
    return new ConcreteProductB();
}
    

5. main.cpp (Client Code)

#include <iostream>
#include "ConcreteCreator.h"

int main() {
    // Create a factory for ProductA
    Creator* creatorA = new ConcreteCreatorA();
    Product* productA = creatorA->factoryMethod();
    productA->use(); // Output: Using ConcreteProductA

    // Create a factory for ProductB
    Creator* creatorB = new ConcreteCreatorB();
    Product* productB = creatorB->factoryMethod();
    productB->use(); // Output: Using ConcreteProductB

    // Cleanup
    delete productA;
    delete creatorA;
    delete productB;
    delete creatorB;

    return 0;
}
    

🎯 Key Takeaways

• Encapsulation: The factory method ensures the client only depends on the abstract Product interface, not concrete classes.
• Scalability: Adding new products only requires adding new concrete products and their corresponding creators.
• Decoupling: The client does not depend on the actual product classes.

PHP Creational Singelton

📁 File Structure

1. Singleton.php - This file contains the actual Singleton class.
2. index.php - This demonstrates the Singleton pattern in action.
3. SomeClass.php - An additional class to showcase how the Singleton can be used with other classes.
    

1. Singleton.php

<?php

class Singleton {
    private static $instance = null;

    // The constructor is private so that the object can't be instantiated from outside
    private function __construct() { }

    // Cloning is disabled to ensure the uniqueness of the instance
    private function __clone() { }

    // This method returns the singleton instance of this class
    public static function getInstance() {
        if (self::$instance === null) {
            self::$instance = new Singleton();
        }
        return self::$instance;
    }
}

?>
    

2. SomeClass.php

<?php

class SomeClass {
    private $singleton;

    public function __construct() {
        $this->singleton = Singleton::getInstance();
    }

    public function doSomething() {
        echo "Using the Singleton instance within SomeClass!";
    }
}

?>
    

3. index.php

<?php

include 'Singleton.php';
include 'SomeClass.php';

// Trying to get two instances of Singleton
$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();

// Both instances are the same
if ($instance1 === $instance2) {
    echo "Both instances are the same!<br>";
}

// Demonstrating the use of Singleton in another class
$obj = new SomeClass();
$obj->doSomething();

?>
    

🛠 Explanation

• Singleton Class:
  • Private static variable $instance: This holds the only instance of the class.
  • Private Constructor: To prevent any external instantiations.
  • Private __clone Method: To prevent the object from being cloned.
  • getInstance Method: Ensures only one instance is created.
• SomeClass:
  • Demonstrates how we might use the Singleton within another class.
• index.php:
  • Demonstrates that both instances retrieved from Singleton::getInstance() are the same.
  • Shows the usage of the Singleton instance within another class.

⚠️ Important Note

When working with the Singleton pattern, ensure you genuinely need a singleton. Overusing this pattern can lead to design issues and difficulties in testing.

Java Creational Singelton

📁 File Structure

/ProjectFolder
│── Singleton.java
│── PlainClass.java
│── Main.java (Main file)
    

1. Singleton.java (Singleton Class)

public class Singleton {
    // Private static instance - holds the single instance of the class
    private static volatile Singleton instance; // Use volatile for thread safety

    // Private constructor to prevent direct instantiation
    private Singleton() {
        System.out.println("Singleton instance created.");
    }

    // Public static method to get the single instance
    public static Singleton getInstance() {
        if (instance == null) { // First check (without lock)
            synchronized (Singleton.class) { // Ensure thread safety
                if (instance == null) { // Second check (inside synchronized)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    // Example method to demonstrate functionality
    public void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}
    

2. PlainClass.java (Regular Class)

public class PlainClass {
    // Constructor
    public PlainClass() {
        System.out.println("PlainClass instance created.");
    }

    // Example method
    public void showMessage() {
        System.out.println("Hello from PlainClass!");
    }
}
    

3. Main.java (Main Program)

public class Main {
    public static void main(String[] args) {
        // Get the first instance of Singleton
        Singleton singleton1 = Singleton.getInstance();
        singleton1.showMessage();

        // Get another instance of Singleton
        Singleton singleton2 = Singleton.getInstance();

        // Verify that both Singleton instances are the same
        if (singleton1 == singleton2) {
            System.out.println("Both Singleton instances are the SAME object.");
        } else {
            System.out.println("ERROR: Singleton instances are different! (This should not happen)");
        }

        System.out.println("\n--- Creating PlainClass instances ---");

        // Create two separate instances of PlainClass
        PlainClass plain1 = new PlainClass();
        PlainClass plain2 = new PlainClass();

        // Verify that they are different objects
        if (plain1 == plain2) {
            System.out.println("ERROR: PlainClass instances are the same! (This should not happen)");
        } else {
            System.out.println("PlainClass instances are DIFFERENT objects.");
        }
    }
}
    

🛠 How It Works

• Singleton Class (Singleton.java):
  • Uses lazy initialization.
  • Implements double-checked locking for thread safety.
  • The constructor is private to prevent direct instantiation.
  • The getInstance() method ensures only one instance is created.
• PlainClass (PlainClass.java):
  • A normal class where each new PlainClass() creates a new object.
• Main Program (Main.java):
  • Calls Singleton.getInstance() twice to show that it returns the same instance.
  • Creates two separate PlainClass objects and verifies that they are different.

🎯 Expected Output

Singleton instance created.
Hello from Singleton!
Both Singleton instances are the SAME object.

--- Creating PlainClass instances ---
PlainClass instance created.
PlainClass instance created.
PlainClass instances are DIFFERENT objects.
    

🔧 How to Compile and Run in Java

Compile the files:

    javac Singleton.java PlainClass.java Main.java
    

Run the program:

    java Main
    

🎯 Key Takeaways

• ✅ Singleton enforces a single instance using lazy initialization & thread safety.
• ✅ PlainClass allows multiple instances using new.
• ✅ Proper file separation for better organization.

C# Creational Singleton

📁 File Structure

/ProjectFolder
│── Singleton.cs
│── PlainClass.cs
│── Program.cs (Main file)
    

1. Singleton.cs (Singleton Class)

using System;

public class Singleton
{
    // Private static instance (lazy initialization)
    private static Singleton? _instance;

    // Lock object for thread safety
    private static readonly object _lock = new object();

    // Private constructor prevents direct instantiation
    private Singleton()
    {
        Console.WriteLine("Singleton instance created.");
    }

    // Public static method to get the single instance
    public static Singleton Instance()
    {
        if (_instance == null)  // First check (without lock)
        {
            lock (_lock)  // Ensure thread safety
            {
                if (_instance == null)  // Second check (inside lock)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }

    // Example method
    public void ShowMessage()
    {
        Console.WriteLine("Hello from Singleton!");
    }
}
    

2. PlainClass.cs (Regular Class)

using System;

public class PlainClass
{
    public PlainClass()
    {
        Console.WriteLine("PlainClass instance created.");
    }

    public void ShowMessage()
    {
        Console.WriteLine("Hello from PlainClass!");
    }
}
    

3. Program.cs (Main Program)

using System;

class Program
{
    static void Main()
    {
        // Get the first instance of Singleton
        Singleton singleton1 = Singleton.Instance();
        singleton1.ShowMessage();

        // Get another instance of Singleton
        Singleton singleton2 = Singleton.Instance();

        // Verify that both Singleton instances are the same
        if (singleton1 == singleton2)
        {
            Console.WriteLine("Both Singleton instances are the SAME object.");
        }
        else
        {
            Console.WriteLine("ERROR: Singleton instances are different! (This should not happen)");
        }

        Console.WriteLine("\n--- Creating PlainClass instances ---");

        // Create two separate instances of PlainClass
        PlainClass plain1 = new PlainClass();
        PlainClass plain2 = new PlainClass();

        // Verify that they are different objects
        if (plain1 == plain2)
        {
            Console.WriteLine("ERROR: PlainClass instances are the same! (This should not happen)");
        }
        else
        {
            Console.WriteLine("PlainClass instances are DIFFERENT objects.");
        }
    }
}
    

🛠 How It Works

• Singleton Class:
  • Uses lazy initialization for the _instance variable.
  • Implements thread safety using lock (_lock).
  • The constructor is private to prevent external instantiation.
  • The Instance() method ensures only one instance exists.
• PlainClass:
  • Allows multiple instances.
  • Each new PlainClass() creates a separate object.
• Main Program (Program.cs):
  • Calls Singleton.Instance() twice, verifying that the same instance is returned.
  • Creates two PlainClass instances and verifies that they are different objects.

🎯 Expected Output

Singleton instance created.
Hello from Singleton!
Both Singleton instances are the SAME object.

--- Creating PlainClass instances ---
PlainClass instance created.
PlainClass instance created.
PlainClass instances are DIFFERENT objects.
    

🔧 How to Run in C#

Using .NET CLI:

    dotnet run
    

Using Visual Studio:

1. Open Visual Studio.
2. Create a Console App project.
3. Add the Singleton.cs, PlainClass.cs, and Program.cs files.
4. Click Run (▶).

🎯 Key Takeaways

• ✅ Singleton enforces a single instance using lazy initialization & thread safety.
• ✅ PlainClass allows multiple objects using new.
• ✅ Encapsulation & Separation of Concerns by organizing files properly.

C++ Creational Singleton

1. Singleton.h (Singleton Class Header)

#ifndef SINGLETON_H
#define SINGLETON_H

#include <iostream>

// Singleton class definition
class Singleton {
private:
    static Singleton* _instance;  // Static instance pointer

    // Private constructor to prevent direct instantiation
    Singleton();

public:
    // Static method to get the single instance
    static Singleton* Instance();

    // Example method to demonstrate functionality
    void ShowMessage();

    // Delete copy constructor and assignment operator
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

#endif // SINGLETON_H
    

2. Singleton.cpp (Singleton Class Implementation)

#include "Singleton.h"

// Initialize the static member
Singleton* Singleton::_instance = nullptr;

// Private constructor
Singleton::Singleton() {
    std::cout << "Singleton instance created." << std::endl;
}

// Static method to return the single instance
Singleton* Singleton::Instance() {
    if (_instance == nullptr) {
        _instance = new Singleton();
    }
    return _instance;
}

// Example method implementation
void Singleton::ShowMessage() {
    std::cout << "Hello from Singleton!" << std::endl;
}
    

3. PlainClass.h (Regular Class Header)

#ifndef PLAINCLASS_H
#define PLAINCLASS_H

#include <iostream>

// Plain class definition
class PlainClass {
public:
    PlainClass();  // Constructor
    void ShowMessage();  // Example method
};

#endif // PLAINCLASS_H
    

4. PlainClass.cpp (Regular Class Implementation)

#include "PlainClass.h"

// Constructor implementation
PlainClass::PlainClass() {
    std::cout << "PlainClass instance created." << std::endl;
}

// Example method implementation
void PlainClass::ShowMessage() {
    std::cout << "Hello from PlainClass!" << std::endl;
}
    

5. main.cpp (Main Program)

#include "Singleton.h"
#include "PlainClass.h"

int main() {
    // Get the first instance of Singleton
    Singleton* singleton1 = Singleton::Instance();
    singleton1->ShowMessage();

    // Get another instance of Singleton
    Singleton* singleton2 = Singleton::Instance();

    // Verify that both Singleton instances are the same
    if (singleton1 == singleton2) {
        std::cout << "Both Singleton instances are the SAME object." << std::endl;
    } else {
        std::cout << "ERROR: Singleton instances are different! (This should not happen)" << std::endl;
    }

    std::cout << "\n--- Creating PlainClass instances ---" << std::endl;

    // Create two separate instances of PlainClass
    PlainClass* plain1 = new PlainClass();
    PlainClass* plain2 = new PlainClass();

    // Verify that they are different objects
    if (plain1 == plain2) {
        std::cout << "ERROR: PlainClass instances are the same! (This should not happen)" << std::endl;
    } else {
        std::cout << "PlainClass instances are DIFFERENT objects." << std::endl;
    }

    // Clean up allocated memory
    delete plain1;
    delete plain2;

    return 0;
}
    

File Structure

/project-folder
│── Singleton.h
│── Singleton.cpp
│── PlainClass.h
│── PlainClass.cpp
│── main.cpp
    

Compilation (Linux/macOS)

g++ -o main main.cpp Singleton.cpp PlainClass.cpp
./main
    

Compilation (Windows - MinGW)

g++ -o main.exe main.cpp Singleton.cpp PlainClass.cpp
main.exe
    

Expected Output

Singleton instance created.
Hello from Singleton!
Both Singleton instances are the SAME object.

--- Creating PlainClass instances ---
PlainClass instance created.
PlainClass instance created.
PlainClass instances are DIFFERENT objects.
    

Creational Patterns in Java

Creational patterns in Java focus on simplifying and standardizing object creation while ensuring flexibility and minimizing dependencies.

1. Singleton

Ensures a class has only one instance, implemented using private constructors and synchronized methods for thread safety.

2. Factory Method

Defines a method for object creation, allowing subclasses to decide which class to instantiate dynamically.

3. Abstract Factory

Provides an interface for creating families of related objects without specifying their concrete implementations.

4. Builder

Separates the construction of complex objects from their representation, using fluent methods for flexibility and clarity.

5. Prototype

Creates new objects by cloning existing ones, leveraging Cloneable and overriding the clone() method for efficient duplication.

Structural Patterns in Java

Structural patterns emphasize organizing classes and objects for better composition, maintainability, and scalability in Java.

1. Adapter

Converts one interface into another expected by clients, using inheritance or delegation to bridge incompatibility.

2. Bridge

Decouples abstraction from implementation by combining interfaces and concrete implementations, enabling independent extension.

3. Composite

Groups objects into tree structures to represent part-whole hierarchies, leveraging recursion and polymorphism in Java.

4. Decorator

Dynamically adds behavior to objects without modifying their code, often using wrapping and interfaces.

5. Facade

Provides a unified interface to a complex subsystem, simplifying interaction by encapsulating multiple components into one.

6. Flyweight

Shares common state among multiple objects to reduce memory usage, using object pooling or caching mechanisms.

7. Proxy

Acts as a surrogate to control access to another object, often used for lazy initialization or access control.

Behavioral Patterns in Java

Behavioral patterns in Java manage communication and workflows between objects, enhancing flexibility and dynamic interactions.

1. Chain of Responsibility

Passes a request through a chain of handlers, each deciding whether to handle or forward it.

2. Command

Encapsulates requests as objects, allowing parameterization, queuing, and undo/redo functionality in Java applications.

3. Interpreter

Defines a grammar and interprets expressions, suitable for scripting engines, configuration parsers, or DSLs.

4. Iterator

Provides a standard way to traverse collections using Java’s Iterator or enhanced for-loops.

5. Mediator

Centralizes communication between objects, reducing dependencies with event-based systems or a mediator class.

6. Memento

Captures and restores an object’s state without exposing its details, commonly used for undo operations.

7. Observer

Implements a one-to-many relationship where dependents are notified of changes, often using Java’s Observer and Observable.

8. State

Allows an object to change its behavior dynamically based on its internal state, modeled using state classes.

9. Strategy

Encapsulates interchangeable algorithms into separate classes, promoting flexibility and reuse for tasks like sorting or validation.

10. Template Method

Defines the skeleton of an algorithm in a base class, deferring specific steps to subclasses.

11. Visitor

Encapsulates operations performed on elements of an object structure, enabling new functionality without modifying them.

Design Patterns study in C#

Creational Patterns in C#

Creational patterns in C# focus on efficient object creation while reducing coupling and promoting flexibility in design.

1. Singleton

Ensures a class has a single instance, using private constructors and static properties for controlled access.

2. Factory Method

Defines an interface for object creation, letting subclasses specify the type of objects to instantiate.

3. Abstract Factory

Provides an interface for creating families of related objects without specifying their concrete implementations.

4. Builder

Separates complex object construction from representation, enabling flexible configurations through method chaining in C#.

5. Prototype

Creates new objects by cloning existing ones, utilizing ICloneable and deep-copy techniques for duplicating complex objects.

Structural Patterns in C#

Structural patterns emphasize efficient class and object composition, ensuring modular, extensible, and scalable designs in C#.

1. Adapter

Converts one interface to another using inheritance or composition, allowing seamless integration of incompatible components.

2. Bridge

Decouples abstraction from implementation, enabling independent evolution of both through interfaces and composition in C#.

3. Composite

Organizes objects into tree structures to represent part-whole hierarchies, leveraging recursive relationships for complex systems.

4. Decorator

Adds responsibilities dynamically to objects without altering their structure, implemented with composition and interfaces.

5. Facade

Provides a simplified interface to complex subsystems, encapsulating their functionality into a single, cohesive API.

6. Flyweight

Minimizes memory usage by sharing common state among similar objects, often implemented with static caching in C#.

7. Proxy

Acts as a placeholder or surrogate, controlling access to another object using lazy loading or remote proxies.

Behavioral Patterns in C#

Behavioral patterns in C# manage object communication and workflows, promoting dynamic, loosely-coupled systems.

1. Chain of Responsibility

Passes requests through a chain of handlers, allowing each to decide whether to process or forward the request.

2. Command

Encapsulates requests as objects, enabling flexible execution, queuing, and undo/redo operations in C#.

3. Interpreter

Defines and evaluates a grammar for a language, suitable for scripting engines and domain-specific languages.

4. Iterator

Provides a standard way to traverse collections, leveraging IEnumerable and IEnumerator for seamless iteration.

5. Mediator

Centralizes communication between objects, reducing dependencies by using events, delegates, or a mediator class.

6. Memento

Captures and restores an object’s internal state without exposing implementation details, useful for undo functionality.

7. Observer

Establishes a one-to-many relationship where changes in one object notify dependents, using events or delegates.

8. State

Changes an object’s behavior based on its state, modeled using polymorphism or a state pattern implementation.

9. Strategy

Encapsulates algorithms within classes, allowing dynamic substitution of strategies for tasks like validation or sorting.

10. Template Method

Defines an algorithm’s skeleton in a base class, allowing subclasses to override specific steps while retaining structure.

11. Visitor

Encapsulates operations to be performed on object structures, enabling new functionality without altering the objects.

Study the Design Patterms using C++

Creational Patterns

Creational patterns in C++ focus on flexible object creation while minimizing coupling between classes and their implementations.

1. Singleton

Ensures a class has only one instance, using private constructors and static members for global access.

2. Factory Method

Defines an interface for object creation, delegating type determination to subclasses using inheritance and polymorphism.

3. Abstract Factory

Creates families of related objects without specifying concrete classes, leveraging abstract classes and templates in C++.

4. Builder

Separates complex object construction from representation, enabling fluent APIs for creating diverse configurations.

5. Prototype

Generates new objects by cloning existing ones using copy constructors and deep-copy mechanisms.

Structural Patterns

Structural patterns emphasize class and object composition, facilitating modular, scalable, and extensible C++ systems.

1. Adapter

Converts one interface into another using multiple inheritance or operator overloading to integrate legacy code seamlessly.

2. Bridge

Decouples abstraction from implementation using pointers and virtual functions for independent variation.

3. Composite

Represents part-whole hierarchies with recursive structures and polymorphism, ideal for file systems or graphical elements.

4. Decorator

Dynamically adds behavior to objects without altering their structure, leveraging composition and operator overloading.

5. Facade

Provides a unified interface to encapsulate complex subsystems into a single, simplified class.

6. Flyweight

Minimizes memory usage by sharing data between similar objects through object pooling and explicit memory control.

7. Proxy

Acts as a surrogate for another object, enabling lazy initialization, access control, or remote procedure calls.

Behavioral Patterns

Behavioral patterns facilitate object interactions and workflows, promoting dynamic communication and responsibility management.

1. Chain of Responsibility

Passes requests along a chain of handlers, implemented via function pointers or object references.

2. Command

Encapsulates requests as objects, enabling parameterization, queuing, and undo/redo functionality using callable objects.

3. Interpreter

Defines and evaluates grammars or expressions, suitable for scripting engines or mathematical computations.

4. Iterator

Provides a uniform way to traverse collections without exposing their internal structure, exemplified by STL iterators.

5. Mediator

Centralizes communication between objects, reducing dependencies, often implemented in GUI frameworks with observer patterns.

6. Memento

Captures and restores an object's state using serialization libraries or copy constructors.

7. Observer

Establishes one-to-many relationships, notifying dependents of changes using event-based systems or signals/slots.

8. State

Changes an object's behavior dynamically based on its internal state using polymorphism or function pointers.

9. Strategy

Encapsulates interchangeable algorithms, implemented efficiently with templates and function objects for diverse use cases.

10. Template Method

Defines an algorithm’s skeleton in base classes, deferring specific steps to subclasses via inheritance and virtual functions.

11. Visitor

Encapsulates operations for object structures using double-dispatch, suitable for tasks like syntax tree traversal.