Refactor design principles

Author: XuhuaHuang

DesignPrinciple/CMakeLists.txt

@@ -7,5 +7,14 @@ 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")
+add_executable(code_to_interface
+    code_to_interface_logger.cpp
+)
+
+add_executable(composition_over_inheritance
+    composition_over_inheritance.cpp
+)
+
+add_executable(interface_segregation
+    interface_segregation.cpp
+)

DesignPrinciple/code_to_interface_logger.cpp

@@ -1,38 +1,102 @@
+#include <chrono>
+#include <iomanip>
 #include <iostream>
 #include <memory>
+#include <sstream>
 #include <string>
+#include <vector>
 
-class ILogger {
+inline std::string current_time_string() {
+  // using namespace std::chrono;
+
+  const std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+
+  const std::time_t time = std::chrono::system_clock::to_time_t(now);
+
+  std::ostringstream oss;
+  oss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S");
+  return oss.str();
+}
+
+enum class log_level_t { info, warning, error };
+
+inline std::string to_string(log_level_t level) {
+  switch (level) {
+  case log_level_t::info:
+    return "INFO";
+  case log_level_t::warning:
+    return "WARNING";
+  case log_level_t::error:
+    return "ERROR";
+  }
+  return "UNKNOWN";
+}
+
+class logger_t {
 public:
-  virtual ~ILogger()                             = default;
-  virtual void log(const std::string& msg) const = 0;
+  virtual ~logger_t() = default;
+
+  virtual void log(const std::string& msg, log_level_t level = log_level_t::info) const = 0;
 };
 
-class FileLogger : public ILogger {
+class console_logger_t : public logger_t {
 public:
-  void log(const std::string& msg) const override { std::cout << "[File] " << msg << '\n'; }
+  void log(const std::string& msg, log_level_t level = log_level_t::info) const override {
+    std::cout << "[" << current_time_string() << "] " << "[" << to_string(level) << "] " << "[console] " << msg << '\n';
+  }
 };
 
-class ConsoleLogger : public ILogger {
+class file_logger_t : public logger_t {
 public:
-  void log(const std::string& msg) const override { std::cout << "[Console] " << msg << '\n'; }
+  void log(const std::string& msg, log_level_t level = log_level_t::info) const override {
+    std::cout << "[" << current_time_string() << "] " << "[" << to_string(level) << "] " << "[file] " << msg << '\n';
+  }
 };
 
-class Application {
+class multi_logger_t : public logger_t {
 public:
-  explicit Application(std::unique_ptr<ILogger> logger_in)
+  void add_logger(std::unique_ptr<logger_t> logger) { loggers.push_back(std::move(logger)); }
+
+  void log(const std::string& msg, log_level_t level = log_level_t::info) const override {
+    for (const auto& logger : loggers) {
+      logger->log(msg, level);
+    }
+  }
+
+private:
+  std::vector<std::unique_ptr<logger_t>> loggers;
+};
+
+class application_t {
+public:
+  explicit application_t(std::unique_ptr<logger_t> logger_in)
     : logger(std::move(logger_in)) {}
 
-  void run() const { logger->log("App is running"); }
+  void run() const {
+    logger->log("application starting");
+    perform_task();
+    logger->log("application finished", log_level_t::info);
+  }
 
 private:
-  std::unique_ptr<ILogger> logger;
+  void perform_task() const {
+    logger->log("processing data...");
+    logger->log("minor issue detected", log_level_t::warning);
+    logger->log("critical failure avoided", log_level_t::error);
+  }
+
+private:
+  std::unique_ptr<logger_t> logger;
 };
 
 int main() {
-  std::unique_ptr<ILogger> logger = std::unique_ptr<ILogger>(new ConsoleLogger());
+  auto root_logger = std::make_unique<multi_logger_t>();
 
-  Application app(std::move(logger));
+  root_logger->add_logger(std::make_unique<console_logger_t>());
+  root_logger->add_logger(std::make_unique<file_logger_t>());
+
+  application_t app(std::move(root_logger));
   app.run();
+
   return 0;
 }

DesignPrinciple/composition_over_inheritance.cpp

@@ -1,89 +1,127 @@
 /**
  * @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
+ * @brief Demonstration of composition over inheritance using runtime strategies
  *
+ * Key ideas:
+ * - Prefer HAS-A over IS-A
+ * - Compose behavior dynamically
+ * - Keep components orthogonal and swappable
  */
 
 #include <iostream>
 #include <memory>
-// #include <string>
+#include <vector>
+
+namespace experimental {
+template <typename MovementPolicy, typename PowerPolicy>
+class vehicle_t;
+}
 
-class IMovement {
+class movement_t {
 public:
-  virtual ~IMovement()      = default;
-  virtual void move() const = 0;
+  virtual ~movement_t()                = default;
+  virtual void        move() const     = 0;
+  virtual const char* describe() const = 0;
 };
 
-class IPowerSource {
+class power_source_t {
 public:
-  virtual ~IPowerSource()           = default;
-  virtual void supply_power() const = 0;
+  virtual ~power_source_t()                = default;
+  virtual void        supply_power() const = 0;
+  virtual const char* describe() const     = 0;
 };
 
-class WheelMovement : public IMovement {
+class wheel_movement_t : public movement_t {
 public:
   void move() const override { std::cout << "Moving on wheels\n"; }
+
+  const char* describe() const override { return "Wheel-based movement"; }
 };
 
-class FlyingMovement : public IMovement {
+class flying_movement_t : public movement_t {
 public:
   void move() const override { std::cout << "Flying in the air\n"; }
+
+  const char* describe() const override { return "Aerial movement"; }
 };
 
-class GasEngine : public IPowerSource {
+class gas_engine_t : public power_source_t {
 public:
   void supply_power() const override { std::cout << "Supplying power from gas engine\n"; }
+
+  const char* describe() const override { return "Gas engine"; }
 };
 
-class ElectricBattery : public IPowerSource {
+class electric_battery_t : public power_source_t {
 public:
   void supply_power() const override { std::cout << "Supplying power from battery\n"; }
+
+  const char* describe() const override { return "Electric battery"; }
+};
+
+class solar_panel_t : public power_source_t {
+public:
+  void supply_power() const override { std::cout << "Supplying power from solar energy\n"; }
+
+  const char* describe() const override { return "Solar panel"; }
+};
+
+// Composite power source (aggregation of multiple sources)
+class hybrid_power_t : public power_source_t {
+public:
+  void add_source(std::unique_ptr<power_source_t> source) { sources.push_back(std::move(source)); }
+
+  void supply_power() const override {
+    std::cout << "Hybrid power system engaged:\n";
+    for (const auto& src : sources) {
+      src->supply_power();
+    }
+  }
+
+  const char* describe() const override { return "Hybrid power system"; }
+
+private:
+  std::vector<std::unique_ptr<power_source_t>> sources;
 };
 
-class Vehicle {
+class vehicle_t {
 public:
-  Vehicle(std::unique_ptr<IMovement> movement, std::unique_ptr<IPowerSource> power_source)
+  vehicle_t(std::unique_ptr<movement_t> movement, std::unique_ptr<power_source_t> power_source)
     : movement(std::move(movement))
     , power_source(std::move(power_source)) {}
 
   void operate() const {
+    std::cout << "[Vehicle Start]\n";
+    std::cout << "Movement: " << movement->describe() << "\n";
+    std::cout << "Power: " << power_source->describe() << "\n";
+
     power_source->supply_power();
     movement->move();
+
+    std::cout << "[Vehicle End]\n\n";
   }
 
 private:
-  std::unique_ptr<IMovement>    movement;
-  std::unique_ptr<IPowerSource> power_source;
+  std::unique_ptr<movement_t>     movement;
+  std::unique_ptr<power_source_t> power_source;
 };
 
 int main() {
-  // Traditional car
-  Vehicle car(std::make_unique<WheelMovement>(), std::make_unique<GasEngine>());
+  vehicle_t car(std::make_unique<wheel_movement_t>(), std::make_unique<gas_engine_t>());
+
+  vehicle_t ev(std::make_unique<wheel_movement_t>(), std::make_unique<electric_battery_t>());
 
-  // Electric car
-  Vehicle ev(std::make_unique<WheelMovement>(), std::make_unique<ElectricBattery>());
+  vehicle_t drone(std::make_unique<flying_movement_t>(), std::make_unique<electric_battery_t>());
 
-  // Futuristic flying electric vehicle
-  Vehicle drone(std::make_unique<FlyingMovement>(), std::make_unique<ElectricBattery>());
+  // Hybrid example: battery + solar
+  auto hybrid_power = std::make_unique<hybrid_power_t>();
+  hybrid_power->add_source(std::make_unique<electric_battery_t>());
+  hybrid_power->add_source(std::make_unique<solar_panel_t>());
+
+  vehicle_t futuristic_vehicle(std::make_unique<flying_movement_t>(), std::move(hybrid_power));
 
   car.operate();
   ev.operate();
   drone.operate();
+  futuristic_vehicle.operate();
 }
-
-class SolarPanel : public IPowerSource {
-public:
-  void supply_power() const override { std::cout << "Supplying power from solar energy\n"; }
-};