工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。
二. 工厂方法模式
所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。
还以刚才的例子解释，这家电子厂赚了不少钱，于是决定再开设一个厂，其中一个工厂专门用来生产A型号的产品，也就是只生产电吹风，而另一工厂专门用来生产B型号的产品，也就是只生产电风扇，这样分工明确了。以后客户要再下定单时，可以直接找到相关的工厂了，比如要A型号的产品，就找A工厂要，不再担心下的定单是A，生产出来的是B产品了。
代码实现：
abstractClass.h
#ifndef ABSTRACTCLASS_H
#define ABSTRACTCLASS_H
#include
#include
typedef struct {
size_t size;
void* (*ctor)(void *_self, va_list *params);
void* (*dtor)(void *_self);
} AbstractClass;
#endif
factory.h
#ifndef FACTORY_H
#define FACTORY_H
#include
#include
typedef struct {
size_t size;
void* (*ctor)(void *_self, va_list *params);
void* (*dtor)(void *_self);
void* (*createProduct)(const void *_self);
} Factory;
#endif
factoryA.h
#ifndef FACTORYA_H
#define FACTORYA_H
typedef struct {
const void *_;
} _FactoryA;
extern const void *FactoryA;
#endif
factoryA.c
#include "factory.h"
#include "factoryA.h"
#include "productA.h"
#include "new.h"
#include
static void *factoryACtor(void *_self, va_list *params){
_FactoryA *self = _self;
return self;
}
static void *factoryADtor(void *_self) {
_FactoryA *self = _self;
return self;
}
static void* factoryACreateProduct(const void *self) {
return New(ProductA);
}
static const Factory _factory = {
sizeof(_FactoryA),
factoryACtor,
factoryADtor,
factoryACreateProduct
};
const void *FactoryA = &_factory;
factoryB.h
#ifndef FACTORYB_H
#define FACTORYB_H
typedef struct {
const void *_;
} _FactoryB;
extern const void *FactoryB;
#endif
factoryB.c
#include "factory.h"
#include "factoryB.h"
#include "productB.h"
#include "new.h"
#include
static void *factoryBCtor(void *_self, va_list *params){
_FactoryB *self = _self;
return self;
}
static void *factoryBDtor(void *_self) {
_FactoryB *self = _self;
return self;
}
static void* factoryBCreateProduct(const void *self) {
return New(ProductB);
}
static const Factory _factory = {
sizeof(_FactoryB),
factoryBCtor,
factoryBDtor,
factoryBCreateProduct
};
const void *FactoryB = &_factory;
product.h
#ifndef PRODUCT_H
#define PRODUCT_H
#include
#include
typedef struct {
size_t size;
void* (*ctor)(void *_self, va_list *params);
void* (*dtor)(void *_self);
void (*show)(const void *_self);
} Product;
#endif
productA.h
#ifndef PRODUCTA_H
#define PRODUCTA_H
typedef struct {
const void *_;
} _ProductA;
extern const void *ProductA;
#endif
productA.c
#include "product.h"
#include "productA.h"
#include
#include
static void *productACtor(void *_self, va_list *params) {
_ProductA *self = _self;
return self;
}
static void *productADtor(void *_self) {
_ProductA *self = _self;
return self;
}
static void productAShow(const void *_self) {
(void)_self;
fprintf(stdout, "Product A\n");
}
static const Product _product = {
sizeof(_ProductA),
productACtor,
productADtor,
productAShow
};
const void *ProductA = &_product;
productB.h
#ifndef PRODUCTB_H
#define PRODUCTB_H
typedef struct {
const void *_;
} _ProductB;
extern const void *ProductB;
#endif
productB.c
#include "product.h"
#include "productB.h"
#include
#include
#include
static void *productBCtor(void *_self, va_list *params) {
_ProductB *self = _self;
return self;
}
static void *productBDtor(void *_self) {
_ProductB *self = _self;
return self;
}
static void productBShow(const void *_self) {
(void)_self;
fprintf(stdout, "Product B\n");
}
static const Product _product = {
sizeof(_ProductB),
productBCtor,
productBDtor,
productBShow
};
const void *ProductB = &_product;
new.h
#ifndef NEW_H
#define NEW_H
void *New(const void *_class, ...);
void Delete(void *_class);
void *CreateProduct(const void *_factory);
void Show(const void *product);
#endif
new.c
#include "new.h"
#include "abstractClass.h"
#include "factory.h"
#include "product.h"
#include
#include
#include
#include
void *New(const void *_class, ...) {
const AbstractClass *class = _class;
void *p = calloc(1, class->size);
assert(p);
*(const AbstractClass **)p = class;
if (class->ctor) {
va_list params;
va_start(params, _class);
p = class->ctor(p, ¶ms);
va_end(params);
}
return p;
}
void Delete(void *_class) {
const AbstractClass **class = _class;
if (_class && *class && (*class)->dtor) {
_class = (*class)->dtor(_class);
}
free(_class);
}
void *CreateProduct(const void *_factory) {
const Factory * const *factory = _factory;
if (_factory && *factory && (*factory)->createProduct) {
return (*factory)->createProduct(_factory);
} else {
return NULL;
}
}
void Show(const void *_product) {
const Product * const *product = _product;
if (_product && *product && (*product)->show) {
(*product)->show(_product);
}
}
main.c
#include "new.h"
#include "factoryA.h"
#include "factoryB.h"
int main(int argc, char *argv[]) {
void *facA = New(FactoryA);
void *facB = New(FactoryB);
void *pro1 = CreateProduct(facA);
void *pro2 = CreateProduct(facB);
void *pro3 = CreateProduct(facA);
Show(pro1);
Show(pro2);
Show(pro3);
Delete(facA);
Delete(facB);
Delete(pro1);
Delete(pro2);
Delete(pro3);
return 0;
}
图片来源：http://blog.csdn.net/hmsiwtv/article/details/9627109
