Upload creational pattern notes

Author: XuhuaHuang

DesignPattern/abstract_factory.cpp

@@ -0,0 +1,89 @@
+#include <iostream>
+#include <memory>
+
+class monster_t {
+public:
+  virtual ~monster_t() = default;
+
+  virtual void attack() const = 0;
+};
+
+class wall_t {
+public:
+  virtual ~wall_t() = default;
+
+  virtual void build() const = 0;
+};
+
+class fire_monster_t : public monster_t {
+public:
+  void attack() const override { std::cout << "Fire monster attacks with flames\n"; }
+};
+
+class fire_wall_t : public wall_t {
+public:
+  void build() const override { std::cout << "Building a fire wall\n"; }
+};
+
+class ice_monster_t : public monster_t {
+public:
+  void attack() const override { std::cout << "Ice monster attacks with frost\n"; }
+};
+
+class ice_wall_t : public wall_t {
+public:
+  void build() const override { std::cout << "Building an ice wall\n"; }
+};
+
+class game_object_factory_t {
+public:
+  virtual ~game_object_factory_t() = default;
+
+  virtual std::unique_ptr<monster_t> create_monster() const = 0;
+  virtual std::unique_ptr<wall_t>    create_wall() const    = 0;
+};
+
+class fire_game_object_factory_t : public game_object_factory_t {
+public:
+  std::unique_ptr<monster_t> create_monster() const override { return std::make_unique<fire_monster_t>(); }
+
+  std::unique_ptr<wall_t> create_wall() const override { return std::make_unique<fire_wall_t>(); }
+};
+
+class ice_game_object_factory_t : public game_object_factory_t {
+public:
+  std::unique_ptr<monster_t> create_monster() const override { return std::make_unique<ice_monster_t>(); }
+
+  std::unique_ptr<wall_t> create_wall() const override { return std::make_unique<ice_wall_t>(); }
+};
+
+class game_level_t {
+public:
+  explicit game_level_t(const game_object_factory_t& factory) {
+    monster = factory.create_monster();
+    wall    = factory.create_wall();
+  }
+
+  void play() const {
+    monster->attack();
+    wall->build();
+  }
+
+private:
+  std::unique_ptr<monster_t> monster;
+  std::unique_ptr<wall_t>    wall;
+};
+
+int main() {
+  std::cout << "=== Fire Level ===\n";
+  fire_game_object_factory_t fire_factory;
+  game_level_t               fire_level(fire_factory);
+  fire_level.play();
+
+  std::cout << "\n=== Ice Level ===\n";
+  ice_game_object_factory_t ice_factory;
+  game_level_t              ice_level(ice_factory);
+  ice_level.play();
+
+  return 0;
+}

DesignPattern/factory_method.cpp

@@ -0,0 +1,100 @@
+/**
+ * @file factory_method.cpp
+ * @author Xuhua Huang
+ * @brief
+ * @version 0.1
+ * @date 2026-04-10
+ *
+ * @copyright Copyright (c) 2026
+ *
+ */
+
+#include <functional>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <string>
+
+class registrar_t {
+public:
+  virtual ~registrar_t() = default;
+
+  virtual void admit_student(const std::string& name) const = 0;
+};
+
+class computer_science_registrar_t : public registrar_t {
+public:
+  void admit_student(const std::string& name) const override { std::cout << "CS registrar admitting " << name << "\n"; }
+};
+
+class engineering_registrar_t : public registrar_t {
+public:
+  void admit_student(const std::string& name) const override {
+    std::cout << "Engineering registrar admitting " << name << "\n";
+  }
+};
+
+class math_registrar_t : public registrar_t {
+public:
+  void admit_student(const std::string& name) const override {
+    std::cout << "Math registrar admitting " << name << "\n";
+  }
+};
+
+class registrar_factory_t {
+public:
+  virtual ~registrar_factory_t() = default;
+
+  // factory method
+  virtual std::unique_ptr<registrar_t> create() const = 0;
+};
+
+class cs_factory_t : public registrar_factory_t {
+public:
+  std::unique_ptr<registrar_t> create() const override { return std::make_unique<computer_science_registrar_t>(); }
+};
+
+class eng_factory_t : public registrar_factory_t {
+public:
+  std::unique_ptr<registrar_t> create() const override { return std::make_unique<engineering_registrar_t>(); }
+};
+
+class math_factory_t : public registrar_factory_t {
+public:
+  std::unique_ptr<registrar_t> create() const override { return std::make_unique<math_registrar_t>(); }
+};
+
+void enroll_students(
+  const std::map<std::string, std::unique_ptr<registrar_factory_t>>& factories,
+  const std::map<std::string, std::string>&                          students_to_enroll
+) {
+  for (const auto& [student, program] : students_to_enroll) {
+    auto it = factories.find(program);
+    if (it != factories.end()) {
+      std::unique_ptr<registrar_t> registrar = it->second->create(); // factory method
+      registrar->admit_student(student);
+    }
+  }
+}
+
+using registrar_factory_fn_t = std::function<std::unique_ptr<registrar_t>()>;
+
+int main() {
+  std::map<std::string, std::unique_ptr<registrar_factory_t>> factories;
+
+  // std::map<std::string, registrar_factory_fn_t> factories;
+  // factories["cs"]  = [] { return std::make_unique<computer_science_registrar_t>(); };
+  // factories["eng"] = [] { return std::make_unique<engineering_registrar_t>(); };
+
+  factories["cs"]   = std::make_unique<cs_factory_t>();
+  factories["eng"]  = std::make_unique<eng_factory_t>();
+  factories["math"] = std::make_unique<math_factory_t>();
+
+  std::map<std::string, std::string> students_to_enroll{
+    {"jeff", "cs"  },
+    {"bob",  "eng" },
+    {"jane", "math"}
+  };
+
+  enroll_students(factories, students_to_enroll);
+}