add c for decorator

Author: Jarry

.vscode/settings.json

@@ -13,6 +13,20 @@
     "vehicle.h": "c",
     "queue": "c",
     "stack": "c",
-    "filesystem": "c"
+    "filesystem": "c",
+    "__functional_base": "c",
+    "__functional_base_03": "c",
+    "__hash_table": "c",
+    "__tuple": "c",
+    "algorithm": "c",
+    "array": "c",
+    "chrono": "c",
+    "functional": "c",
+    "iterator": "c",
+    "limits": "c",
+    "tuple": "c",
+    "istream": "c",
+    "ostream": "c",
+    "__locale": "c"
   }
 }

decorator-pattern/README.md

@@ -1,4 +1,4 @@
-# 【装饰器设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【装饰器设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 装饰器模式（Decorator Pattern）是一种结构型设计模式。将对象放入到一个特殊封装的对象中，为这个对象绑定新的行为，具备新的能力，同时又不改变其原有结构。
@@ -18,7 +18,7 @@
 # UML
 <img src="../docs/uml/decorator-pattern.png">
 
-# 代码
+# Java代码
 
 ## 基础形状接口
 ```java
@@ -138,5 +138,121 @@ public class ShadowShapeDecorator extends ShapeDecorator {
     shadowSquare.draw();
 ```
 
+# Go代码
+
+## 基础形状接口
+```go
+// Shape.go 基础形状接口
+type Shape interface {
+  Draw()
+  GetName() string
+}
+
+```
+
+## 具体形状实现
+```go
+// Circle.go 具体形状实现了基础形状接口
+type Circle struct {
+}
+
+func (c *Circle) Draw() {
+  fmt.Println("Circle::Draw()")
+}
+
+func (c *Circle) GetName() string {
+  return "Circle"
+}
+
+```
+
+```go
+// Square.go 具体形状实现了基础形状接口
+type Square struct {
+}
+
+func (c *Square) Draw() {
+  fmt.Println("Square::Draw()")
+}
+
+func (c *Square) GetName() string {
+  return "Square"
+}
+```
+
+## 抽象装饰器
+```go
+// ShapeDecorator.go 抽象装饰类，是否实现Shape可选
+type ShapeDecorator interface {
+  Draw()
+}
+```
+
+## 具体装饰器
+```go
+// RedShapeDecorator.go 具体装饰器1
+type RedShapeDecorator struct {
+  DecoratedShape Shape
+}
+
+func (r *RedShapeDecorator) Draw() {
+  r.DecoratedShape.Draw()
+  r.SetRedColor(r.DecoratedShape)
+}
+
+func (r *RedShapeDecorator) SetRedColor(decoratedShape Shape) {
+  fmt.Println("RedShapeDecorator::setRedColor() " + decoratedShape.GetName())
+}
+```
+
+```go
+// ShadowShapeDecorator.go 具体装饰器2
+type ShadowShapeDecorator struct {
+  DecoratedShape Shape
+}
+
+func (s *ShadowShapeDecorator) Draw() {
+  // 装饰器根据需要是否调用形状的Draw方法
+  // s.DecoratedShape.Draw()
+  s.SetShadow(s.DecoratedShape)
+}
+
+func (s *ShadowShapeDecorator) SetShadow(decoratedShape Shape) {
+  fmt.Println("ShadowShapeDecorator::SetShadow() " + decoratedShape.GetName())
+}
+```
+
+## 测试调用
+```go
+  /**
+   * 装饰器模式是将一个对象放到一个装饰器对象中，执行装饰器类里的方法时，对象的行为能力得到增强。
+   * 先声明具体对象，然后放到装饰器，得到一个带有装饰器的新对象，该对象具备了新的能力。
+   */
+
+  // 声明形状
+  var circle = new(src.Circle)
+  var square = new(src.Square)
+
+  // 增加红色装饰
+  var redCircle = &src.RedShapeDecorator{
+    DecoratedShape: circle,
+  }
+  var redSquare = &src.RedShapeDecorator{
+    DecoratedShape: square,
+  }
+  circle.Draw()
+  redCircle.Draw()
+  redSquare.Draw()
+
+  // 增加影子装饰
+  var shadowCircle = &src.ShadowShapeDecorator{
+    DecoratedShape: circle,
+  }
+  var shadowSquare = &src.ShadowShapeDecorator{
+    DecoratedShape: square,
+  }
+  shadowCircle.Draw()
+  shadowSquare.Draw()
+```
 ## 更多语言版本
 不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)

