add memento for c

Author: Jarry

README.md

@@ -100,4 +100,4 @@ Implemented in different languages, including Java/JS/Python/TypeScript/Go, etc.
 ### Contact 联系
 欢迎共建 Welcome to join
 - Wechat:  **springbuild**
-- QQ: **12263529**
+- QQ: **12263539**

memento-pattern/README.md

@@ -1,4 +1,4 @@
-# 【备忘录设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【备忘录设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 备忘录模式（Memento Pattern）是一种结构型设计模式。这种模式就是在不破坏封装的条件下，将一个对象的状态捕捉(Capture)住，并放在外部存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。备忘录模式常常与命令模式和迭代子模式一同使用。
@@ -23,7 +23,7 @@
 # UML
 <img src="../docs/uml/memento-pattern.png">
 
-# 代码
+# Java代码
 
 ## 具体备忘录
 ```java
@@ -135,5 +135,142 @@ public class Caretaker {
       System.out.println("state: " + i + ")" + originator.getState());
     }
 ```
+
+# JavaScript代码
+
+## 具体备忘录
+```js
+// Memento.js 备忘录(Memento)角色，负责存储发起人传入的状态
+// 备忘录(Memento)角色，负责存储发起人传入的状态
+export class Memento {
+  constructor(state) {
+    console.log(this.constructor.name + '::Memento() [state = ' + state + ']')
+    this.state = state
+  }
+
+  getState() {
+    return this.state
+  }
+
+  setState(state) {
+    this.state = state
+  }
+}
+
+```
+
+## 发起人
+```js
+// Originator.js 发起人(Originator)负责生成状态快照，即利用一个新备忘录对象将自己的内部状态存储起来
+import { Memento } from './Memento.js'
+
+export class Originator {
+  constructor() {
+    this.state = undefined
+  }
+
+  // 每次创建一个新备忘录来保存状态
+  saveMemento() {
+    console.log(
+      this.constructor.name + '::saveMemento() [state = ' + this.state + ']'
+    )
+    return new Memento(this.state)
+  }
+
+  // 从备忘录中恢复状态
+  restoreMemento(memento) {
+    this.state = memento.getState()
+  }
+
+  getState() {
+    return this.state
+  }
+
+  setState(state) {
+    this.state = state
+  }
+}
+```
+
+## 负责人类
+```js
+// Caretaker.js 负责人(Caretaker)角色，只负责保存备忘录记录，不能修改备忘录对象的内容
+export class Caretaker {
+  constructor() {
+    // 备忘录可以是一个记录，也可以就是一个对象，根据业务场景设置
+    this.mementoList = []
+  }
+
+  add(memento) {
+    console.log(
+      this.constructor.name +
+        '::add() [memento = ' +
+        memento.constructor.name +
+        ']'
+    )
+    this.mementoList.push(memento)
+  }
+
+  get(index) {
+    return this.mementoList[index]
+  }
+
+  getMementoList() {
+    return this.mementoList
+  }
+}
+```
+
+## 测试调用
+```js
+import { Originator } from '../src/Originator.js'
+import { Caretaker } from '../src/Caretaker.js'
+
+export function test() {
+  /*
+   * 备忘录模式是在不暴露对象实现细节的情况下保存和恢复对象之前的状态。
+   * 先声明发起人Originator，再声明负责人Caretaker，发起人生成备忘录Memento
+   * 通过负责人则保存备忘录历史记录，读取备忘录由负责人来完成。
+   */
+  const originator = new Originator()
+  const careTaker = new Caretaker()
+  // 发起人产生一个状态
+  originator.setState('state1')
+  // 覆盖了状态，那么前面的状态未保存
+  originator.setState('state2')
+  // 发起人生成备忘录，一般添加时直接保存即可
+  const memento = originator.saveMemento()
+  // 负责人保添加备忘录历史记录
+  careTaker.add(memento)
+
+  // 直接生成备忘录并添加到负责人的备忘录列表
+  originator.setState('state3')
+  careTaker.add(originator.saveMemento())
+  originator.setState('state4')
+  careTaker.add(originator.saveMemento())
+
+  console.log('发起人当前的状态: ' + originator.getState())
+
+  // 发起人通过负责人那里取出状态
+  originator.restoreMemento(careTaker.get(0))
+  console.log('第一个保存的状态: ' + originator.getState())
+  originator.restoreMemento(careTaker.get(1))
+  console.log('第二个保存的状态: ' + originator.getState())
+
+  // 遍历全部备忘录
+  for (let i = 0; i < careTaker.getMementoList().length; i++) {
+    // 外部一般不直接访问备忘录里面的状态，而是逐个恢复备忘录，再取出状态来
+    originator.restoreMemento(careTaker.get(i))
+    console.log('state: ' + i + ')' + originator.getState())
+  }
+}
+
+// 执行测试
+;(function () {
+  console.log('test start:')
+  test()
+})()
+```
+
 ## 更多语言版本
 不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)

