创建型模式：③抽象工厂模式（Abstract Factory）

创建型模式：③抽象工厂模式（Abstract Factory）

c语言写法

核心思想
提供创建 “产品族” 的接口（多个相关产品），具体工厂负责创建对应族的所有产品（比工厂方法更抽象，处理多产品组合）。
关键要点
1.抽象工厂管理 产品族（如 “华为产品” 包含屏幕 + 电池），而非单个产品。
2.扩展新品牌（如小米）只需新增 “小米工厂” 和对应产品，无需修改原有代码（符合开闭原则）。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// -------------------------- 产品族1：屏幕（抽象产品A）--------------------------
typedef struct Screen {
    void (*display)(struct Screen*);
    char brand[32];
    void (*destroy)(struct Screen*);
} Screen;

void screen_destroy(Screen* screen) {
    if (screen) {
        printf("销毁屏幕：%s\n", screen->brand);
        free(screen);
    }
}

// 具体产品A1：华为屏幕
void huawei_screen_display(Screen* screen) {
    printf("华为屏幕[%s]：2K分辨率，90Hz刷新率\n", screen->brand);
}

Screen* create_huawei_screen() {
    Screen* screen = (Screen*)malloc(sizeof(Screen));
    strncpy(screen->brand, "华为Mate屏幕", sizeof(screen->brand));
    screen->display = huawei_screen_display;
    screen->destroy = screen_destroy;
    return screen;
}

// 具体产品A2：苹果屏幕
void apple_screen_display(Screen* screen) {
    printf("苹果屏幕[%s]：OLED材质，60Hz刷新率\n", screen->brand);
}

Screen* create_apple_screen() {
    Screen* screen = (Screen*)malloc(sizeof(Screen));
    strncpy(screen->brand, "iPhone屏幕", sizeof(screen->brand));
    screen->display = apple_screen_display;
    screen->destroy = screen_destroy;
    return screen;
}

// -------------------------- 产品族2：电池（抽象产品B）--------------------------
typedef struct Battery {
    void (*power)(struct Battery*);
    char brand[32];
    void (*destroy)(struct Battery*);
} Battery;

void battery_destroy(Battery* battery) {
    if (battery) {
        printf("销毁电池：%s\n", battery->brand);
        free(battery);
    }
}

// 具体产品B1：华为电池
void huawei_battery_power(Battery* battery) {
    printf("华为电池[%s]：4000mAh，快充66W\n", battery->brand);
}

Battery* create_huawei_battery() {
    Battery* battery = (Battery*)malloc(sizeof(Battery));
    strncpy(battery->brand, "华为超级快充电池", sizeof(battery->brand));
    battery->power = huawei_battery_power;
    battery->destroy = battery_destroy;
    return battery;
}

// 具体产品B2：苹果电池
void apple_battery_power(Battery* battery) {
    printf("苹果电池[%s]：3000mAh，磁吸充电\n", battery->brand);
}

Battery* create_apple_battery() {
    Battery* battery = (Battery*)malloc(sizeof(Battery));
    strncpy(battery->brand, "苹果磁吸电池", sizeof(battery->brand));
    battery->power = apple_battery_power;
    battery->destroy = battery_destroy;
    return battery;
}

// -------------------------- 抽象工厂（创建产品族接口）--------------------------
typedef struct AbstractFactory {
    Screen* (*create_screen)(void);   // 创建产品A
    Battery* (*create_battery)(void); // 创建产品B
    void (*destroy)(struct AbstractFactory*);
} AbstractFactory;

// -------------------------- 具体工厂 --------------------------
// 华为工厂（生产华为产品族）
AbstractFactory* create_huawei_factory() {
    AbstractFactory* factory = (AbstractFactory*)malloc(sizeof(AbstractFactory));
    factory->create_screen = create_huawei_screen;
    factory->create_battery = create_huawei_battery;
    factory->destroy = free;
    return factory;
}

// 苹果工厂（生产苹果产品族）
AbstractFactory* create_apple_factory() {
    AbstractFactory* factory = (AbstractFactory*)malloc(sizeof(AbstractFactory));
    factory->create_screen = create_apple_screen;
    factory->create_battery = create_apple_battery;
    factory->destroy = free;
    return factory;
}

// 测试代码
int main() {
    // 1. 华为工厂：生产华为屏幕+电池（产品族）
    AbstractFactory* huawei_factory = create_huawei_factory();
    Screen* huawei_screen = huawei_factory->create_screen();
    Battery* huawei_battery = huawei_factory->create_battery();
    printf("=== 华为产品族 ===\n");
    huawei_screen->display(huawei_screen);
    huawei_battery->power(huawei_battery);

    // 2. 苹果工厂：生产苹果屏幕+电池（产品族）
    AbstractFactory* apple_factory = create_apple_factory();
    Screen* apple_screen = apple_factory->create_screen();
    Battery* apple_battery = apple_factory->create_battery();
    printf("\n=== 苹果产品族 ===\n");
    apple_screen->display(apple_screen);
    apple_battery->power(apple_battery);

    // 3. 资源释放
    huawei_screen->destroy(huawei_screen);
    huawei_battery->destroy(huawei_battery);
    huawei_factory->destroy(huawei_factory);

    apple_screen->destroy(apple_screen);
    apple_battery->destroy(apple_battery);
    apple_factory->destroy(apple_factory);

    return 0;
}

