C - 语言设计模式¶

#include "common.h"
#include <assert.h>
/***************************************************************
  *  @brief： 一个制造家具的工厂，可以根据用户不同的诉求，制造出不同风格的家具；
 **************************************************************/

void modern_chair(void)
{
    printf("A modern chair\r\n");
}

void modern_desk(void)
{
    printf("A modern desk\r\n");
}

void victorian_chair(void)
{
    printf("A victorian chair\r\n");
}

void victorian_desk(void)
{
    printf("A victorian desk\r\n");
}

typedef struct
{
    void (*chair)(void);
} chair_t;

typedef struct
{
    void (*desk)(void);
} desk_t;

chair_t *make_modern_chair(void)
{
    chair_t *pChair = (chair_t *)malloc(sizeof(chair_t));
    assert(pChair != NULL);
    pChair->chair = modern_chair;
    return pChair;
}

chair_t *make_victorian_chair(void)
{
    chair_t *pChair = (chair_t *)malloc(sizeof(chair_t));
    assert(pChair != NULL);
    pChair->chair = victorian_chair;
    return pChair;
}

desk_t *make_modern_desk(void)
{
    desk_t* pDesk = (desk_t *)malloc(sizeof(desk_t));
    assert(pDesk != NULL);
    pDesk->desk = modern_desk;
    return pDesk;
}

desk_t *make_victorian_desk(void)
{
    desk_t *pDesk = (desk_t *)malloc(sizeof(desk_t));
    assert(pDesk != NULL);
    pDesk->desk = victorian_desk;
    return pDesk;
}

typedef struct
{
    chair_t *(*make_chair)(void);
    desk_t *(*make_desk)(void);
} furnitureFactory;

#define MODERN "modern"
#define VICTORIAN "vitorian"

furnitureFactory *Creat_furnitureFactory(char* type)
{
    furnitureFactory *pfurnitureFactory = (furnitureFactory *)malloc(sizeof(furnitureFactory));
    assert(pfurnitureFactory != NULL);
    if (memcmp(type, MODERN, sizeof(MODERN)) == 0) {
        printf("modern mode!!!!\n");
        pfurnitureFactory->make_chair = make_modern_chair;
        pfurnitureFactory->make_desk = make_modern_desk;
    } else if (memcmp(type, VICTORIAN, sizeof(VICTORIAN)) == 0) {
        printf("vitorian mode!!!!\n");
        pfurnitureFactory->make_chair = make_victorian_chair;
        pfurnitureFactory->make_desk = make_victorian_desk;
    } else {
        printf("type is invalid\r\n");
    }
    return pfurnitureFactory;
}

int main(void)
{
    char type[] = "modern";
    furnitureFactory *my_factory = Creat_furnitureFactory(type);
    my_factory->make_chair()->chair();
    my_factory->make_desk()->desk();
    free(my_factory);

}

#include "common.h"
/***************************************************************
  *  @brief：模拟组装电脑
 **************************************************************/

typedef struct computer{
    void (*assemble_cpu)(void);
    void (*assemble_memory)(void);
    void (*assemble_harddisk)(void);
    void (*build_computer)(void *);
} computer_t;

void assemble_intel_cpu(void)
{
    printf("intel cpu!\n");
}

void assemble_samsung_memory(void)
{
    printf("samsung memory!\n");
}

void assemble_hitachi_harddisk(void)
{
    printf("hitachi harddisk!\n");
}

void build_body(void *computer)
{
    if (computer == NULL) {
        return;
    }
    computer_t *p = (computer_t *)computer;
    p->assemble_cpu();
    p->assemble_harddisk();
    p->assemble_memory();
}

int main(void)
{
    computer_t computer = { 0 };
    computer.build_computer = build_body;
    computer.assemble_cpu = assemble_intel_cpu;
    computer.assemble_harddisk = assemble_hitachi_harddisk;
    computer.assemble_memory = assemble_samsung_memory;
    computer.build_computer(&computer);

}

#include "common.h"
#include <assert.h>
/***************************************************************
  *  @brief：模拟一个衣服工厂可以根据不同的诉求生产出不同面料的衣服
 **************************************************************/

typedef enum {
    COTTON,
    LEATHER,
} clothingType;


typedef struct {
    clothingType fabric;
    void (*generateClothing)(void);
} clothing;

void make_cotton_clothes(void)
{
    printf("Make cotton clothes\r\n");
}

