工厂模式深度对比：简单工厂 vs 工厂方法 vs 抽象工厂

工厂模式深度对比：简单工厂 vs 工厂方法 vs 抽象工厂

目录

1. 简单工厂
2. 工厂方法
3. 抽象工厂
4. 对比表
5. 选择指南

简单工厂

定义

单一工厂函数根据参数类型创建并返回不同的具体产品。

核心特点

• 集中式创建：所有创建逻辑集中在一个工厂函数中
• 参数驱动：调用者传入类型参数，工厂返回对应产品
• 简单直接：实现最简单，类数量少

结构示例

Shape *SimpleFactoryCreateShape(ShapeType type) {
    switch (type) {
        case SHAPE_CIRCLE:
            return CreateCircleInstance();
        case SHAPE_RECTANGLE:
            return CreateRectangleInstance();
        case SHAPE_SQUARE:
            return CreateSquareInstance();
        default:
            return NULL;
    }
}

优点

• 实现简单，易于理解
• 逻辑集中，便于维护
• 适合产品族小且稳定的场景

缺点

• 违反开闭原则：增加新产品需修改工厂代码
• 工厂与所有产品耦合
• 工厂函数可能变得臃肿（产品多时）

适用场景

• 产品种类少且变化不频繁
• 项目规模小
• 快速原型开发

本工程实现

• 文件：simpleFactory.h / simpleFactory.c
• 函数：SimpleFactoryCreateShape(ShapeType type)
• 演示：SimpleFactoryDemo()

simpleFactory.h

#ifndef SIMPLE_FACTORY_H
#define SIMPLE_FACTORY_H

#include "abstractFactory.h"

/* 简单工厂接口 */
Shape *SimpleFactoryCreateShape(ShapeType type);

/* 演示函数 */
void SimpleFactoryDemo(void);

#endif /* SIMPLE_FACTORY_H */

simpleFactory.c

#include <stdio.h>
#include <stdlib.h>
#include "simpleFactory.h"

/* ========== 简单工厂实现 ========== */

static void SimpleCircleDraw(Shape *self __attribute__((unused))) {
    printf("[简单工厂产品] 圆形\n");
}

static void SimpleRectangleDraw(Shape *self __attribute__((unused))) {
    printf("[简单工厂产品] 矩形\n");
}

static void SimpleSquareDraw(Shape *self __attribute__((unused))) {
    printf("[简单工厂产品] 正方形\n");
}

static void SimpleShapeDestroy(Shape *self) {
    free(self);
}

Shape *SimpleFactoryCreateShape(ShapeType type) {
    switch (type) {
        case SHAPE_CIRCLE: {
            Circle *instance = malloc(sizeof(Circle));
            if (!instance) return NULL;
            instance->base.draw = SimpleCircleDraw;
            instance->base.destroy = SimpleShapeDestroy;
            return (Shape *)instance;
        }
        case SHAPE_RECTANGLE: {
            Rectangle *instance = malloc(sizeof(Rectangle));
            if (!instance) return NULL;
            instance->base.draw = SimpleRectangleDraw;
            instance->base.destroy = SimpleShapeDestroy;
            return (Shape *)instance;
        }
        case SHAPE_SQUARE: {
            Square *instance = malloc(sizeof(Square));
            if (!instance) return NULL;
            instance->base.draw = SimpleSquareDraw;
            instance->base.destroy = SimpleShapeDestroy;
            return (Shape *)instance;
        }
        default:
            return NULL;
    }
}

/* ========== 演示函数 ========== */

void SimpleFactoryDemo(void) {
    printf("=== 简单工厂模式演示 ===\n");
    
    Shape *circleShape = SimpleFactoryCreateShape(SHAPE_CIRCLE);
    Shape *rectangleShape = SimpleFactoryCreateShape(SHAPE_RECTANGLE);
    Shape *squareShape = SimpleFactoryCreateShape(SHAPE_SQUARE);
    
    if (circleShape) circleShape->draw(circleShape);
    if (rectangleShape) rectangleShape->draw(rectangleShape);
    if (squareShape) squareShape->draw(squareShape);
    
    if (circleShape) circleShape->destroy(circleShape);
    if (rectangleShape) rectangleShape->destroy(rectangleShape);
    if (squareShape) squareShape->destroy(squareShape);
    
    printf("简单工厂演示完成\n\n");
}

