init

Signed-off-by: Jean-Michel Batto <jean-michel.batto@eldarsoft.com>

23patterns-cplusplus/Abstract_Factory.cpp

@@ -0,0 +1,94 @@
+/*
+ * C++ Design Patterns: ABSTRACT FACTORY
+ * http://www.plantuml.com/plantuml/uml/VP51ojim48NtEiN0lqXBCARRO4piG9PjIBFfKfQdZOeifQDnmRIzIvVrENonIgeJ-XiJGMBptZVFevczPqdSTqRa6wZgZvTpTRZ0CVnzE7-2JIx2KKPw3mUZqR8GsZBIPwaGgiOpISN7y7Cqm0y1uRo08fIC9t9jhxXwytPDheFywn7jh29aV1sqNG_QhWMjT3Nx8Um5lEkGhzf-cSN_FtwF3-1s7LoGzHFogbi4x6uyG8TTW-I5M8wf-9bbookBPTSHUhJsrAt5lyr0bfNBbQnPSvaGrZ62zF3-NPfhqPI5SiRHZjmWJMrwBEyrCESLUIBA8c_AUz5bkE4k2d28Uz7EIfEy4rA734Q2ecbC3hGRrtn5zl2jrmdopWP4JwE7wJUqw27DEZwTjJtwH25349sQnc1uQJt8xqvJB348Dvf6fJrIOjje6-nfJef1YgO_Z09j2_7MOX_U-ixy1G00
+ * 2021 / JMB
+ *
+ */
+
+
+#include <iostream>
+
+class AbstractProductA {
+public:
+  AbstractProductA() { std::cout << "AbstractProductA instancied" << std::endl; }
+  virtual ~AbstractProductA() {}
+  virtual void somethingProduct() = 0;
+};
+
+class AbstractProductB {
+public:
+  AbstractProductB() { std::cout << "AbstractProductB instancied" << std::endl; }
+  virtual  ~AbstractProductB() {}
+  virtual void somethingProduct() = 0;
+};
+
+class ProductA1 : public AbstractProductA {
+public:
+  ProductA1() { std::cout << "ProductA1 instancied" << std::endl; }
+  ~ProductA1() {}
+  void somethingProduct() { std::cout << "ProductA1 has been created" << std::endl;}
+
+};
+
+class ProductA2 : public AbstractProductA {
+public:
+  ProductA2() { std::cout << "ProductA2 instancied" << std::endl; }
+  ~ProductA2() {}
+  void somethingProduct() { std::cout << "ProductA2 has been created" << std::endl; }
+
+};
+
+class ProductB1 : public AbstractProductB {
+public:
+  ProductB1() { std::cout << "ProductB1 instancied" << std::endl; }
+  ~ProductB1() {}
+  void somethingProduct() { std::cout << "ProductB1 has been created" << std::endl; }
+
+};
+
+class ProductB2 : public AbstractProductB {
+public:
+  ProductB2() { std::cout << "ProductB2 instancied" << std::endl; }
+  ~ProductB2() {}
+  void somethingProduct() { std::cout << "ProductB2 has been created" << std::endl; }
+
+};
+
+class AbstractFactory {
+public:
+  AbstractFactory() { std::cout << "AbstractFactory instancied" << std::endl; }
+  virtual ~AbstractFactory() {}
+  virtual AbstractProductA* createProductA() = 0;
+  virtual AbstractProductB* createProductB() = 0;
+};
+
+class ConcreateFactory1 : public AbstractFactory {
+public:
+  ConcreateFactory1() { std::cout << "ConcreateFactory1 instancied" << std::endl; }
+  ~ConcreateFactory1() {}
+  AbstractProductA* createProductA() { return new ProductA1; }
+  AbstractProductB* createProductB() { return new ProductB1; }
+};
+
+class ConcreateFactory2 : public AbstractFactory {
+public:
+  ConcreateFactory2() { std::cout << "ConcreateFactory2 instancied" << std::endl; }
+  ~ConcreateFactory2() {}
+  AbstractProductA* createProductA() { return new ProductA2; }
+  AbstractProductB* createProductB() { return new ProductB2; }
+};
+
+int main(int argc, char* argv[]) {
+  AbstractFactory* cf1 = new ConcreateFactory1();
+  AbstractProductA* productA1 = cf1->createProductA();
+  productA1->somethingProduct();
+  AbstractProductB* productB1 = cf1->createProductB();
+  productB1->somethingProduct();
+
+  AbstractFactory* cf2 = new ConcreateFactory2();
+  AbstractProductA* productA2 = cf2->createProductA();
+  productA2->somethingProduct();
+  AbstractProductB* productB2 = cf1->createProductB();
+  productB2->somethingProduct();
+
+}

23patterns-cplusplus/Adapter.cpp

@@ -0,0 +1,61 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: ADAPTER
+ * http://www.plantuml.com/plantuml/uml/XP9DRi8m48NtFiL8NG2gGaIMA8g0jhkggYXxD76cgYl7Zkm94lsvIxUSWulL3I652BMpchpvdbzipSmpEgvBBU81p6_dZwkx9GnY4KeP9lUCac1UO1LwU1SGwWfiHGvPMJCSYKyXf4RluKOhCjmorr3OjMoKzMNQ6kc8wVpegAyFbMdJQJBw5qb6RVYboEwSuozsmaAzeNDqWKtwR7B6YXTL451PyHPAAdDoNeZZZTAeVP9VvIEAkj1pjNSdqVk6AEkCVymI8Onb0lJmC14GAispL5fjtTJPBUg5hYbhVMdS3B8qphCZkzfMDFqHu8bTBRbsg9lPShz3hJn1RGYaDHjoNbaJsh92Lhacm0r9Q61D7f2P38UcgE6m1sEunnDhGnO1wDRC0ta6TqZQxmZsNw07odX68nNogSdchyH-BCWKO2oJc8MkBlKt
+ *
+ */
+
+
+#include <iostream>
+#include <string>
+#include <functional>
+
+/* Legacy code -------------------------------------------------------------- */
+
+struct Adapter {
+    Adapter() { std::cout << "Constructor Adapter" << std::endl;}
+    virtual void operation() = 0;
+};
+
+struct Adaptee1 : Adapter {
+    void Adaptee1Bizarre() { std::cout << "perform Adaptee1Bizarre" << std::endl;}
+    void operation() { Adaptee1Bizarre(); }
+};
+
+//exported interface to the client
+class Client {
+public:
+    void do_client_operation(Adapter &do_client){
+    std::cout << "do_client operation()" << std::endl;
+    do_client.operation();                // Interface from Adapter
+};
+};
+
+// Evolution with ConcreteAdapter & Adaptee2
+
+struct Adaptee2 {                     // Introduced later on - don't call Adapter Constructor
+    void Adaptee2Bizarre() { std::cout << "perform Adaptee2Bizarre" << std::endl; }
+    //void operation() { Adaptee2Bizarre(); }
+};
+
+struct ConcreteAdapter : Adapter {              // Expanding Adapter with lambda function
+    std::function<void()>    m_request;
+    //lambda function, copy cm in m_request and call specific adaptee operation
+    ConcreteAdapter(Adaptee1* cm1) { m_request = [cm1] ( ) {  std::cout << "lambda cm1" << std::endl; cm1->Adaptee1Bizarre(); }; }
+    ConcreteAdapter(Adaptee2* cm2) { m_request = [cm2] ( ) { std::cout << "lambda cm2" << std::endl; cm2->Adaptee2Bizarre(); }; }
+    void operation() { m_request(); }
+};
+
+int main() {
+    Client client;
+    std::cout << "new Adaptee1" << std::endl;
+    ConcreteAdapter adp1(new Adaptee1());
+    client.do_client_operation(adp1);
+    std::cout << "new Adaptee2" << std::endl;
+    ConcreteAdapter adp2(new Adaptee2());
+    client.do_client_operation(adp2);
+}
+
+
+

23patterns-cplusplus/Bridge.cpp

@@ -0,0 +1,76 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: BRIDGE
+ * http://www.plantuml.com/plantuml/uml/bP7DIiD04CVl-nG37jegDUYnXD36YlJYGRtBTZDAO3-MsTb2KHyepv4NSxEO4b14zvBX_n5-mwm3I-9ej2XcK3_ijdUtC2j4UahB462p3qnISUiil0b8xmoSHvA3CbzaPGcU7ADYR9vRupKQj9m3C3zbTyOln8SGhMMa5waGTcFKqVTV9tEUyYF6ZREAa77IsNoLBlvJgdyfJLSzNowdV6BAMhudyoUWFwLg8QnZ11dW_YgpbFkgL4uxMf4xIbthY5LDRVEAPP7rgYpsrHXzEdfS3G8yCaN5aQJEthRlb8jU8-YPdApI88Jq6GxJTwVBv0eoQ0nm3HxZ8JdGTmSNaQ2rJTzvj8qqG-DIf146RB5EKpJw4m00
+ *
+ */
+
+
+
+#include <iostream>
+#include <string>
+
+class Implementor {
+public:
+  Implementor() { std::cout << "Constructor Implementor" << std::endl; }
+  virtual ~Implementor() {}
+  virtual std::string operationImp()  const = 0;
+ 
+};
+
+class ConcreteImplementorA : public Implementor {
+public:
+  ConcreteImplementorA() { std::cout << "Constructor ConcreteImplementorA" << std::endl; }
+  ~ConcreteImplementorA() {}
+  std::string operationImp() const override { return "operationImp from ConcreteImplementorA\n"; }
+};
+
+class ConcreteImplementorB : public Implementor {
+public:
+  ConcreteImplementorB() { std::cout << "Constructor ConcreteImplementorB" << std::endl; }
+  ~ConcreteImplementorB() {}
+  std::string operationImp() const override { return "operationImp from ConcreteImplementorB\n"; }
+};
+
+class Abstraction {
+protected:
+  Implementor* protected_implementation;
+public:
+Abstraction(Implementor* implementation) : protected_implementation(implementation) {
+    }
+virtual ~Abstraction() {}
+virtual std::string operation() const {
+    return "Abstraction: Base operation with: " +
+           this->protected_implementation->operationImp();
+}
+  
+};
+
+class RefinedAbstraction : public Abstraction {
+public:
+virtual ~RefinedAbstraction() {}
+RefinedAbstraction(Implementor* implementation) : Abstraction(implementation) {
+  }
+std::string operation() const {  
+return "RefinedAbstraction: Extended operation with: " +
+           this->protected_implementation->operationImp();
+}
+
+};
+
+int main() {
+
+  Implementor* implementation = new ConcreteImplementorA;
+  Abstraction* abstraction = new Abstraction(implementation);
+  std::cout << abstraction->operation();
+  std::cout << std::endl;
+  delete implementation;
+  delete abstraction;
+  implementation = new ConcreteImplementorB;
+  abstraction = new RefinedAbstraction(implementation);
+  std::cout << abstraction->operation();
+  std::cout << std::endl;
+  delete implementation;
+  delete abstraction;
+}

23patterns-cplusplus/Builder.cpp