void make_leather_clothes(void)
{
    printf("Make leather clothes\r\n");
}

clothing *manufacture_clothing(clothingType fabric)
{
    clothing *cl = (clothing *)malloc(sizeof(clothing));
    assert(cl);
    cl->fabric = fabric;
    switch(fabric) {
        case COTTON:
            cl->generateClothing = make_cotton_clothes;
            break;
        case LEATHER:
            cl->generateClothing = make_leather_clothes;
            break;
        default:
            break;
    }
    return cl;
}

int main(void)
{
    clothing *cl = manufacture_clothing(COTTON);
    cl->generateClothing();
}

#include "common.h"
#include "list.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define VAR(name, id)   name##id
/***************************************************************
  *  @brief：模拟试卷拷贝
 **************************************************************/

typedef struct Paper
{
    char *teacher_name;
    int class;
    char *question;
    struct Paper *(*copy)(struct Paper* pPaper);
} paper_t;


/*原型的复制接口*/
paper_t* paper_copy(paper_t* pPaper)
{
    paper_t *copy = (paper_t*)malloc(sizeof(paper_t));
    access(copy);
    memcpy(copy, pPaper, sizeof(paper_t));
    return copy;
}


paper_t *clone(paper_t *pPaper)
{
    return pPaper->copy(pPaper);
}

int main(void)
{
    /*定义原型*/
    paper_t origin_paper = {"Li", 5, "1 + 1 = ?", paper_copy};

    /*复制10份试卷*/
    for (int i = 0; i < 10; i++) {
        paper_t *VAR(paper, i) = clone(&origin_paper);
        printf("paper_%d => name: %s, class: %d, question: %s\r\n",
                i, VAR(paper, i)->teacher_name, VAR(paper, i)->class, VAR(paper, i)->question);
    }
    return 0;
}

#include "common.h"
/***************************************************************
  *  @brief： 提供一个访问该实例的全局接口；
 **************************************************************/

/*共享资源大小*/
#define SHARED_MEM_SIZE 100

/*访问该实例的全局接口*/
void* memory_get(void)
{
    /*注意static*/
    static void* pMem = NULL;

    /*当实例已经存在时直接返回这个实例*/
    if(pMem) {
        return pMem;
    }

    /*当实例不存在时创建一个新的实例*/
    pMem = (void*)malloc(SHARED_MEM_SIZE);
    assert(pMem);
    return (void*)pMem;
}

#include "common.h"
#include <assert.h>
/***************************************************************
  *  @brief：模拟代理情形
  *  @param:
  *  @note:
  *  @Sample usage:
 **************************************************************/
typedef struct
{
    void (*ftp_request)(void);
    void (*http_request)(void);
    void (*smtp_request)(void);
} pc_client_t;

typedef struct
{
    pc_client_t* pClient;
    void (*process)(void *)
} proxy_t;

void ftp_request(void)
{
    printf("request from ftp!\n");
}

void http_request(void)
{
    printf("request from http!\n");
}

void smtp_request(void)
{
    printf("request from smtp!\n");
}

void process(void *proxy)
{
    assert(NULL != proxy);
    proxy_t *data = (proxy_t *)proxy;
    data->pClient->ftp_request();
    data->pClient->http_request();
    data->pClient->smtp_request();
}

int main(void)
{
    pc_client_t pc_client = { 0 };
    proxy_t proxy = { 0 };
    pc_client.ftp_request = ftp_request;
    pc_client.http_request = http_request;
    pc_client.smtp_request = smtp_request;
    proxy.process = process;
    proxy.pClient = &pc_client;
    proxy.process(&proxy);
    return 0;
}

#include "common.h"
/***************************************************************
  *  @brief：模拟cpu组装
 **************************************************************/
typedef struct _cpu_t{
    void (*assemble_cpu_imc)(struct _cpu_t *);
    int type;
} cpu_t;

static void assemble_cpu_imp(cpu_t *cpu)
{
    printf("%d cpu\n", cpu->type);
}

typedef struct {
    void (*assemble_cpu)(cpu_t *cpu);
} computer_t;

/* 组装cpu*/
static void assemble_cpu(cpu_t *cpu)
{
    cpu->assemble_cpu_imc(cpu);
}

#define LOW_TYPE 0X01
#define HIGH_TYPE 0X02

