refactor(queue): 统一初始化接口并添加 resize 功能

demo/demo_queue.c

@@ -17,7 +17,7 @@ static void demo_queue_num(void)
     int temp = 0;
     size_t len = sizeof(data) / sizeof(data[0]);
 
-    queue_t queue = queue_new(sizeof(int));
+    queue_t queue = queue_new(sizeof(int), len);
     queue->print_obj = print_num;
 
     printf("\n\n----- demo_queue_num -----\n");
@@ -101,7 +101,7 @@ static void demo_queue_char(void)
     char temp = 0;
     size_t len = sizeof(data) / sizeof(data[0]) - 1;
 
-    queue_t queue = queue_new2(sizeof(char), 10);
+    queue_t queue = queue_new(sizeof(char), 10);
     queue->print_obj = print_char;
 
     printf("\n\n----- demo_queue_char -----\n");
@@ -213,7 +213,7 @@ static void demo_queue_struct(void)
     struct _student temp;
     size_t len = sizeof(data) / sizeof(data[0]) - 1;
 
-    queue_t queue = queue_new(sizeof(struct _student));
+    queue_t queue = queue_new(sizeof(struct _student), len);
     queue->print_obj = print_struct;
 
     printf("\n\n----- demo_queue_struct -----\n");

include/queue.h

@@ -31,6 +31,7 @@ struct _queue
     bool (*front)(struct _queue* self, void* obj);
 
     // base
+    size_t (*resize)(struct _queue* self, size_t capacity);
     size_t (*size)(struct _queue* self);
     size_t (*capacity)(struct _queue* self);
     bool (*empty)(struct _queue* self);
@@ -47,9 +48,7 @@ struct _queue
 typedef struct _queue* queue_t;
 
 // create and free queue
-queue_t queue_new2( size_t obj_size, size_t capacity);
+queue_t queue_new(size_t obj_size, size_t capacity);
 void queue_free(queue_t* queue);
 
-#define queue_new(obj_size) queue_new2(obj_size, 16)
-
 #endif // _QUEUE_H_

include/stack.h

@@ -29,7 +29,7 @@ struct _stack
     bool (*peek)(struct _stack* self, void* obj);
     
     // base
-    size_t (*resize)(struct _stack* self, size_t new_size);
+    size_t (*resize)(struct _stack* self, size_t capacity);
     size_t (*size)(struct _stack* self);
     size_t (*capacity)(struct _stack* self);
     bool (*empty)(struct _stack* self);

perf/perf_queue.c

@@ -14,8 +14,7 @@ static queue_t queue = NULL;
 
 void perf_queue_new(void)
 {
-    // queue = queue_new2(g_test_obj.obj_size, g_test_obj.capacity);
-    queue = queue_new(g_test_obj.obj_size);
+    queue = queue_new(g_test_obj.obj_size, g_test_obj.capacity);
 }
 
 void perf_queue_push(void)

src/graph.c

@@ -1009,7 +1009,7 @@ static bool graph_init(struct _graph *self, size_t obj_size)
     {
         return false;
     }
-    self->queue = queue_new(sizeof(struct _graph_node *));
+    self->queue = queue_new(sizeof(struct _graph_node *), 16);
     if (self->queue == NULL)
     {
         stack_free(&self->stack);

src/queue.c

@@ -39,25 +39,11 @@ static bool queue_front(struct _queue* self, void* obj)
     return self->_deque->front(self->_deque, obj);
 }
 
-static bool queue_clear(struct _queue* self)
+static size_t queue_resize(struct _queue* self, size_t capacity)
 {
     unicstl_assert(self != NULL);
     unicstl_assert(self->_deque != NULL);
-    return self->_deque->clear(self->_deque);
-}
-
-static bool queue_empty(struct _queue* self)
-{
-    unicstl_assert(self != NULL);
-    unicstl_assert(self->_deque != NULL);
-    return self->_deque->empty(self->_deque);
-}
-
-static bool queue_full(struct _queue* self)
-{
-    unicstl_assert(self != NULL);
-    unicstl_assert(self->_deque != NULL);
-    return self->_deque->full(self->_deque);
+    return self->_deque->resize(self->_deque, capacity);
 }
 
 static size_t queue_size(struct _queue* self)
