Add design principle examples

Author: XuhuaHuang

DesignPrinciple/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.20)
+
+project("design_principle" LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+add_executable(composition_over_inheritance "composition_over_inheritance.cpp")
+add_executable(interface_segregation "interface_segregation.cpp")

DesignPrinciple/code_to_interface_logger.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+#include <memory>
+#include <string>
+
+class ILogger {
+public:
+  virtual ~ILogger()                             = default;
+  virtual void log(const std::string& msg) const = 0;
+};
+
+class FileLogger : public ILogger {
+public:
+  void log(const std::string& msg) const override { std::cout << "[File] " << msg << '\n'; }
+};
+
+class ConsoleLogger : public ILogger {
+public:
+  void log(const std::string& msg) const override { std::cout << "[Console] " << msg << '\n'; }
+};
+
+class Application {
+public:
+  explicit Application(std::unique_ptr<ILogger> logger_in)
+    : logger(std::move(logger_in)) {}
+
+  void run() const { logger->log("App is running"); }
+
+private:
+  std::unique_ptr<ILogger> logger;
+};
+
+int main() {
+  std::unique_ptr<ILogger> logger = std::unique_ptr<ILogger>(new ConsoleLogger());
+
+  Application app(std::move(logger));
+  app.run();
+  return 0;
+}

DesignPrinciple/composition_over_inheritance.cpp

@@ -0,0 +1,89 @@
+/**
+ * @file composition_over_inheritance.cpp
+ * @author Xuhua Huang
+ * @brief Inheritance establishes an IS-A relaHonship
+ * Composition/aggregation establish a HAS-A relaHonship – this can often be preferable
+ *
+ * Aggregation
+ * An object comprised of other objects uses those objects
+ * Those objects exist outside of the object
+ * When the object is destroyed, the objects that comprise it remain
+ *
+ * @version 0.1
+ * @date 2026-04-09
+ *
+ * @copyright Copyright (c) 2026
+ *
+ */
+
+#include <iostream>
+#include <memory>
+// #include <string>
+
+class IMovement {
+public:
+  virtual ~IMovement()      = default;
+  virtual void move() const = 0;
+};
+
+class IPowerSource {
+public:
+  virtual ~IPowerSource()           = default;
+  virtual void supply_power() const = 0;
+};
+
+class WheelMovement : public IMovement {
+public:
+  void move() const override { std::cout << "Moving on wheels\n"; }
+};
+
+class FlyingMovement : public IMovement {
+public:
+  void move() const override { std::cout << "Flying in the air\n"; }
+};
+
+class GasEngine : public IPowerSource {
+public:
+  void supply_power() const override { std::cout << "Supplying power from gas engine\n"; }
+};
+
+class ElectricBattery : public IPowerSource {
+public:
+  void supply_power() const override { std::cout << "Supplying power from battery\n"; }
+};
+
+class Vehicle {
+public:
+  Vehicle(std::unique_ptr<IMovement> movement, std::unique_ptr<IPowerSource> power_source)
+    : movement(std::move(movement))
+    , power_source(std::move(power_source)) {}
+
+  void operate() const {
+    power_source->supply_power();
+    movement->move();
+  }
+
+private:
+  std::unique_ptr<IMovement>    movement;
+  std::unique_ptr<IPowerSource> power_source;
+};
+
+int main() {
+  // Traditional car
+  Vehicle car(std::make_unique<WheelMovement>(), std::make_unique<GasEngine>());
+
+  // Electric car
+  Vehicle ev(std::make_unique<WheelMovement>(), std::make_unique<ElectricBattery>());
+
+  // Futuristic flying electric vehicle
+  Vehicle drone(std::make_unique<FlyingMovement>(), std::make_unique<ElectricBattery>());
+
+  car.operate();
+  ev.operate();
+  drone.operate();
+}
+
+class SolarPanel : public IPowerSource {
+public:
+  void supply_power() const override { std::cout << "Supplying power from solar energy\n"; }
+};

DesignPrinciple/dependency_inversion.cpp

@@ -0,0 +1,86 @@
+// High-level modules should not depend upon low-level modules. Both should depend upon abstractions.
+// Abstractions should not depend upon details. Details should depend upon abstractions.
+
+/**
+ * @file dependency_inversion.cpp
+ * @author Xuhua Huang
+ * @brief Demonstration of the Dependency Inversion Principle (DIP)
+ *
+ * High-level modules should not depend on low-level modules.
+ * Both should depend on abstractions.
+ *
+ * @version 0.1
+ * @date 2026-04-09
+ */
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+// Abstractions
+class data_source_t {
+public:
+  virtual ~data_source_t()         = default;
+  virtual std::string read() const = 0;
+};
+
+class report_format_t {
+public:
+  virtual ~report_format_t()                        = default;
+  virtual void write(const std::string& data) const = 0;
+};
+
+// Low-Level Implementations (Depend on Abstractions)
+class database_source_t : public data_source_t {
+public:
+  std::string read() const override { return "data from database"; }
+};
+
+class text_file_source_t : public data_source_t {
+public:
+  std::string read() const override { return "data from text file"; }
+};
+
+class html_report_writer_t : public report_format_t {
+public:
+  void write(const std::string& data) const override { std::cout << "<html><body>" << data << "</body></html>\n"; }
+};
+
+class pdf_report_writer_t : public report_format_t {
+public:
+  void write(const std::string& data) const override { std::cout << "PDF Report: " << data << '\n'; }
+};
+
+// High-Level Module (Depends Only on Abstractions)
+class report_generator_t {
+public:
+  report_generator_t(std::unique_ptr<data_source_t> source, std::unique_ptr<report_format_t> formatter)
+    : source(std::move(source))
+    , formatter(std::move(formatter)) {}
+
+  void generate_report() const {
+    std::string data = source->read();
+    formatter->write(data);
+  }
+
+private:
+  std::unique_ptr<data_source_t>   source;
+  std::unique_ptr<report_format_t> formatter;
+};
+
+// Composition Root (Client Code)
+int main() {
+  // Example 1: Database + HTML
+  report_generator_t generator(std::make_unique<database_source_t>(), std::make_unique<html_report_writer_t>());
+
+  generator.generate_report();
+
+  std::cout << "------------------------\n";
+
+  // Example 2: Text File + PDF
+  report_generator_t generator2(std::make_unique<text_file_source_t>(), std::make_unique<pdf_report_writer_t>());
+
+  generator2.generate_report();
+
+  return 0;
+}

DesignPrinciple/interface_segregation.cpp

@@ -0,0 +1,80 @@
+#include <iostream>
+
+class door_t {
+public:
+  virtual ~door_t()            = default;
+
+  virtual void lock()          = 0;
+  virtual void unlock()        = 0;
+  virtual bool is_open() const = 0;
+};
+
+class timer_client_t {
+public:
+  virtual ~timer_client_t() = default;
+  virtual void timeout()    = 0;
+};
+
+class timer {
+public:
+  void register_client(timer_client_t& client, int seconds) {
+    std::cout << "Timer started for " << seconds << " seconds\n";
+
+    // Simulated timeout
+    client.timeout();
+  }
+};
+
+class timed_door_t : public door_t, public timer_client_t {
+public:
+  void lock() override {
+    std::cout << "Timed door locked\n";
+    locked = true;
+  }
+
+  void unlock() override {
+    std::cout << "Timed door unlocked\n";
+    locked = false;
+  }
+
+  bool is_open() const override { return !locked; }
+
+  void timeout() override {
+    std::cout << "Timed door auto-locking after timeout\n";
+    lock();
+  }
+
+private:
+  bool locked{true};
+};
+
+class glass_door_t : public door_t {
+public:
+  void lock() override {
+    std::cout << "Glass door locked\n";
+    locked = true;
+  }
+
+  void unlock() override {
+    std::cout << "Glass door unlocked\n";
+    locked = false;
+  }
+
+  bool is_open() const override { return !locked; }
+
+private:
+  bool locked{true};
+};
+
+int main() {
+  timer timer;
+
+  timed_door_t timed_door;
+  glass_door_t glass_door;
+
+  timed_door.unlock();
+  timer.register_client(timed_door, 5); // Works
+
+  glass_door.unlock();
+  // timer.register_client(glass_door, 5); // ❌ compile-time error (correct!)
+}

DesignPrinciple/liskov_substitution.cpp

@@ -0,0 +1,67 @@
+// Subtypes must be substitutable for their base types
+
+#include <iostream>
+#include <memory>
+
+// class rectangle_t {
+// public:
+//   virtual ~rectangle_t() = default;
+
+//   virtual void set_width(double w) { width = w; }
+//   virtual void set_height(double h) { height = h; }
+
+//   double area() const { return width * height; }
+
+// protected:
+//   double width{0};
+//   double height{0};
+// };
+
+// class square_t : public rectangle_t {
+// public:
+//   void set_width(double w) override { width = height = w; }
+
+//   void set_height(double h) override { width = height = h; }
+// };
+
+class shape_t {
+public:
+  virtual ~shape_t()          = default;
+  virtual double area() const = 0;
+};
+
+class rectangle_t : public shape_t {
+public:
+  rectangle_t(double w, double h)
+    : width(w)
+    , height(h) {}
+
+  double area() const override { return width * height; }
+
+private:
+  double width;
+  double height;
+};
+
+class square_t : public shape_t {
+public:
+  explicit square_t(double side)
+    : side(side) {}
+
+  double area() const override { return side * side; }
+
+private:
+  double side;
+};
+
+void print_area(const shape_t& shape) {
+  std::cout << "Area: " << shape.area() << '\n';
+}
+
+int main() {
+  rectangle_t rect(5, 10);
+  square_t    square(5);
+
+  print_area(rect);   // OK
+  print_area(square); // OK
+}