add iterator for c

Author: Jarry

iterator-pattern/README.md

@@ -1,4 +1,4 @@
-# 【迭代器设计模式详解】Java/JS/Go/Python/TS不同语言实现
+# 【迭代器设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
 
 # 简介
 迭代器模式（Iterator Pattern），是一种结构型设计模式。给数据对象构建一套按顺序访问集合对象元素的方式，而不需要知道数据对象的底层表示。
@@ -18,7 +18,7 @@
 # UML
 <img src="../docs/uml/iterator-pattern.png">
 
-# 代码
+# Java代码
 
 ## 迭代器抽象接口
 ```java
@@ -63,7 +63,7 @@ public class ObjectIterator implements Iterator {
 
 ## 数据容器接口
 ```java
-// 创建抽象容器接口，创建一个迭代器
+// Container.go 创建抽象容器接口，创建一个迭代器
 public interface Container {
    public Iterator createIterator();
 }
@@ -116,9 +116,117 @@ public class ObjectList implements Container {
 
     // while循环迭代对象
     Iterator iter2 = objectList.createIterator();
+    objectList.setObjects(new Integer[] { 3, 5, 7, 9, 11 });
     while (iter2.hasNext()) {
       System.out.println(iter2.next());
     }
 ```
+
+# Go代码
+
+## 迭代器抽象接口
+```go
+// Iterator.go 迭代器抽象接口，提供next和hasNext方法
+type Iterator interface {
+  HasNext() bool
+  Next() string
+}
+```
+
+## 具体迭代器
+```go
+// ObjectIterator.go 对象迭代器，实现了抽象迭代器的方法，聚合了对象列表
+type ObjectIterator struct {
+  // 迭代器索引
+  index int
+  // 聚合了数据对象
+  objectList *ObjectList
+}
+
+func (o *ObjectIterator) HasNext() bool {
+  if o.index < o.objectList.Size() {
+    return true
+  }
+  return false
+}
+
+func (o *ObjectIterator) Next() string {
+  if o.HasNext() {
+    // 返回数据对象提供的get方法，每访问一次下标增加1位
+    item := o.objectList.Get(o.index)
+    o.index += 1
+    return item
+  }
+  return ""
+}
+```
+
+## 数据容器接口
+```go
+// Container.go 创建抽象容器接口，创建一个迭代器
+type Container interface {
+  CreateIterator() Iterator
+}
+```
+
+## 具体数据对象
+```go
+// ObjectList.go 对象列表，是一种数据容器，可以创建一个迭代器
+type ObjectList struct {
+  // 内部的数据结构
+  objects []string
+}
+
+func (o *ObjectList) CreateIterator() Iterator {
+  fmt.Println("ObjectList::CreateIterator() [获取迭代器 ObjectIterator]")
+  // 创建迭代器实例，绑定新建当前对象
+  return &ObjectIterator{
+    objectList: o,
+  }
+}
+
+func (o *ObjectList) SetObjects(objects []string) {
+  o.objects = objects
+}
+
+func (o *ObjectList) GetObjects() []string {
+  return o.objects
+}
+
+func (o *ObjectList) Size() int {
+  return len(o.objects)
+}
+
+func (o *ObjectList) Get(index int) string {
+  return o.objects[index]
+}
+```
+
+## 测试调用
+```go
+    /*
+     * 迭代器模式是给数据容器创建单独的迭代器，用来遍历里面的数据对象
+     * 数据容器和迭代器相互关联，外部通过迭代器来访问数据容器
+     * 通过这种方式由迭代器类来负责数据遍历，这样可以做到不暴露集合的内部结构
+     */
+
+    int i = 0;
+    ObjectList objectList = new ObjectList();
+    objectList.setObjects(new String[] { "Thomas", "Merry", "Jack", "Tony", "Jerry", "Joey" });
+    // for循环迭代对象
+    for (Iterator iter = objectList.createIterator(); iter.hasNext();) {
+      String name = (String) iter.next();
+      System.out.println("objectList[" + i + "] = " + name);
+      i++;
+    }
+
+    // while循环迭代对象
+    Iterator iter2 = objectList.createIterator();
+    objectList.setObjects(new Integer[] { 3, 5, 7, 9, 11 });
+    while (iter2.hasNext()) {
+      System.out.println(iter2.next());
+    }
+```
+
 ## 更多语言版本
 不同语言实现设计模式：[https://github.com/microwind/design-pattern](https://github.com/microwind/design-pattern)

iterator-pattern/c/src/container.c

@@ -0,0 +1,3 @@
+#include "func.h"
+
+// 抽象容器struct，定义在head，可选

iterator-pattern/c/src/func.h

@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+
+// 创建抽象容器接口，创建一个迭代器，可选
+typedef struct Container
+{
+    void (*set_objects)(struct Container *, char **objects, int);
+    char **(*get_objects)(struct Container *);
+    char *(*get)(struct Container *, int index);
+    int length;
+    // 字符串数组
+    char **objects;
+    struct Iterator *(*create_iterator)(struct Container *object_list);
+} Container;
+
+// 数据对象，是一种数据容器，实现了数据容器接口，可以创建一个迭代器
+typedef struct ObjectList
+{
+    void (*set_objects)(struct ObjectList *, char **objects, int);
+    char **(*get_objects)(struct ObjectList *);
+    char *(*get)(struct ObjectList *, int index);
+    int length;
+    // 字符串数组
+    char **objects;
+    struct Iterator *(*create_iterator)(struct ObjectList *object_list);
+} ObjectList;
+ObjectList *object_list_constructor();
+
+// 迭代器抽象接口，提供next和hasNext方法
+typedef struct Iterator
+{
+    // 迭代器索引
+    int index;
+    // 数据对象数组
+    struct ObjectList *object_list;
+    bool (*has_next)(struct Iterator *);
+    char *(*next)(struct Iterator *);
+} Iterator;
+
+// 对象迭代器，实现了抽象迭代器的方法，聚合了数据对象
+typedef struct ObjectIterator
+{
+    // 迭代器索引
+    int index;
+    // 数据对象数组
+    struct ObjectList *object_list;
+    bool (*has_next)(struct Iterator *);
+    char *(*next)(struct Iterator *);
+} ObjectIterator;
+ObjectIterator *object_iterator_constructor(ObjectList *object_list);

iterator-pattern/c/src/iterator.c

@@ -0,0 +1,4 @@
+#include "func.h"
+#include <stdarg.h>
+
+// 迭代器抽象接口，约定next和has_next方法，定义在head

iterator-pattern/c/src/object_iterator.c

@@ -0,0 +1,34 @@
+#include "func.h"
+
+bool has_next(Iterator *iter)
+{
+  if (iter->index < iter->object_list->length)
+  {
+    return true;
+  }
+  return false;
+}
+
+char *next(Iterator *iter)
+{
+  if (iter->has_next(iter))
+  {
+    // 返回数据对象提供的get方法，每访问一次下标增加1位
+    char *item = iter->object_list->get(iter->object_list, iter->index);
+    iter->index += 1;
+    return item;
+  }
+  return NULL;
+}
+
+// 对象迭代器，实现了抽象迭代器的方法，聚合了数据对象
+ObjectIterator *object_iterator_constructor(ObjectList *object_list)
+{
+  printf("\r\n object_iterator_constructor() [构建容器迭代器]");
+  ObjectIterator *iter = (ObjectIterator *)malloc(sizeof(ObjectIterator));
+  iter->object_list = object_list;
+  iter->index = 0;
+  iter->next = &next;
+  iter->has_next = &has_next;
+  return iter;
+}

iterator-pattern/c/src/object_list.c

@@ -0,0 +1,38 @@
+#include "func.h"
+
+void set_objects(ObjectList *object_list, char **objects, int len)
+{
+  object_list->length = len;
+  object_list->objects = objects;
+}
+
+char **get_objects(ObjectList *object_list)
+{
+  return object_list->objects;
+}
+
+char *get(ObjectList *object_list, int index)
+{
+  return object_list->objects[index];
+}
+
+Iterator *create_iterator(ObjectList *object_list)
+{
+  // 创建迭代器实例，绑定新建当前对象
+  return (Iterator *)object_iterator_constructor(object_list);
+}
+
+// 数据对象，是一种具体的数据容器，实现了数据容器抽象接口，可以创建一个迭代器
+ObjectList *object_list_constructor()
+{
+  printf("\r\n object_list_constructor() [构建数据容器对象]");
+  Container *obj = (Container *)malloc(sizeof(Container));
+  ObjectList *list = (ObjectList *)obj;
+  list->objects = NULL;
+  list->length = 0;
+  list->set_objects = &set_objects;
+  list->get_objects = &get_objects;
+  list->get=&get;
+  list->create_iterator = &create_iterator;
+  return list;
+}

iterator-pattern/c/test/simple_iterator.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+// 简单版C语言迭代器模式，自己构建List数据类型
+
+// 数据结构，这里使用链表作为示例
+struct List
+{
+  char *data;
+  struct List *next;
+};
+
+// 迭代器结构体
+struct Iterator
+{
+  struct List *current;
+  int (*has_next)(struct Iterator *);        // 判断是否还有下一个元素
+  char *(*next)(struct Iterator *, char **); // 获取下一个元素
+};
+
+// 判断是否还有下一个元素
+int has_next(struct Iterator *iter)
+{
+  return iter->current != NULL;
+}
+
+// 获取下一个元素
+char *next(struct Iterator *iter, char **value)
+{
+  if (iter->current == NULL)
+  {
+    return NULL;
+  }
+  *value = iter->current->data;
+  iter->current = iter->current->next;
+  return *value;
+}
+
+// 初始化迭代器
+void create_iterator(struct Iterator *iter, struct List *head)
+{
+  iter->current = head;
+  iter->has_next = &has_next;
+  iter->next = &next;
+}
+
+// 遍历链表
+void iterate_list(struct List *head)
+{
+  struct Iterator iter;
+  char *value;
+  create_iterator(&iter, head);
+  while (iter.has_next(&iter))
+  {
+    iter.next(&iter, &value);
+    printf("\r\n %s ", value);
+  }
+  printf("\n");
+}
+
+int main()
+{
+  printf("test start:\r\n");
+  // 构造一个链表
+  struct List *head = (struct List *)malloc(sizeof(struct List));
+  head->data = "Tom";
+  head->next = (struct List *)malloc(sizeof(struct List));
+  head->next->data = "Jerry";
+  head->next->next = (struct List *)malloc(sizeof(struct List));
+  head->next->next->data = "Max";
+  head->next->next->next = NULL;
+
+  // 使用迭代器遍历链表
+  iterate_list(head);
+
+  // 释放链表内存
+  while (head != NULL)
+  {
+    struct List *temp = head;
+    head = head->next;
+    free(temp);
+  }
+
+  return 0;
+}
+
+/**
+jarry@jarrys-MacBook-Pro c % gcc test/simple_iterator.c
+jarry@jarrys-MacBook-Pro c % ./a.out 
+test start:
+
+ Tom 
+ Jerry 
+ Max 
+*/