@@ -0,0 +1,141 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: BUILDER
+ * http://www.plantuml.com/plantuml/uml/hL9HJiCm3FtFAIpniS5KAdwdgXhjG492Q1fmWBJre2XjAiT1JC21UevUZ2pB1c9eN-GdplFpUqxYcM59R1ibuX5aZpUtywibZ6BXLgcaCJ2l2KlM1Ey2t8gWiBMgaFnf0gLk3PCjUNmQ48ESRIdZiEyo2zALOy8JSWXTqQSGTSj8AraYX8BWTRBrMaZYIyVy1MM7KExrGkEvRaj2ng1vNPFX83mv4Fu9POTGleTSxqiqLl4HgtjqhrBzkvVOVyLP1C5AX1sIZoZwyyh76A5J8LhD2DB0tOMtJeeqARNID2MzbYfJ5jDGaSG-aIPnaUwu3-iEfni0SaB9jMwbyha5KeCCIe8P-awIpq651fgXvsVj8i-hy7kEDem8R0kwU45sUDCfV4FFwz0oo5TT4rJrQZNqX2qxDSAEXjwuWtSmvmBT-syk9MOkSjFz1G00
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+class Product {
+public:
+  void partA(const std::string &part) {
+    part_a = part;
+  }
+  void partB(const std::string &part) {
+    part_b = part;
+  }
+  void partC(const std::string &part) {
+    part_c = part;
+  }
+
+  void checkProduct() {
+    std::cout << part_a + " " + part_b + " " + part_c + " have been created" << std::endl;
+  }
+
+private:
+  std::string part_a;
+  std::string part_b;
+  std::string part_c;
+};
+
+class Builder {
+public:
+  Builder() { std::cout << "Constructor Builder" << std::endl; }
+  virtual ~Builder() {}
+  Product getProduct() { return product; }
+
+  virtual void buildPartA() =0;
+  virtual void buildPartB() =0;
+  virtual void buildPartC() =0;
+
+protected:
+  Product product;
+};
+
+class ConcreateBuilder1 : public Builder {
+public:
+  ConcreateBuilder1() { std::cout << "Constructor ConcreateBuilder-1" << std::endl; }
+  ~ConcreateBuilder1() {}
+
+  void buildPartA() {
+    product.partA("1-A");
+  }
+  void buildPartB() {
+    product.partB("1-B");
+  }
+  void buildPartC() {
+    product.partC("1-C");
+  }
+
+};
+
+class ConcreateBuilder2 : public Builder {
+public:
+  ConcreateBuilder2() { std::cout << "Constructor ConcreateBuilder-2" << std::endl; }
+  ~ConcreateBuilder2() {}
+
+  void buildPartA() {
+    product.partA("2-A");
+  }
+  void buildPartB() {
+    product.partB("2-B");
+  }
+  void buildPartC() {
+    product.partC("2-C");
+  }
+
+};
+
+class Director {
+public:
+  Director() { std::cout << "Constructor Director" << std::endl; }
+  ~Director() {
+    if (builder) {
+      delete builder;
+    }
+  }
+
+  void setBuilder(Builder *b) {
+    if (builder) {
+      delete builder;
+    }
+    builder = b;
+  }
+
+  Product getProduct() { 
+      Builder *builder_ok = dynamic_cast<Builder*>(builder);
+      if (builder_ok) {
+      return builder->getProduct();
+        } else { 
+            std::cout << "Director does construct : empty_product !" << std::endl;
+            Product empty_product;
+            return empty_product;} 
+      }
+
+  void construct() {
+    Builder* builder_ok = dynamic_cast<Builder*>(builder);
+    std::cout << "Director does construct" << std::endl;
+    if (builder_ok) {
+    builder_ok->buildPartA();
+    builder_ok->buildPartB();
+    builder_ok->buildPartC();
+    } else {
+        std::cout << "Director does construct : no method available !" << std::endl;
+    }
+  }
+
+private:
+  Builder *builder = nullptr;
+};
+
+int main(int argc, char* argv[]) {
+  Director director;
+  director.setBuilder(new ConcreateBuilder1);
+  director.construct();
+
+  Product product1 = director.getProduct();
+  product1.checkProduct();
+
+  director.setBuilder(new ConcreateBuilder2);
+  director.construct();
+  Product product2 = director.getProduct();
+  product2.checkProduct();
+
+  director.setBuilder(0);
+  director.construct();
+  Product product3 = director.getProduct();
+  product3.checkProduct();
+}

23patterns-cplusplus/Chain_of_responsability.cpp

@@ -0,0 +1,76 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: CHAIN OF RESPONSABILITY
+ * http://www.plantuml.com/plantuml/uml/ZP11Qnin48Nl-XKFUaXBwvhaQ9ObjMc9eJZ1oQMdejM-T5Mqqdea6KpR7vGU-YVynwgku-HGC9cBXddpFkRfCYOjAVTEJS-mkFgmNE7w4zOVRs-kLxVB-VBpykuBpgQgb74wHYoSfKzAMPyezzeGLzgtZe8V2gKc6CHkTUBNc8rXZ476-IjquzwQcyoONhzHlvwGmHjXuYFe_97qziMEYrEEphO4-o7jqBDlA56fGmXCwkFnwXYY-ZcP_7VGIVNYINt6OORdzCg7HEY8rVbuPTNKbGako4p2JhkvowmNdROUuHvhnY7uQ1lhRDfLqt6nhgPDVVJUxGRE_WqmPwUtDeXsetP3wPdG4gOGacGhHFQ4wVJ-JtcB8WUy7l7x1un6lQL1ktym8GzEV-CxE2A9jeaz_KXq6i9DtlzEnC2SK3hXmLwS4h8hj44B1fUZPPQ8q7ndYjXaYwwis3Ioyl6FtYlw5ZuagilIvTxz1G00
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+
+
+
+class Handler {
+public:
+    virtual ~Handler() {};
+  
+    void setSuccessor(Handler *s) {
+        private_successor = s;
+    }
+
+    Handler* getSuccessor() {
+        return private_successor;
+    }
+
+    virtual void handleRequest() = 0;
+private:
+    Handler *private_successor;
+};
+
+class ConcreteHandler1 : public Handler {
+public:
+    ~ConcreteHandler1() {}
+    ConcreteHandler1(){std::cout << "Constructor ConcreteHandler1" << std::endl;}
+    void handleRequest() {
+        if (!this->getSuccessor()) {
+            std::cout << "Request handled by Concrete Handler 1 // no successor" << std::endl;
+        }
+        else {
+            std::cout << "Request handled by the Successor (=chain of responsability) : ";
+            this->getSuccessor()->handleRequest();
+        }
+    }
+};
+
+class ConcreteHandler2 : public Handler {
+public:
+    ~ConcreteHandler2() {}
+    ConcreteHandler2(){std::cout << "Constructor ConcreteHandler2" << std::endl;}
+    void handleRequest() {
+        if (!this->getSuccessor()) {
+            std::cout << "Request handled by Concrete Handler 2 // no successor" << std::endl;
+        }
+        else {
+            std::cout << "Request handled by the Successor (=chain of responsability) : " << std::endl;
+            this->getSuccessor()->handleRequest();
+        }
+    }
+};
+
+class Client {
+public:
+    Handler *h;
+};
+
+int main() {
+    Client* client = new Client();
+    client->h = new ConcreteHandler1();
+    Handler* h2 = new ConcreteHandler2();
+    client->h->handleRequest();
+    client->h->setSuccessor(h2);
+    client->h->handleRequest();
+    //h2->setSuccessor(client->h);
+    client->h->handleRequest();
+}

23patterns-cplusplus/Command.cpp

@@ -0,0 +1,62 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: COMMAND
+ * http://www.plantuml.com/plantuml/uml/PP7DIiD058NtynGNN5IhCRWj8THM5ovQGTpBP79AH-Sdp4-mg0_aS_XYfkaaQhra4SxzxZadPEu3To5gnV89BUzNg-lr3KrorezGt7kwCwrzWQCtHjrar3ZPye0dORNcfkxLS_88ouDmUfOal4B4W1_vOx1yW81ia-SUvI98Qmw8D05kmmKeNIRgP33yxRIqHZYC8VzAkfIKSluuR6KDWcx2ZZHq1USPOyFNJhDio6TZtIoR7YUoumRPUpaUCcC3Y7jQN_K5YgeiX5NMpPpTSRLG4MLYYxnVb4LUbGFxk6imsmkqm9QtqZgk-jsj4RpnKO6Y0QKV0QgvyPr2jdf6kEZ9-kjJsDXqPFS89M42rP4sDZeZlKTqbmnTwtrHDk_UebRV
+ *
+ */
+#include <iostream>
+
+class Receiver {
+public:
+    void action() {
+        std::cout << "Receiver: execute action" << std::endl;
+    }
+    Receiver() { std::cout << "Constructor Receiver" << std::endl; }
+};
+
+class Command {
+public:
+    virtual ~Command() {}
+    virtual void execute() = 0;
+};
+
+class ConcreteCommand : public Command {
+public:
+    ConcreteCommand(Receiver *r) : private_receiver(r) {std::cout << "Constructor ConcretCommand" << std::endl; };
+    ~ConcreteCommand() {
+        if (!private_receiver) {
+            delete private_receiver;
+        }
+    }
+    void execute() {
+        std::cout << "ConcreteCommand execute" << std::endl;
+        private_receiver->action();
+    }
+private:
+    Receiver* private_receiver;
+};
+
+class Invoker {
+public:
+    void setCommand(Command* c) {
+        private_command = c;
+    }
+    
+    void executeCommand() {
+        std::cout << "Invoker: executeCommand" << std::endl;
+        if (private_command) private_command->execute();
+    }
+
+private:
+    Command* private_command;
+};
+
+int main() {
+    Receiver* receiver = new Receiver();
+    Command *command = new ConcreteCommand(receiver);
+    
+    Invoker invoker;
+    invoker.setCommand(command);
+    invoker.executeCommand();
+}

23patterns-cplusplus/Composite.cpp

@@ -0,0 +1,101 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: COMPOSITE
+ * https://www.plantuml.com/plantuml/uml/VL7BRjH04BpxArhYu8J5hBYkh5LWnG49259oNxN75JDe7bPFpqeHy3_m7Vanx65Z0alIfvcgckegpKLI5itULUkQTfSVFbrUlRj-I_MwciO6XTom0UsY7sD0KFfQqJGD-NrWZt9vHd64iDeOpiwF2FVzcGraQFFxRRAAyuKL-7Z0gU183z3TP-kAWvq4DkWzXP3zl0kJr_UgCevJelVWcoNOAFR00_QsBy3g9Dpg_oPBYh-T57ipPn44Ei1ebCTid-oyUhhpwj7Eft7__4NxhMbA-N-nnVq1qJJF7-1LY0hYH1zVbIrjjsrDT54s4c_PlN4PsqNThWkrRTVTzbvzVJjYCmDqfPADPc5NkDSfmNUE1r1Vn-uBD57F8L4Ee7JKeaXPkYX81a7nWbnj-xkV82Ib7jHnO6SJf4XTpSRS_KZKJ3vMsGeevbatICpZikjbXT3JNAwwc4xPkry0
+ *
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+class Component {
+public:
+  std::string  m_name;
+  Component() { std::cout << "Constructor Component" << std::endl; }
+  virtual ~Component() {}
+  virtual void operation() = 0;
+
+  virtual void add(Component *) {};
+  virtual void remove(Component *) {};
+  virtual Component* getChild(int) { return nullptr; };
+  
+  virtual void enumerate() = 0 ;
+};
+
+class Leaf : public Component {
+public:
+  Leaf(int id) : private_id(id) { std::cout << "Constructor Leaf" << std::endl; }
+  ~Leaf() {}
+
+  void operation() { std::cout << "This is operation from Leaf: " << private_id << std::endl; }
+  void enumerate() { std::cout << "Enumerate from Leaf: " << private_id << std::endl;};
+private:
+  int private_id;
+};
+
+class Composite : public Component {
+public:
+  Composite() { std::cout << "Constructor Composite" << std::endl; }
+  ~Composite() {
+    for (unsigned int i = 0; i < private_children.size(); ++i) {
+      delete private_children[i];
+    }
+  }
+
+  void operation() {
+    std::cout << "size of children: " << private_children.size() << std::endl;
+    for (unsigned int i = 0; i < private_children.size(); ++i) {
+      private_children[i]->operation();
+    }
+  }
+
+  void add(Component *c) {
+    private_children.push_back(c);
+  }
+
+  void remove(Component *c) {
+    for (auto iter = private_children.begin(); iter != private_children.end(); ++iter) {
+      if (*iter == c) {
+        private_children.erase(iter);
+      }
+    }
+  }
+
+  Component* getChild(unsigned int idx) {
+    return idx < private_children.size() ? private_children[idx] : nullptr;
+  }
+ 
+ void group(const std::string &n) {m_name=n;};
+ void enumerate() {
+        std::cout << "Group " << m_name.c_str() << " contains:" << std::endl;
+        for (auto &&o : private_children)
+            o->enumerate();
+    }
+private:
+  std::vector<Component*> private_children;
+};
+
+int main() {
+  Composite composite;
+  composite.group("principal");
+  for (unsigned int i = 0; i < 3; ++i) {
+    composite.add(new Leaf(i));
+  }
+
+  Composite composite2;
+  composite2.group("secondaire");
+
+  composite.add(&composite2);
+
+  composite.remove(0);
+  composite.operation();
+
+  Component *component1 = composite.getChild(0);
+  component1->operation();
+
+  Component *component2 = composite.getChild(3);
+  component2->operation();
+  composite.enumerate();
+}

23patterns-cplusplus/Decorator.cpp

