将iter相关配置，包括成员函数的配置，都放在iter的初始化中

src/deque.c

@@ -295,25 +295,6 @@ static void deque_print(struct _deque* self)
     }
 }
 
-iterator_t deque_iter(struct _deque* self, enum _deque_order order)
-{
-    assert(self != NULL);
-    iterator_t iter = &self->_iter;
-
-    iter->_container = self;
-    iter->_index = 0;
-    iter->_order = order;
-    if(iter->_order == DEQUE_FORWARD)
-    {
-        iter->_node = self->_head;
-    }
-    else
-    {
-        iter->_node = self->_tail;
-    }
-    return iter;
-}
-
 bool deque_iter_hasnext(struct _iterator* iter)
 {
     assert(iter != NULL);
@@ -355,6 +336,28 @@ const void* deque_iter_next(struct _iterator* iter)
     return obj;
 }
 
+iterator_t deque_iter(struct _deque* self, enum _deque_order order)
+{
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    iter->_order = order;
+    if(iter->_order == DEQUE_FORWARD)
+    {
+        iter->_node = self->_head;
+    }
+    else
+    {
+        iter->_node = self->_tail;
+    }
+
+    iter->hasnext = deque_iter_hasnext;
+    iter->next = deque_iter_next;
+    return iter;
+}
+
 static bool deque_init(struct _deque* self, uint32_t obj_size)
 {
     assert(self != NULL);
@@ -371,9 +374,6 @@ static bool deque_init(struct _deque* self, uint32_t obj_size)
     self->_head = NULL;
     self->_tail = NULL;
 
-    self->_iter.hasnext = deque_iter_hasnext;
-    self->_iter.next = deque_iter_next;
-
     self->_destory = deque_destory;
 
     // -------------------- public -------------------- 

src/graph.c

@@ -822,52 +822,6 @@ static struct _graph_node * graph_find_next_unvisited_target(struct _graph *self
     return NULL;
 }
 
-iterator_t graph_iter(struct _graph *self, enum _graph_search search_type, void *start)
-{
-    assert(self != NULL);
-    iterator_t iter = &self->_iter;
-
-    iter->_container = self;
-    iter->_index = 0;
-    iter->_node = self->_head->next;
-
-    struct _graph_node *start_node = find_node(self, start);
-    if (start_node == NULL)
-    {
-        goto done;
-    }
-    iter->_node = start_node;
-
-    struct _graph_node *node = self->_head->next;
-    while (node != NULL)
-    {
-        node->visited = false;
-        node = node->next;
-    }
-
-    self->_search = search_type;
-    switch (self->_search)
-    {
-    case GRAPH_BFS:
-    {
-        self->queue->push(self->queue, &iter->_node);
-    }
-    break;
-    case GRAPH_DFS:
-    {
-        // pass
-    }
-    break;
-    default:
-    {
-    }
-    break;
-    }
-
-done:
-    return iter;
-}
-
 bool graph_iter_hasnext(struct _iterator *iter)
 {
     assert(iter != NULL);
@@ -987,6 +941,55 @@ const void *graph_iter_next(struct _iterator *iter)
     return obj;
 }
 
+iterator_t graph_iter(struct _graph *self, enum _graph_search search_type, void *start)
+{
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    // iter->_node = self->_head->next;
+
+    struct _graph_node *start_node = find_node(self, start);
+    if (start_node == NULL)
+    {
+        goto done;
+    }
+    iter->_node = start_node;
+
+    iter->hasnext = graph_iter_hasnext;
+    iter->next = graph_iter_next;
+
+    struct _graph_node *node = self->_head->next;
+    while (node != NULL)
+    {
+        node->visited = false;
+        node = node->next;
+    }
+
+    self->_search = search_type;
+    switch (self->_search)
+    {
+    case GRAPH_BFS:
+    {
+        self->queue->push(self->queue, &iter->_node);
+    }
+    break;
+    case GRAPH_DFS:
+    {
+        // pass
+    }
+    break;
+    default:
+    {
+    }
+    break;
+    }
+
+done:
+    return iter;
+}
+
 static bool graph_init(struct _graph *self, uint32_t obj_size)
 {
     assert(self != NULL);
@@ -1028,9 +1031,6 @@ static bool graph_init(struct _graph *self, uint32_t obj_size)
     self->_type = GRAPH_UNDIRECTED;
     // self->_type = GRAPH_DIRECTED;
 
-    self->_iter.hasnext = graph_iter_hasnext;
-    self->_iter.next = graph_iter_next;
-
     self->_destory = graph_destory;
 
     // -------------------- public --------------------

src/heap.c

@@ -249,18 +249,6 @@ static void heap_print(struct _heap* self)
     }
 }
 