@@ -75,6 +61,28 @@ static size_t queue_capacity(struct _queue* self)
     return self->_deque->capacity(self->_deque);
 }
 
+static bool queue_empty(struct _queue* self)
+{
+    unicstl_assert(self != NULL);
+    unicstl_assert(self->_deque != NULL);
+    return self->_deque->empty(self->_deque);
+}
+
+static bool queue_full(struct _queue* self)
+{
+    unicstl_assert(self != NULL);
+    unicstl_assert(self->_deque != NULL);
+    return self->_deque->full(self->_deque);
+}
+
+static bool queue_clear(struct _queue* self)
+{
+    unicstl_assert(self != NULL);
+    unicstl_assert(self->_deque != NULL);
+    return self->_deque->clear(self->_deque);
+}
+
+
 static void queue_destory(struct _queue* self)
 {
     unicstl_assert(self != NULL);
@@ -127,10 +135,6 @@ static iterator_t queue_iter(struct _queue* self)
 static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity)
 {
     unicstl_assert(self != NULL);
-    if(self == NULL || obj_size == 0 || capacity == 0)
-    {
-        return false;
-    }
 
     // -------------------- private --------------------
     self->_deque = deque_new(obj_size, capacity);
@@ -138,13 +142,10 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity)
     {
         return false;
     }
+
     // 
     self->_destory = queue_destory;
 
-    // iter
-    self->_iter.hasnext = queue_iter_hasnext;
-    self->_iter.next = queue_iter_next;
-
     // -------------------- public -------------------- 
     // kernel
     self->push = queue_push;
@@ -153,6 +154,7 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity)
     self->front = queue_front;
 
     // base
+    self->resize = queue_resize;
     self->size = queue_size;
     self->capacity = queue_capacity;
     self->empty = queue_empty;
@@ -180,7 +182,7 @@ static bool queue_init(struct _queue * self, size_t obj_size, size_t capacity)
  * 
  * @return queue_t 队列指针
  */
-queue_t queue_new2(size_t obj_size, size_t capacity)
+queue_t queue_new(size_t obj_size, size_t capacity)
 {
     struct _queue * queue = NULL;
     queue = (struct _queue *)unicstl_malloc(sizeof(struct _queue));

src/tree.c

@@ -75,7 +75,7 @@ static size_t tree_height_node(struct _tree* self, struct _tree_node* root)
     size_t count_next_level = 0;
 
     struct _tree_node* node = root;
-    queue_t queue = queue_new(sizeof(struct _tree_node*));
+    queue_t queue = queue_new(sizeof(struct _tree_node*), self->size(self));
 
     queue->push(queue, &node);
     while (!queue->empty(queue))
@@ -1058,7 +1058,7 @@ static bool tree_clear(struct _tree* self)
     }
 
     struct _tree_node* node = self->_root;
-    queue_t queue = queue_new(sizeof(struct _tree_node*));
+    queue_t queue = queue_new(sizeof(struct _tree_node*), self->size(self));
 
     queue->push(queue, &node);
     while (!queue->empty(queue))
@@ -1393,7 +1393,7 @@ static bool tree_avl_init(struct _tree* self, size_t obj_size)
     {
         return false;
     }
-    self->queue = queue_new(sizeof(struct _tree_node*));
+    self->queue = queue_new(sizeof(struct _tree_node*), self->size(self));
     if (self->queue == NULL)
     {
         stack_free(&self->stack);
@@ -1440,12 +1440,12 @@ static bool tree_rb_init(struct _tree* self, size_t obj_size)
 
     self->_root = NULL;
 
-    self->stack = stack_new(sizeof(struct _tree_node*), self->size(self));
+    self->stack = stack_new(sizeof(struct _tree_node*), 16);
     if (self->stack == NULL)
     {
         return false;
     }
-    self->queue = queue_new(sizeof(struct _tree_node*));
+    self->queue = queue_new(sizeof(struct _tree_node*), 16);
     if (self->queue == NULL)
     {
         stack_free(&self->stack);