@@ -0,0 +1,69 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: DECORATOR
+ * http://www.plantuml.com/plantuml/uml/ROvDJiCm48NtFiL8BCgFGiIsYg92ovQYqZsQEWDrvTXXF4QgWFlGS_HYE97weuHPZTxxvisR146MM5kLZs3sE9qlxfVp1OnobSOu8Nv3JJ3rTUCTEO4l1Makm3V4ACQxoolrevIs64B2d6OIwkCt_-CpqZwfdW-fvrGhPD2m-KIXLtr873xhfGoVdTeKtrasBDa3JhNEZ2oxFjEFMtimBAAKyqA00Pxkkah5gYoqjvx7xBTe7soayaWNUMULHRug3_Hosz2u5U15E6g9ZBRpdebh4gX6-vsGgvWWEl2hJT82kW3h_OwDu3j1ZIPq9-G0DpuAEabmCjBfsbS4LGivi__bj6yTrkOZqgrAiT3sLvEqnTh-0G00
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+class Component {
+public:
+  virtual ~Component() {}
+
+  virtual void operation() = 0;
+};
+
+class ConcreteComponent : public Component {
+public:
+  ~ConcreteComponent() {}
+
+  void operation() {
+    std::cout << "Base operation for ConcreteComponent" << std::endl;
+  }
+};
+
+class Decorator : public Component {
+public:
+  ~Decorator() {}
+
+  Decorator(Component *c) : private_component(c) {}
+
+  virtual void operation() {
+    private_component->operation();
+  }
+private:
+  Component *private_component;
+};
+
+class ConcreteDecoratorA : public Decorator {
+public:
+  ConcreteDecoratorA(Component *c) : Decorator(c) {}
+
+  void operation() {
+    Decorator::operation();
+    std::cout << "Augmented operation for ConcreteDecoratorA" << std::endl;
+  }
+};
+
+class ConcreteDecoratorB : public Decorator {
+public:
+  ConcreteDecoratorB(Component *c) : Decorator(c) {}
+
+  void operation() {
+      Decorator::operation();
+      std::cout << "Augmented operation for ConcreteDecoratorB" << std::endl;
+  }
+};
+
+int main() {
+  Component *cc = new ConcreteComponent();
+  ConcreteDecoratorA *cda = new ConcreteDecoratorA(cc);
+  ConcreteDecoratorB *cdb = new ConcreteDecoratorB(cc);
+
+  cda->operation();
+  cdb->operation();
+
+}

23patterns-cplusplus/Facade.cpp

@@ -0,0 +1,77 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: FACADE
+ * http://www.plantuml.com/plantuml/uml/RP1DJiCm48NtFiMecwv2HDjL5LajXUxefbnWuaofXLqRZus847TXsPuZ5oC_WAYKMVbzCqzlnYkE66AoHkHJsAutw_i7cEQYBMMG6RQei2Bu4901S2gvvaZszbhEhkNyMYx4fn0UrGi-4qmspdf3xp3q9b0KErUHb5r4MqFg_Yze3Cx6u7m43j57NH6GzR46IxQam4Byd9Lbyb_MA9sDqlaeNGXnSf406NR3vaKf2-MC2ylWQZHt9f4Sd4NUSrdafVmTVQezBJi0-nYIYYcWwNkFoA-9m22euVjqR2wG0KL89trmmMfksrDKgZbpRsc-e286TecpRhlcR5k9RwHQ2m5w7vmwKZ_BsdgZ3xgvq8sWKmNT5MBLlf8rtm00
+ *
+ */
+
+#include <iostream>
+
+class SubSystem1 {
+public:
+  void suboperation() {
+    std::cout << "Simplified SubSystem1 operation" << std::endl;
+  }
+};
+
+class SubSystem2 {
+public:
+  void suboperation() {
+    std::cout << "Simplified SubSystem2 operation" << std::endl;
+  }
+};
+
+class SubSystem3 {
+public:
+  void suboperation() {
+    std::cout << "Simplified SubSystem3 operation" << std::endl;
+  }
+};
+
+class SubSystem4 {
+public:
+  void suboperation() {
+    std::cout << "Simplified SubSystem4 operation" << std::endl;
+  }
+};
+
+class Facade {
+public:
+  Facade() {
+    std::cout << "Constructor Facade" << std::endl;
+    subsystem1 = new SubSystem1();
+    subsystem2 = new SubSystem2();
+    subsystem3 = new SubSystem3();
+    subsystem4 = new SubSystem4();
+  }
+
+  ~Facade() {
+    if (subsystem1) {
+      delete  subsystem1;
+    }
+    if (subsystem2) {
+      delete subsystem2;
+    }
+  }
+
+  void operationWrapper() {
+    std::cout << "begin operationWrapper Facade" << std::endl;
+    subsystem1->suboperation();
+    subsystem2->suboperation();
+    subsystem3->suboperation();
+    subsystem4->suboperation();
+    std::cout << "end operationWrapper Facade" << std::endl;
+  }
+
+private:
+  SubSystem1 *subsystem1;
+  SubSystem2 *subsystem2;
+  SubSystem3 *subsystem3;
+  SubSystem4 *subsystem4;
+};
+
+int main() {
+  Facade facade;
+  facade.operationWrapper();
+}

23patterns-cplusplus/Factory_Method.cpp

@@ -0,0 +1,70 @@
+/*
+ * C++ Design Patterns: FACTORY METHOD
+ * http://www.plantuml.com/plantuml/uml/RL3DJZen4B_tAIRv7_WRXOrNijcW8F4WOWmNZztkA3LjXqpRmqPz89w35xEK1SF77Fenlu_v6FaWEKHhHD63wTruCNzzWzd3ud4-WLuXKYWZlOSnemp4y2KWnJzubofzsnc69JN_hyJFWKXECGOy5bnV4cWNa5CUuOMfYIeSt3tPnDFkemCk5UWW8PQwGK2x2YrOj3Mo5s9lM7xt-sUAhhLZi4kA4pAKWpEAS1GGf8VdsznlMLUb8aCyP6gbkJSHg-bkNDZDMnOPhygYhlQIHRl2uJQnswqc9qt69fkrOXqWEeI_5QqeCYZUh94J0bH_OhZ9V2kr1vCEZ-a2Jz7tyweGccIb6-H19ZxrjFD1EgLpEK0VG2r9Uvti9P-81m9T0zjHnIYzeZM_
+ *
+ * 2021 / JMB
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+class Product {
+public:
+  Product() { std::cout << "Product instancied" << std::endl; }
+  virtual ~Product() {}
+
+  virtual void somethingProduct() = 0;
+};
+
+class ConcreateProductA : public Product {
+public:
+  ConcreateProductA() { std::cout << "ConcreateProductA instancied" << std::endl; }
+  ~ConcreateProductA() {}
+
+  void somethingProduct() { std::cout << "ProductA has been created" << std::endl; }
+};
+
+class ConcreateProductB : public Product {
+public:
+  ConcreateProductB() { std::cout << "ConcreateProductB instancied" << std::endl; }
+  ~ConcreateProductB() {}
+
+  void somethingProduct() { std::cout << "ProductB has been created" << std::endl; }
+};
+
+class Creator {
+public:
+  Creator() { std::cout << "Creator instancied" << std::endl; }
+  virtual ~Creator() {}
+
+  virtual Product* factoryMethod() = 0;
+};
+
+class ConcreateCreator : public Creator {
+public:
+
+  enum TProduct { A, B};
+  TProduct private_a;
+  ConcreateCreator(  TProduct b) { std::cout << "ConcreateCreator instancied" << std::endl; private_a=b; }
+  ~ConcreateCreator() {}
+
+  Product* factoryMethod() { 
+      if (private_a==A) {
+      return new ConcreateProductA; }
+      else if (private_a==B) {
+      return new ConcreateProductB; }
+      else return 0;
+    }
+};
+
+int main(int argc, char* argv[]) {
+  Creator *creator = new ConcreateCreator(ConcreateCreator::A);
+
+  Product *productA = creator->factoryMethod();
+  productA->somethingProduct();
+
+  Product *productB = creator->factoryMethod();
+  productB->somethingProduct();
+
+}

23patterns-cplusplus/Flyweight.cpp

@@ -0,0 +1,92 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: FLYWEIGHT
+ * https://www.plantuml.com/plantuml/uml/bL3DZjCm4BxxAKRYq1O85TTLLAr0Mq12N7OHueGSPzeQEUDePWn4m0F1Q-oBuLgXgOWgiLOEyNm_y_cx5hMigGjclO3jsuyVRjwyUdq7YxN9nmKh0jimV4M_F-ZMEeqym7S3-LIGA7ABZEsdplPbzWJsg2V-SZKEWvTfAiiLc9_6U5BadNKuBHYT7q7iaQtwI4jFWD-KFObtjseLLrax1diPF9AURf4Se-A_RXLuEZSOC_tVYlSa1ylONZQt8Jp4zk1R1Enw7Q33ha4MOsO5FwwcJYOKwXzLDNlcZ70nydnFdUbZYJFsENZHyfnaA2g25NZtl7HHDvlQnH3vYkDWmukGS7CIrki2RUfri_dBlXjwl3eEu5OvEKriGy5kY77lHHaXe41iFgCAj9O44Y78o4PeynU9xd-XF2rAPtlRX098wll8YfmrWBiTElKx-695Cxmedj0cwEv_TrYqckCyCqWj71zchlDVwi8V
+ *
+ */
+
+#include <iostream>
+#include <string>
+#include <unordered_map>
+
+class Flyweight {
+public:
+  virtual ~Flyweight() {}
+
+  virtual void operation(const std::string& extrinsicState) = 0;
+};
+
+class ConcreteFlyweight : public Flyweight {
+public:
+  ConcreteFlyweight(const std::string& intrinsicState) :
+    intrinsicState(intrinsicState) {
+    std::cout << "ConcreteFlyweight intrinsicState: " << intrinsicState << std::endl;
+  }
+  ~ConcreteFlyweight() {}
+
+  void operation(const std::string& extrinsicState) {
+    std::cout << "ConcreteFlyweight operation extrinsicState: " << extrinsicState << std::endl;
+  }
+
+private:
+  std::string intrinsicState;
+};
+
+class UnsharedConcreteFlyweight : public Flyweight {
+public:
+  UnsharedConcreteFlyweight(const std::string& allState) : private_allState(allState) {
+    std::cout << "UnsharedConcreteFlyweight  allState: " << private_allState << std::endl;
+  }
+  void operation(const std::string& extrinsicState) {
+    std::cout << "UnsharedConcreteFlyweight operation extrinsicState: " << extrinsicState << std::endl;
+  }
+private:
+  std::string private_allState;
+};
+
+class FlyweightFactory {
+public:
+  ~FlyweightFactory() {
+    for (auto it = mapflys.begin(); it != mapflys.end(); ++it) {
+      delete it->second;
+    }
+    mapflys.clear();
+  }
+
+  Flyweight *getFlyweight(const std::string& key) {
+    if (mapflys.find(key) != mapflys.end()) {
+      std::cout << "Key : " << key << ", already exist" << std::endl;
+      return mapflys[key];
+    }
+
+    Flyweight *fly = new ConcreteFlyweight(key);
+    mapflys.insert(std::make_pair(key, fly));
+    std::cout << "New entry for key: " << key<< std::endl;
+    return  fly;
+  }
+
+  void listFlyweights() const
+    {
+        size_t count = this->mapflys.size();
+        std::cout << "\nFlyweightFactory: I have " << count << " flyweights:\n";
+        for (auto& it: mapflys) {
+                            // Do stuff
+                            std::cout << it.first << ";";
+                            }
+        std::cout << std::endl;
+    }
+
+private:
+  std::unordered_map<std::string, Flyweight*> mapflys;
+};
+
+int main() {
+  FlyweightFactory *factory = new FlyweightFactory();
+  factory->getFlyweight("Hello Greeting")->operation("Greeting the world");
+  factory->getFlyweight("Hello")->operation("Greeting group");
+  factory->getFlyweight("Hello")->operation("Greeting classroom");
+  factory->listFlyweights();
+  Flyweight* unsharedfly = new UnsharedConcreteFlyweight("Unshared");
+  unsharedfly->operation("Greeting");
+}

23patterns-cplusplus/Interpreter.cpp