-
-iterator_t heap_iter(struct _heap* self)
-{
-    assert(self != NULL);
-    iterator_t iter = &self->_iter;
-
-    iter->_container = self;
-    iter->_index = 0;
-    iter->_node = self->obj;
-    return iter;
-}
-
 bool heap_iter_hasnext(struct _iterator* iter)
 {
     assert(iter != NULL);
@@ -289,6 +277,20 @@ const void* heap_iter_next(struct _iterator* iter)
     return obj;
 }
 
+iterator_t heap_iter(struct _heap* self)
+{
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    iter->_node = self->obj;
+
+    iter->hasnext = heap_iter_hasnext;
+    iter->next = heap_iter_next;
+    return iter;
+}
+
 static bool heap_init2(struct _heap* self, uint32_t obj_size, uint32_t capacity)
 {
     assert(self != NULL);
@@ -305,9 +307,6 @@ static bool heap_init2(struct _heap* self, uint32_t obj_size, uint32_t capacity)
         return false;
     }
 
-    self->_iter.hasnext = heap_iter_hasnext;
-    self->_iter.next = heap_iter_next;
-    
     self->_destory = heap_destory;
 
     // -------------------- public -------------------- 

src/list.c

@@ -179,14 +179,6 @@ static void list_print(struct _list* self)
     }
 }
 
-static const void* list_iter_next(struct _iterator* iter)
-{
-    list_t self = (list_t)iter->_container;
-    void *obj = self->obj + iter->_index * self->_obj_size;
-    iter->_index += 1;
-    return obj;
-}
-
 static bool list_iter_hasnext(struct _iterator* iter)
 {
     list_t self = (list_t)iter->_container;
@@ -198,6 +190,14 @@ static bool list_iter_hasnext(struct _iterator* iter)
     return false;
 }
 
+static const void* list_iter_next(struct _iterator* iter)
+{
+    list_t self = (list_t)iter->_container;
+    void *obj = self->obj + iter->_index * self->_obj_size;
+    iter->_index += 1;
+    return obj;
+}
+
 iterator_t list_iter(struct _list* self)
 {
     assert(self != NULL);
@@ -205,6 +205,9 @@ iterator_t list_iter(struct _list* self)
 
     iter->_container = self;
     iter->_index = 0;
+
+    iter->hasnext = list_iter_hasnext;
+    iter->next = list_iter_next;
     return iter;
 }
 

src/queue.c

@@ -306,17 +306,6 @@ static void queue2_print(struct _queue* self)
     }
 }
 
-static iterator_t queue_iter(struct _queue* self)
-{
-    assert(self != NULL);
-    iterator_t iter = &self->_iter;
-
-    iter->_container = self;
-    iter->_index = 0;
-    iter->_node = self->_front;
-    return iter;
-}
-
 static bool queue_iter_hasnext(struct _iterator* iter)
 {
     assert(iter != NULL);
@@ -349,6 +338,20 @@ static const void* queue_iter_next(struct _iterator* iter)
     return obj;
 }
 
+static iterator_t queue_iter(struct _queue* self)
+{
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    iter->_node = self->_front;
+
+    iter->hasnext = queue_iter_hasnext;
+    iter->next = queue_iter_next;
+    return iter;
+}
+
 static const void* queue2_iter_next(struct _iterator* iter)
 {
     assert(iter != NULL);
@@ -365,6 +368,20 @@ static const void* queue2_iter_next(struct _iterator* iter)
     return obj;
 }
 