int main(void)
{
    cpu_t myCPu  = { 0 };
    myCPu.type = LOW_TYPE;
    myCPu.assemble_cpu_imc = assemble_cpu_imp;

    computer_t myComp = { 0 };
    myComp.assemble_cpu = assemble_cpu;
    myComp.assemble_cpu(&myCPu);
}

#include "common.h"
/***************************************************************
  *  @brief：模拟多态
 **************************************************************/
typedef int (*fun)(int, int);

void wrapper(fun func, int num1, int num2)
{
    printf("enter wrapper\n");
    func(num1, num2);
    printf("get out og wrapper\n");
}

int add(int num1, int num2)
{
    int sum = num1 + num2;
    printf("%d+%d=%d\n", num1, num2, sum);
    return sum;
}
int sub(int num1, int num2)
{
    int sub = num1 - num2;
    printf("%d-%d=%d\n", num1, num2, sub);
    return sub;
}
int mul(int num1, int num2)
{
    int mul = num1 * num2;
    printf("%d*%d=%d\n", num1, num2, mul);
    return mul;
}

int main(int argc, char *argv[])
{
    wrapper(add, 20, 30);
    wrapper(sub, 20, 30);
    wrapper(mul, 20, 30);
    return 0;
}

#include "common.h"
/***************************************************************
  *  @brief： 提供一个统一的接口，用来访问子系统中的一群接口
 **************************************************************/

typedef struct {
    void (*work)(void);
} computer_t;

void work(void)
{
    printf("working\n");
}

typedef struct {
    void (*contact)(void);
} phone_t;

void contact(void)
{
    printf("contacting\n");
}

typedef struct _factory{
    computer_t *computer;
    phone_t *phone;
    void (*create)(struct _factory *);
} factory_t;

void create(factory_t *fac)
{
    printf("create\n");
    if (fac == NULL) {
        return;
    }
    fac->computer->work();
    fac->phone->contact();
}

int main(void)
{
    computer_t computer = {
        .work = work,
    };
    phone_t phone = {
        .contact = contact,
    };
    factory_t factory = {
        .create = create,
        .computer = &computer,
        .phone = &phone,
    };
    factory.create(&factory);

}

#include "common.h"
/***************************************************************
  *  @brief： 适配接口的实现——通过宏定义
 **************************************************************/

#define RTOS_TYPE

static void create_freertos_1( void )
{
    printf( "create_freertos_1\n" );
}

static void create_freertos_2( void )
{
    printf( "create_freertos_2\n" );
}

static void create_ucos( void )
{
    printf( "create_ucos\n" );
}

static void run_freertos_1( void )
{
    printf( "run_freertos_1\n" );
}

static void run_freertos_2( void )
{
    printf( "run_freertos_2\n" );
}

static void run_ucos( void )
{
    printf( "run_ucos\n" );
}

typedef struct _OsAdapter {
    void( *create )( void );
    void( *run )( void );
} OsAdapter;

void create( void )
{
#ifdef RTOS_TYPE
    create_freertos_1();
    create_freertos_2();
#elif UCOS_TYPE
    create_ucos();
#endif
}

void run( void )
{
#ifdef RTOS_TYPE
    run_freertos_1();
    run_freertos_2();
#elif UCOS_TYPE
    run_ucos();
#endif
}