@@ -0,0 +1,97 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: INTERPRETER
+ * http://www.plantuml.com/plantuml/uml/XL7Dpjem4BpxALRg0IXre_OOHH6bui058SIzseHjiEgVQEqWKCi3zJdwOdK2-OBqWU93ifuPxux72n-GGsEqI2QmtknNk-rk5RymIKHSfKRluRjMPCFRpjb0vm2_1SGb8RXVPEzrpUg4WNuOh3ja3fx2LDcRw1F4gd1Ep-vazK3E8EquSHL2nGdy4qk2RuKFZ6LOdMicxvMpzxaVe1D5D4ndujgRsnCRPL6_qm_U1h_pnnwGzZSRkcqYCDxmmUENrzJNiP57TI0WKuSB6385iHUYppgJ_IFSVY1b_YGRyIIkx8-KGooZqlxEusefFxuG2-i20SRyRdbaHPwLJZjEsLrGBtL3-RgFWJXBEZBFaYBlzVjBJMaBm9AEU5AEKNVSDewZ036gmx-_9IicQ2n1nMWCjhlQDHoXJgpHLbWHj0Scolg0jbJ4u9qTte4Q_Yp87g1rBHQnQep-3m00
+ *
+ */
+#include <iostream>
+#include <unordered_map>
+
+/*
+ * Simple Interpreter example:
+ * (digit+digit) => digit
+ * (|+|digit|) = terminal
+ * exemple : (9 = non-terminal
+ * context : 9 -> true, )->true, (->false, (digit->false, digit)->true, digit+->false, +digit->false
+ *
+ */
+
+class Context {
+public:
+    typedef char token;
+    enum class std_token:token{digit='9',open_bracket='(', close_bracket=')', plus_symbol='+'};
+
+    void set(std_token var, bool value) {
+        maps.insert(std::make_pair(var, value));
+    }
+
+    char get(std_token var) {
+        return maps[var];
+    }
+private:
+    std::unordered_map<std_token, bool> maps;
+};
+
+class AbstractExpression {
+public:
+    virtual ~AbstractExpression() {}
+    virtual bool interpret(Context* const context) = 0;
+};
+
+class TerminalExpression : public AbstractExpression {
+public:
+    TerminalExpression(Context::std_token token) : private_token(token) {}
+    ~TerminalExpression() {}
+
+    bool interpret(Context* const context) {
+        return context->get(private_token);
+    }
+private:
+    Context::std_token private_token;
+};
+
+class NonTerminalExpression : public AbstractExpression {
+public:
+    NonTerminalExpression(AbstractExpression* f, AbstractExpression* s)
+    : first(f), second(s) {}
+
+    ~NonTerminalExpression() {
+        if (first) delete first;
+        if (second) delete second;
+    }
+
+    bool interpret(Context* const context) {
+        return first->interpret(context) && second->interpret(context);
+    }
+private:
+    AbstractExpression* first;
+    AbstractExpression* second;
+};
+
+int main() {
+    Context context;
+    //define way "basic" token property
+    context.set(Context::std_token::close_bracket, true);
+    context.set(Context::std_token::digit, true);
+    context.set(Context::std_token::open_bracket, false);
+    context.set(Context::std_token::plus_symbol, false);
+
+    AbstractExpression* expressionCloseBracket = new TerminalExpression(Context::std_token::close_bracket); // )
+    AbstractExpression* expressionOpenBracket = new TerminalExpression(Context::std_token::open_bracket); // (
+    AbstractExpression* expressionDigit = new TerminalExpression(Context::std_token::digit); // 9
+    AbstractExpression* expressionPlus = new TerminalExpression(Context::std_token::plus_symbol); // +
+    AbstractExpression* expressionOpenBracketDigit = new NonTerminalExpression(expressionOpenBracket, expressionDigit); // (9
+    AbstractExpression* expressionDigitCloseBracket = new NonTerminalExpression(expressionDigit, expressionCloseBracket); // 9)
+    AbstractExpression* expressionDigitPlus = new NonTerminalExpression(expressionDigit, expressionPlus); // 9+
+    AbstractExpression* expressionPlusDigit = new NonTerminalExpression(expressionPlus, expressionDigit); // +9
+
+    std::cout << "( -> " << expressionOpenBracket->interpret(&context) << std::endl;
+    std::cout << "9 -> " << expressionDigit->interpret(&context) << std::endl;
+    std::cout << "+ -> " << expressionPlus->interpret(&context) << std::endl;
+
+    std::cout << "(9 -> " << expressionOpenBracketDigit->interpret(&context) << std::endl;
+    std::cout << "9+ -> " << expressionDigitPlus->interpret(&context) << std::endl;
+    std::cout << "+9 -> " << expressionPlusDigit->interpret(&context) << std::endl;
+    std::cout << "9) -> " << expressionDigitCloseBracket->interpret(&context) << std::endl;
+}

23patterns-cplusplus/Iterator.cpp

@@ -0,0 +1,96 @@
+/*
+ * C++ Design Patterns: ITERATOR
+ * 
+ * http://www.plantuml.com/plantuml/uml/VP71RjD048Rl-nGZzP1MKOYuHfRL1ZZa0gY41vXuf-wYzMoPdQqQeE_2aJo7NuoDWqrIHzsJv_-_yJ-ZkOwAegdnPZw1rVh3xStwqorCvYQ_ocECyCuxOZN6iPBSOKLmKzT2DIh1JmFvNK0bbCjL1b23N5wPvw4xS3QLNlPCHpsmsCDAJ_eFg4cpstJEYe_KB-u7NLujuAiRLBIsPuU_F1_FtESC8tD6Jl0Bk7CIJxK3wkBxmDGPon1yltCI8TPHx6Zr5z7JSVH1FXy_FHi_VIt-tba2QXvq2mqr6v9epE6AC9kL_yztBFP3ci65ujTiDhwVwSbJV-Wt79G08tnysqrQRCgY2Zx8Gi8M_T8dAdkuc7TEMSmtPG-ljm-qs0kmf7jyT47miF9daeOKx0IhgjrP4i3q13OmjpkAMKyCM4kxgr6x1alG8BlsZn34TlSz4QiZxtE5704VWnFeoFOtL84PdMRK8qILL6dAXQMZXEnDmkORwHj3R66_gBdENwdnVm40http://www.plantuml.com/plantuml/uml/VP71RjD048Rl-nGZzP1MKOYuHfRL1ZZa0gY41vXuf-wYzMoPdQqQeE_2aJo7NuoDWqrIHzsJv_-_yJ-ZkOwAegdnPZw1rVh3xStwqorCvYQ_ocECyCuxOZN6iPBSOKLmKzT2DIh1JmFvNK0bbCjL1b23N5wPvw4xS3QLNlPCHpsmsCDAJ_eFg4cpstJEYe_KB-u7NLujuAiRLBIsPuU_F1_FtESC8tD6Jl0Bk7CIJxK3wkBxmDGPon1yltCI8TPHx6Zr5z7JSVH1FXy_FHi_VIt-tba2QXvq2mqr6v9epE6AC9kL_yztBFP3ci65ujTiDhwVwSbJV-Wt79G08tnysqrQRCgY2Zx8Gi8M_T8dAdkuc7TEMSmtPG-ljm-qs0kmf7jyT47miF9daeOKx0IhgjrP4i3q13OmjpkAMKyCM4kxgr6x1alG8BlsZn34TlSz4QiZxtE5704VWnFeoFOtL84PdMRK8qILL6dAXQMZXEnDmkORwHj3R66_gBdENwdnVm40
+ * 2021 / JMB
+ *
+ */
+
+#include <iostream>
+#include <vector>
+
+class Iterator;
+class ConcreteIterator;
+
+class Aggregate {
+public:
+  virtual ~Aggregate() {}
+  virtual Iterator* createIterator() = 0;
+};
+
+class ConcreteAggregate : public Aggregate {
+public:
+  ConcreteAggregate(int N) {
+    //do a memory allocation  
+    v.reserve(N);
+    for (int i = 0; i < N; ++i) {
+      //direct move in memory of i value 
+      v.emplace_back(i);
+    }
+  }
+  ~ConcreteAggregate() {}
+
+  Iterator* createIterator();
+
+  int getItem(int idx) { return v.at(idx); }
+
+  unsigned int getSize() { return v.size(); }
+  //emplace_back ==> move in memory
+  void addItem(int obj) { v.emplace_back(obj); }
+
+private:
+  std::vector<int> v;
+};
+
+class Iterator {
+public:
+  virtual ~Iterator() {}
+
+  virtual void first() = 0;
+  virtual void next() = 0;
+  virtual bool isDone() = 0;
+  virtual int currentItem() = 0;
+};
+
+class ConcreteIterator : public Iterator {
+public:
+  ConcreteIterator(ConcreteAggregate *ag)
+  : p_cag(ag), p_index(0) {}
+
+  void first() {
+    p_index = 0;
+  }
+
+  void next() {
+    ++p_index;
+  }
+
+  bool isDone() {
+    return p_index >= p_cag->getSize();
+  }
+
+  int currentItem() {
+    return p_cag->getItem(p_index);
+  }
+private:
+  ConcreteAggregate *p_cag;
+  int p_index;
+};
+
+Iterator *ConcreteAggregate::createIterator() {
+  std::cout << "createIterator" << std::endl;
+  return new ConcreteIterator(this);
+}
+
+int main() {
+  ConcreteAggregate *concreteAggregate = new ConcreteAggregate(10);
+  concreteAggregate->addItem(123);
+
+  Iterator* it = concreteAggregate->createIterator();
+  for ( ; !it->isDone(); it->next()) {
+    std::cout << "Item value: " << it->currentItem() << std::endl;
+  }
+
+}
+
+

23patterns-cplusplus/Mediator.cpp

@@ -0,0 +1,98 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: MEDIATOR
+ * http://www.plantuml.com/plantuml/uml/TL31RXCn4BtxAqRg8Q1e6t6DLgjIoe53G4AzLxFs8pNoseizNX417zJlw8_XEDqIPOLFC-_DUsyyDqauIXwSsgnez_7kq_lxBrzfjL77fnsdH3iOon8Y_L9KtXMnCM_UljJ69ecspu82_Pab7uBN4O8BAJKqGPV-GGVdmFkCT2BMisbj_kSwY_xPZT5EB7WONe8kSMjEo1KbUBDB-vfHWGWDEw5YoyqNMUjBX_N2uT4Q48PH3ZHWw16JKgyNQ9kp_RTa_RSG1vpnlvjcSJUrE6JJBLTKhzN9PJcWV10G9_hyhYxVzbshWmjn6yE1tQtBwEQ8TbEPhjtqtJnyVnYnFG9qYqUUR8ZiAdVt_AIZ5SgUGlyTGZ-o9NZDOyeEv938Ua5aBJRuL3LcLQRXKpcHG-cgy9fsa88IJ-o52b5dTSYZupt8FJ_j4MdaMB9GJAUW-UX9-3awgwtWMi4RElvKtPGg3-ul
+ *
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+class Mediator;
+
+class Colleague {
+public:
+    Colleague(Mediator* const m, unsigned int i)
+    : private_mediator(m), private_id(i) {}
+
+    virtual ~Colleague() = default;
+
+    unsigned int getId() {
+        return private_id;
+    }
+
+    virtual void sendMsg(std::string) = 0;
+    virtual void receiveMsg(std::string) = 0;
+
+protected:
+    Mediator* private_mediator;
+    unsigned int private_id;
+};
+
+class ConcreteColleague : public Colleague {
+public:
+    ConcreteColleague(Mediator* const m, unsigned int i)
+    : Colleague(m, i) {}
+
+    ~ConcreteColleague() = default;
+
+    void sendMsg(std::string msg) override;
+
+    void receiveMsg(std::string msg) override {
+        std::cout << "Message: " << msg << " is received by Colleague(id=" << this->getId() << ")" << std::endl;
+    }
+};
+
+class Mediator {
+public:
+    virtual ~Mediator() = default;
+    virtual void add(Colleague* const c) = 0;
+    virtual void distribute(Colleague* const sender, const std::string& msg) = 0;
+};
+
+class ConcreteMediator : public Mediator {
+public:
+    ~ConcreteMediator() {
+        for (unsigned int i = 0; i < colleagues_.size(); ++i) {
+            delete colleagues_[i];
+        }
+        vector_colleagues.clear();
+    }
+
+    void add(Colleague* const c) {
+        vector_colleagues.push_back(c);
+    }
+
+    void distribute(Colleague* const sender, const std::string& msg) {
+        for (auto colleague : colleagues_) {
+            if (colleague->getId() != sender->getId()) {
+                colleague->receiveMsg(msg);
+            }
+        }
+    }
+private:
+    std::vector<Colleague*> vector_colleagues;
+};
+
+void ConcreteColleague::sendMsg(std::string msg) {
+    std::cout << "Message: " << msg << " is sent by Colleague(id=" << this->getId() << ")" << std::endl;
+    private_mediator->distribute(this, msg);
+}
+
+int main() {
+    Mediator *mediator = new ConcreteMediator();
+
+    Colleague *colleague1 = new ConcreteColleague(mediator, 1);
+    Colleague *colleague2 = new ConcreteColleague(mediator, 2);
+    Colleague *colleague3 = new ConcreteColleague(mediator, 3);
+
+    mediator->add(colleague1);
+    mediator->add(colleague2);
+    mediator->add(colleague3);
+
+    colleague1->sendMsg("Hello");
+    colleague2->sendMsg("World");
+    colleague3->sendMsg("Mediator Pattern");
+}