decorator-pattern/c/src/circle.c

@@ -0,0 +1,18 @@
+#include "func.h"
+
+// 具体形状实现了基础形状接口
+void circle_draw(Circle *circle)
+{
+  printf("\r\n Circle::draw() [name=%s]", circle->name);
+}
+
+// 创建Circle对象
+Circle *circle_constructor(char *name)
+{
+  Shape *shape = (Shape *)malloc(sizeof(Shape));
+  strncpy(shape->name, name, 50);
+  // 转为Circle
+  Circle *circle = (Circle *)shape;
+  circle->draw = &circle_draw;
+  return circle;
+}

decorator-pattern/c/src/func.h

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+// 基础形状类，可定义公共方法
+typedef struct Shape
+{
+    char name[50];
+    void (*draw)(struct Shape *);
+} Shape;
+
+// 具体形状实现了基础形状接口
+typedef struct Circle
+{
+    char name[50];
+    void (*draw)(struct Circle *);
+} Circle;
+Circle *circle_constructor(char *name);
+
+// 具体形状实现了基础形状接口
+typedef struct Square
+{
+    char name[50];
+    void (*draw)(struct Square *);
+} Square;
+Square *square_constructor(char *name);
+
+// 抽象装饰器接口
+typedef struct ShapeDecorator
+{
+    char name[50];
+    void (*draw)(struct ShapeDecorator *);
+    struct ShapeDecorator *decorated_shape;
+    // void (*set_red_color)(struct ShapeDecorator *);
+    // void (*set_shadow)(struct ShapeDecorator *);
+} ShapeDecorator;
+
+// 具体装饰器1，实现基础装饰器接口
+typedef struct RedShapeDecorator
+{
+    char name[50];
+    void (*draw)(struct RedShapeDecorator *);
+    // 聚合具体形状对象
+    struct ShapeDecorator *decorated_shape;
+    void (*set_red_color)(struct RedShapeDecorator *);
+} RedShapeDecorator;
+RedShapeDecorator *red_shape_decorator_constructor(char *, ShapeDecorator *);
+
+// 具体装饰器2，实现基础装饰器接口
+typedef struct ShadowShapeDecorator
+{
+    char name[50];
+    void (*draw)(struct ShadowShapeDecorator *);
+    // 聚合具体形状对象
+    struct ShapeDecorator *decorated_shape;
+    void (*set_shadow)(struct ShadowShapeDecorator *);
+} ShadowShapeDecorator;
+ShadowShapeDecorator *shadow_shape_decorator_constructor(char *, ShapeDecorator *);

decorator-pattern/c/src/red_shape_decorator.c

@@ -0,0 +1,27 @@
+#include "func.h"
+
+// 具体装饰器1，实现基础装饰器接口
+void red_shape_decorator_draw(RedShapeDecorator *decorator)
+{
+  printf("\r\n RedShapeDecorator::draw() [name=%s]", decorator->name);
+  decorator->decorated_shape->draw((ShapeDecorator *)decorator);
+  decorator->set_red_color(decorator);
+}
+
+void decorator_set_red_color(RedShapeDecorator *decorator)
+{
+  printf("\r\n RedShapeDecorator::set_red_color() [name=%s]", decorator->name);
+}
+
+// 创建RedShapeDecorator对象
+RedShapeDecorator *red_shape_decorator_constructor(char *name, ShapeDecorator *decorated_shape)
+{
+  ShapeDecorator *decorator = (ShapeDecorator *)malloc(sizeof(ShapeDecorator));
+  strncpy(decorator->name, name, 50);
+  // 转为RedShapeDecorator
+  RedShapeDecorator *red_shape_decorator = (RedShapeDecorator *)decorator;
+  red_shape_decorator->draw = &red_shape_decorator_draw;
+  red_shape_decorator->decorated_shape = decorated_shape;
+  red_shape_decorator->set_red_color = &decorator_set_red_color;
+  return red_shape_decorator;
+}

decorator-pattern/c/src/shadow_shape_decroator.c