c++语言写法

核心思想
抽象工厂定义 产品族的创建接口（多个相关产品），具体工厂实现接口并创建对应族的所有产品，解决 “多产品组合” 的创建问题。
关键要点
1.产品族概念：抽象工厂包含多个产品的创建接口（CreateScreen/CreateBattery），具体工厂确保创建的产品属于同一 “族”（如华为屏幕 + 华为电池）。
2.类型安全：C++ 的类继承和纯虚函数确保子类必须实现所有接口，避免 C 语言函数指针的类型错误。
3.扩展灵活：新增产品族（如米）只需新增 XiaomiFactory 和对应 XiaomiScreen/XiaomiBattery，不影响现有代码。

#include <iostream>
#include <string>
#include <memory>

// -------------------------- 抽象产品A：Screen --------------------------
class Screen {
public:
    virtual ~Screen() = default;
    virtual void Display() const = 0;
    std::string GetBrand() const { return brand_; }

protected:
    Screen(std::string brand) : brand_(std::move(brand)) {}

private:
    std::string brand_;
};

// 具体产品A1：华为屏幕
class HuaweiScreen : public Screen {
public:
    HuaweiScreen() : Screen("华为Mate屏幕") {}
    void Display() const override {
        std::cout << "华为屏幕[" << GetBrand() << "]：2K分辨率，90Hz刷新率" << std::endl;
    }
};

// 具体产品A2：苹果屏幕
class AppleScreen : public Screen {
public:
    AppleScreen() : Screen("iPhone屏幕") {}
    void Display() const override {
        std::cout << "苹果屏幕[" << GetBrand() << "]：OLED材质，60Hz刷新率" << std::endl;
    }
};

// -------------------------- 抽象产品B：Battery --------------------------
class Battery {
public:
    virtual ~Battery() = default;
    virtual void Power() const = 0;
    std::string GetBrand() const { return brand_; }

protected:
    Battery(std::string brand) : brand_(std::move(brand)) {}

private:
    std::string brand_;
};

// 具体产品B1：华为电池
class HuaweiBattery : public Battery {
public:
    HuaweiBattery() : Battery("华为超级快充电池") {}
    void Power() const override {
        std::cout << "华为电池[" << GetBrand() << "]：4000mAh，快充66W" << std::endl;
    }
};

// 具体产品B2：苹果电池
class AppleBattery : public Battery {
public:
    AppleBattery() : Battery("苹果磁吸电池") {}
    void Power() const override {
        std::cout << "苹果电池[" << GetBrand() << "]：3000mAh，磁吸充电" << std::endl;
    }
};

// -------------------------- 抽象工厂（创建产品族）--------------------------
class AbstractFactory {
public:
    virtual ~AbstractFactory() = default;
    virtual std::unique_ptr<Screen> CreateScreen() = 0;   // 产品A创建接口
    virtual std::unique_ptr<Battery> CreateBattery() = 0; // 产品B创建接口
};

// -------------------------- 具体工厂1：华为工厂 --------------------------
class HuaweiFactory : public AbstractFactory {
public:
    std::unique_ptr<Screen> CreateScreen() override {
        return std::make_unique<HuaweiScreen>();
    }
    std::unique_ptr<Battery> CreateBattery() override {
        return std::make_unique<HuaweiBattery>();
    }
};

// -------------------------- 具体工厂2：苹果工厂 --------------------------
class AppleFactory : public AbstractFactory {
public:
    std::unique_ptr<Screen> CreateScreen() override {
        return std::make_unique<AppleScreen>();
    }
    std::unique_ptr<Battery> CreateBattery() override {
        return std::make_unique<AppleBattery>();
    }
};

// 测试代码
int main() {
    // 1. 华为工厂：生产华为产品族（屏幕+电池）
    std::unique_ptr<AbstractFactory> huawei_factory = std::make_unique<HuaweiFactory>();
    auto huawei_screen = huawei_factory->CreateScreen();
    auto huawei_battery = huawei_factory->CreateBattery();

    std::cout << "=== 华为产品族 ===" << std::endl;
    huawei_screen->Display();
    huawei_battery->Power();

    // 2. 苹果工厂：生产苹果产品族
    std::unique_ptr<AbstractFactory> apple_factory = std::make_unique<AppleFactory>();
    auto apple_screen = apple_factory->CreateScreen();
    auto apple_battery = apple_factory->CreateBattery();

    std::cout << "\n=== 苹果产品族 ===" << std::endl;
    apple_screen->Display();
    apple_battery->Power();

    return 0;
}