工厂方法

定义

定义抽象 ShapeCreator 接口和工厂方法；具体 Creator 子类实现该方法以创建对应的具体产品。

核心特点

• 延迟创建：创建逻辑延迟给具体子类
• 多个工厂：每种产品有对应的 Creator 实现
• 遵循开闭原则：添加新产品仅需新增 Creator，无需修改现有代码

结构示例

typedef struct ShapeCreator {
    Shape *(*create)(ShapeCreator *self);
    void (*destroy)(ShapeCreator *self);
} ShapeCreator;

// 具体实现
ShapeCreator *CircleCreatorNew(void);
ShapeCreator *RectangleCreatorNew(void);
ShapeCreator *SquareCreatorNew(void);

优点

• 符合开闭原则
• 低耦合：调用者依赖抽象 ShapeCreator，不依赖具体产品
• 易于测试和替换

缺点

• 类数量增多（每种产品需一个 Creator）
• 结构复杂度提升
• 小项目中可能显得过度设计

适用场景

• 需要频繁添加新产品
• 产品创建逻辑复杂或多样
• 希望解耦创建与使用逻辑
• 项目需要高可扩展性和可测试性

本工程实现

• 文件：factoryPattern.h / factoryPattern.c
• 接口：ShapeCreator（含 create() 和 destroy() 方法）
• 具体实现：CircleCreatorNew()、RectangleCreatorNew()、SquareCreatorNew()
• 演示：FactoryMethodDemo()

#ifndef FACTORY_PATTERN_H
#define FACTORY_PATTERN_H

#include "abstractFactory.h"

/* ===== ShapeCreator 接口（工厂方法模式）===== */
typedef struct ShapeCreator ShapeCreator;

struct ShapeCreator {
    Shape *(*create)(ShapeCreator *self);
    void (*destroy)(ShapeCreator *self);
};

/* 具体创建者构造函数 */
ShapeCreator *CircleCreatorNew(void);
ShapeCreator *RectangleCreatorNew(void);
ShapeCreator *SquareCreatorNew(void);

/* 演示函数 */
void FactoryMethodDemo(void);

#endif /* FACTORY_PATTERN_H */

factoryPattern.c

#include <stdio.h>
#include <stdlib.h>
#include "factoryPattern.h"

/* ========== 形状工厂方法 ========== */

static void CircleDrawMethod(Shape *self __attribute__((unused))) {
    printf("[工厂方法产品] 圆形\n");
}

static void RectangleDrawMethod(Shape *self __attribute__((unused))) {
    printf("[工厂方法产品] 矩形\n");
}

static void SquareDrawMethod(Shape *self __attribute__((unused))) {
    printf("[工厂方法产品] 正方形\n");
}

static void ShapeDestroyMethod(Shape *self) {
    free(self);
}

/* ===== 圆形创建者 ===== */
typedef struct { ShapeCreator base; } CircleCreatorImpl;

static Shape *CircleCreatorCreate(ShapeCreator *self __attribute__((unused))) {
    Circle *instance = malloc(sizeof(Circle));
    if (!instance) return NULL;
    instance->base.draw = CircleDrawMethod;
    instance->base.destroy = ShapeDestroyMethod;
    return (Shape *)instance;
}

static void CircleCreatorDestroy(ShapeCreator *self) {
    free(self);
}

ShapeCreator *CircleCreatorNew(void) {
    CircleCreatorImpl *creator = malloc(sizeof(CircleCreatorImpl));
    if (!creator) return NULL;
    creator->base.create = CircleCreatorCreate;
    creator->base.destroy = CircleCreatorDestroy;
    return (ShapeCreator *)creator;
}