memento-pattern/c/src/caretaker.c

@@ -0,0 +1,32 @@
+#include "func.h"
+
+void caretaker_add(Caretaker *caretaker, Memento *memento)
+{
+  printf("\r\n Caretaker::add() [memento = %s]", memento->name);
+  caretaker->memento_length += 1;
+  Memento **new_memento_list = (Memento **)calloc(caretaker->memento_length, sizeof(Memento));
+  // 复制原有数组，并追加新内容到新数组
+  for (int i = 0; i < caretaker->memento_length - 1; i++)
+  {
+    new_memento_list[i] = caretaker->memento_list[i];
+  }
+  new_memento_list[caretaker->memento_length - 1] = memento;
+  free(caretaker->memento_list);
+  // 指向新数组
+  caretaker->memento_list = new_memento_list;
+}
+
+Memento *caretaker_get(Caretaker *caretaker, int index)
+{
+  return caretaker->memento_list[index];
+}
+
+// 负责人(Caretaker)角色，只负责保存备忘录记录，不能修改备忘录对象的内容
+Caretaker *caretaker_constructor()
+{
+  printf("\r\n caretaker_constructor() [构建Caretaker]");
+  Caretaker *caretaker = (Caretaker *)malloc(sizeof(Caretaker));
+  caretaker->add = &caretaker_add;
+  caretaker->get = &caretaker_get;
+  return caretaker;
+}

memento-pattern/c/src/func.h

@@ -0,0 +1,36 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+// 备忘录(Memento)角色，负责存储发起人传入的状态
+typedef struct Memento
+{
+    char name[50];
+    char state[50];
+    void (*set_state)(struct Memento *memento, char *state);
+    char *(*get_state)(struct Memento *memento);
+} Memento;
+Memento *memento_constructor(char *name, char *state);
+
+// 负责人(Caretaker)角色，只负责保存备忘录记录，不能修改备忘录对象的内容
+typedef struct Caretaker
+{
+    Memento **memento_list;
+    int memento_length;
+    void (*add)(struct Caretaker *caretaker, Memento *memento);
+    Memento *(*get)(struct Caretaker *caretaker, int index);
+} Caretaker;
+Caretaker *caretaker_constructor();
+
+// 发起人(Originator)负责生成状态快照，即利用一个新备忘录对象将自己的内部状态存储起来
+typedef struct Originator
+{
+    char state[50];
+    struct Memento *(*save_memento)(struct Originator *originator);
+    void (*restore_memento)(struct Originator *originator, struct Memento *memento);
+    void (*set_state)(struct Originator *originator, char *state);
+    char *(*get_state)(struct Originator *originator);
+} Originator;
+Originator *originator_constructor();

memento-pattern/c/src/memento.c

@@ -0,0 +1,23 @@
+#include "func.h"
+
+char *get_state(Memento *m)
+{
+  return m->state;
+}
+
+void set_state(Memento *m, char *state)
+{
+  strncpy(m->state, state, 50);
+}
+
+// 备忘录(Memento)角色，负责存储发起人传入的状态
+Memento *memento_constructor(char *name, char *state)
+{
+  printf("\r\n memento_constructor() [构建Memento name=%s state=%s]", name, state);
+  Memento *memento = (Memento *)malloc(sizeof(Memento));
+  strncpy(memento->name, name, 50);
+  strncpy(memento->state, state, 50);
+  memento->get_state = &get_state;
+  memento->set_state = &set_state;
+  return memento;
+}

memento-pattern/c/src/originator.c

