add state for c

Author: Jarry

state-pattern/README.md

@@ -1,4 +1,4 @@
-# 【状态设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【状态设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 状态模式（State Pattern）是一种行为型模式，类的行为是基于它的状态改变的，不同的状态下有不同的行为。状态模式和策略模式相似，但是状态模式中的行为是平行的，不可替换的，策略模式中的行为是彼此独立的，可以相互替换，且提前预置到某个具体对象类Context中。状态模式将对象的行为封装在不同的状态对象中，将对象的状态从对象中分离出来，客户端无需关心对象的当前状态和状态的转换。
@@ -23,11 +23,11 @@ ConcreteStateA,ConcreteStateB: 具体的实现类，实现了State中定义的
 # UML
 <img src="../docs/uml/state-pattern.png">
 
-# 代码
+# Java代码
 
 ## 状态基础接口
 ```java
-// 定义状态接口和状态方法，当前context只有一种状态
+// State.java 定义状态接口和状态方法，当前context只有一种状态
 public interface State {
   public void on(Context context);
   public void off(Context context);
@@ -73,7 +73,6 @@ public class ConcreteStateOn implements State {
     System.out.println(this.getClass().getSimpleName() + "::off() [turn OFF ok!]");
     context.setState(new ConcreteStateOff());
   }
-
 }
 ```
 