/* ===== 矩形创建者 ===== */
typedef struct { ShapeCreator base; } RectangleCreatorImpl;

static Shape *RectangleCreatorCreate(ShapeCreator *self __attribute__((unused))) {
    Rectangle *instance = malloc(sizeof(Rectangle));
    if (!instance) return NULL;
    instance->base.draw = RectangleDrawMethod;
    instance->base.destroy = ShapeDestroyMethod;
    return (Shape *)instance;
}

static void RectangleCreatorDestroy(ShapeCreator *self) {
    free(self);
}

ShapeCreator *RectangleCreatorNew(void) {
    RectangleCreatorImpl *creator = malloc(sizeof(RectangleCreatorImpl));
    if (!creator) return NULL;
    creator->base.create = RectangleCreatorCreate;
    creator->base.destroy = RectangleCreatorDestroy;
    return (ShapeCreator *)creator;
}

/* ===== 正方形创建者 ===== */
typedef struct { ShapeCreator base; } SquareCreatorImpl;

static Shape *SquareCreatorCreate(ShapeCreator *self __attribute__((unused))) {
    Square *instance = malloc(sizeof(Square));
    if (!instance) return NULL;
    instance->base.draw = SquareDrawMethod;
    instance->base.destroy = ShapeDestroyMethod;
    return (Shape *)instance;
}

static void SquareCreatorDestroy(ShapeCreator *self) {
    free(self);
}

ShapeCreator *SquareCreatorNew(void) {
    SquareCreatorImpl *creator = malloc(sizeof(SquareCreatorImpl));
    if (!creator) return NULL;
    creator->base.create = SquareCreatorCreate;
    creator->base.destroy = SquareCreatorDestroy;
    return (ShapeCreator *)creator;
}

/* ========== 演示函数 ========== */

void FactoryMethodDemo(void) {
    printf("=== 工厂方法模式演示 ===\n");
    
    ShapeCreator *circleCreator = CircleCreatorNew();
    ShapeCreator *rectangleCreator = RectangleCreatorNew();
    ShapeCreator *squareCreator = SquareCreatorNew();
    
    Shape *circle = circleCreator ? circleCreator->create(circleCreator) : NULL;
    Shape *rectangle = rectangleCreator ? rectangleCreator->create(rectangleCreator) : NULL;
    Shape *square = squareCreator ? squareCreator->create(squareCreator) : NULL;
    
    if (circle) circle->draw(circle);
    if (rectangle) rectangle->draw(rectangle);
    if (square) square->draw(square);
    
    if (circle) circle->destroy(circle);
    if (rectangle) rectangle->destroy(rectangle);
    if (square) square->destroy(square);
    
    if (circleCreator) circleCreator->destroy(circleCreator);
    if (rectangleCreator) rectangleCreator->destroy(rectangleCreator);
    if (squareCreator) squareCreator->destroy(squareCreator);
    
    printf("工厂方法演示完成\n\n");
}

抽象工厂

定义

提供一个接口，用于创建一系列相互关联或相互依赖的对象族。具体工厂实现该接口，生产一整套产品。与简单工厂不同的是，抽象工厂完全避免 switch 语句，通过分离的创建者接口为不同产品类型创建对象。

核心特点

• 产品族概念：一次创建多个相关产品，保证彼此兼容
• 创建者分离：为不同产品类型定义独立的创建者接口（ShapeCreatorFamily、ColorCreatorFamily）
• 避免条件判断：无 switch/if 语句；使用多态创建者调用
• 高度可扩展：添加新工厂变体仅需新增工厂，无需修改现有代码

结构示例

/* ShapeCreatorFamily 接口 */
typedef struct ShapeCreatorFamily {
    Shape *(*createCircle)(struct ShapeCreatorFamily *self);
    Shape *(*createRectangle)(struct ShapeCreatorFamily *self);
    Shape *(*createSquare)(struct ShapeCreatorFamily *self);
    void (*destroy)(struct ShapeCreatorFamily *self);
} ShapeCreatorFamily;