23patterns-cplusplus/Memento.cpp

@@ -0,0 +1,132 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: MEMENTO
+ * http://www.plantuml.com/plantuml/uml/NO_Dxjem4CJlVegzqN_RDEeLHH6YuWXKXPxH9fc2Mtz4wmqIglf0VOw-M9Ce0OGljdupE-DT9MNHpZkJBsYxsMvsnpqjSjEVsd5Az8K5ohyWzDjGVpBwAlRAYjDUxDa6rYWqAGU-eZbjuH4qJknxQE8B-eOdz6Skci2z9Yah7lAZxSKnl3zGWau1xsmWJyivxsqor09Mp9wt8VXY6n1ygpVoy1Ka6VDOztqsHvZffYBBdlvXJ8WAuaIxpsD9KPL57LsKfSGRkxNhK4wZHJuAPP5NvUmztbei1q1hNFXgex0RjGE7H3uszeU5a5iWrDocph7Q6AX1ZsBr4_fnT2C8pZQf3FpVNsKTB3LSPxFQKXixeHRYeIeO9noJ82btSazC_JNEVZ883GsBcLN_whpx3m00
+ *
+ */
+
+#include <iostream>
+
+
+class Memento {
+private:
+    friend class Originator;
+
+    Memento(int s) : private_state(s) {}
+
+    void setState(int s) {
+        private_state = s;
+    }
+
+    int getState() {
+        return private_state;
+    }
+private:
+    int private_state;
+};
+
+class Originator {
+public:
+    void setState(int s) {
+        private_state = s;
+    }
+
+    int getState() {
+        return private_state;
+    }
+
+    void setMemento(Memento* const m) {
+        private_state = m->getState();
+    }
+
+    Memento* createMemento() {
+        return new Memento(private_state);
+    }
+
+    int getMementoState(Memento* const m) {
+        return m->getState();
+    }
+
+private:
+    int private_state;
+};
+
+class CareTaker {
+public:
+    CareTaker(Originator* const o) : private_originator(o) {}
+
+    ~CareTaker() {}
+
+    void save() {
+        std::cout << "Save state: " << private_originator->getState() << std::endl;
+        Undo_Memento=Saved_Memento;
+        Redo_Memento=Saved_Memento;
+        Saved_Memento=(private_originator->createMemento());
+    }
+
+    void printSavedStates() {
+        std::cout << "Saved states: " ;
+        if (Saved_Memento==0) {
+            std::cout << "it's empty" << std::endl;
+        } else {
+            std::cout << "saved state " << private_originator->getMementoState(Saved_Memento) ;
+            std::cout << " undo state " << private_originator->getMementoState(Undo_Memento) ;
+            std::cout << " redo state " << private_originator->getMementoState(Redo_Memento) << std::endl;
+        }
+    }
+
+    void undo() {
+        if (Undo_Memento==0) {
+            std::cout << "Unable to undo state." << std::endl;
+            return;
+        }
+        if (private_originator->getMementoState(Saved_Memento)==private_originator->getMementoState(Undo_Memento)) {
+            std::cout << "Unable to undo state." << std::endl;
+            return;
+        }
+        Memento* m = Undo_Memento;
+        Redo_Memento = Saved_Memento;
+        Saved_Memento = Undo_Memento;
+        private_originator->setMemento(m);
+        std::cout << "Perform Undo : " << private_originator->getState() << std::endl;
+    }
+
+    void redo() {
+        if (Redo_Memento==0) {
+            std::cout << "Unable to redo state." << std::endl;
+            return;
+        }
+        Memento* m = Redo_Memento;
+        Saved_Memento=Redo_Memento;
+        private_originator->setMemento(m);
+        std::cout << "Perform Redo : " << private_originator->getState() << std::endl;
+    }
+
+    private:
+    Originator* private_originator;
+    Memento* Saved_Memento; // for saved
+    Memento* Undo_Memento; // for undo
+    Memento* Redo_Memento; // for redo
+};
+
+int main() {
+    Originator *originator = new Originator();
+    CareTaker *careTaker = new CareTaker( originator);
+
+    originator->setState(0);
+    careTaker->save();
+    originator->setState(1);
+    careTaker->save();
+    originator->setState(2);
+    careTaker->save();
+    careTaker->printSavedStates();
+    careTaker->undo();
+    careTaker->printSavedStates();
+    careTaker->redo();
+    careTaker->printSavedStates();
+    careTaker->undo();
+    careTaker->undo();
+    careTaker->undo();
+    careTaker->printSavedStates();
+}

23patterns-cplusplus/Observer.cpp

@@ -0,0 +1,118 @@
+/*
+ * C++ Design Patterns: OBSERVER
+ * 
+ * http://www.plantuml.com/plantuml/uml/XL51Rjim4Bpp5OFqaBY1xVOg24RWDeTS6Y0ESgUaTSo08bLoQTH8yvTUzGvzh9GYkguCj3nnPuOxiyiRpz9ngBLONk9-lRbzUBfzmELInACCazlAah09nGkLZ5U1UEROtnUUt9uSCZn5mhg1k8PabkNkIXdOI2NLR6Gh-XThBAljuUgz_81duWrBfYFW_m1lGfHQUeylrfIEcAO1_NizwAFLdU7HPDBr-gGhnDlfpCSHNqV_q5IzpYDB-vWXwnCm_U2pqCarmNTLmixJJwpci2DmbZ-5cFr_dDvcfoe2rGqVK5DTaFD2f5NDLnUV5ekF5pZvo-4B5FcZAFyvdq-NBDA3lzc4YeaS-Ra6MHen1egc1EdnxVCmGrwiyj9gwp9d3rAlTQ1LUfSl1sQLBujL4ZyU6ifw06lQoRsoJkg1-zgrMsKK8nY28orPMHCBTB_GwE0L1US7PME3W-jQgLNqWPQeuwNNlVICjgEkkeolovqqprIJuLXtBKjUuD463qqUDexCexXh6pALDEpXhU5nkLth8GFREiRv7eO-2n5rFKtY9jv2hNy3
+ *
+ * 2021 / JMB
+ *
+ */
+
+
+#include <iostream>
+#include <vector>
+
+class Subject;
+
+class Observer {
+public:
+    Observer(const int id) : p_id(id) {}
+    virtual ~Observer() {}
+
+    virtual int getState() = 0;
+    virtual void update(Subject* subject) = 0;
+    virtual int getId() = 0;
+protected:
+    int p_id;
+};
+
+class ConcreteObserver : public Observer {
+public:
+    ConcreteObserver(const int state, const int id)
+    : observerState(state), Observer(id) {}
+    ~ConcreteObserver() {}
+
+    int getState() {
+        return observerState;
+    }
+
+    int getId() {
+        return p_id; //protected
+    }
+
+    void update(Subject* subject);
+private:
+    int observerState;
+};
+
+class Subject {
+public:
+    virtual ~Subject() {}
+
+    void attach(Observer* observer) {
+        vObserver.emplace_back(observer);
+    }
+
+    void detach(const int id) {
+        for (auto it = vObserver.begin(); it != vObserver.end(); ++it) {
+            if ((*it)->getId() == id) {
+                vObserver.erase(it);
+            }
+        }
+    }
+
+    void notify() {
+        for (auto observer : vObserver) {
+            observer->update(this);
+        }
+    }
+
+    virtual int getState() = 0;
+    virtual void setState(const int state) = 0;
+private:
+    std::vector<Observer*> vObserver;
+};
+
+class ConcreteSubject : public Subject {
+public:
+    ~ConcreteSubject() {}
+
+    int getState() {
+        return subjectState;
+    }
+
+    void setState(const int state) {
+        subjectState = state;
+    }
+private:
+    int subjectState;
+};
+
+void ConcreteObserver::update(Subject *subject) {
+    observerState = subject->getState();
+    std::cout << "Observer(id=" << p_id << ") update state to: " << observerState << std::endl;
+}
+
+int main() {
+    ConcreteObserver observer1(1000, 1);
+    ConcreteObserver observer2(2000, 2);
+
+    std::cout << "Observer1 state: " << observer1.getState() << std::endl;
+    std::cout << "Observer2 state: " << observer2.getState() << std::endl;
+
+    Subject* subject = new ConcreteSubject();
+    subject->attach(&observer1);
+    subject->attach(&observer2);
+
+    subject->setState(10);
+    subject->notify();
+
+    std::cout << "Observer1 state: " << observer1.getState() << std::endl;
+    std::cout << "Observer2 state: " << observer2.getState() << std::endl;
+
+    subject->detach(1);
+    subject->setState(100);
+    subject->notify();
+
+    std::cout << "Observer1 state: " << observer1.getState() << std::endl;
+    std::cout << "Observer2 state: " << observer2.getState() << std::endl;
+}

23patterns-cplusplus/Prototype.cpp

@@ -0,0 +1,73 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: PROTOTYPE
+ * http://www.plantuml.com/plantuml/uml/XP71JW8n48RlVOf9F2nerWqSoMP395w5A1TFf5i6hUcspNHAGjHtySfpy6BM1fQ39CnfC__t_pEpdGQMnB4peYfWyJnVpfUlYqSeAf5AMqRQI8Mm8CUETnxXKq2g6r36MHmCnRSGoiWGO6OqMZxgTn2GUzFWRB_rmmoKu4bl9UFAdxIZKUMSrVzyPnKXOvyrwcTTPyUNs7UzHi3Eymuwx5ga8CJnYh9ipZUBy_hrLrbUsEGgCHR2EaQG0Pv6UPEwRMhbZAC9kPqq3oPYq-DrbQMchjhcH2zJV_BNW1cXPEsiD5bxyOUzqXkDO0hNVY23bmJHWd8sC4N560ciwxh37ef-Hf7DYTQ9abOb_ne3v8G0XnzWabiaC9Z_cNnBUeJ-jUu5sZLOnoYcwIjsvXS0
+ *
+ */
+
+#include <iostream>
+#include <string>
+
+class Prototype {
+public:
+  Prototype() { std::cout << "Constructor Prototype" << std::endl; }
+  virtual ~Prototype() {std::cout << "Destructor Prototype" << std::endl;}
+  virtual Prototype* clone() = 0;
+  virtual void checkPrototype() = 0;
+};
+
+class ConcretePrototype1 : public Prototype {
+public:
+  ConcretePrototype1() { std::cout << "Constructor ConcretePrototype1" << std::endl; }
+  ~ConcretePrototype1() {std::cout << "Destructor ConcretePrototype1" << std::endl;}
+  Prototype* clone() { std::cout << "Clone ConcretePrototype1" << std::endl; return new ConcretePrototype1; }
+  void checkPrototype() { std::cout << "Prototype1 has been created" << std::endl; }
+};
+
+class ConcretePrototype2 : public Prototype {
+public:
+  ConcretePrototype2() { std::cout << "Constructor ConcretePrototype2" << std::endl; }
+  ~ConcretePrototype2() {std::cout << "Destructor ConcretePrototype2" << std::endl;}
+  Prototype* clone() { std::cout << "Clone ConcretePrototype2" << std::endl; return new ConcretePrototype2; }
+  void checkPrototype() { std::cout << "Prototype2 has been created" << std::endl; }
+};
+
+class Client {
+public:
+  Client() { private_prototype = nullptr; std::cout << "Constructor Client" << std::endl; }
+  ~Client() {
+    if (private_prototype) {
+      delete private_prototype;
+    }
+  }
+
+  void setPrototype(Prototype *p) {
+    std::cout << "Client setPrototype" << std::endl;
+    if (private_prototype) {
+      delete private_prototype;
+    } 
+    private_prototype = p;
+  }
+
+  Prototype* client_clone() {
+    if (!private_prototype) {
+      return nullptr;
+    }
+    std::cout << "Clone() Client" << std::endl;
+    return private_prototype->clone(); 
+  }
+
+private:
+  Prototype *private_prototype;
+};
+
+int main(int argc, char* argv[]) {
+  Client client;
+  client.setPrototype(new ConcretePrototype1);
+  Prototype *p1 = client.client_clone();
+  p1->checkPrototype();
+  client.setPrototype(new ConcretePrototype2);
+  Prototype *p2 = client.client_clone();
+  p2->checkPrototype();
+}