@@ -0,0 +1,37 @@
+#include "func.h"
+
+// 每次创建一个新备忘录来保存状态
+Memento *originator_save_memento(Originator *originator)
+{
+  printf("\r\n Originator::save_memento() [state = %s]", originator->state);
+  Memento *memento = memento_constructor("Memento", originator->state);
+  return memento;
+}
+
+// 从备忘录中恢复状态
+void originator_restore_memento(Originator *originator, Memento *memento)
+{
+  strncpy(originator->state, memento->get_state(memento), 50);
+}
+
+void originator_set_state(Originator *originator, char *state)
+{
+  strncpy(originator->state, state, 50);
+}
+
+char *originator_get_state(Originator *originator)
+{
+  return originator->state;
+}
+
+// 发起人(Originator)负责生成状态快照，即利用一个新备忘录对象将自己的内部状态存储起来
+Originator *originator_constructor()
+{
+  printf("\r\n originator_constructor() [构建通用聊天室]");
+  Originator *originator = (Originator *)malloc(sizeof(Originator));
+  originator->save_memento = &originator_save_memento;
+  originator->restore_memento = &originator_restore_memento;
+  originator->set_state = &originator_set_state;
+  originator->get_state = &originator_get_state;
+  return originator;
+}

memento-pattern/c/test/test.c

@@ -0,0 +1,68 @@
+#include "../src/func.h"
+
+int main(void)
+{
+  printf("test start:\r\n");
+  /*
+   * 备忘录模式是在不暴露对象实现细节的情况下保存和恢复对象之前的状态。
+   * 先声明发起人Originator，再声明负责人Caretaker，发起人生成备忘录Memento
+   * 通过负责人则保存备忘录历史记录，读取备忘录由负责人来完成。
+   */
+  Originator *originator = originator_constructor();
+  Caretaker *caretaker = caretaker_constructor();
+  // 发起人产生一个状态
+  originator->set_state(originator, "state1");
+  // 覆盖了状态，那么前面的状态未保存
+  originator->set_state(originator, "state2");
+  // 发起人生成备忘录，一般添加时直接保存即可
+  Memento *memento = originator->save_memento(originator);
+  // 负责人保添加备忘录历史记录
+  caretaker->add(caretaker, memento);
+
+  // 直接生成备忘录并添加到负责人的备忘录列表
+  originator->set_state(originator, "state3");
+  caretaker->add(caretaker, originator->save_memento(originator));
+  originator->set_state(originator, "state4");
+  caretaker->add(caretaker, originator->save_memento(originator));
+
+  printf("\r\n 发起人当前的状态: %s", originator->get_state(originator));
+
+  // 发起人通过负责人那里取出状态
+  originator->restore_memento(originator, caretaker->get(caretaker, 0));
+  printf("\r\n 第一个保存的状态: %s", originator->get_state(originator));
+  originator->restore_memento(originator, caretaker->get(caretaker, 1));
+  printf("\r\n 第二个保存的状态: %s", originator->get_state(originator));
+
+  printf("\r\n 遍历全部备忘录:");
+  for (int i = 0; i < caretaker->memento_length; i++)
+  {
+    // 外部一般不直接访问备忘录里面的状态，而是逐个恢复备忘录，再取出状态来
+    originator->restore_memento(originator, caretaker->get(caretaker, i));
+    printf("\r\n %d) state=%s", i, originator->get_state(originator));
+  }
+}
+
+/**
+jarry@jarrys-MacBook-Pro c % gcc test/test.c ./src下*.c
+jarry@jarrys-MacBook-Pro c % ./a.out
+test start:
+
+ originator_constructor() [构建通用聊天室]
+ caretaker_constructor() [构建Caretaker]
+ Originator::save_memento() [state = state2]
+ memento_constructor() [构建Memento name=Memento state=state2]
+ Caretaker::add() [memento = Memento]
+ Originator::save_memento() [state = state3]
+ memento_constructor() [构建Memento name=Memento state=state3]
+ Caretaker::add() [memento = Memento]
+ Originator::save_memento() [state = state4]
+ memento_constructor() [构建Memento name=Memento state=state4]
+ Caretaker::add() [memento = Memento]
+ 发起人当前的状态: state4
+ 第一个保存的状态: state2
+ 第二个保存的状态: state3
+ 遍历全部备忘录:
+ 0) state=state2
+ 1) state=state3
+ 2) state=state4%
+ */