本文已参与「新人创作礼」活动，一起开启掘金创作之路。

  在需要对某个功能做拓展时，使用工厂模式能给代码带来尽量少的修改量。本文将通过遵循SOLID设计原则中的开闭原则和依赖倒置原则在C语言上实现工厂模式。

  下面将使用解码器功能作为例子进行讲解，下图为使用工厂模式设计的类关系图和程序运行流程图。

@TOC

工厂设计

  以下为工厂类中的成员与成员函数。

/**
 * @enum ret_t
 * @annotation ["scriptable"]
 * 函数返回值常量定义。
 */
typedef enum _ret_t {
  /**
   * @const RET_OK
   * 成功。
   */
  RET_OK = 0,
  /**
   * @const RET_OOM
   * Out of memory。
   */
  RET_OOM,
  /**
   * @const RET_FAIL
   * 失败。
   */
  RET_FAIL,
  // ...
  /**
   * @const RET_BAD_PARAMS
   * 无效参数。
   */
  RET_BAD_PARAMS = 16,
} ret_t;

/* decoder_factory.h */
#ifndef DECODER_FACTORY_H
#define DECODER_FACTORY_H

#include "tkc/darray.h"
#include "audio_decoder.h"

typedef decoder_t* (*decoder_create_t)(void);

/**
 * @class decoder_factory_t
 * decoder工厂。
 */
typedef struct _audio_decoder_factory_t {
  /*private*/
  darray_t creators;
} audio_decoder_factory_t;

/**
 * @method decoder_factory_instance
 * 获取decoder工厂实例。
 * @annotation ["constructor"]
 * @return {decoder_factory_t*} 返回decoder工厂实例。
 */
decoder_factory_t* decoder_factory_instance(void);

/**
 * @method decoder_factory_register
 * 注册decoder创建函数。
 * @param {decoder_factory_t*} factory decoder工厂对象。
 * @param {const char*} type 类型(如mp3)。
 * @param {decoder_create_t} create decoder创建函数。
 *
 * @return {ret_t} 返回RET_OK表示成功，否则表示失败。
 */
ret_t decoder_factory_register(decoder_factory_t* factory, const char* type,
                               decoder_create_t create);

/**
 * @method decoder_factory_create_decoder
 * 创建指定类型的decoder对象。
 * @param {decoder_factory_t*} factory decoder工厂对象。
 * @param {const char*} type 类型(如mp3)。
 *
 * @return {decoder_t*} 创建decoder对象。
 */
decoder_t* decoder_factory_create_decoder(decoder_factory_t* factory,
                                          const char* type);
#endif /* DECODER_FACTORY_H */

使用工厂注册对象类型

  注册的实现方式是将对象创建的函数指针与类型使用结构体creator_item_t捆绑在一起，然后插入到动态数组中。（代码中使用的是AWTK中的动态数组darray，可以使用链表等方式代替。）

#define NAME_LEN 31
#define return_value_if_fail(p, value)                  \
  if (!(p)) {                                           \
    printf("%s:%d " #p "\n", __FUNCTION__, __LINE__);   \
    return (value);                                     \
  }

typedef struct _creator_item_t {
  char type[NAME_LEN + 1];
  decoder_create_t create;
} creator_item_t;

ret_t decoder_factory_register(decoder_factory_t* factory, const char* type,
                               decoder_create_t create) {
  creator_item_t* item = NULL;
  return_value_if_fail(factory != NULL && type != NULL && create != NULL, RET_BAD_PARAMS);

  item = (creator_item_t*)malloc(sizeof(creator_item_t));
  return_value_if_fail(item != NULL, RET_OOM);

  item->create = create;
  strncpy(item->type, type, NAME_LEN);
  darray_push(&(factory->creators), item);

  return RET_OK;
}

decoder_factory_register(decoder_factory_instance(), "mp3", decoder_mp3_create);

使用工厂创建对象

  通过类型在动态数组中寻找对应函数指针创建对象。

decoder_t* decoder_factory_create_decoder(decoder_factory_t* factory,
                                          const char* type) {
  const creator_item_t* iter = NULL;
  return_value_if_fail(type != NULL, NULL);
  return_value_if_fail(factory != NULL && factory->creators != NULL, NULL);

  iter = darray_find(&(factory->creators), (void*)type);

  return (NULL != iter) ? iter->create() : NULL;
}

decoder_mp3_t* mp3_decoder = decoder_factory_create_decoder(decoder_factory_instance(), "mp3");

通过接口调用对象功能

  在调用具体对象的创建函数时，让对象的虚函数表指针vt指向该类型的虚函数表，这样就可以通过对象的虚函数表指针调用具体方法。详情请查看文章：用C语言实现C++继承与多态。

/**
 * @class decoder_t
 * 解码器接口。
 */
struct _decoder_t {
  const decoder_vtable_t* vt;
}

int32_t decoder_decode(decoder_t* decoder, void* buff, uint32_t size) {
  return_value_if_fail(buff != NULL && size > 0, 0);
  return_value_if_fail(decoder != NULL && decoder->vt != NULL && decoder->vt->decode != NULL, 0);

  return decoder->vt->decode(decoder, buff, size);
}

ret_t decoder_destroy(decoder_t* decoder) {
  return_value_if_fail(decoder != NULL && decoder->vt != NULL && decoder->vt->destroy != NULL, RET_BAD_PARAMS);
  return decoder->vt->destroy(decoder);
}

typedef struct _decoder_mp3_t {
  decoder_t decoder;
} decoder_mp3_t;

static int32_t decoder_mp3_decode(decoder_t* decoder, void* buff, uint32_t size) {
  /* 具体实现 略 */
}

static ret_t decoder_mp3_destroy(decoder_t* decoder) {
  /* 具体实现 略 */
}

static const decoder_vtable_t s_decoder_mp3_vtable = {
    .decode  = decoder_mp3_decode,
    .destroy = decoder_mp3_destroy,
};

decoder_t* decoder_mp3_create(void) {
  decoder_mp3_t* mp3_decoder = (decoder_mp3_t*)malloc(sizeof(decoder_mp3_t));
  return_value_if_fail(mp3_decoder != NULL, NULL);

  mp3_decoder->decoder.vt = &s_decoder_mp3_vtable;

  return (decoder_t*)mp3_decoder;
}

decoder_decode(mp3_decoder, buff, sizeof(buff));
decoder_destroy(mp3_decoder);