+static iterator_t queue2_iter(struct _queue* self)
+{
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    iter->_node = self->_front;
+
+    iter->hasnext = queue_iter_hasnext;
+    iter->next = queue2_iter_next;
+    return iter;
+}
+
 static bool queue_init(struct _queue * self, uint32_t obj_size)
 {
     assert(self != NULL);
@@ -387,10 +404,6 @@ static bool queue_init(struct _queue * self, uint32_t obj_size)
     // base
     self->_destory = queue_destory;
 
-    // iter
-    self->_iter.hasnext = queue_iter_hasnext;
-    self->_iter.next = queue_iter_next;
-
     // -------------------- public -------------------- 
     // kernel
     self->push = queue_push;
@@ -471,7 +484,7 @@ static bool queue_init2(struct _queue * self, uint32_t obj_size, uint32_t capaci
     self->clear = queue2_clear;
 
     // iter
-    self->iter = queue_iter;
+    self->iter = queue2_iter;
 
     // -------------------- debug -------------------- 
     self->print = queue2_print;

src/stack.c

@@ -254,13 +254,22 @@ static void stack2_print(struct _stack* self)
     }
 }
 
+bool stack_iter_hasnext(struct _iterator* iter)
+{
+    assert(iter != NULL);
+    assert(iter->parent != NULL);
+
+    stack_t self = (stack_t)iter->_container;
+    if(iter->_index < self->size(self))
+    {
+        return true;
+    }
+    return false;
+}
+
 /**
- * @brief iterator next
+ * @brief iter next
  *  from top to bottom
- * 
- * @param iter 
- * @return const void* 
- *  the value of return is const, so you can't modify it.
  */
 const void* stack_iter_next(struct _iterator* iter)
 {
@@ -291,19 +300,6 @@ const void* stack_iter_next(struct _iterator* iter)
     return obj;
 }
 
-bool stack_iter_hasnext(struct _iterator* iter)
-{
-    assert(iter != NULL);
-    assert(iter->parent != NULL);
-
-    stack_t self = (stack_t)iter->_container;
-    if(iter->_index < self->size(self))
-    {
-        return true;
-    }
-    return false;
-}
-
 iterator_t stack_iter(struct _stack* self)
 {
     assert(self != NULL);
@@ -312,6 +308,9 @@ iterator_t stack_iter(struct _stack* self)
     iter->_container = self;
     iter->_index = 0;
     iter->_node = self->_head->next;
+
+    iter->hasnext = stack_iter_hasnext;
+    iter->next = stack_iter_next;
     return iter;
 }
 
@@ -338,9 +337,6 @@ static bool stack_init(struct _stack* self, uint32_t obj_size)
     self->_head->obj = NULL;
     self->_head->next = NULL;
 
-    self->_iter.next = stack_iter_next;
-    self->_iter.hasnext = stack_iter_hasnext;
-
     self->_destory = stack_destory;
 
     // ---------- public ----------

src/tree.c

@@ -1151,88 +1151,9 @@ static bool tree_rb_delete(struct _tree* self, void* obj)
     return true;
 }
 
