（12）外观模式

外观模式：为一个复杂的子系统提供一个统一的接口，简化客户端的使用

场景：电脑启动系统

我们模拟一台电脑，它内部有很多复杂组件：
 - CPU
 - 内存（Memory）
 - 硬盘（HardDrive）
 - BIOS（固件）
 - 启动过程很复杂，但用户只需要调用 computer.turnOn() 就行了。

#include <iostream>
#include <string>

// ============= 1. 复杂子系统组件（不需要用户直接操作） ===============
// CPU 类
class CPU {
public:
    void freeze() const {
        std::cout << "CPU: 冻结所有寄存器...\n";
    }

    void jump(long position) const {
        std::cout << "CPU: 跳转到内存地址 0x" << std::hex << position << std::dec << "\n";
    }

    void execute() const {
        std::cout << "CPU: 开始执行指令...\n";
    }
};

// 内存类
class Memory {
public:
    void load(long position, const std::string& data) const {
        std::cout << "内存: 将数据 '" << data << "' 加载到地址 0x" << std::hex << position << std::dec << "\n";
    }
};

// 硬盘类
class HardDrive {
public:
    std::string read(long lba, int size) const {
        std::string data = "操作系统内核数据";
        std::cout << "硬盘: 从 LBA " << lba << " 读取 " << size << " 字节数据\n";
        return data;
    }
};

负责协调启动

// BIOS 固件（负责协调启动）
class BIOS {
private:
    CPU cpu;
    Memory memory;
    HardDrive hardDrive;

public:
    void start() {
        std::cout << "BIOS: 启动自检（POST）...\n";
        cpu.freeze();

        // 从硬盘加载内核到内存
        std::string kernel = hardDrive.read(0, 1024);
        memory.load(0x1000, kernel);

        // CPU 跳转到内核入口并执行
        cpu.jump(0x1000);
        cpu.execute();

        std::cout << "BIOS: 操作系统加载完成！\n";
    }
};

外观类：Computer

// ==================== 外观类：Computer ====================
// 它封装了所有复杂的启动流程
class Computer {
private:
    BIOS bios;  // 内部使用 BIOS 来控制底层硬件

public:
    // 简单的开机方法 —— 用户只需要调用这一个函数
    void turnOn() {
        std::cout << "🖥用户按下电源键...\n";
        std::cout << "=============== 开机过程开始 ===============\n";
        bios.start();  // 外观类把复杂工作交给子系统
        std::cout << "=============== 开机过程结束 ===============\n";
        std::cout << "欢迎使用电脑！\n";
    }

    // 关机
    void turnOff() {
        std::cout << "电脑正在关机...\n";
        std::cout << "再见！\n";
    }
};

模板优化可复用、类型安全、零成本抽象的模板化外观模式（Template Facade）

#include <iostream>
#include <string>
// ============== 1. 硬件组件基类（接口） ================
// 所有组件都继承这些接口，便于统一调用
struct CpuInterface {
    virtual ~CpuInterface() = default;
    virtual void freeze() const = 0;
    virtual void jump(long pos) const = 0;
    virtual void execute() const = 0;
};

struct MemoryInterface {
    virtual ~MemoryInterface() = default;
    virtual void load(long pos, const std::string& data) const = 0;
};

struct HardDriveInterface {
    virtual ~HardDriveInterface() = default;
    virtual std::string read(long lba, int size) const = 0;
};

// ==================== 2. 具体硬件实现（可替换） ====================
// 高性能 CPU
class HighPerfCPU : public CpuInterface {
public:
    void freeze() const override {
        std::cout << "HighPerfCPU: 冻结寄存器（超频模式）\n";
    }
    void jump(long pos) const override {
        std::cout << "HighPerfCPU: 跳转到 0x" << std::hex << pos << std::dec << "\n";
    }
    void execute() const override {
        std::cout << "HighPerfCPU: 执行指令（4.5GHz）\n";
    }
};

// 低功耗 CPU
class LowPowerCPU : public CpuInterface {
public:
    void freeze() const override {
        std::cout << "LowPowerCPU: 冻结寄存器（节能模式）\n";
    }
    void jump(long pos) const override {
        std::cout << "LowPowerCPU: 跳转到 0x" << std::hex << pos << std::dec << "\n";
    }
    void execute() const override {
        std::cout << "LowPowerCPU: 执行指令（1.2GHz）\n";
    }
};

// 标准内存
class StandardMemory : public MemoryInterface {
public:
    void load(long pos, const std::string& data) const override {
        std::cout << "StandardMemory: 加载 '" << data << "' 到 0x" << std::hex << pos << std::dec << "\n";
    }
};

// 快速 SSD
class SSD : public HardDriveInterface {
public:
    std::string read(long lba, int size) const override {
        std::cout << "SSD: 从 LBA " << lba << " 读取 " << size << " 字节（高速）\n";
        return "操作系统数据（SSD版）";
    }
};

// 普通 HDD
class HDD : public HardDriveInterface {
public:
    std::string read(long lba, int size) const override {
        std::cout << "HDD: 从 LBA " << lba << " 读取 " << size << " 字节（较慢）\n";
        return "操作系统数据（HDD版）";
    }
};

模板 BIOS：协调启动流程（依赖具体类型）

// ============ 模板 BIOS：根据硬件类型定制启动流程 ================
template<typename CpuType, typename MemoryType, typename DriveType>
class BIOS {
private:
    CpuType cpu;
    MemoryType memory;
    DriveType drive;

public:
    // 构造函数（可传入硬件实例，支持依赖注入）
    BIOS() = default;

    template<typename C, typename M, typename D>
    BIOS(C c, M m, D d) : cpu(c), memory(m), drive(d) {}

    // 启动流程（统一接口）
    void start() {
        std::cout << "BIOS: 正在执行开机自检...\n";
        cpu.freeze();

        // 从硬盘读取内核
        std::string kernel = drive.read(0, 1024);
        memory.load(0x1000, kernel);

        // CPU 跳转并执行
        cpu.jump(0x1000);
        cpu.execute();

        std::cout << "BIOS: 操作系统加载完成！\n";
    }
};

模板外观类：Computer（最终用户接口）

int main() {
    std::cout << "欢迎使用模板化外观模式！\n\n";

    // 配置1：高性能电脑（SSD + 高性能CPU）
    using GamingComputer = Computer<HighPerfCPU, StandardMemory, SSD>;
    GamingComputer gamingPC;
    std::cout << "游戏电脑启动：\n";
    gamingPC.turnOn();

    // 配置2：低功耗笔记本（HDD + 低功耗CPU）
    using Laptop = Computer<LowPowerCPU, StandardMemory, HDD>;
    Laptop laptop;
    std::cout << "笔记本电脑启动：\n";
    laptop.turnOn();

    // 配置3：自定义注入（高级用法）
    HighPerfCPU cpu;
    StandardMemory mem;
    SSD ssd;

    Computer<HighPerfCPU, StandardMemory, SSD> customPC(cpu, mem, ssd);
    std::cout << "自定义电脑启动：\n";
    customPC.turnOn();

    return 0;
}