/* ColorCreatorFamily 接口 */
typedef struct ColorCreatorFamily {
    Color *(*createRed)(struct ColorCreatorFamily *self);
    Color *(*createGreen)(struct ColorCreatorFamily *self);
    Color *(*createBlue)(struct ColorCreatorFamily *self);
    void (*destroy)(struct ColorCreatorFamily *self);
} ColorCreatorFamily;

/* 抽象工厂 - 组合两个创建者族 */
typedef struct AbstractFactory {
    ShapeCreatorFamily *shapeCreator;
    ColorCreatorFamily *colorCreator;
    void (*destroy)(struct AbstractFactory *self);
} AbstractFactory;

优点

• 保证兼容性：同一工厂创建的产品彼此协同工作
• 便于切换：只需替换工厂实例，即可切换整个产品族
• 产品族一致：规范了产品之间的协作方式
• 避免 switch 膨胀：创建者分离意味着无条件判断，代码更清晰
• 高可扩展性：添加新产品族变体仅需新增工厂

缺点

• 结构复杂度高：类和接口众多
• 类数量多：比简单工厂多很多（2n+1 vs n）
• 初期投入大：小项目中容易过度设计
• 接口扩展困难：添加新产品类别（如 Volume 创建者）需修改所有创建者接口

适用场景

• 需要创建相互关联的对象族
• 有多个产品族变体（如主题、数据库驱动）
• 产品族之间需要协同工作
• 希望透明地切换产品族
• 示例：GUI 框架（Windows 风格、Mac 风格）、数据库驱动（MySQL、PostgreSQL）

本工程实现

• 文件：abstractFactory.h / abstractFactory.c
• 关键接口：
  • ShapeCreatorFamily：形状创建者，包含 createCircle()、createRectangle()、createSquare() 方法
  • ColorCreatorFamily：颜色创建者，包含 createRed()、createGreen()、createBlue() 方法
  • AbstractFactory：组合上述两个创建者族
• 具体实现：ConcreteShapeCreator、ConcreteColorCreator、ConcreteFactory
• 特点：完全避免 switch 语句，通过创建者接口组合实现产品族创建
• 用法：factory->shapeCreator->createCircle(factory->shapeCreator)
• 演示：AbstractFactoryDemo()

abstractFactory.h

#ifndef ABSTRACT_FACTORY_H
#define ABSTRACT_FACTORY_H

/* ===== 类型枚举 ===== */
typedef enum { SHAPE_CIRCLE, SHAPE_RECTANGLE, SHAPE_SQUARE } ShapeType;
typedef enum { COLOR_RED, COLOR_GREEN, COLOR_BLUE } ColorType;

/* ===== 形状类型 ===== */
typedef struct Shape {
    void (*draw)(struct Shape *self);
    void (*destroy)(struct Shape *self);
} Shape;

typedef struct { Shape base; } Circle;
typedef struct { Shape base; } Rectangle;
typedef struct { Shape base; } Square;

/* ===== 颜色类型 ===== */
typedef struct Color {
    void (*fill)(struct Color *self);
    void (*destroy)(struct Color *self);
} Color;

typedef struct { Color base; } Red;
typedef struct { Color base; } Green;
typedef struct { Color base; } Blue;

/* ===== 形状创建者族接口 ===== */
typedef struct ShapeCreatorFamily {
    Shape *(*createCircle)(struct ShapeCreatorFamily *self);
    Shape *(*createRectangle)(struct ShapeCreatorFamily *self);
    Shape *(*createSquare)(struct ShapeCreatorFamily *self);
    void (*destroy)(struct ShapeCreatorFamily *self);
} ShapeCreatorFamily;

/* ===== 颜色创建者族接口 ===== */
typedef struct ColorCreatorFamily {
    Color *(*createRed)(struct ColorCreatorFamily *self);
    Color *(*createGreen)(struct ColorCreatorFamily *self);
    Color *(*createBlue)(struct ColorCreatorFamily *self);
    void (*destroy)(struct ColorCreatorFamily *self);
} ColorCreatorFamily;