-static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
+static uint32_t tree_height(struct _tree* self)
 {
-    assert(self != NULL);
+    return tree_height_node(self, self->_root);
-    iterator_t iter = &self->_iter;
-
-    iter->_container = self;
-    iter->_index = 0;
-    iter->_node = self->_root;
-
-    iter->_order = order;
-    self->stack->clear(self->stack);
-    self->queue->clear(self->queue);
-
-    switch (iter->_order)
-    {
-    case ORDER_PRE:
-    case ORDER_PRE_R:
-    {
-        // pass
-    }break;
-    case ORDER_IN:
-    case ORDER_IN_R:
-    {
-        // pass
-    }break;
-    case ORDER_POST:
-    case ORDER_POST_R:
-    {
-        struct _tree_node* node = self->_root;
-        self->stack->clear(self->stack);
-
-        stack_t stack = stack_new(sizeof(struct _tree_node*));
-        if (iter->_order == ORDER_POST)
-        {
-            while (!stack->empty(stack) || node != NULL)
-            {
-                if (node != NULL)
-                {
-                    self->stack->push(self->stack, &node);
-
-                    stack->push(stack, &node);
-                    node = node->right;
-                }
-                else
-                {
-                    stack->pop(stack, &node);
-                    node = node->left;
-                }
-            }
-        }
-        else
-        {
-            while (!stack->empty(stack) || node != NULL)
-            {
-                if (node != NULL)
-                {
-                    self->stack->push(self->stack, &node);
-
-                    stack->push(stack, &node);
-                    node = node->left;
-                }
-                else
-                {
-                    stack->pop(stack, &node);
-                    node = node->right;
-                }
-            }
-        }
-        stack_free(&stack);
-    }break;
-    case ORDER_BREADTH:
-    case ORDER_BREADTH_R:
-    {
-        // pass
-        self->queue->push(self->queue, &self->_root);
-    }break;
-    default:
-    {
-    }break;
-    }
-
-    return iter;
 }
 
 static bool tree_iter_hasnext(struct _iterator* iter)
@@ -1398,9 +1319,91 @@ static const void* tree_iter_next(struct _iterator* iter)
     return obj;
 }
 
-static uint32_t tree_height(struct _tree* self)
+
+static iterator_t tree_iter(struct _tree* self, enum _tree_order order)
 {
-    return tree_height_node(self, self->_root);
+    assert(self != NULL);
+    iterator_t iter = &self->_iter;
+
+    iter->_container = self;
+    iter->_index = 0;
+    iter->_node = self->_root;
+    iter->_order = order;
+    iter->hasnext = tree_iter_hasnext;
+    iter->next = tree_iter_next;
+    
+    self->stack->clear(self->stack);
+    self->queue->clear(self->queue);
+
+    switch (iter->_order)
+    {
+    case ORDER_PRE:
+    case ORDER_PRE_R:
+    {
+        // pass
+    }break;
+    case ORDER_IN:
+    case ORDER_IN_R:
+    {
+        // pass
+    }break;
+    case ORDER_POST:
+    case ORDER_POST_R:
+    {
+        struct _tree_node* node = self->_root;
+        self->stack->clear(self->stack);
+
+        stack_t stack = stack_new(sizeof(struct _tree_node*));
+        if (iter->_order == ORDER_POST)
+        {
+            while (!stack->empty(stack) || node != NULL)
+            {
+                if (node != NULL)
+                {
+                    self->stack->push(self->stack, &node);
+
+                    stack->push(stack, &node);
+                    node = node->right;
+                }
+                else
+                {
+                    stack->pop(stack, &node);
+                    node = node->left;
+                }
+            }
+        }
+        else
+        {
+            while (!stack->empty(stack) || node != NULL)
+            {
+                if (node != NULL)
+                {
+                    self->stack->push(self->stack, &node);
+
+                    stack->push(stack, &node);
+                    node = node->left;
+                }
+                else
+                {
+                    stack->pop(stack, &node);
+                    node = node->right;
+                }
+            }
+        }
+        stack_free(&stack);
+    }break;
+    case ORDER_BREADTH:
+    case ORDER_BREADTH_R:
+    {
+        // pass
+        self->queue->push(self->queue, &self->_root);
+    }break;
+    default:
+    {
+    }break;
+    }
+
+    return iter;
 }
 
 static bool tree_avl_init(struct _tree* self, uint32_t obj_size)
@@ -1427,9 +1430,6 @@ static bool tree_avl_init(struct _tree* self, uint32_t obj_size)
         return false;
     }
 
-    self->_iter.hasnext = tree_iter_hasnext;
-    self->_iter.next = tree_iter_next;
-
     self->_rebalance = tree_avl_rebalance;
     self->_destory = tree_destory;
 
@@ -1478,9 +1478,6 @@ static bool tree_rb_init(struct _tree* self, uint32_t obj_size)
         return false;
     }
 
-    self->_iter.hasnext = tree_iter_hasnext;
-    self->_iter.next = tree_iter_next;
-
     self->_rebalance = tree_rb_rebalance;
     self->_destory = tree_destory;