int main( void )
{
    OsAdapter os = { NULL };
    os.create = create;
    os.run = run;
    os.create();
    os.run();
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "list.h"
/***************************************************************
  *  @brief：模拟流程审阅，内核链表实现
 **************************************************************/

enum {PASS, REFUSE, };

typedef struct {
    int money;
    char* files;
} info_t;

typedef int (*request_handle)(info_t* info);

typedef struct {
    request_handle func;
    struct list_head myList;
} chainNode;

chainNode *init_list(void)
{
    chainNode *head = (chainNode *)malloc(sizeof(chainNode));
    if (head == NULL) {
        perror("malloc failed in init_list\n");
        return NULL;
    }
    INIT_LIST_HEAD(&(head->myList));
    return head;
}

chainNode *create_node(request_handle func)
{
    chainNode *newNode = (chainNode *)malloc(sizeof(chainNode));
    if (newNode == NULL) {
        perror("malloc failed in create_node\n");
        return NULL;
    }
    newNode->func = func;
    INIT_LIST_HEAD(&(newNode->myList));
    return newNode;
}

int leader_handle(info_t* info)
{
    assert(info);
    if(info->money < 1000) {
        //金额小于1000就行
        return PASS;
    }
    return REFUSE;
}

int hr_handle(info_t* info)
{
    assert(info);
    if(info->money < 2000 && info->files != NULL) {
        //金额小于2000且材料齐全
        return PASS;
    }
    return REFUSE;
}

int boss_handle(info_t* info)
{
    assert(info);
    if(info->files != NULL) {
        //材料齐全就行，不差钱
        return PASS;
    }
    return REFUSE;
}

#define PROCESS_NUM 3
//For this we only need to focus on the ordering of the elements of this array
request_handle req_table[] = {
    hr_handle,
    leader_handle,
    boss_handle
};

int main(void)
{
    chainNode *head = init_list();
    /*将审批节点添加到责任链上*/
    for (int i = 0; i < PROCESS_NUM; i++) {
        chainNode *new_node = create_node(req_table[i]);
        list_add_tail(&(new_node->myList), &(head->myList));
    }

    /*报销内容*/
    info_t info = {.money = 900, .files = "files"};
    chainNode *p = NULL;
    chainNode *n = NULL;
    list_for_each_entry_safe(p, n, &(head->myList), myList) {
        if (p->func(&info) != PASS) {
            printf("failed to to reimburse\n");
            return EXIT_FAILURE;
        }
    }
    printf("success to to reimburse, thank you\n");
    return EXIT_SUCCESS;

}

#include <stdio.h>
/***************************************************************
  *  @brief：命令模式实现事件处理
 **************************************************************/

void eatting(void)
{
    printf("eatting\n");
}

void running(void)
{
    printf("running\n");
}

void sleeping(void)
{
    printf("sleeping\n");
}

# 传统模式
void parsing_cmd_trandition_mode(int cmd)
{
    switch (cmd)
    {
    case 0x01:
        eatting();
        break;
    case 0x02:
        running();
        break;
    case 0x03:
        sleeping();
        break;
    default:
        break;
    }
}

typedef void (*parsing_cmd)(void);
typedef struct
{
    int cmd;
    parsing_cmd parsing_fun;
} cmd_t;

#define ACTION_NUM 3
static cmd_t cmd_table[ACTION_NUM] = {
    {0x01, eatting},
    {0x02, running},
    {0x03, sleeping}
};

# 命令模式
void parsing_cmd_command_mode(int cmd)
{
    for (int i = 0; i < ACTION_NUM; ++i) {
        if (cmd == cmd_table[i].cmd) {
            cmd_table[i].parsing_fun();
        }
    }
}

int main(int argc, char const *argv[])
{
    parsing_cmd_trandition_mode(0x02);
    parsing_cmd_command_mode(0x01);
    parsing_cmd_command_mode(0x03);

    return 0;
}

#include "common.h"


// 当心字节对齐的问题
typedef struct {
    u_int8_t head;
    u_int8_t cmd;
    u_int16_t length;
    u_int8_t data[1];
} package_t;

static void parse_temperature(u_int8_t *buffer)
{
    int value = *buffer;
    printf( "temperature = %d\n", value);
}
static void parse_humidity(u_int8_t *buffer)
{
    int value = *buffer;
    printf( "humidity = %d\n", value);
}
static void parse_illumination(u_int8_t *buffer)
{
    int value = *buffer;
    printf( "illumination = %d\n", value);
}

typedef struct {
    u_int8_t cmd;
    void (* handle)(u_int8_t *);
} parse_handler;

static const parse_handler  handlers[] = {
    {0x01, parse_temperature},
    {0x02, parse_humidity},
    {0x03, parse_illumination},
    {0xFF, NULL},
};

static u_int8_t parse(u_int8_t *buffer, u_int8_t length)
{
    package_t *frame = (package_t *)buffer;
    u_int8_t tail = buffer[length - 1];
    const parse_handler *entry;

    if (frame->head != 0xFF) {
        return 0;
    }

    for (entry =  handlers; entry->handle != NULL; ++entry) {
        if (frame->cmd == entry->cmd) {
            entry->handle(frame->data);
            break;
        }
    }

    return 1;
}

int main(void)
{
    u_int8_t buffer[] = {0xFF, 0x01, 0x00, 0x05, 0x02};
    parse(buffer, 5);
    u_int8_t buffer_2[] = {0xFF, 0x02, 0x00, 0x05, 0x02};
    parse(buffer_2, 5);
    u_int8_t buffer_3[] = {0xFF, 0x03, 0x00, 0x05, 0x02};
    parse(buffer_3, 5);
}

#include "common.h"
/***************************************************************
  *  @brief：
 **************************************************************/

typedef struct interpreter
{
    int type;
    void *pData;
    int result;
    int* (*process)(struct interpreter *);
} interpreter_t;

int *process_1(struct interpreter *interpreter)
{
    ...
}

int *process_2(struct interpreter *interpreter)
{
    ...
}

int main(void)
{
    interpreter_t interpreter = { 0 };
    interpreter.type = 0x01;
    interpreter.pData = "helloworld";
    interpreter.result = true;
    interpreter.process = process_1;
    if (interpreter.process(&interpreter)) {
        ...
    }
}

#include "common.h"

struct Customer {
    struct Waiter* waiter;
    int ( *request) (struct Customer* customer, int fish);
};

struct Cooker {
    struct Waiter* waiter;
    void ( *cook)(struct Cooker* cooker, int fish);
};

// 中介者waiter负责提供数据供双方访问，类似于全局变量
struct Waiter {
    int fish;
    // 当customer指向waiter后，就可以通过访问waiter中的结构体来访问其他对象
    struct Customer* customer;
    struct Cooker* cooker;
    int ( *wrequest)(struct Customer* customer, int fish);  //customer
};

void cook(struct Cooker* cooker, int fish)
{
    cooker->waiter->fish = fish;
}

int request(struct Customer* customer, int fish)
{
    // 调用中介者中的函数 ，使维护集中在中介者中
    return customer->waiter->wrequest(customer, fish);
}

int wrequest(struct Customer* customer, int fish)
{
    // 很多资源和函数都集中在中介者中，
    if (fish > customer->waiter->fish) {
        printf ("抱歉，厨师反馈没有 %d 那么多鱼了，重新点菜吧。\n", fish);
        return -1;
    } else {
        printf ("点菜成功，厨房还有%d鱼,足够你们吃了\n", fish);
        return 0;
    }
}

int fish(void)
{
    return (rand() % 50 + 40);
}

int main(void)
{
    struct Customer customer = { 0 };
    struct Cooker cooker = { 0 };
    struct Waiter waiter = { 0 };

    waiter.wrequest = wrequest;
    cooker.waiter = &waiter;
    customer.waiter = &waiter;
    cooker.cook = cook;
    customer.request = request;
    cooker.cook (&cooker, 50);                            //厨师今天只能做50条鱼

    while (customer.request (&customer, fish()));         //消费者跟服务员waiter说要个N条大鱼
}

#include "common.h"
#define OK 0
#define U_OK 1
/***************************************************************
  *  @brief：模拟不同的人对不同豆腐类型的喜好
 **************************************************************/

typedef enum {
    SPICY_FOOD,
    STRONG_SMELL_FOOD,
} toufuType_e;

typedef enum {
    WEST,
    EAST,
} region_e;


typedef struct _tofu {
    int type;
    int (*eat)(void *, void *);
} tofu_t;

typedef struct _vistor {
    int region;
    int (*process)(void *, void *);
} vistor_t;

int process(void *tofu, void *vistor)
{
    if (tofu == NULL || vistor == NULL) {
        return U_OK;
    }

    tofu_t *p_tofu = (tofu_t *)tofu;
    vistor_t *p_vistor = (vistor_t *)vistor;
    if ((p_tofu->type == SPICY_FOOD && p_vistor->region == WEST ) ||
        (p_tofu->type == STRONG_SMELL_FOOD) && p_vistor->region == EAST) {
            printf("it tastes so good\n");
            return OK;
        }
    printf("I don't like it\n");
    return U_OK;
}

int eat(void * vistor, void * tofu)
{
    if (vistor == NULL || tofu == NULL) {
        return U_OK;
    }
    tofu_t *p_tofu = (tofu_t *)tofu;
    vistor_t *p_vistor = (vistor_t *)vistor;
    p_vistor->process(p_tofu, p_tofu);
    return OK;
}

int main(void)
{
    tofu_t *tf = (tofu_t *)malloc(sizeof(tofu_t));
    vistor_t *vst = (vistor_t *)malloc(sizeof(vistor_t));
    if (tf == NULL || vst == NULL) {
        return U_OK;
    }

    tf->eat = eat;
    tf->type = SPICY_FOOD;
    vst->proces = process;
    vst->region = EAST;
    tf->eat(tf, vst);

    free(tf);
    free(vst);
}