@@ -131,5 +130,180 @@ public class Context {
     context.turnOff();
     System.out.println("context.state: " + context.getState().getClass().getSimpleName());
 ```
+
+# Go代码
+
+## 状态基础接口
+```go
+// State.go 定义状态接口和状态方法，当前context只有一种状态
+type State interface {
+  GetName() string
+  On(context *Context)
+  Off(context *Context)
+}
+```
+
+## 状态实现类 
+```go
+// ConcreteStateOff.go 具体的状态实现者
+
+type ConcreteStateOff struct {
+  Name string
+}
+
+func (c *ConcreteStateOff) GetName() string {
+  if c.Name == "" {
+    c.Name = "ConcreteStateOff"
+  }
+  return c.Name
+}
+
+func (c *ConcreteStateOff) On(context *Context) {
+  fmt.Println("ConcreteStateOff::On() [turn ON ok!]")
+  // 状态变为on后，状态类切换到ConcreteStateOn
+  context.SetState(&ConcreteStateOn{})
+}
+
+func (c *ConcreteStateOff) Off(context *Context) {
+  // 当前是off状态，再点击off只是提示，不切换状态类
+  fmt.Println("ConcreteStateOff::Off() [needn't switch, state is OFF.]")
+}
+```
+
+```go
+// ConcreteStateOn.go 具体的状态实现者
+type ConcreteStateOn struct {
+  Name string
+}
+
+func (c *ConcreteStateOn) GetName() string {
+  if c.Name == "" {
+    c.Name = "ConcreteStateOn"
+  }
+  return c.Name
+}
+
+func (c *ConcreteStateOn) On(context *Context) {
+  // 当前是on状态，再点击on只是提示，不切换状态类
+  fmt.Println("ConcreteStateOn::On() [needn't switch, state is ON.]")
+}
+
+func (c *ConcreteStateOn) Off(context *Context) {
+  // 状态变为off后，状态类切换到ConcreteStateOff
+  fmt.Println("ConcreteStateOn::Off() [turn OFF ok!]")
+  // 此处状态对象可以每次是新实例，也可以外部传入
+  context.SetState(&ConcreteStateOff{})
+}
+```
+
+## 业务状态类
+```go
+// Context.go 执行实体类，内部关联状态
+type Context struct {
+  state State
+}
+
+func (c *Context) GetState() State {
+  return c.state
+}
+
+func (c *Context) SetState(state State) {
+  fmt.Println("Context::SetState() [state = " + state.GetName() + "]")
+  c.state = state
+}
+
+func (c *Context) TurnOn() {
+  c.state.On(c)
+}
+
+func (c *Context) TurnOff() {
+  c.state.Off(c)
+}
+```
+
+## 测试调用
+```go
+func main() {
+  fmt.Println("test start:")
+
+  /**
+   * 状态模式就是对象Context在不同行为下有不同的状态，当前只有一种状态。
+   * 通过行为的改变，状态也随之自动发生了改变。
+   * 策略模式与状态模式类似，但策略模式是可以重新设置策略，而状态则通过行为来切换状态。
+   */
+
+  context := &src.Context{}
+  // 初始状态是off
+  context.SetState(&src.ConcreteStateOff{})
+  // turn on
+  context.TurnOn()
+  // 再次turn on
+  context.TurnOn()
+  // turn off
+  context.TurnOff()
+  // 再次turn off
+  context.TurnOff()
+  fmt.Println("context.state: " + context.GetState().GetName())
+}
+```
+
+# C语言简版
+```c
+#include <stdio.h>
+// 状态模式将对象的行为封装在不同的状态对象中
+// 将对象的状态从对象中分离出来，客户端无需关心对象的当前状态和状态的转换。
+typedef struct Context Context;
+
+// 执行对象
+struct Context
+{
+    // 设置状态
+    char name[50];
+    void (*change_state)(Context *context);
+};
+
+// 定义不同状态函数
+void state_A_change_state(Context *context);
+void state_B_change_state(Context *context);
+void state_C_change_state(Context *context);
+
+void state_A_change_state(Context *context)
+{
+    printf("\r\n state_A_change_state() [context=%s change to=%s]", context->name, "state_B");
+    // 切换到状态 B
+    context->change_state = state_B_change_state;
+}
+
+void state_B_change_state(Context *context)
+{
+    printf("\r\n state_B_change_state() [context=%s change to=%s]", context->name, "state_C");
+    // 切换到状态 C
+    context->change_state = state_C_change_state;
+}
+
+void state_C_change_state(Context *context)
+{
+    printf("\r\n state_C_change_state() [context=%s change to=%s]", context->name, "state_A");
+    // 切换到状态 A
+    context->change_state = state_A_change_state;
+}
+
+int main()
+{
+    printf("test start:\r\n");
+    Context context = {
+        .name = "Context01",
+        .change_state = state_A_change_state};
+
+    // 当前只有一种状态
+    for (int i = 0; i < 5; i++)
+    {
+        context.change_state(&context);
+    }
+
+    return 0;
+}
+```
+
 ## 更多语言版本
-不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)
+不同语言设计模式源码：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)

state-pattern/c/src/concrete_state_off.c

@@ -0,0 +1,27 @@
+#include "func.h"
+
+/// 具体的状态实现者
+
+void concrete_state_off_on(Context *context)
+{
+  // 状态变为on后，状态类切换到ConcreteStateOn
+  printf("\r\n ConcreteStateOff::on() [turn ON ok!]");
+  context->set_state(context, (State *)concrete_state_on_constructor());
+}
+
+void concrete_state_off_off(Context *context)
+{
+  // 当前是off状态，再点击off只是提示，不切换状态类
+  printf("\r\n ConcreteStateOff::off() [needn't switch, state is OFF.]");
+}
+
+ConcreteStateOff *concrete_state_off_constructor()
+{
+  // printf("\r\n proxy_off_constructor() [构建ConcreteStateOff]");
+  State *state = (State *)malloc(sizeof(State));
+  ConcreteStateOff *state_off = (ConcreteStateOff *)state;
+  strcpy(state_off->name, "ConcreteStateOff");
+  state_off->on = &concrete_state_off_on;
+  state_off->off = &concrete_state_off_off;
+  return state_off;
+}

state-pattern/c/src/concrete_state_on.c

@@ -0,0 +1,28 @@
+#include "func.h"
+
+// 具体的状态实现者
+// 策略模式与状态模式都是将策略/状态绑定到执行对象(Context)上
+// 不同的是策略模式是客户可设定策略，而状态则是通过状态动作来实现改变
+void concrete_state_on_on(Context *context)
+{
+  // 当前是on状态，再点击on只是提示，不切换状态类
+  printf("\r\n ConcreteStateOn::on() [needn't switch, state is ON.]");
+}
+
+void concrete_state_on_off(Context *context)
+{
+  // 状态变为off后，状态类切换到ConcreteStateOff
+  printf("\r\n ConcreteStateOn::off() [turn OFF ok!]");
+  context->set_state(context, (State *)concrete_state_off_constructor());
+}
+
+ConcreteStateOn *concrete_state_on_constructor()
+{
+  // printf("\r\n proxy_off_constructor() [构建ConcreteStateOff]");
+  State *state = (State *)malloc(sizeof(State));
+  ConcreteStateOn *state_on = (ConcreteStateOn *)state;
+  strcpy(state_on->name, "ConcreteStateOn");
+  state_on->on = &concrete_state_on_on;
+  state_on->off = &concrete_state_on_off;
+  return state_on;
+}

state-pattern/c/src/context.c

@@ -0,0 +1,34 @@
+#include "func.h"
+
+// 具体执行实体类，内部关联状态
+State *context_get_state(Context *context)
+{
+  return context->state;
+}
+
+void context_set_state(Context *context, State *state)
+{
+  printf("\r\n Context::set_state() [state = %s]", state->name);
+  context->state = state;
+}
+
+void context_turn_on(Context *context)
+{
+  context->state->on(context);
+}
+
+void context_turn_off(Context *context)
+{
+  context->state->off(context);
+}
+
+Context *context_constructor()
+{
+  printf("\r\n context_constructor() [构建Context]");
+  Context *context = (Context *)malloc(sizeof(Context));
+  context->get_state = &context_get_state;
+  context->set_state = &context_set_state;
+  context->turn_on = &context_turn_on;
+  context->turn_off = &context_turn_off;
+  return context;
+}

state-pattern/c/src/func.h

@@ -0,0 +1,45 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+typedef struct Context Context;
+typedef struct State State;
+
+// 定义状态接口和状态方法，当前context只有一种状态
+typedef struct State
+{
+  char name[50];
+  void (*on)(Context *context);
+  void (*off)(Context *context);
+} State;
+
+// 具体执行实体类，内部关联状态
+typedef struct Context
+{
+  State *state;
+  void (*set_state)(Context *context, State *state);
+  State *(*get_state)(Context *context);
+  void (*turn_on)(Context *context);
+  void (*turn_off)(Context *context);
+} Context;
+Context *context_constructor();
+
+// 具体的状态实现者
+typedef struct ConcreteStateOff
+{
+  char name[50];
+  void (*on)(Context *context);
+  void (*off)(Context *context);
+} ConcreteStateOff;
+ConcreteStateOff *concrete_state_off_constructor();
+
+// 具体的状态实现者
+typedef struct ConcreteStateOn
+{
+  char name[50];
+  void (*on)(Context *context);
+  void (*off)(Context *context);
+} ConcreteStateOn;
+ConcreteStateOn *concrete_state_on_constructor();

state-pattern/c/src/state.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 状态struct，约束状态state，当前context只有一种状态