/* ===== 抽象工厂接口 ===== */
typedef struct AbstractFactory {
    ShapeCreatorFamily *shapeCreator;
    ColorCreatorFamily *colorCreator;
    void (*destroy)(struct AbstractFactory *self);
} AbstractFactory;

/* 公共函数 */
AbstractFactory *AbstractFactoryCreate(void);
void AbstractFactoryDemo(void);

#endif /* ABSTRACT_FACTORY_H */

abstractFactory.c

#include <stdio.h>
#include <stdlib.h>
#include "abstractFactory.h"

/* ========== 形状创建者 ========== */

static Shape *CreateCircleInstance(void) {
    Circle *instance = malloc(sizeof(Circle));
    if (!instance) return NULL;
    instance->base.draw = NULL;
    instance->base.destroy = NULL;
    return (Shape *)instance;
}

static Shape *CreateRectangleInstance(void) {
    Rectangle *instance = malloc(sizeof(Rectangle));
    if (!instance) return NULL;
    instance->base.draw = NULL;
    instance->base.destroy = NULL;
    return (Shape *)instance;
}

static Shape *CreateSquareInstance(void) {
    Square *instance = malloc(sizeof(Square));
    if (!instance) return NULL;
    instance->base.draw = NULL;
    instance->base.destroy = NULL;
    return (Shape *)instance;
}

static void CircleDraw(Shape *self __attribute__((unused))) {
    printf("  [形状] 绘制圆形\n");
}

static void RectangleDraw(Shape *self __attribute__((unused))) {
    printf("  [形状] 绘制矩形\n");
}

static void SquareDraw(Shape *self __attribute__((unused))) {
    printf("  [形状] 绘制正方形\n");
}

static void ShapeDestroy(Shape *self) {
    free(self);
}

/* 具体的形状创建者族 */
typedef struct { ShapeCreatorFamily base; } ConcreteShapeCreator;

static Shape *ConcreteCreateCircle(ShapeCreatorFamily *self __attribute__((unused))) {
    Circle *instance = (Circle *)CreateCircleInstance();
    if (instance) {
        instance->base.draw = CircleDraw;
        instance->base.destroy = ShapeDestroy;
    }
    return (Shape *)instance;
}

static Shape *ConcreteCreateRectangle(ShapeCreatorFamily *self __attribute__((unused))) {
    Rectangle *instance = (Rectangle *)CreateRectangleInstance();
    if (instance) {
        instance->base.draw = RectangleDraw;
        instance->base.destroy = ShapeDestroy;
    }
    return (Shape *)instance;
}

static Shape *ConcreteCreateSquare(ShapeCreatorFamily *self __attribute__((unused))) {
    Square *instance = (Square *)CreateSquareInstance();
    if (instance) {
        instance->base.draw = SquareDraw;
        instance->base.destroy = ShapeDestroy;
    }
    return (Shape *)instance;
}

static void ShapeCreatorFamilyDestroy(ShapeCreatorFamily *self) {
    free(self);
}

static ShapeCreatorFamily *ShapeCreatorFamilyNew(void) {
    ConcreteShapeCreator *creator = malloc(sizeof(ConcreteShapeCreator));
    if (!creator) return NULL;
    
    creator->base.createCircle = ConcreteCreateCircle;
    creator->base.createRectangle = ConcreteCreateRectangle;
    creator->base.createSquare = ConcreteCreateSquare;
    creator->base.destroy = ShapeCreatorFamilyDestroy;
    
    return (ShapeCreatorFamily *)creator;
}

/* ========== 颜色创建者 ========== */

static void RedFill(Color *self __attribute__((unused))) {
    printf("  [颜色] 填充红色\n");
}

static void GreenFill(Color *self __attribute__((unused))) {
    printf("  [颜色] 填充绿色\n");
}

static void BlueFill(Color *self __attribute__((unused))) {
    printf("  [颜色] 填充蓝色\n");
}

