C 设计模式：装饰模式

最近在公司分享了下C语言版的设计模式，记录一下吧。

参考：《设计模式之禅》中“装饰模式”章节。

上面书中是用C++来实现的，我使用了书中的例子，改用C语言来实现。

 

一、基础知识

 面向对象最重要的三个特性，在C语言中大致的实现如下所示。

//1、继承性

typedef struct _Parent
{
    int data_parent;
}Parent;

typedef struct _Child
{
    struct _Parent parent;
    int data_child;
}Child;

//2、封装性

struct _Data;

typedef void (*fProc)(struct _Data* pData);

typedef struct _Data
{
    int value;
    fProc Process;
}Data;

//3、多态

typedef struct _Run
{
    void* pData;
    void (*fProc)(struct _Run* pRun);
}Run;

 

装饰模式，在C语言中的实现：

typedef struct _Object  
{  
    struct _Object* prev;  
  
    void (*decorate)(struct _Object* pObject);  
}Object;  

void decorate(struct _Object* pObeject)  
{  
    assert(NULL != pObject);  
  
    if(NULL != pObject->prev)  
        pObject->prev->decorate(pObject->prev);  
  
    printf("normal decorate!\n");  
}  

 

二、讲个故事

很久很久以前，大概还是小学的时候，期末考试完，最可怕的事情就是：老师让把试卷拿回家里，让家长签字。

typedef struct _SchoolRpt
{
    void (*Report)();
    void (*Sign)(char* name);
}

void Report()
{
    printf("我这次考了：语文62 数学65 体育98 自然63 \n");
}

void Sign(char* name)
{
    printf("家长签名：%s \n", name);
}

int main()
{
    SchoolRpt sr = {Report, Sign};
    
    sr.Report();
    
    return 0;
}

/*
Output:

我这次考了：语文62 数学65 体育98 自然63

////////////挨打中/////////////
*/

得，这么耿直的直接拿给老爹看，一定得被啪啪啪。还想要签字？做梦！

 

三、故事还得继续

得想个办法呀。这个事情，跟写作文一样，得润色润色，不能太耿直。

这样，先告诉老爹这次最高分时多少，“看，最高分也不高，大家考的都不好，题难呢！”。

然后再说自己的成绩。

最后，再说下自己的班级排名，“其实，排名比往常还有点小进步的哦~”。

好办法，我们试一试。

typedef struct _SchoolRpt
{
    void (*Report)();
    void (*Sign)(char* name);
}

void Report()
{
    printf("我这次考了：语文62 数学65 体育98 自然63 \n");
}

void ReportHighScore()
{
    printf("最高分：语文82 数学81 体育100 自然79 \n");
}

void ReportSort()
{
    printf("排名：30 \n");
}

void Sign(char* name)
{
    printf("家长签名：%s \n", name);
}

int main()
{
    SchoolRpt sr = {Report, Sign};
    
    ReportHighScore();
    sr.Report();
    ReportSort();
    
    sr.Sign("FATHER");
    
    return 0;
}

/*
Output:

最高分：语文82 数学81 体育100 自然79
我这次考了：语文62 数学65 体育98 自然63
排名：30
家长签名：FATHER
*/

好嘞，成了，拿到了老爹的签名，少挨了一次打。开心~

 

 四、故事有时候会变

但是呢，事情都不是绝对的。

有时候老爹心情比较好，只说了最高成绩，老爹就要签名了，还没来得及说自己的排名呢。

有时候老爹心情不太好，那得想更多的法子才行。

那得给每种场景都写个 方法吗？那得累死啦。

噔噔噔，装饰模式出场了：

//抽象组件
typedef struct _iobject
{
    struct _iobject* prev;
    
    void (*frame_creater)(struct _iobject* obj); //接口函数

    void (*report)();
}Iobject;

//初始化某个Iobject的变量
void init_iobject(Iobject* obj, void (*report)(), void (*frame_creater)(Iobject* m_obj))
{
    obj->frame_creater = frame_creater;
    obj->prev = NULL;
    obj->report = report;
}

//置current的prev值
void add_iobject(Iobject* current, Iobject* prev)
{
    current->prev = prev;
}

//接口函数
void decorator_frame_creater(struct _iobject* obj)
{
    if(obj->prev != NULL)
        obj->prev->frame_creater(obj->prev);
    
    obj->report();
}

/* ============================================================= */
typedef struct _SchoolRpt
{
    struct _iobject scoreRpt;
    
    void (*Sign)(char* name);
}SchoolRpt;

void Report()
{
    printf("我这次考了：语文62 数学65 体育98 自然63 \n");
}

void Sign(char* name)
{
    printf("家长签名：%s \n", name);
}

//装饰者
Iobject HighScoreDecorator;
Iobject SortDecorator;

void ReportHighScore()
{
    printf("最高分：语文82 数学81 体育100 自然79 \n");
}

void ReportSort()
{
    printf("排名：30 \n");
}

int main()
{
    SchoolRpt father = {{}, Sign};
    
    //老爹看报告前，得做些准备工作
    Iobject *sr = &((Iobject)father);
    
    init_iobject(sr, Report, decorator_frame_creater);
    init_iobject(&HighScoreDecorator, ReportHighScore, decorator_frame_creater);
    init_iobject(&SortDecorator, ReportSort, decorator_frame_creater);
    
    //快加上装饰
    add_iobject(&SortDecorator, sr);
    add_iobject(sr, &HighScoreDecorator);
    
    //小心翼翼拿给老爹
    sr->frame_creater(sr);
    
    //老爹签名
    father.Sign("FATHER");
    
    return 0;
}

/*
Output:

最高分：语文82 数学81 体育100 自然79
我这次考了：语文62 数学65 体育98 自然63
排名：30
家长签名：FATHER
*/

这样就好了，不同的场景，只需要配置不同的报告方式就好。再也不用担心老爹揍我啦，哈哈~（假的）。

 

五、装饰模式

装饰者模式

Decorator模式（别名Wrapper）：动态将职责附加到对象上，若要扩展功能，装饰者提供了比继承更具弹性的代替方案。

 

意图：

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

 

设计原则：

1. 多用组合，少用继承。

利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。

2. 类应设计的对扩展开放，对修改关闭。

 

要点：

1． 装饰者和被装饰对象有相同的超类型。

2． 可以用一个或多个装饰者包装一个对象。

3． 装饰者可以在所委托被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的。

4． 对象可以在任何时候被装饰，所以可以在运行时动态的，不限量的用你喜欢的装饰者来装饰对象。

5． 装饰模式中使用继承的关键是想达到装饰者和被装饰对象的类型匹配，而不是获得其行为。

6． 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。在实际项目中可以根据需要为装饰者添加新的行为，做到“半透明”装饰者。

7． 适配器模式的用意是改变对象的接口而不一定改变对象的性能，而装饰模式的用意是保持接口并增加对象的职责。