@@ -0,0 +1,28 @@
+#include "func.h"
+
+// 具体装饰器2，实现基础装饰器接口
+void shadow_shape_decorator_draw(ShadowShapeDecorator *decorator)
+{
+  printf("\r\n ShadowShapeDecorator::draw() [name=%s]", decorator->name);
+  // 装饰器根据需要是否也调用形状的draw方法
+  // decorator->decorated_shape->draw((ShapeDecorator *)decorator);
+  decorator->set_shadow(decorator);
+}
+
+void decorator_set_shadow(ShadowShapeDecorator *decorator)
+{
+  printf("\r\n ShadowShapeDecorator::set_shadow() [name=%s]", decorator->name);
+}
+
+// 创建ShadowShapeDecorator对象
+ShadowShapeDecorator *shadow_shape_decorator_constructor(char *name, ShapeDecorator *decorated_shape)
+{
+  ShapeDecorator *decorator = (ShapeDecorator *)malloc(sizeof(ShapeDecorator));
+  strncpy(decorator->name, name, 50);
+  // 转为ShadowShapeDecorator
+  ShadowShapeDecorator *shadow_shape_decorator = (ShadowShapeDecorator *)decorator;
+  shadow_shape_decorator->decorated_shape = decorated_shape;
+  shadow_shape_decorator->draw = &shadow_shape_decorator_draw;
+  shadow_shape_decorator->set_shadow = &decorator_set_shadow;
+  return shadow_shape_decorator;
+}

decorator-pattern/c/src/shape.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 基础形状类，定义在head

decorator-pattern/c/src/shape_decorator.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 抽象装饰器接口，定义在head

decorator-pattern/c/src/square.c

@@ -0,0 +1,18 @@
+#include "func.h"
+
+// 具体形状实现了基础形状接口
+void square_draw(Square *square)
+{
+  printf("\r\n Square::draw() [name=%s]", square->name);
+}
+
+// 创建Square对象
+Square *square_constructor(char *name)
+{
+  Shape *shape = (Shape *)malloc(sizeof(Shape));
+  strncpy(shape->name, name, 50);
+  // 转为Square
+  Square *square = (Square *)shape;
+  square->draw = &square_draw;
+  return square;
+}

decorator-pattern/c/test/test.c

@@ -0,0 +1,54 @@
+#include "../src/func.h"
+
+int main(void)
+{
+    printf("test start:\r\n");
+    /**
+     * 装饰器模式是将一个对象放到一个装饰器对象中，执行装饰器类里的方法时，对象的行为能力得到增强。
+     * 先声明具体对象，然后放到装饰器，得到一个带有装饰器的新对象，该对象具备了新的能力。
+     */
+
+    // 声明两个形状对象
+    Shape *circle = (Shape *)circle_constructor("circle");
+    Square *square = square_constructor("square");
+
+    // 增加红色装饰器
+    RedShapeDecorator *red_circle = red_shape_decorator_constructor("red_circle", (ShapeDecorator *)circle);
+    ShapeDecorator *red_square = (ShapeDecorator *)red_shape_decorator_constructor("red_square", (ShapeDecorator *)square);
+    circle->draw(circle);
+    red_circle->draw(red_circle);
+    red_square->draw(red_square);
+
+    // 增加影子装饰器
+    ShapeDecorator *shadow_circle = (ShapeDecorator *)shadow_shape_decorator_constructor("shadow_circle", (ShapeDecorator *)circle);
+    ShadowShapeDecorator *shadow_square = shadow_shape_decorator_constructor("shadow_square", (ShapeDecorator *)square);
+    shadow_circle->draw(shadow_circle);
+    shadow_square->draw(shadow_square);
+
+    free(circle);
+    free(square);
+    free(red_circle);
+    free(red_square);
+    free(shadow_circle);
+    free(shadow_square);
+
+    return 0;
+}
+
+/**
+jarry@jarrys-MacBook-Pro c % gcc test/test.c src/*.c
+jarry@jarrys-MacBook-Pro c % ./a.out
+test start:
+
+ Circle::draw() [name=circle]
+ RedShapeDecorator::draw() [name=red_circle]
+ Circle::draw() [name=red_circle]
+ RedShapeDecorator::set_red_color() [name=red_circle]
+ RedShapeDecorator::draw() [name=red_square]
+ Square::draw() [name=red_square]
+ RedShapeDecorator::set_red_color() [name=red_square]
+ ShadowShapeDecorator::draw() [name=shadow_circle]
+ ShadowShapeDecorator::set_shadow() [name=shadow_circle]
+ ShadowShapeDecorator::draw() [name=shadow_square]
+ ShadowShapeDecorator::set_shadow() [name=shadow_square]%
+ */