static void ColorDestroy(Color *self) {
    free(self);
}

/* 具体的颜色创建者族 */
typedef struct { ColorCreatorFamily base; } ConcreteColorCreator;

static Color *ConcreteCreateRed(ColorCreatorFamily *self __attribute__((unused))) {
    Red *instance = malloc(sizeof(Red));
    if (!instance) return NULL;
    instance->base.fill = RedFill;
    instance->base.destroy = ColorDestroy;
    return (Color *)instance;
}

static Color *ConcreteCreateGreen(ColorCreatorFamily *self __attribute__((unused))) {
    Green *instance = malloc(sizeof(Green));
    if (!instance) return NULL;
    instance->base.fill = GreenFill;
    instance->base.destroy = ColorDestroy;
    return (Color *)instance;
}

static Color *ConcreteCreateBlue(ColorCreatorFamily *self __attribute__((unused))) {
    Blue *instance = malloc(sizeof(Blue));
    if (!instance) return NULL;
    instance->base.fill = BlueFill;
    instance->base.destroy = ColorDestroy;
    return (Color *)instance;
}

static void ColorCreatorFamilyDestroy(ColorCreatorFamily *self) {
    free(self);
}

static ColorCreatorFamily *ColorCreatorFamilyNew(void) {
    ConcreteColorCreator *creator = malloc(sizeof(ConcreteColorCreator));
    if (!creator) return NULL;
    
    creator->base.createRed = ConcreteCreateRed;
    creator->base.createGreen = ConcreteCreateGreen;
    creator->base.createBlue = ConcreteCreateBlue;
    creator->base.destroy = ColorCreatorFamilyDestroy;
    
    return (ColorCreatorFamily *)creator;
}

/* ========== 抽象工厂 ========== */

typedef struct { AbstractFactory base; } ConcreteFactory;

static void ConcreteFactoryDestroy(AbstractFactory *self) {
    if (!self) return;
    if (self->shapeCreator) {
        self->shapeCreator->destroy(self->shapeCreator);
    }
    if (self->colorCreator) {
        self->colorCreator->destroy(self->colorCreator);
    }
    free(self);
}

AbstractFactory *AbstractFactoryCreate(void) {
    ConcreteFactory *factory = malloc(sizeof(ConcreteFactory));
    if (!factory) return NULL;
    
    factory->base.shapeCreator = ShapeCreatorFamilyNew();
    factory->base.colorCreator = ColorCreatorFamilyNew();
    factory->base.destroy = ConcreteFactoryDestroy;
    
    if (!factory->base.shapeCreator || !factory->base.colorCreator) {
        factory->base.destroy((AbstractFactory *)factory);
        return NULL;
    }
    
    return (AbstractFactory *)factory;
}

/* ========== 演示函数 ========== */

void AbstractFactoryDemo(void) {
    printf("=== 抽象工厂模式演示 ===\n\n");
    
    AbstractFactory *factory = AbstractFactoryCreate();
    if (!factory) {
        fprintf(stderr, "工厂创建失败\n");
        return;
    }
    
    /* 示例 1：圆形 + 红色 */
    printf("示例 1 - 圆形 + 红色:\n");
    Shape *circle = factory->shapeCreator->createCircle(factory->shapeCreator);
    Color *red = factory->colorCreator->createRed(factory->colorCreator);
    if (circle) circle->draw(circle);
    if (red) red->fill(red);
    printf("\n");
    
    /* 示例 2：矩形 + 绿色 */
    printf("示例 2 - 矩形 + 绿色:\n");
    Shape *rectangle = factory->shapeCreator->createRectangle(factory->shapeCreator);
    Color *green = factory->colorCreator->createGreen(factory->colorCreator);
    if (rectangle) rectangle->draw(rectangle);
    if (green) green->fill(green);
    printf("\n");
    
    /* 示例 3：正方形 + 蓝色 */
    printf("示例 3 - 正方形 + 蓝色:\n");
    Shape *square = factory->shapeCreator->createSquare(factory->shapeCreator);
    Color *blue = factory->colorCreator->createBlue(factory->colorCreator);
    if (square) square->draw(square);
    if (blue) blue->fill(blue);
    printf("\n");
    
    /* 清理资源 */
    if (circle) circle->destroy(circle);
    if (red) red->destroy(red);
    if (rectangle) rectangle->destroy(rectangle);
    if (green) green->destroy(green);
    if (square) square->destroy(square);
    if (blue) blue->destroy(blue);
    if (factory) factory->destroy(factory);
    
    printf("抽象工厂演示完成\n\n");
}