23patterns-cplusplus/Proxy.cpp

@@ -0,0 +1,54 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: PROXY
+ * http://www.plantuml.com/plantuml/uml/RO_FIiD06CJl-nGVUAWYCNWj8HJ5gvRMWvvainbnPV-attuh1lM1z3NwOgPf2otqEoqpls5cPqaqI_PEbHEQBnwUdcbIgk6CqodHhRC8efGD0dxL1hJCpJkCq9UYuSw8iSf8SdwXVlQX1RGxnYvFONEEd_qEAAXZ-w45BsaRF1Lxioq8lfEUF7m3JahjUwhleZWiFZR6AdMugzg9D2L6n-lVX21QR0pKGcs_JKLHxw8gH07fHFVNuxAggIiJNUGfnrwx6vTHZsHLZd9TbKsz9n_x3jEDG4lXR2IpTgDt5upkKdQW72WEmuGAGY0VMv2tpD4oGKQMaJeO0GsqN_zva8b1M0kjCiZ0PLiOUwKGMjgCLRFXbRtx1m00
+ *
+ */
+#include <iostream>
+// A subject exposes a contract
+class Subject {
+public:
+  virtual ~Subject() {}
+  virtual void request() = 0;
+};
+
+// Implementation of the contract
+class RealSubject : public Subject {
+public:
+  void request() {
+    std::cout << "RealSubject Request" << std::endl;
+  }
+};
+
+// A proxy encapsulates an already known class - with the same contract as Subject
+class Proxy : public Subject
+{
+public:
+  Proxy()
+  {
+    private_subject = new RealSubject();
+  }
+
+  ~Proxy()
+  {
+    delete private_subject;
+  }
+
+  void request()
+  {
+    std::cout << "Do Proxy Request" << std::endl;
+    private_subject->request();
+  }
+
+private:
+  RealSubject *private_subject;
+};
+
+
+int main()
+{
+  Proxy *proxy = new Proxy();
+  proxy->request();
+  delete proxy;
+}

23patterns-cplusplus/Singleton.cpp

@@ -0,0 +1,48 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: SINGLETON
+ * http://www.plantuml.com/plantuml/uml/LP11ImCn48Nl-HNljeheuhKiIx6856Gzj7V9PeSI66VQJI8KyV_uF_nZpWOhEAVaVUybZrcdxETStjYr3NRRuUdvSVyoe6cTJM2V4dPH3anP1HyEDhUmJ8u1HUAfq6iKkqkW2cykSFkhNbsxJ-T4Cy4d3FVLrOrz5vHrNirwzlp0XVg_Rxgsehvhn_xYtf-Fj5e4R6QozrKyLxPPAX9E9K88HoeP_btZR4fJJ4bKcF2l8kLgdrICboMbKJAcneVm_PLmO1qztpcI2KjljxQJRUW7
+ *
+ */
+
+
+
+#include <iostream>
+#include <string>
+
+class Singleton {
+public:
+//remove some standard method
+//copy constructor and affectation
+  Singleton(const Singleton&) = delete;
+  Singleton& operator=(const Singleton&) = delete;
+
+  static Singleton* Instance() {
+    if (!unique_instance) {
+      unique_instance = new Singleton();
+    } else {std::cout << "constructor : Unique Singleton already created" << std::endl;}
+    return unique_instance;
+  }
+
+  void checkSingleton() { std::cout << "checkSingleton" << std::endl;
+  if (!unique_instance) { std::cout << "checkSingleton : Unique Singleton not created" << std::endl; 
+  } else  { 
+      std::cout << "checkSingleton : Unique Singleton already created" << std::endl;
+   }
+  }
+private:
+  Singleton() { std::cout << "Unique Singleton Constructor" << std::endl; }
+  static Singleton* unique_instance;
+};
+
+//global variable
+Singleton* Singleton::unique_instance = nullptr;
+
+int main(int argc, char* argv[]) {
+  Singleton *singleton = Singleton::Instance();
+  singleton->checkSingleton();
+  //we create a new singleton2 but...
+  Singleton *singleton2 = Singleton::Instance();
+  singleton2->checkSingleton();
+}

23patterns-cplusplus/State.cpp

@@ -0,0 +1,67 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: STATE
+ * http://www.plantuml.com/plantuml/uml/ZP3FIiD04CRlynHpgo8rjCSIGcqfUF9W-mBRpMWZ-oVEpXQB-YwUVGrVpCr8fOA2GqZ2z_s-cPsT9p4isJkeHhZUN6rMEAgWb7Kc9Lp68FGaMA_525rUcz0wEZjly1cmr0NUqcEc98DTT7W5w4g2xumbLF6RrAmo9yqjav1oa_-2qr_1NTSIak_bW9xybZW170yVnsFKAEWRwvSY_1p-fpC52B4u9k7DHEVMswQsqKMUSJmOjt2P6aNhIkMchhRDaTmSUfeD0YveP_PTPEFKMmLh-fGTONbiz7ra8Kz1yECDXSsUE64EkDCTMJDBShb3ss5FkN3lmeI-IqFY8MOUligTn6t9tt_rRGdrDWaej3Wi1VFobxtx1000
+ *
+ */
+
+#include <iostream>
+
+class State {
+public:
+    virtual ~State() {}
+    
+    virtual void Handle() = 0;
+};
+
+class ConcreteStateA : public State {
+    ~ConcreteStateA() {}
+    
+    void Handle() {
+        std::cout << "State A handled." << std::endl;
+    }
+};
+
+class ConcreteStateB : public State {
+    ~ConcreteStateB() {}
+
+    void Handle() {
+        std::cout << "State B handled." << std::endl;
+    }
+};
+
+class Context {
+public:
+    Context() : state() {}
+    ~Context() {
+        if (state) {
+            delete state;
+        }
+    }
+    
+    void setState(State* const s) {
+        if (state) {
+            delete state;
+        }
+        state = s;
+    }
+    
+    void Request() {
+        std::cout << "call handler()" << std::endl;
+        state->Handle();
+    }
+    
+private:
+    State* state;
+};
+
+int main() {
+    Context* context = new Context();
+    
+    context->setState(new ConcreteStateA());
+    context->Request();
+    
+    context->setState(new ConcreteStateB());
+    context->Request();
+}

23patterns-cplusplus/Strategy.cpp

@@ -0,0 +1,61 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: STRATEGY
+ * http://www.plantuml.com/plantuml/uml/bP3FIiD04CRlynHpgw8rU2qXj57nvi7cud6ocIOB-oTiPgL1VQ0-Hr_CRJ15K12_q_9zluKVinw4WaHh85lWjdhUL0-FBxZ884KP6WQyyqvuBm3Q2OSTASQj119kHtm3JBb2thEAmXUNyF7jcmeiFBER_y3bxt2d6qQslOnesTOS1e0lFVJBvTaBpeBvUwf_gFonbm3E2oCD-7GxUUHraIjlV5W5Fv8fJUHYflDiMeeyguiPhiQULwS2I-xeLVj0PjhkZuUTTbemEYJJ-g2bitoDXZ6mQoPckhFgoBLCTHfOKjKS3tq2o0as4PNHxEG6KeCdLLYdLxJc4m00
+ *
+ */
+
+
+#include <iostream>
+
+class Strategy {
+public:
+    virtual ~Strategy() {}
+    virtual void execute() = 0;
+};
+
+class ConcreteStrategyA : public Strategy {
+    ~ConcreteStrategyA() {}
+
+    void execute() {
+        std::cout << "Concrete Strategy A" << std::endl;
+    }
+};
+
+class ConcreteStrategyB : public Strategy {
+    ~ConcreteStrategyB() {}
+
+    void execute() {
+        std::cout << "Concrete Strategy B" << std::endl;
+    }
+};
+
+class ConcreteStrategyC : public Strategy {
+    ~ConcreteStrategyC() {}
+
+    void execute() {
+        std::cout << "Concrete Strategy C" << std::endl;
+    }
+};
+
+class Context {
+public:
+    Context(Strategy* s) : strategy(s) {
+        std::cout << "Assign Concrete Strategy : " << typeid(*s).name() << std::endl;
+    }
+    ~Context() {
+        delete strategy;
+    }
+
+    void execute() {
+        strategy->execute();
+    }
+private:
+    Strategy* strategy;
+};
+
+int main() {
+    Context context(new ConcreteStrategyB());
+    context.execute();
+}

23patterns-cplusplus/Template_Method.cpp

@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: TEMPLATE METHOD
+ * http://www.plantuml.com/plantuml/uml/PL5BJiCm4Dtx52EnAAXjedPPHL4_hSI2KXQvWECCn99Z1tjIgGBkGy-HYp59gGJDhCRFxwEdMGQIdfhAY7W4sMx_yhJATh3VPO-7BOnYmQEC305MUI0l5MtwLq9OrKOIxf5ALzm_W9B6mA56BqaxEvlC9r4KfV0XW6SCj_mUlliZ649pXhwkyHjdbKV2I_pLTI0V3-IbBX0ud4vGOPMZ3qBSTFcSJl_x2s4T8SW0ppC1F4cU9iePvnVUdQHPcmRJxBSHN2ebSKz8apXFhvhiLEEY0s2DfJngvwNf_xRj-LLRJT1OaERDUKrbXH3U6pH8x5auIptJO82gFNS9l1sr9wPqO606QCldiqgtPqPgwS58w6Mggu6WkbRjDs4aq1RGjH9BtlZUFm00
+ *
+ */
+
+
+#include <iostream>
+
+class AbstractClass {
+public:
+  virtual ~AbstractClass() {}
+
+  void templateMethod() {
+    std::cout << "generic design step1" << std::endl;
+    Operation1();
+    std::cout << "generic design step2" << std::endl;
+    Operation2();
+  }
+
+  virtual void Operation1() = 0;
+  virtual void Operation2() = 0;
+};
+
+class ConcreteClass : public AbstractClass {
+public:
+  ~ConcreteClass() {}
+
+  void Operation1() {
+    std::cout << "ConcreteClass Operation 1" << std::endl;
+  }
+
+  void Operation2() {
+    std::cout << "ConcreteClass Operation 2" << std::endl;
+  }
+};
+
+int main() {
+  AbstractClass *templateClass = new ConcreteClass();
+  templateClass->templateMethod();
+}

23patterns-cplusplus/Visitor.cpp

