{"id":1961,"date":"2024-06-22T09:39:09","date_gmt":"2024-06-22T09:39:09","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1961"},"modified":"2024-06-22T23:32:54","modified_gmt":"2024-06-22T23:32:54","slug":"how-to-implement-design-patterns-in-cpp","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/","title":{"rendered":"How to Implement Design Patterns in C++"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced object-oriented software developers. Design patterns are like pre-defined blueprints that can be customized to solve recurring design problems in various contexts. In this tutorial, we will explore several fundamental design patterns and implement them in C++.<\/p>\n\n\n\n

We will cover the following design patterns:<\/p>\n\n\n\n

    \n
  1. Creational Patterns\n
      \n
    • Singleton<\/li>\n\n\n\n
    • Factory Method<\/li>\n\n\n\n
    • Abstract Factory<\/li>\n\n\n\n
    • Builder<\/li>\n\n\n\n
    • Prototype<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • Structural Patterns\n
        \n
      • Adapter<\/li>\n\n\n\n
      • Composite<\/li>\n\n\n\n
      • Proxy<\/li>\n\n\n\n
      • Flyweight<\/li>\n\n\n\n
      • Facade<\/li>\n\n\n\n
      • Bridge<\/li>\n\n\n\n
      • Decorator<\/li>\n<\/ul>\n<\/li>\n\n\n\n
      • Behavioral Patterns\n
          \n
        • Strategy<\/li>\n\n\n\n
        • Observer<\/li>\n\n\n\n
        • Command<\/li>\n\n\n\n
        • Chain of Responsibility<\/li>\n\n\n\n
        • State<\/li>\n\n\n\n
        • Template Method<\/li>\n\n\n\n
        • Iterator<\/li>\n\n\n\n
        • Mediator<\/li>\n\n\n\n
        • Memento<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n

          By the end of this tutorial, you will have a comprehensive understanding of these design patterns and how to implement them in C++.<\/p>\n\n\n\n

          1. Creational Patterns<\/h2>\n\n\n\n

          Singleton<\/h3>\n\n\n\n

          The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is useful when exactly one object is needed to coordinate actions across the system.<\/p>\n\n\n\n

          Implementation:<\/strong><\/p>\n\n\n

          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <mutex><\/span><\/span>\n\nclass<\/span> Singleton<\/span> {<\/span>\nprivate<\/span>:\n    static<\/span> Singleton* instance;\n    static<\/span> std<\/span>::mutex mtx;\n\n    \/\/ Private constructor to prevent instantiation.<\/span>\n    Singleton() {}\n\npublic<\/span>:\n    \/\/ Static method to get the single instance of the class.<\/span>\n    static<\/span> Singleton* getInstance<\/span>()<\/span> <\/span>{\n        std<\/span>::lock_guard<std<\/span>::mutex> lock<\/span>(mtx)<\/span><\/span>;\n        if<\/span> (instance == nullptr<\/span>) {\n            instance = new<\/span> Singleton();\n        }\n        return<\/span> instance;\n    }\n\n    void<\/span> showMessage<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Singleton Instance\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Initialize static member variables.<\/span>\nSingleton* Singleton::instance = nullptr<\/span>;\nstd<\/span>::mutex Singleton::mtx;\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Singleton* s1 = Singleton::getInstance();\n    s1->showMessage();\n\n    Singleton* s2 = Singleton::getInstance();\n    s2->showMessage();\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Factory Method<\/h3>\n\n\n\n
          The Factory Method pattern defines an interface for creating an object, but lets subclasses alter the type of objects that will be created.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Product interface<\/span>\nclass<\/span> Product<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> use<\/span>()<\/span> <\/span>= 0<\/span>;\n};\n\n\/\/ Concrete Products<\/span>\nclass<\/span> ConcreteProductA<\/span> :<\/span> public<\/span> Product {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductA\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\nclass<\/span> ConcreteProductB<\/span> :<\/span> public<\/span> Product {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductB\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Creator class<\/span>\nclass<\/span> Creator<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> Product* factoryMethod<\/span>()<\/span> <\/span>= 0<\/span>;\n\n    void<\/span> anOperation<\/span>()<\/span> <\/span>{\n        Product* product = factoryMethod();\n        product->use();\n        delete<\/span> product;\n    }\n};\n\n\/\/ Concrete Creators<\/span>\nclass<\/span> ConcreteCreatorA<\/span> :<\/span> public<\/span> Creator {\npublic<\/span>:\n    Product* factoryMethod<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductA();\n    }\n};\n\nclass<\/span> ConcreteCreatorB<\/span> :<\/span> public<\/span> Creator {\npublic<\/span>:\n    Product* factoryMethod<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductB();\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Creator* creatorA = new<\/span> ConcreteCreatorA();\n    creatorA->anOperation();\n\n    Creator* creatorB = new<\/span> ConcreteCreatorB();\n    creatorB->anOperation();\n\n    delete<\/span> creatorA;\n    delete<\/span> creatorB;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Abstract Factory<\/h3>\n\n\n\n
          The Abstract Factory pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Abstract Product A<\/span>\nclass<\/span> AbstractProductA<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> use<\/span>()<\/span> <\/span>= 0<\/span>;\n};\n\n\/\/ Abstract Product B<\/span>\nclass<\/span> AbstractProductB<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> use<\/span>()<\/span> <\/span>= 0<\/span>;\n};\n\n\/\/ Concrete Product A1<\/span>\nclass<\/span> ConcreteProductA1<\/span> :<\/span> public<\/span> AbstractProductA {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductA1\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Product A2<\/span>\nclass<\/span> ConcreteProductA2<\/span> :<\/span> public<\/span> AbstractProductA {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductA2\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Product B1<\/span>\nclass<\/span> ConcreteProductB1<\/span> :<\/span> public<\/span> AbstractProductB {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductB1\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Product B2<\/span>\nclass<\/span> ConcreteProductB2<\/span> :<\/span> public<\/span> AbstractProductB {\npublic<\/span>:\n    void<\/span> use<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcreteProductB2\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Abstract Factory<\/span>\nclass<\/span> AbstractFactory<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> AbstractProductA* createProductA<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> AbstractProductB* createProductB<\/span>()<\/span> <\/span>= 0<\/span>;\n};\n\n\/\/ Concrete Factory 1<\/span>\nclass<\/span> ConcreteFactory1<\/span> :<\/span> public<\/span> AbstractFactory {\npublic<\/span>:\n    AbstractProductA* createProductA<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductA1();\n    }\n\n    AbstractProductB* createProductB<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductB1();\n    }\n};\n\n\/\/ Concrete Factory 2<\/span>\nclass<\/span> ConcreteFactory2<\/span> :<\/span> public<\/span> AbstractFactory {\npublic<\/span>:\n    AbstractProductA* createProductA<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductA2();\n    }\n\n    AbstractProductB* createProductB<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteProductB2();\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    AbstractFactory* factory1 = new<\/span> ConcreteFactory1();\n    AbstractProductA* productA1 = factory1->createProductA();\n    AbstractProductB* productB1 = factory1->createProductB();\n\n    productA1->use();\n    productB1->use();\n\n    delete<\/span> productA1;\n    delete<\/span> productB1;\n    delete<\/span> factory1;\n\n    AbstractFactory* factory2 = new<\/span> ConcreteFactory2();\n    AbstractProductA* productA2 = factory2->createProductA();\n    AbstractProductB* productB2 = factory2->createProductB();\n\n    productA2->use();\n    productB2->use();\n\n    delete<\/span> productA2;\n    delete<\/span> productB2;\n    delete<\/span> factory2;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Builder<\/h3>\n\n\n\n
          The Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <string><\/span><\/span>\n\n\/\/ Product<\/span>\nclass<\/span> Product<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> setPartA<\/span>(const<\/span> std<\/span>::string<\/span>& part)<\/span> <\/span>{ partA = part; }\n    void<\/span> setPartB<\/span>(const<\/span> std<\/span>::string<\/span>& part)<\/span> <\/span>{ partB = part; }\n    void<\/span> setPartC<\/span>(const<\/span> std<\/span>::string<\/span>& part)<\/span> <\/span>{ partC = part; }\n\n    void<\/span> show<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Product Parts: \"<\/span> << partA << \", \"<\/span> << partB << \", \"<\/span> << partC << std<\/span>::endl<\/span>;\n    }\n\nprivate<\/span>:\n    std<\/span>::string<\/span> partA;\n    std<\/span>::string<\/span> partB;\n    std<\/span>::string<\/span> partC;\n};\n\n\/\/ Builder interface<\/span>\nclass<\/span> Builder<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> buildPartA<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> buildPartB<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> buildPartC<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> Product* getResult<\/span>()<\/span> <\/span>= 0<\/span>;\n};\n\n\/\/ Concrete Builder<\/span>\nclass<\/span> ConcreteBuilder<\/span> :<\/span> public<\/span> Builder {\npublic<\/span>:\n    ConcreteBuilder() { product = new<\/span> Product(); }\n\n    void<\/span> buildPartA<\/span>()<\/span> override<\/span> <\/span>{\n        product->setPartA(\"PartA1\"<\/span>);\n    }\n\n    void<\/span> buildPartB<\/span>()<\/span> override<\/span> <\/span>{\n        product->setPartB(\"PartB1\"<\/span>);\n    }\n\n    void<\/span> buildPartC<\/span>()<\/span> override<\/span> <\/span>{\n        product->setPartC(\"PartC1\"<\/span>);\n    }\n\n    Product* getResult<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> product;\n    }\n\nprivate<\/span>:\n    Product* product;\n};\n\n\/\/ Director<\/span>\nclass<\/span> Director<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> setBuilder<\/span>(Builder* b)<\/span> <\/span>{ builder = b; }\n\n    Product* construct<\/span>()<\/span> <\/span>{\n        builder->buildPartA();\n        builder->buildPartB();\n        builder->buildPartC();\n        return<\/span> builder->getResult();\n    }\n\nprivate<\/span>:\n    Builder* builder;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Director director;\n    Builder* builder = new<\/span> ConcreteBuilder();\n\n    director.setBuilder(builder);\n    Product* product = director.construct();\n\n    product->show();\n\n    delete<\/span> product;\n    delete<\/span> builder;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Prototype<\/h3>\n\n\n\n
          The Prototype pattern is used to create a new object by copying an existing object, known as the prototype.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <unordered_map><\/span><\/span>\n\n\/\/ Prototype interface<\/span>\nclass<\/span> Prototype<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> Prototype* clone<\/span>()<\/span> const<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> use<\/span>()<\/span> const<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Prototype() = default<\/span>;\n};\n\n\/\/ Concrete Prototype 1<\/span>\nclass<\/span> ConcretePrototype1<\/span> :<\/span> public<\/span> Prototype {\npublic<\/span>:\n    Prototype* clone<\/span>()<\/span> const<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcretePrototype1(*this<\/span>);\n    }\n\n    void<\/span> use<\/span>()<\/span> const<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcretePrototype1\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Prototype 2<\/span>\nclass<\/span> ConcretePrototype2<\/span> :<\/span> public<\/span> Prototype {\npublic<\/span>:\n    Prototype* clone<\/span>()<\/span> const<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcretePrototype2(*this<\/span>);\n    }\n\n    void<\/span> use<\/span>()<\/span> const<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Using ConcretePrototype2\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Prototype Factory<\/span>\nclass<\/span> PrototypeFactory<\/span> {<\/span>\npublic<\/span>:\n    PrototypeFactory() {\n        prototypes[\"type1\"<\/span>] = new<\/span> ConcretePrototype1();\n        prototypes[\"type2\"<\/span>] = new<\/span> ConcretePrototype2();\n    }\n\n    ~PrototypeFactory() {\n        for<\/span> (auto<\/span>& pair : prototypes) {\n            delete<\/span> pair.second;\n        }\n    }\n\n    Prototype* createPrototype<\/span>(const<\/span> std<\/span>\n\n::string<\/span>& type)<\/span> <\/span>{\n        return<\/span> prototypes[type]->clone();\n    }\n\nprivate<\/span>:\n    std<\/span>::unordered_map<\/span><std<\/span>::string<\/span>, Prototype*> prototypes;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    PrototypeFactory factory;\n\n    Prototype* prototype1 = factory.createPrototype(\"type1\"<\/span>);\n    prototype1->use();\n    delete<\/span> prototype1;\n\n    Prototype* prototype2 = factory.createPrototype(\"type2\"<\/span>);\n    prototype2->use();\n    delete<\/span> prototype2;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          2. Structural Patterns<\/h2>\n\n\n\n
          Adapter<\/h3>\n\n\n\n
          The Adapter pattern allows objects with incompatible interfaces to collaborate. It acts as a bridge between two incompatible interfaces.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Target interface<\/span>\nclass<\/span> Target<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> request<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Target() = default<\/span>;\n};\n\n\/\/ Adaptee class with a specific interface<\/span>\nclass<\/span> Adaptee<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> specificRequest<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Adaptee specific request\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Adapter class that makes Adaptee compatible with Target<\/span>\nclass<\/span> Adapter<\/span> :<\/span> public<\/span> Target {\npublic<\/span>:\n    Adapter(Adaptee* adaptee) : adaptee(adaptee) {}\n\n    void<\/span> request<\/span>()<\/span> override<\/span> <\/span>{\n        adaptee->specificRequest();\n    }\n\nprivate<\/span>:\n    Adaptee* adaptee;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Adaptee* adaptee = new<\/span> Adaptee();\n    Target* adapter = new<\/span> Adapter(adaptee);\n\n    adapter->request();\n\n    delete<\/span> adapter;\n    delete<\/span> adaptee;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Composite<\/h3>\n\n\n\n
          The Composite pattern allows you to compose objects into tree structures to represent part-whole hierarchies. It lets clients treat individual objects and compositions of objects uniformly.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n\n\/\/ Component interface<\/span>\nclass<\/span> Component<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> operation<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> add<\/span>(Component* component)<\/span> <\/span>{}\n    virtual<\/span> void<\/span> remove<\/span>(Component* component)<\/span> <\/span>{}\n    virtual<\/span> Component* getChild<\/span>(int<\/span> index)<\/span> <\/span>{ return<\/span> nullptr<\/span>; }\n    virtual<\/span> ~Component() = default<\/span>;\n};\n\n\/\/ Leaf class representing a leaf node in the tree<\/span>\nclass<\/span> Leaf<\/span> :<\/span> public<\/span> Component {\npublic<\/span>:\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Leaf operation\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Composite class representing a composite node in the tree<\/span>\nclass<\/span> Composite<\/span> :<\/span> public<\/span> Component {\npublic<\/span>:\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Composite operation\"<\/span> << std<\/span>::endl<\/span>;\n        for<\/span> (Component* component : children) {\n            component->operation();\n        }\n    }\n\n    void<\/span> add<\/span>(Component* component)<\/span> override<\/span> <\/span>{\n        children.push_back(component);\n    }\n\n    void<\/span> remove<\/span>(Component* component)<\/span> override<\/span> <\/span>{\n        children.erase(std<\/span>::remove(children.begin(), children.end(), component), children.end());\n    }\n\n    Component* getChild<\/span>(int<\/span> index)<\/span> override<\/span> <\/span>{\n        return<\/span> children.at(index);\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><Component*> children;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Component* leaf1 = new<\/span> Leaf();\n    Component* leaf2 = new<\/span> Leaf();\n    Component* composite = new<\/span> Composite();\n\n    composite->add(leaf1);\n    composite->add(leaf2);\n\n    composite->operation();\n\n    delete<\/span> composite;\n    delete<\/span> leaf2;\n    delete<\/span> leaf1;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Proxy<\/h3>\n\n\n\n
          The Proxy pattern provides a surrogate or placeholder for another object to control access to it.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Subject interface<\/span>\nclass<\/span> Subject<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> request<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Subject() = default<\/span>;\n};\n\n\/\/ RealSubject class<\/span>\nclass<\/span> RealSubject<\/span> :<\/span> public<\/span> Subject {\npublic<\/span>:\n    void<\/span> request<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"RealSubject request\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Proxy class<\/span>\nclass<\/span> Proxy<\/span> :<\/span> public<\/span> Subject {\npublic<\/span>:\n    Proxy(RealSubject* realSubject) : realSubject(realSubject) {}\n\n    void<\/span> request<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Proxy request\"<\/span> << std<\/span>::endl<\/span>;\n        realSubject->request();\n    }\n\nprivate<\/span>:\n    RealSubject* realSubject;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    RealSubject* realSubject = new<\/span> RealSubject();\n    Proxy* proxy = new<\/span> Proxy(realSubject);\n\n    proxy->request();\n\n    delete<\/span> proxy;\n    delete<\/span> realSubject;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Flyweight<\/h3>\n\n\n\n
          The Flyweight pattern is used to minimize memory usage or computational expenses by sharing as much as possible with similar objects.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <unordered_map><\/span><\/span>\n\n\/\/ Flyweight interface<\/span>\nclass<\/span> Flyweight<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> operation<\/span>(int<\/span> extrinsicState)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Flyweight() = default<\/span>;\n};\n\n\/\/ ConcreteFlyweight class<\/span>\nclass<\/span> ConcreteFlyweight<\/span> :<\/span> public<\/span> Flyweight {\npublic<\/span>:\n    void<\/span> operation<\/span>(int<\/span> extrinsicState)<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteFlyweight: \"<\/span> << extrinsicState << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ FlyweightFactory class<\/span>\nclass<\/span> FlyweightFactory<\/span> {<\/span>\npublic<\/span>:\n    Flyweight* getFlyweight<\/span>(const<\/span> std<\/span>::string<\/span>& key)<\/span> <\/span>{\n        if<\/span> (flyweights.find(key) == flyweights.end()) {\n            flyweights[key] = new<\/span> ConcreteFlyweight();\n        }\n        return<\/span> flyweights[key];\n    }\n\n    ~FlyweightFactory() {\n        for<\/span> (auto<\/span>& pair : flyweights) {\n            delete<\/span> pair.second;\n        }\n    }\n\nprivate<\/span>:\n    std<\/span>::unordered_map<\/span><std<\/span>::string<\/span>, Flyweight*> flyweights;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    FlyweightFactory factory;\n\n    Flyweight* flyweight1 = factory.getFlyweight(\"key1\"<\/span>);\n    Flyweight* flyweight2 = factory.getFlyweight(\"key2\"<\/span>);\n    Flyweight* flyweight3 = factory.getFlyweight(\"key1\"<\/span>);\n\n    flyweight1->operation(1<\/span>);\n    flyweight2->operation(2<\/span>);\n    flyweight3->operation(3<\/span>);\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Facade<\/h3>\n\n\n\n
          The Facade pattern provides a simplified interface to a complex subsystem.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Subsystem 1<\/span>\nclass<\/span> Subsystem1<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> operation1<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Subsystem1 operation1\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Subsystem 2<\/span>\nclass<\/span> Subsystem2<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> operation2<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Subsystem2 operation2\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Facade class<\/span>\nclass<\/span> Facade<\/span> {<\/span>\npublic<\/span>:\n    Facade() : subsystem1(new<\/span> Subsystem1()), subsystem2(new<\/span> Subsystem2()) {}\n\n    ~Facade() {\n        delete<\/span> subsystem1;\n        delete<\/span> subsystem2;\n    }\n\n    void<\/span> operation<\/span>()<\/span> <\/span>{\n        subsystem1->operation1();\n        subsystem2->operation2();\n    }\n\nprivate<\/span>:\n    Subsystem1* subsystem1;\n    Subsystem2* subsystem2;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Facade facade;\n    facade.operation();\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Bridge<\/h3>\n\n\n\n
          The Bridge pattern decouples an abstraction from its implementation so that the two can vary independently.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Implementor interface<\/span>\nclass<\/span> Implementor<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> operationImpl<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Implementor() = default<\/span>;\n};\n\n\/\/ Concrete Implementor A<\/span>\nclass<\/span> ConcreteImplementorA<\/span> :<\/span> public<\/span> Implementor {\npublic<\/span>:\n    void<\/span> operationImpl<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteImplementorA operation\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Implementor B<\/span>\nclass<\/span> ConcreteImplementorB<\/span> :<\/span> public<\/span> Implementor {\npublic<\/span>:\n    void<\/span> operationImpl<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteImplementorB operation\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Abstraction class<\/span>\nclass<\/span> Abstraction<\/span> {<\/span>\npublic<\/span>:\n    Abstraction(Implementor* impl) : implementor(impl) {}\n\n    virtual<\/span> void<\/span> operation<\/span>()<\/span> <\/span>{\n        implementor->operationImpl();\n    }\n\nprotected<\/span>:\n    Implementor* implementor;\n};\n\n\/\/ Refined Abstraction class<\/span>\nclass<\/span> RefinedAbstraction<\/span> :<\/span> public<\/span> Abstraction {\npublic<\/span>:\n    RefinedAbstraction(Implementor* impl) : Abstraction(impl) {}\n\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        implementor->operationImpl();\n        std<\/span>::cout<\/span> << \"RefinedAbstraction operation\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Implementor* implA = new<\/span> ConcreteImplementorA();\n    Abstraction* abstractionA = new<\/span> RefinedAbstraction(implA);\n\n    abstractionA->operation();\n\n    delete<\/span> abstractionA;\n    delete<\/span> implA;\n\n    Implementor* implB = new<\/span> ConcreteImplementorB();\n    Abstraction* abstractionB = new<\/span> RefinedAbstraction(implB);\n\n    abstractionB->operation();\n\n    delete<\/span> abstractionB;\n    delete<\/span> implB;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Decorator<\/h3>\n\n\n\n
          The Decorator pattern allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Component interface<\/span>\nclass<\/span> Component<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> operation<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Component() = default<\/span>;\n};\n\n\/\/ Concrete Component<\/span>\nclass<\/span> ConcreteComponent<\/span> :<\/span> public<\/span> Component {\npublic<\/span>:\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteComponent operation\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Decorator class<\/span>\nclass<\/span> Decorator<\/span> :<\/span> public<\/span> Component {\npublic<\/span>:\n    Decorator(Component* component) : component(component) {}\n\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        component->operation();\n    }\n\nprotected<\/span>:\n    Component* component;\n};\n\n\/\/ Concrete Decorator A<\/span>\nclass<\/span> ConcreteDecoratorA<\/span> :<\/span> public<\/span> Decorator {\npublic<\/span>:\n    ConcreteDecoratorA(Component* component) : Decorator(component) {}\n\n    void<\/span> operation<\/span>()<\/span> override<\/span> <\/span>{\n        Decorator::operation();\n        addedBehavior();\n    }\n\nprivate<\/span>:\n    void<\/span> addedBehavior<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteDecoratorA added behavior\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Decorator B<\/span>\nclass<\/span> ConcreteDecoratorB<\/span> :<\/span> public<\/span> Decorator {\npublic<\/span>:\n    ConcreteDecoratorB(Component* component) : Decorator(component) {}\n\n    void<\/span> operation<\/span>()<\/span> override<\/span>\n\n <\/span>{\n        Decorator::operation();\n        addedBehavior();\n    }\n\nprivate<\/span>:\n    void<\/span> addedBehavior<\/span>()<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteDecoratorB added behavior\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Component* component = new<\/span> ConcreteComponent();\n    Component* decoratorA = new<\/span> ConcreteDecoratorA(component);\n    Component* decoratorB = new<\/span> ConcreteDecoratorB(decoratorA);\n\n    decoratorB->operation();\n\n    delete<\/span> decoratorB;\n    delete<\/span> decoratorA;\n    delete<\/span> component;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          3. Behavioral Patterns<\/h2>\n\n\n\n
          Strategy<\/h3>\n\n\n\n
          The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. It lets the algorithm vary independently from clients that use it.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Strategy interface<\/span>\nclass<\/span> Strategy<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> algorithmInterface<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Strategy() = default<\/span>;\n};\n\n\/\/ Concrete Strategy A<\/span>\nclass<\/span> ConcreteStrategyA<\/span> :<\/span> public<\/span> Strategy {\npublic<\/span>:\n    void<\/span> algorithmInterface<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteStrategyA algorithm\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Strategy B<\/span>\nclass<\/span> ConcreteStrategyB<\/span> :<\/span> public<\/span> Strategy {\npublic<\/span>:\n    void<\/span> algorithmInterface<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteStrategyB algorithm\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Context class<\/span>\nclass<\/span> Context<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> setStrategy<\/span>(Strategy* strategy)<\/span> <\/span>{\n        this<\/span>->strategy = strategy;\n    }\n\n    void<\/span> executeStrategy<\/span>()<\/span> <\/span>{\n        strategy->algorithmInterface();\n    }\n\nprivate<\/span>:\n    Strategy* strategy;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Context context;\n\n    Strategy* strategyA = new<\/span> ConcreteStrategyA();\n    Strategy* strategyB = new<\/span> ConcreteStrategyB();\n\n    context.setStrategy(strategyA);\n    context.executeStrategy();\n\n    context.setStrategy(strategyB);\n    context.executeStrategy();\n\n    delete<\/span> strategyA;\n    delete<\/span> strategyB;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Observer<\/h3>\n\n\n\n
          The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n#include<\/span> <algorithm><\/span><\/span>\n\n\/\/ Observer interface<\/span>\nclass<\/span> Observer<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> update<\/span>(int<\/span> state)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Observer() = default<\/span>;\n};\n\n\/\/ Subject class<\/span>\nclass<\/span> Subject<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> attach<\/span>(Observer* observer)<\/span> <\/span>{\n        observers.push_back(observer);\n    }\n\n    void<\/span> detach<\/span>(Observer* observer)<\/span> <\/span>{\n        observers.erase(std<\/span>::remove(observers.begin(), observers.end(), observer), observers.end());\n    }\n\n    void<\/span> notify<\/span>()<\/span> <\/span>{\n        for<\/span> (Observer* observer : observers) {\n            observer->update(state);\n        }\n    }\n\n    void<\/span> setState<\/span>(int<\/span> state)<\/span> <\/span>{\n        this<\/span>->state = state;\n        notify();\n    }\n\n    int<\/span> getState<\/span>()<\/span> const<\/span> <\/span>{\n        return<\/span> state;\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><Observer*> observers;\n    int<\/span> state;\n};\n\n\/\/ Concrete Observer A<\/span>\nclass<\/span> ConcreteObserverA<\/span> :<\/span> public<\/span> Observer {\npublic<\/span>:\n    void<\/span> update<\/span>(int<\/span> state)<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteObserverA: \"<\/span> << state << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Observer B<\/span>\nclass<\/span> ConcreteObserverB<\/span> :<\/span> public<\/span> Observer {\npublic<\/span>:\n    void<\/span> update<\/span>(int<\/span> state)<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteObserverB: \"<\/span> << state << std<\/span>::endl<\/span>;\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Subject subject;\n\n    Observer* observerA = new<\/span> ConcreteObserverA();\n    Observer* observerB = new<\/span> ConcreteObserverB();\n\n    subject.attach(observerA);\n    subject.attach(observerB);\n\n    subject.setState(1<\/span>);\n    subject.setState(2<\/span>);\n\n    subject.detach(observerA);\n    subject.setState(3<\/span>);\n\n    delete<\/span> observerA;\n    delete<\/span> observerB;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Command<\/h3>\n\n\n\n
          The Command pattern encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n\n\/\/ Command interface<\/span>\nclass<\/span> Command<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> execute<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Command() = default<\/span>;\n};\n\n\/\/ Concrete Command<\/span>\nclass<\/span> ConcreteCommand<\/span> :<\/span> public<\/span> Command {\npublic<\/span>:\n    ConcreteCommand(int<\/span> payload) : payload(payload) {}\n\n    void<\/span> execute<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"Executing command with payload: \"<\/span> << payload << std<\/span>::endl<\/span>;\n    }\n\nprivate<\/span>:\n    int<\/span> payload;\n};\n\n\/\/ Invoker class<\/span>\nclass<\/span> Invoker<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> setCommand<\/span>(Command* command)<\/span> <\/span>{\n        this<\/span>->command = command;\n    }\n\n    void<\/span> executeCommand<\/span>()<\/span> <\/span>{\n        if<\/span> (command) {\n            command->execute();\n        }\n    }\n\nprivate<\/span>:\n    Command* command = nullptr<\/span>;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Invoker invoker;\n\n    Command* command1 = new<\/span> ConcreteCommand(10<\/span>);\n    Command* command2 = new<\/span> ConcreteCommand(20<\/span>);\n\n    invoker.setCommand(command1);\n    invoker.executeCommand();\n\n    invoker.setCommand(command2);\n    invoker.executeCommand();\n\n    delete<\/span> command1;\n    delete<\/span> command2;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Chain of Responsibility<\/h3>\n\n\n\n
          The Chain of Responsibility pattern avoids coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Handler interface<\/span>\nclass<\/span> Handler<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> setNext<\/span>(Handler* next)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> handleRequest<\/span>(int<\/span> request)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Handler() = default<\/span>;\n};\n\n\/\/ Abstract Handler<\/span>\nclass<\/span> AbstractHandler<\/span> :<\/span> public<\/span> Handler {\npublic<\/span>:\n    AbstractHandler() : nextHandler(nullptr<\/span>) {}\n\n    void<\/span> setNext<\/span>(Handler* next)<\/span> override<\/span> <\/span>{\n        nextHandler = next;\n    }\n\n    void<\/span> handleRequest<\/span>(int<\/span> request)<\/span> override<\/span> <\/span>{\n        if<\/span> (nextHandler) {\n            nextHandler->handleRequest(request);\n        } else<\/span> {\n            std<\/span>::cout<\/span> << \"Request \"<\/span> << request << \" unhandled\"<\/span> << std<\/span>::endl<\/span>;\n        }\n    }\n\nprotected<\/span>:\n    Handler* nextHandler;\n};\n\n\/\/ Concrete Handler 1<\/span>\nclass<\/span> ConcreteHandler1<\/span> :<\/span> public<\/span> AbstractHandler {\npublic<\/span>:\n    void<\/span> handleRequest<\/span>(int<\/span> request)<\/span> override<\/span> <\/span>{\n        if<\/span> (request < 10<\/span>) {\n            std<\/span>::cout<\/span> << \"ConcreteHandler1 handled request \"<\/span> << request << std<\/span>::endl<\/span>;\n        } else<\/span> {\n            AbstractHandler::handleRequest(request);\n        }\n    }\n};\n\n\/\/ Concrete Handler 2<\/span>\nclass<\/span> ConcreteHandler2<\/span> :<\/span> public<\/span> AbstractHandler {\npublic<\/span>:\n    void<\/span> handleRequest<\/span>(int<\/span> request)<\/span> override<\/span> <\/span>{\n        if<\/span> (request >= 10<\/span> && request < 20<\/span>) {\n            std<\/span>::cout<\/span> << \"ConcreteHandler2 handled request \"<\/span> << request << std<\/span>::endl<\/span>;\n        } else<\/span> {\n            AbstractHandler::handleRequest(request);\n        }\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Handler* handler1 = new<\/span> ConcreteHandler1();\n    Handler* handler2 = new<\/span> ConcreteHandler2();\n\n    handler1->setNext(handler2);\n\n    handler1->handleRequest(5<\/span>);\n    handler1->handleRequest(15<\/span>);\n    handler1->handleRequest(25<\/span>);\n\n    delete<\/span> handler1;\n    delete<\/span> handler2;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          State<\/h3>\n\n\n\n
          The State pattern allows an object to alter its behavior when its internal state changes. The object will appear to change its class.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Context class<\/span>\nclass<\/span> Context<\/span>;<\/span>\n\n\/\/ State interface<\/span>\nclass<\/span> State<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> handle<\/span>(Context* context)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~State() = default<\/span>;\n};\n\n\/\/ Concrete State A<\/span>\nclass<\/span> ConcreteStateA<\/span> :<\/span> public<\/span> State {\npublic<\/span>:\n    void<\/span> handle<\/span>(Context* context)<\/span> override<\/span><\/span>;\n\n    static<\/span> ConcreteStateA* getInstance<\/span>()<\/span> <\/span>{\n        static<\/span> ConcreteStateA instance;\n        return<\/span> &instance;\n    }\n};\n\n\/\/ Concrete State B<\/span>\nclass<\/span> ConcreteStateB<\/span> :<\/span> public<\/span> State {\npublic<\/span>:\n    void<\/span> handle<\/span>(Context* context)<\/span> override<\/span><\/span>;\n\n    static<\/span> ConcreteStateB* getInstance<\/span>()<\/span> <\/span>{\n        static<\/span> ConcreteStateB instance;\n        return<\/span> &instance;\n    }\n};\n\n\/\/ Context class<\/span>\nclass<\/span> Context<\/span> {<\/span>\npublic<\/span>:\n    Context() : state(ConcreteStateA::getInstance()) {}\n\n    void<\/span> setState<\/span>(State* state)<\/span> <\/span>{\n        this<\/span>->state = state;\n    }\n\n    void<\/span> request<\/span>()<\/span> <\/span>{\n        state->handle(this<\/span>);\n    }\n\nprivate<\/span>:\n    State* state;\n};\n\nvoid<\/span> ConcreteStateA::handle<\/span>(Context* context)<\/span> <\/span>{\n    std<\/span>::cout<\/span> << \"ConcreteStateA handling request\"<\/span> << std<\/span>::endl<\/span>;\n    context->setState(ConcreteStateB::getInstance());\n}\n\nvoid<\/span> ConcreteStateB::handle<\/span>(Context* context)<\/span> <\/span>{\n    std<\/span>::cout<\/span> << \"ConcreteStateB handling request\"<\/span> << std<\/span>::endl<\/span>;\n    context->setState(ConcreteStateA::getInstance());\n}\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Context context;\n\n    context.request();\n    context.request();\n    context.request();\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Template Method<\/h3>\n\n\n\n
          The Template Method pattern defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. It lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n\n\/\/ Abstract Class<\/span>\nclass<\/span> AbstractClass<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> templateMethod<\/span>()<\/span> <\/span>{\n        primitiveOperation1();\n        primitiveOperation2();\n    }\n\nprotected<\/span>:\n    virtual<\/span> void<\/span> primitiveOperation1<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> void<\/span> primitiveOperation2<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~AbstractClass() = default<\/span>;\n};\n\n\/\/ Concrete Class<\/span>\nclass<\/span> ConcreteClass<\/span> :<\/span> public<\/span> AbstractClass {\nprotected<\/span>:\n    void<\/span> primitiveOperation1<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteClass primitiveOperation1\"<\/span> << std<\/span>::endl<\/span>;\n    }\n\n    void<\/span> primitiveOperation2<\/span>()<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteClass primitiveOperation2\"<\/span> << std<\/span>::endl<\/span>;\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    AbstractClass* instance = new<\/span> ConcreteClass();\n    instance->templateMethod();\n\n    delete<\/span> instance;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Iterator<\/h3>\n\n\n\n
          The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation.<\/p>\n\n\n\n
          Implementation<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n\n\/\/ Iterator interface<\/span>\ntemplate<\/span> <typename<\/span> T>\nclass<\/span> Iterator<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> bool<\/span> hasNext<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> T next<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Iterator() = default<\/span>;\n};\n\n\/\/ Concrete Iterator<\/span>\ntemplate<\/span> <typename<\/span> T>\nclass<\/span> ConcreteIterator<\/span> :<\/span> public<\/span> Iterator<T> {\npublic<\/span>:\n    ConcreteIterator(const<\/span> std<\/span>::vector<\/span><T>& collection) : collection(collection), index(0<\/span>) {}\n\n    bool<\/span> hasNext<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> index < collection.size();\n    }\n\n    T next<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> collection[index++];\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><T> collection;\n    size_t<\/span> index;\n};\n\n\/\/ Aggregate interface<\/span>\ntemplate<\/span> <typename<\/span> T>\nclass<\/span> Aggregate<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> Iterator<T>* createIterator<\/span>()<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Aggregate() = default<\/span>;\n};\n\n\/\/ Concrete Aggregate<\/span>\ntemplate<\/span> <typename<\/span> T>\nclass<\/span> ConcreteAggregate<\/span> :<\/span> public<\/span> Aggregate<T> {\npublic<\/span>:\n    ConcreteAggregate(const<\/span> std<\/span>::vector<\/span><T>& collection) : collection(collection) {}\n\n    Iterator<T>* createIterator<\/span>()<\/span> override<\/span> <\/span>{\n        return<\/span> new<\/span> ConcreteIterator<T>(collection);\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><T> collection;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    std<\/span>::vector<\/span><int<\/span>> collection = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>};\n    Aggregate<int<\/span>>* aggregate = new<\/span> ConcreteAggregate<int<\/span>>(collection);\n\n    Iterator<int<\/span>>* iterator = aggregate->createIterator();\n    while<\/span> (iterator->hasNext()) {\n        std<\/span>::cout<\/span> << iterator->next() << \" \"<\/span>;\n    }\n\n    delete<\/span> iterator;\n    delete<\/span> aggregate;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Mediator<\/h3>\n\n\n\n
          The Mediator pattern defines an object that encapsulates how a set of objects interact. It promotes loose coupling by keeping objects from referring to each other explicitly and lets you vary their interaction independently.<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <string><\/span><\/span>\n#include<\/span> <vector><\/span><\/span>\n\nclass<\/span> Colleague<\/span>;<\/span>\n\n\/\/ Mediator interface<\/span>\nclass<\/span> Mediator<\/span> {<\/span>\npublic<\/span>:\n    virtual<\/span> void<\/span> send<\/span>(const<\/span> std<\/span>::string<\/span>& message, Colleague* colleague)<\/span> <\/span>= 0<\/span>;\n    virtual<\/span> ~Mediator() = default<\/span>;\n};\n\n\/\/ Colleague class<\/span>\nclass<\/span> Colleague<\/span> {<\/span>\npublic<\/span>:\n    Colleague(Mediator* mediator) : mediator(mediator) {}\n\n    virtual<\/span> void<\/span> send<\/span>(const<\/span> std<\/span>::string<\/span>& message)<\/span> <\/span>{\n        mediator->send(message, this<\/span>);\n    }\n\n    virtual<\/span> void<\/span> receive<\/span>(const<\/span> std<\/span>::string<\/span>& message)<\/span> <\/span>= 0<\/span>;\n\nprotected<\/span>:\n    Mediator* mediator;\n};\n\n\/\/ Concrete Mediator<\/span>\nclass<\/span> ConcreteMediator<\/span> :<\/span> public<\/span> Mediator {\npublic<\/span>:\n    void<\/span> addColleague<\/span>(Colleague* colleague)<\/span> <\/span>{\n        colleagues.push_back(colleague);\n    }\n\n    void<\/span> send<\/span>(const<\/span> std<\/span>::string<\/span>& message, Colleague* sender)<\/span> override<\/span> <\/span>{\n        for<\/span> (Colleague* colleague : colleagues) {\n            if<\/span> (colleague != sender) {\n                colleague->receive(message);\n            }\n        }\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><Colleague*> colleagues;\n};\n\n\/\/ Concrete Colleague 1<\/span>\nclass<\/span> ConcreteColleague1<\/span> :<\/span> public<\/span> Colleague {\npublic<\/span>:\n    using<\/span> Colleague::Colleague;\n\n    void<\/span> receive<\/span>(const<\/span> std<\/span>::string<\/span>& message)<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteColleague1 received: \"<\/span> << message << std<\/span>::endl<\/span>;\n    }\n};\n\n\/\/ Concrete Colleague 2<\/span>\nclass<\/span> ConcreteColleague2<\/span> :<\/span> public<\/span> Colleague {\npublic<\/span>:\n    using<\/span> Colleague::Colleague;\n\n    void<\/span> receive<\/span>(const<\/span> std<\/span>::string<\/span>& message)<\/span> override<\/span> <\/span>{\n        std<\/span>::cout<\/span> << \"ConcreteColleague2 received: \"<\/span> << message << std<\/span>::endl<\/span>;\n    }\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    ConcreteMediator mediator;\n\n    ConcreteColleague1* colleague1 = new<\/span> ConcreteColleague1(&mediator);\n    ConcreteColleague2* colleague2 = new<\/span> ConcreteColleague2(&mediator);\n\n    mediator.addColleague(colleague1);\n    mediator.addColleague(colleague2);\n\n    colleague1->send(\"Hello from Colleague1\"<\/span>);\n    colleague2->send(\"Hello from Colleague2\"<\/span>);\n\n    delete<\/span> colleague1;\n    delete<\/span> colleague2;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Memento<\/h3>\n\n\n\n
          The Memento pattern provides the ability to restore an object to its previous state (undo via rollback).<\/p>\n\n\n\n
          Implementation:<\/strong><\/p>\n\n\n
          #include<\/span> <iostream><\/span><\/span>\n#include<\/span> <string><\/span><\/span>\n\n\/\/ Memento class<\/span>\nclass<\/span> Memento<\/span> {<\/span>\npublic<\/span>:\n    Memento(const<\/span> std<\/span>::string<\/span>& state) : state(state) {}\n\n    std<\/span>::string<\/span> getState<\/span>()<\/span> const<\/span> <\/span>{\n        return<\/span> state;\n    }\n\nprivate<\/span>:\n    std<\/span>::string<\/span> state;\n};\n\n\/\/ Originator class<\/span>\nclass<\/span> Originator<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> setState<\/span>(const<\/span> std<\/span>::string<\/span>& state)<\/span> <\/span>{\n        this<\/span>->state = state;\n        std<\/span>::cout<\/span> << \"State set to: \"<\/span> << state << std<\/span>::endl<\/span>;\n    }\n\n    std<\/span>::string<\/span> getState<\/span>()<\/span> const<\/span> <\/span>{\n        return<\/span> state;\n    }\n\n    Memento* saveStateToMemento<\/span>()<\/span> <\/span>{\n        return<\/span> new<\/span> Memento(state);\n    }\n\n    void<\/span> getStateFromMemento<\/span>(Memento* memento)<\/span> <\/span>{\n        state = memento->getState();\n    }\n\nprivate<\/span>:\n    std<\/span>::string<\/span> state;\n};\n\n\/\/ Caretaker class<\/span>\nclass<\/span> Caretaker<\/span> {<\/span>\npublic<\/span>:\n    void<\/span> addMemento<\/span>(Memento* memento)<\/span> <\/span>{\n        mementos.push_back(memento);\n    }\n\n    Memento* getMemento<\/span>(int<\/span> index)<\/span> <\/span>{\n        return<\/span> mementos[index];\n    }\n\n    ~Caretaker() {\n        for<\/span> (Memento* memento : mementos) {\n            delete<\/span> memento;\n        }\n    }\n\nprivate<\/span>:\n    std<\/span>::vector<\/span><Memento*> mementos;\n};\n\nint<\/span> main<\/span>()<\/span> <\/span>{\n    Originator originator;\n    Caretaker caretaker;\n\n    originator.setState(\"State1\"<\/span>);\n    caretaker.addMemento(originator.saveStateToMemento());\n\n    originator.setState(\"State2\"<\/span>);\n    caretaker.addMemento(originator.saveStateToMemento());\n\n    originator.setState(\"State3\"<\/span>);\n\n    originator.getStateFromMemento(caretaker.getMemento(0<\/span>));\n    std<\/span>::cout<\/span> << \"First saved state: \"<\/span> << originator.getState() << std<\/span>::endl<\/span>;\n\n    originator.getStateFromMemento(caretaker.getMemento(1<\/span>));\n    std<\/span>::cout<\/span> << \"Second saved state: \"<\/span> << originator.getState() << std<\/span>::endl<\/span>;\n\n    return<\/span> 0<\/span>;\n}<\/code><\/span>Code language:<\/span> C++<\/span> (<\/span>cpp<\/span>)<\/span><\/small><\/pre>\n\n\n
          Conclusion<\/h2>\n\n\n\n
          Design patterns are an essential toolkit for any software developer. They provide tested, proven development paradigms that enhance code readability, maintainability, and reusability. In this tutorial, we’ve covered various creational, structural, and behavioral design patterns, explaining their concepts and providing C++ implementations.<\/p>\n\n\n\n
          As you continue to grow as a developer, you’ll find that understanding and applying these patterns will help you solve complex design problems more efficiently. Practice implementing these patterns in your projects, and you’ll gain a deeper insight into their practical benefits and usage.<\/p>\n","protected":false},"excerpt":{"rendered":"
          Introduction Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced object-oriented software developers. Design patterns are like pre-defined blueprints that can be customized to solve recurring design problems in various contexts. In this tutorial, we will explore several fundamental design patterns and implement them in […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[9,4],"tags":[],"class_list":["post-1961","post","type-post","status-publish","format-standard","category-cplusplus","category-programming-languages","entry"],"yoast_head":"\nHow to Implement Design Patterns in C++<\/title>\n<meta name=\"description\" content=\"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to Implement Design Patterns in C++\" \/>\n<meta property=\"og:description\" content=\"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/\" \/>\n<meta property=\"article:published_time\" content=\"2024-06-22T09:39:09+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-06-22T23:32:54+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"How to Implement Design Patterns in C++\",\"datePublished\":\"2024-06-22T09:39:09+00:00\",\"dateModified\":\"2024-06-22T23:32:54+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/\"},\"wordCount\":761,\"articleSection\":[\"C++\",\"Programming Languages\"],\"inLanguage\":\"en-US\"},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/\",\"name\":\"How to Implement Design Patterns in C++\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2024-06-22T09:39:09+00:00\",\"dateModified\":\"2024-06-22T23:32:54+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/how-to-implement-design-patterns-in-cpp\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"How to Implement Design Patterns in C++\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"How to Implement Design Patterns in C++","description":"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/","og_locale":"en_US","og_type":"article","og_title":"How to Implement Design Patterns in C++","og_description":"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced","og_url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/","article_published_time":"2024-06-22T09:39:09+00:00","article_modified_time":"2024-06-22T23:32:54+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"How to Implement Design Patterns in C++","datePublished":"2024-06-22T09:39:09+00:00","dateModified":"2024-06-22T23:32:54+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/"},"wordCount":761,"articleSection":["C++","Programming Languages"],"inLanguage":"en-US"},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/","url":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/","name":"How to Implement Design Patterns in C++","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2024-06-22T09:39:09+00:00","dateModified":"2024-06-22T23:32:54+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"Design patterns are typical solutions to commonly occurring problems in software design. They represent best practices used by experienced","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/how-to-implement-design-patterns-in-cpp\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"How to Implement Design Patterns in C++"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1961","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1961"}],"version-history":[{"count":2,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1961\/revisions"}],"predecessor-version":[{"id":1974,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1961\/revisions\/1974"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1961"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1961"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1961"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}