main函数

#include <stdio.h>
#include <stdlib.h>
#include "pattern/abstractFactory.h"
#include "pattern/simpleFactory.h"
#include "pattern/factoryPattern.h"

int main() {
    /* 抽象工厂演示 */
    AbstractFactoryDemo();

    /* 简单工厂演示 */
    SimpleFactoryDemo();

    /* 工厂方法演示 */
    FactoryMethodDemo();

    printf("所有演示完成\n");
    return 0;
}

对比表

选择指南

选择简单工厂，当：

• ✅ 产品种类少（≤3）且很少变化
• ✅ 项目初期，快速验证想法
• ✅ 简单脚本或工具
• ✅ 创建逻辑简单

选择工厂方法，当：

• ✅ 产品种类可能增加
• ✅ 需要高度可重用和可测试的代码
• ✅ 希望遵循面向对象原则
• ✅ 项目中等以上规模
• ✅ 团队重视代码质量和可维护性

选择抽象工厂，当：

• ✅ 需要创建相互关联的产品族
• ✅ 有多个产品族变体（如主题、数据库方案）
• ✅ 产品族之间需要保证协同工作
• ✅ 希望透明地切换整个产品族
• ✅ 示例：GUI 框架（Windows、Mac）、数据库驱动（MySQL、PostgreSQL）

实现对比：简单工厂 vs 抽象工厂创建者方式

简单工厂的问题

// ❌ 简单工厂使用 switch 语句
Shape *SimpleFactoryCreateShape(ShapeType type) {
    switch (type) {
        case SHAPE_CIRCLE:    return CreateCircleInstance();
        case SHAPE_RECTANGLE: return CreateRectangleInstance();
        case SHAPE_SQUARE:    return CreateSquareInstance();
        default: return NULL;
    }
}
// 问题：添加 SHAPE_HEXAGON 需要修改此函数

抽象工厂的改进

// ✅ 抽象工厂使用创建者接口（工厂方法模式）
typedef struct ShapeCreatorFamily {
    Shape *(*createCircle)(struct ShapeCreatorFamily *self);
    Shape *(*createRectangle)(struct ShapeCreatorFamily *self);
    Shape *(*createSquare)(struct ShapeCreatorFamily *self);
} ShapeCreatorFamily;

// 具体实现 - 无需 switch
static Shape *ConcreteCreateCircle(ShapeCreatorFamily *self) {
    Circle *instance = CreateCircleInstance();
    if (instance) {
        instance->base.draw = CircleDraw;
        instance->base.destroy = ShapeDestroy;
    }
    return (Shape *)instance;
}
// 优点：添加新产品族仅需新增工厂

总结

• 简单工厂：快速简单，但扩展性差。适合小项目或原型。
• 工厂方法：符合 OOP 原则，易扩展易测试。适合中大型项目。
• 抽象工厂：解决产品族问题，保证兼容性。适合复杂多变的产品体系。

建议：从简单工厂开始。当需求增加或团队规模扩大时，逐步升级为工厂方法，最后考虑抽象工厂。不要过度设计！

项目文件结构

pattern/
├── abstractFactory.h      # 抽象工厂接口
├── abstractFactory.c      # 抽象工厂实现
├── factoryPattern.h       # 工厂方法接口
├── factoryPattern.c       # 工厂方法实现
├── simpleFactory.h        # 简单工厂接口
├── simpleFactory.c        # 简单工厂实现

最后更新：2026年2月19日