@@ -0,0 +1,104 @@
+#include <stdio.h>
+
+/*
+ * C++ Design Patterns: VISITOR
+ * http://www.plantuml.com/plantuml/uml/jLB1RjGm4BtxAqRYiAsgTDKULr5KKZZq0gXKlQBPPBerSkmm7aUgW7_Xck_8Zv6uTaNLPIK4-93OyzwyDthsXHTa2PrHwnNSNdsykdb_3QkrcbTZq7kuD9giAAMj4DzXGt2hlHR7y5N1l5x1i9pV6kh8okiZRG5XS-bimoIKoyTxkFN2tRxWriVgUpRFKB8yIvudV-1vyfUUv__LyzTSK_qfLsmQwcLf7c2JKzypQFPEZGNqh0SK-jIYO9fdlrO2ToHlKF3ezzhrlz5E69H5VbPFbMz5yUAs3wBdwb42YgBAqQdqVzwGypc8rafP9mJeuTrPdBtSLcNZZECDkmSqjGbK9Uzo7O6gN6-hpBrvw6cp5A2cUnoqOpGHkwQUfz6J5O9W2Lm_ZOoYdONf1ymG6ks98P9xPD127RG41i4BXqO2KpoltFOpoUaZymDnHxBKsscyqrPpLBSk36JCCvl8zsWzDFTeTyHBLxpdkNarZMOQOowz2saCWrz2L8cV-4Hnf-LKaMrXoKbTpBlGcPy0
+ *
+ */
+
+#include <iostream>
+
+class Element;
+class ConcreteElementA;
+class ConcreteElementB;
+
+class Visitor {
+public:
+    virtual ~Visitor() {}
+
+    virtual void visitorElementA(ConcreteElementA* const element) = 0;
+    virtual void visitorElementB(ConcreteElementB* const element) = 0;
+};
+
+class ConcreteVisitor1 : public Visitor {
+public:
+    ~ConcreteVisitor1() {}
+
+    void visitorElementA(ConcreteElementA* const element);
+    void visitorElementB(ConcreteElementB* const element);
+};
+
+class ConcreteVisitor2 : public Visitor {
+public:
+    ~ConcreteVisitor2() {}
+
+    void visitorElementA(ConcreteElementA* const element);
+    void visitorElementB(ConcreteElementB* const element);
+};
+
+class Element {
+public:
+    Element() {std::cout << "Constructor Element "<< std::endl;}
+    virtual ~Element() {std::cout << "Destructor Element "<< std::endl;}
+
+    virtual  void accept(Visitor& v) = 0;
+};
+
+class ConcreteElementA : public Element {
+public:
+    ConcreteElementA(const std::string& data)
+    : private_data(data) {}
+    ~ConcreteElementA() {}
+
+    void accept(Visitor& v) {
+        v.visitorElementA(this);
+    }
+
+    std::string getData() {
+        return private_data;
+    }
+private:
+    std::string private_data;
+};
+
+class ConcreteElementB : public Element {
+public:
+    ConcreteElementB(const std::string& data)
+    : private_data(data) {}
+    ~ConcreteElementB() {}
+
+    void accept(Visitor& v) {
+        v.visitorElementB(this);
+    }
+
+    std::string getData() {
+        return private_data;
+    }
+private:
+    std::string private_data;
+};
+
+void ConcreteVisitor1::visitorElementA(ConcreteElementA *const element) {
+    std::cout << "Concrete Visitor 1 : Element A visited, " << element->getData() << std::endl;
+}
+void ConcreteVisitor1::visitorElementB(ConcreteElementB *const element) {
+    std::cout << "Concrete Visitor 1 : Element B visited, " << element->getData() << std::endl;
+}
+void ConcreteVisitor2::visitorElementA(ConcreteElementA *const element) {
+    std::cout << "Concrete Visitor 2 : Element A visited, " << element->getData() << std::endl;
+}
+void ConcreteVisitor2::visitorElementB(ConcreteElementB *const element) {
+    std::cout << "Concrete Visitor 2 : Element B visited, " << element->getData() << std::endl;
+    
+}
+
+int main() {
+    ConcreteVisitor1 visitor1;
+    ConcreteVisitor2 visitor2;
+    ConcreteElementA elementA("String ElementA ConcreteElementA");
+    elementA.accept(visitor1);
+    elementA.accept(visitor2);
+    ConcreteElementB elementB("String ElementB ConcreteElementB");
+    elementB.accept(visitor1);
+    elementB.accept(visitor2);
+}

23patterns-plantuml/abstract_factory.txt

@@ -0,0 +1,47 @@
+@startuml
+/' ABSTRACT FACTORY '/
+
+
+
+class Client
+
+interface AbstractFactory {
+    # createProductA()
+    # createProductB()
+}
+
+class ConcreteFactory {
+    + createProductA()
+    + createProductB()
+}
+
+interface AbstractProduct {
+# somethingProduct()
+}
+
+class ProductA {
++ somethingProduct()
+}
+
+
+class ProductB {
++ somethingProduct()
+}
+
+hide empty members
+
+AbstractFactory <|-- ConcreteFactory
+AbstractProduct <|-- ProductA
+AbstractProduct <|-- ProductB
+Client --> AbstractFactory
+Client --> AbstractProduct
+
+note as N1
+    <b><color:royalBlue>Abstract Factory</color></b>
+    <b>Type:</b> Creational
+    Permet la création d'objets qui
+    sont liés à des classes connues
+    et assocées sans avoir à le préciser
+    dans leur classe concrète
+end note
+@enduml

23patterns-plantuml/adapter.txt

@@ -0,0 +1,46 @@
+@startuml
+/' ADAPTER '/
+
+
+
+interface Adapter {
+    # operation()
+}
+
+class Client {
+    + do_client_operation()
+}
+
+class ConcreteAdapter {
+    - ConcreteAdapter(in Adaptee1)
+    - ConcreteAdapter(in Adaptee2)
+    + operation()
+}
+
+class Adaptee1 {
+    + Adaptee1Bizarre()
+    + operation()
+}
+
+class Adaptee2 {
+    + Adaptee2Bizarre()
+}
+
+
+hide empty members
+
+Adapter <- Client
+Adapter <|-- Adaptee1
+Adapter <|-- ConcreteAdapter
+ConcreteAdapter -> Adaptee1
+ConcreteAdapter -> Adaptee2
+
+note as N1
+    <b><color:royalBlue>Adapter</color></b>
+    <b>Type:</b> Structural
+    Réalise une conversion compatible avec 
+    les attentes du client. La conversion
+    des interfaces est réalisée à l'instanciation
+    des objets.
+end note
+@enduml

23patterns-plantuml/bridge.txt

@@ -0,0 +1,33 @@
+@startuml
+/' BRIDGE '/
+
+
+
+class Abstraction {
+    # operation()
+    - protected_implementation (operationImp)
+}
+
+interface Implementor {
+    # operationImp()
+}
+
+class ConcreteImplementorA {
+    + operationImp()
+}
+
+class ConcreteImplementorB {
+    + operationImp()
+}
+
+Abstraction *-- Implementor
+Implementor <|-- ConcreteImplementorA
+Implementor <|-- ConcreteImplementorB
+
+note as N1
+    <b><color:royalBlue>Bridge</color></b>
+    <b>Type:</b> Structural
+    Découple l'abstraction de son implémentation
+    et les 2 peuvent évouer indépendamment.
+end note
+@enduml

23patterns-plantuml/builder.txt

@@ -0,0 +1,45 @@
+@startuml
+/' BUILDER '/
+
+
+
+class Director {
+    - builder
+    + construct()
+    + setBuilder(Builder)
+    + Product getProduct()
+}
+
+interface Builder {
+    # buildPartA()
+    # buildPartB()
+    # buildPartC()
+}
+
+class ConcreteBuilderFirst {
+    + buildPartA()
+    + buildPartB()
+    + buildPartC()
+    + getResult()
+}
+
+class ConcreteBuilderSecond {
+    + buildPartA()
+    + buildPartB()
+    + buildPartC()
+    + getResult()
+}
+
+
+Director *- Builder
+Builder <|-- ConcreteBuilderFirst
+Builder <|-- ConcreteBuilderSecond
+
+note as N1
+    <b><color:royalBlue>Builder</color></b>
+    <b>Type:</b> Creational
+    Permet la séparation des méthodes
+    de construction - un objet complexe
+    peut avoir différentes représentations.
+end note
+@enduml

23patterns-plantuml/chain_of_responsibility.txt

@@ -0,0 +1,35 @@
+@startuml
+/' CHAIN OF RESPONSIBILITY '/
+
+
+
+class Client
+
+interface Handler {
+    - private_successor
+    # handleRequest()
+}
+
+class ConcreteHandler1 {
+    + handleRequest()
+}
+
+class ConcreteHandler2 {
+    + handleRequest()
+}
+
+hide empty members
+
+Client -> Handler
+Handler <|-- ConcreteHandler1
+Handler <|-- ConcreteHandler2
+Handler -> Handler : successor
+
+note as N1
+    <b><color:royalBlue>Chain of Responsibility</color></b>
+    <b>Type:</b> Behavioral
+    Permet de construire une chaîne de responsabilité 
+    avec découplage, le traitement de la requête peut être 
+    déroulé par plusieurs objets qui héritent du Handler.
+end note
+@enduml

23patterns-plantuml/command.txt

@@ -0,0 +1,40 @@
+@startuml
+/' COMMAND '/
+
+
+
+
+
+class Invoker {
+    - private_command
+    + setCommand()
+    + executeCommand()
+}
+
+class Receiver {
+    + action()
+}
+
+interface Command {
+    # execute()
+}
+
+class ConcreteCommand {
+    - private_receiver
+    + execute()
+}
+
+hide empty members
+
+
+Invoker *-- Command
+Receiver --* ConcreteCommand
+ConcreteCommand -|> Command
+
+note as N1
+    <b><color:royalBlue>Command</color></b>
+    <b>Type:</b> Behavioral
+    Encapsule une commande dans un objet,
+    découple le client du fournisseur.
+end note
+@enduml

23patterns-plantuml/composite.txt

@@ -0,0 +1,41 @@
+@startuml
+/' COMPOSITE '/
+
+
+
+interface Component {
+    - m_name
+    # operation()
+    # add(in c : Composite)()
+    # remove(in c : Composite)
+    # getChild(in i : int)
+    # enumerate()
+}
+
+class Leaf {
+    - privage_id
+    + operation()
+    + enumerate()
+}
+
+class Composite {
+    - private_children vector
+    + operation()
+    + add(in c : Composite)()
+    + remove(in c : Composite)
+    + getChild(in i : int)
+    + enumerate()
+}
+
+Component <|-- Leaf
+Component <|-- Composite
+Component --* Composite
+
+note as N1
+    <b><color:royalBlue>Composite</color></b>
+    <b>Type:</b> Structural
+    Assemblage d'objets dans une structure
+    arborescente, l'idée est de banaliser
+    l'accès - unitaire ou de groupe d'objet.
+end note
+@enduml

23patterns-plantuml/decorator.txt

@@ -0,0 +1,34 @@
+@startuml
+/' DECORATOR '/
+
+
+
+interface Component {
+    # operation()
+}
+
+class ConcreteComponent {
+    + operation()
+}
+
+class Decorator {
+    #operation()
+    - private_component
+}
+
+class ConcreteDecorator {
+    + operation()
+}
+
+Component <|-- ConcreteComponent
+Component <|-- Decorator
+Component --* Decorator
+Decorator <|- ConcreteDecorator
+
+note as N1
+    <b><color:royalBlue>Decorator</color></b>
+    <b>Type:</b> Structural
+    Permet d'étendre un objet sans héritage mais
+    en ajoutant une méthode de manière dynamique.
+end note
+@enduml

23patterns-plantuml/facade.txt

@@ -0,0 +1,34 @@
+@startuml
+/' FACADE '/
+
+
+
+class Facade {
+ -  subsystem1
+ -  subsystem2
+ -  subsystem3
+ -  subsystem4
+}
+
+package "Complex system" <<Node>> {
+    class Subsystem1
+    class Subsystem2
+    class Subsystem3
+    class Subsystem4
+}
+
+hide empty members
+
+Facade --> Subsystem1
+Facade --> Subsystem2
+Facade --> Subsystem3
+Facade --> Subsystem4
+
+note as N1
+    <b><color:royalBlue>Facade</color></b>
+    <b>Type:</b> Structural
+    Masque la complexité - et uniformise l'accès
+    à des sous-systèmes avec une approche
+    simplifiée.
+end note
+@enduml

23patterns-plantuml/factory_method.txt

@@ -0,0 +1,33 @@
+@startuml
+/' FACTORY METHOD '/
+
+
+
+class Creator {
+    # factoryMethod()
+}
+
+class ConcreteCreator {
+    + factoryMethod()
+}
+
+interface Product {
+    # somethingProduct()
+}
+
+class ConcreteProduct
+
+hide empty members
+
+Product <|-- ConcreteProduct
+Creator <|-- ConcreteCreator
+ConcreteProduct <. ConcreteCreator
+
+note as N1
+    <b><color:royalBlue>Factory Method</color></b>
+    <b>Type:</b> Creational
+    Décrit une interface pour créer un objet,
+    mais laisse la sous-classe décider.
+    L'instanciation est choisie par la sous-classe.
+end note
+@enduml

23patterns-plantuml/flyweight.txt

@@ -0,0 +1,44 @@
+@startuml
+/' FLYWEIGHT '/
+
+
+
+class FlyweightFactory {
+    - unordered_map
+    + getFlyweight()
+    + listFlyweights() 
+}
+
+interface Flyweight {
+    # operation(in extrinsicState)
+}
+
+class Client
+
+class ConcreteFlyweight {
+    - intrinsicState
+    + operation(in extrinsicState)
+}
+
+class UnsharedConcreteFlyweight {
+    - allState
+    + operation(in extrinsicState)
+}
+
+hide empty members
+
+FlyweightFactory *- Flyweight
+Flyweight <|-- ConcreteFlyweight
+Flyweight <|-- UnsharedConcreteFlyweight
+FlyweightFactory <-- Client
+ConcreteFlyweight <-- Client
+UnsharedConcreteFlyweight <-- Client
+
+note as N1
+    <b><color:royalBlue>Flyweight</color></b>
+    <b>Type:</b> Structural
+    Enregistre les objets dans une structure de données,
+    capable de supporter un effectif vaste d'objet du même
+    type.
+end note
+@enduml

23patterns-plantuml/interpreter.txt

@@ -0,0 +1,44 @@
+@startuml
+/' INTERPRETER '/
+
+
+
+class Client
+
+class Context {
+    - token
+    - private_map
+    + set(in token, in bool)
+    + get(in token) : bool
+}
+
+interface AbstractExpression {
+    # interpret()
+}
+
+class TerminalExpression {
+    - private_token
+    + interpret() : Context
+}
+
+class NonterminalExpression {
+    - private_AbstractExp1
+    - private_AbstractExp2
+    + interpret() : Context
+}
+
+hide empty members
+
+Context <- Client
+Client --> AbstractExpression
+AbstractExpression <|-- TerminalExpression
+AbstractExpression <|-- NonterminalExpression
+AbstractExpression --* NonterminalExpression
+
+note as N1
+    <b><color:royalBlue>Interpreter</color></b>
+    <b>Type:</b> Behavioral
+    Permet de décrire une grammaire pour un
+    langage et d'instancier son interpreteur.
+end note
+@enduml

23patterns-plantuml/iterator.txt

@@ -0,0 +1,47 @@
+@startuml
+/' ITERATOR '/
+
+
+
+class Client
+
+interface Aggregate {
+    # createIterator()
+}
+
+class ConcreteAggregate {
+    + createIterator() : Context
+    + getItem() : Int
+    + getSize(): Uint
+    + addItem() : Context
+}
+
+interface Iterator {
+    # next() : Context
+    # first() : Context
+    # isDone() : Bool
+    # currentItem() : Context
+}
+
+class ConcreteIterator {
+    + next() : Context
+    + first() : Context
+    + isDone() : Bool
+    + currentItem() : Context
+}
+
+hide empty members
+
+Client --> Aggregate
+Client --> Iterator
+Aggregate <|-- ConcreteAggregate
+Iterator <|-- ConcreteIterator
+
+note as N1
+    <b><color:royalBlue>Iterator</color></b>
+    <b>Type:</b> Behavioral
+    Permet d'accéder aux données d'un agrégat
+    de manière séquentielle sans avoir 
+    à connaitre la structure de données de l'objet.
+end note
+@enduml

23patterns-plantuml/mediator.txt

@@ -0,0 +1,44 @@
+@startuml
+/' MEDIATOR '/
+
+
+
+
+class Mediator {
+    # add()
+    # distribute()
+}
+
+class ConcreteMediator {
+     - vector_colleagues
+     + add()
+     + distribute()
+}
+
+class Colleague {
+     - private_mediator
+     - private_id
+     # sendMsg()
+     # receiveMsg()
+}
+
+class ConcreteColleague {
+     + sendMsg()
+     + receiveMsg()
+}
+
+hide empty members
+
+Mediator <- Colleague : informe
+Mediator <|-- ConcreteMediator
+ConcreteMediator -> ConcreteColleague
+Colleague <|-- ConcreteColleague
+
+note as N1
+    <b><color:royalBlue>Mediator</color></b>
+    <b>Type:</b> Behavioral
+    Décrit un objet qui encapsule les interactions
+    d'un ensemble d'objet. Met en avant le 
+    couplage léger par une invocation explicite.
+end note
+@enduml

23patterns-plantuml/memento.txt

@@ -0,0 +1,35 @@
+@startuml
+/' MEMENTO '/
+
+
+
+class Caretaker {
+    - Private_Originator 
+    - Saved_Memento
+    - Undo_Memento
+    - Redo_Memento
+}
+
+class Memento {
+    - state
+}
+
+class Originator {
+    - state
+    + setMemento(in m : Memento)
+    + createMemento()
+}
+
+hide empty members
+
+Caretaker *- Memento
+Memento <-- Originator
+
+note as N1
+    <b><color:royalBlue>Memento</color></b>
+    <b>Type:</b> Behavioral
+    Sans modifier l'encapsulation de l'objet,
+    enregistre l'état de celui-ci pour permettre
+    la restauration de son état.
+end note
+@enduml

23patterns-plantuml/observer.txt

@@ -0,0 +1,49 @@
+@startuml
+/' OBSERVER '/
+
+
+
+interface Subject {
+    - vObserver : Vector
+    + attach(in o : Observer)
+    + detach(in o : Observer)
+    + notify()
+    # getState()
+    # setState()
+}
+
+class ConcreteSubject {
+    - subjectState : Int
+    + getState()
+    + setState() 
+}
+
+interface Observer {
+    # update(s : Subject) : Context
+    # getState() : Int
+    # getId() : Int
+}
+
+class ConcreteObserver {
+    - observerState : Int
+    + update()
+    + getState()
+    + setState()
+}
+
+hide empty members
+
+Subject ->"0..*" Observer : notifies
+Subject <|-- ConcreteSubject
+Observer <|-- ConcreteObserver
+ConcreteSubject <- ConcreteObserver : observes
+
+note as N1
+    <b><color:royalBlue>Observer</color></b>
+    <b>Type:</b> Behavioral
+    Définit une relation un à plusieurs
+    pour réaliser la mise à jour lors
+    d'un changement d'état. Tous les objets
+    dépendants sont notifiés automatiquement.
+end note
+@enduml

23patterns-plantuml/prototype.txt

@@ -0,0 +1,36 @@
+@startuml
+/' PROTOTYPE '/
+
+
+
+interface Prototype {
+    # clone()
+}
+
+class Client {
+    + setPrototype(Prototype *p)
+    - private_prototype
+    + client_clone()
+}
+
+class ConcretePrototype1 {
+    + clone()
+}
+
+class ConcretePrototype2 {
+    + clone()
+}
+
+hide empty members
+
+Client --> Prototype
+Prototype <|-- ConcretePrototype1
+Prototype <|-- ConcretePrototype2
+
+note as N1
+    <b><color:royalBlue>Prototype</color></b>
+    <b>Type:</b> Creational
+    Spécifie l'objet par un constructeur nommé 'Prototype'
+    et instancie des objets à traver le clonage du prototype.
+end note
+@enduml

23patterns-plantuml/proxy.txt

@@ -0,0 +1,34 @@
+@startuml
+/' PROXY '/
+
+
+
+class Client
+
+interface Subject {
+    # request()
+}
+
+class RealSubject {
+    + request()
+}
+
+class Proxy {
+    - private_subject
+    + request()
+}
+
+hide empty members
+
+Subject <|-- RealSubject
+Subject <|-- Proxy
+RealSubject <- Proxy : représentation de
+Client --> Proxy
+
+note as N1
+    <b><color:royalBlue>Proxy</color></b>
+    <b>Type:</b> Structural
+    Encapsule un objet - en mode mirroir et
+    respecte le même contrat que celui-ci.
+end note
+@enduml

23patterns-plantuml/singleton.txt

@@ -0,0 +1,17 @@
+@startuml
+/' SINGLETON '/
+
+
+
+class Singleton {
+    - static unique_instance
+    + static Instance()
+}
+
+note as N1
+    <b><color:royalBlue>Singleton</color></b>
+    <b>Type:</b> Creational
+    Classe qui ne peut avoir qu'une seule instance
+    et qui donne une point d'accès global.
+end note
+@enduml

23patterns-plantuml/state.txt

@@ -0,0 +1,35 @@
+@startuml
+/' STATE '/
+
+
+
+class Context <State.handler()> {
+    + Request()
+}
+
+interface State {
+    + Handle()
+}
+
+class ConcreteState1 {
+    + Handle()
+}
+
+class ConcreteState2 {
+    + Handle()
+}
+
+hide empty members
+
+Context o-- State
+State <|-- ConcreteState1
+State <|-- ConcreteState2
+
+note as N1
+    <b><color:royalBlue>State</color></b>
+    <b>Type:</b> Behavioral
+    Encapsule le comportement à travers un handler()
+    Celui ci peut être mis à jour à 
+    travers un changement de classe
+end note
+@enduml

23patterns-plantuml/strategy.txt

@@ -0,0 +1,63 @@
+@startuml
+/' STRATEGY '/
+
+
+
+class Context
+
+interface Strategy {
+    + execute()
+}
+
+class ConcreteStrategyA {
+    + execute()
+}
+
+class ConcreteStrategyB {
+    + execute()
+}
+
+hide empty members
+
+Context o-- Strategy
+Strategy <|-- ConcreteStrategyA
+Strategy <|-- ConcreteStrategyB
+
+note as N1
+    <b><color:royalBlue>Strategy</color></b>
+    <b>Type:</b> Behavioral
+    Définit un algorithme, le rend
+    interchangeable et indépendant du client.
+end note
+@enduml@startuml
+/' STRATEGY '/
+
+
+
+class Context
+
+interface Strategy {
+    + execute()
+}
+
+class ConcreteStrategyA {
+    + execute()
+}
+
+class ConcreteStrategyB {
+    + execute()
+}
+
+hide empty members
+
+Context o-- Strategy
+Strategy <|-- ConcreteStrategyA
+Strategy <|-- ConcreteStrategyB
+
+note as N1
+    <b><color:royalBlue>Strategy</color></b>
+    <b>Type:</b> Behavioral
+    Définit un algorithme, le rend
+    interchangeable et indépendant du client.
+end note
+@enduml

23patterns-plantuml/template_method.txt

@@ -0,0 +1,28 @@
+@startuml
+/' TEMPLATE METHOD '/
+
+
+
+class AbstractClass <templateMethod() call Operation1,2,...> {
+    + templateMethod()
+    # Operation1()
+    # Operation2()
+}
+
+class ConcreteClass {
+    + Operation1()
+    + Operation2()
+}
+
+hide empty members
+
+AbstractClass <|-- ConcreteClass
+
+note as N1
+    <b><color:royalBlue>Template Method</color></b>
+    <b>Type:</b> Behavioral
+    Définit un algorithme squelette dont
+    les méthodes virtuelles sont instanciées par la 
+    classe concrète.
+end note
+@enduml

23patterns-plantuml/visitor.txt

@@ -0,0 +1,56 @@
+@startuml
+/' VISITOR '/
+
+
+
+class Client
+
+interface Visitor {
+    # visitElementA(in a :ConcreteElementA)
+    # visitElementB(in b :ConcreteElementB)
+}
+
+class ConcreteVisitor1 {
+    + visitElementA(in a :ConcreteElementA)
+    + visitElementB(in b :ConcreteElementB)
+}
+
+class ConcreteVisitor2 {
+    + visitElementA(in a :ConcreteElementA)
+    + visitElementB(in b :ConcreteElementB)
+}
+
+
+interface Element {
+    # accept(in v : Visitor)
+}
+
+class ConcreteElementA {
+    - private_data
+    + accept(in v : Visitor)
+    + getData()
+}
+
+class ConcreteElementB {
+    - private_data
+    + accept(in v : Visitor)
+    + getData()
+}
+
+Visitor <- Client
+Visitor <|-- ConcreteVisitor1
+Visitor <|-- ConcreteVisitor2
+Client --> Element
+Element <|-- ConcreteElementA
+Element <|-- ConcreteElementB
+
+note as N1
+    <b><color:royalBlue>Visitor</color></b>
+    <b>Type:</b> Behavioral
+    Représente une opération à réaliser 
+    par item de la structure de l'objet. 
+    Permet de définir une nouvelle opération 
+    sans changer de classe d'élément pour 
+    laquelle elle interagit.
+end note
+@enduml