apaki/unicstl
1
0
Fork 0
mirror of https://gitee.com/apaki/unicstl.git synced 2025-07-03 23:56:54 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

更新队列实现为静态函数

Browse Source
This commit is contained in:
建峰 2024-08-29 15:44:09 +08:00
parent 6ef644b07d
commit 9c0b75e718
3 changed files with 59 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/common.h
View File

@ -11,7 +11,7 @@
#ifndef _COMMON_H_ #ifndef _COMMON_H_
#define _COMMON_H_ #define _COMMON_H_
#define NDEBUG 1 // #define NDEBUG 1
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>

60
src/queue.c
View File

@ -34,7 +34,7 @@ done:
return NULL; return NULL;
} }
bool queue_push(struct _queue* self, void* obj) static bool queue_push(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
assert(obj != NULL); assert(obj != NULL);
@ -73,7 +73,7 @@ done:
return false; return false;
} }
bool queue_pop(struct _queue* self, void* obj) static bool queue_pop(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -92,7 +92,7 @@ bool queue_pop(struct _queue* self, void* obj)
return true; return true;
} }
bool queue_back(struct _queue* self, void* obj) static bool queue_back(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -103,7 +103,7 @@ bool queue_back(struct _queue* self, void* obj)
return true; return true;
} }
bool queue_front(struct _queue* self, void* obj) static bool queue_front(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -114,7 +114,7 @@ bool queue_front(struct _queue* self, void* obj)
return true; return true;
} }
bool queue_clear(struct _queue* self) static bool queue_clear(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
struct _queue_node* node = self->_front; struct _queue_node* node = self->_front;
@ -132,25 +132,25 @@ bool queue_clear(struct _queue* self)
return true; return true;
} }
bool queue_empty(struct _queue* self) static bool queue_empty(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
return !self->size(self); return self->_size == 0;
} }
uint32_t queue_size(struct _queue* self) static uint32_t queue_size(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
return self->_size; return self->_size;
} }
void queue_destory(struct _queue* self) static void queue_destory(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
self->clear(self); self->clear(self);
} }
void queue_print(struct _queue* self) static void queue_print(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
@ -164,13 +164,19 @@ void queue_print(struct _queue* self)
bool queue_init(struct _queue * queue, uint32_t obj_size) bool queue_init(struct _queue * queue, uint32_t obj_size)
{ {
assert(queue != NULL); // assert(queue != NULL);
assert(obj_size > 0); // assert(obj_size > 0);
if(queue == NULL || obj_size == 0) if(queue == NULL || obj_size == 0)
{ {
return false; return false;
} }
// The queue is only initialized once
if(queue->_obj_size != 0)
{
return false;
}
// attribute init // attribute init
queue->_size = 0; queue->_size = 0;
queue->_obj_size = obj_size; queue->_obj_size = obj_size;
@ -195,7 +201,7 @@ bool queue_init(struct _queue * queue, uint32_t obj_size)
bool queue2_push(struct _queue* self, void* obj) static bool queue2_push(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
assert(obj != NULL); assert(obj != NULL);
@ -221,7 +227,7 @@ bool queue2_push(struct _queue* self, void* obj)
return true; return true;
} }
bool queue2_pop(struct _queue* self, void* obj) static bool queue2_pop(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -247,7 +253,7 @@ bool queue2_pop(struct _queue* self, void* obj)
return true; return true;
} }
bool queue2_back(struct _queue* self, void* obj) static bool queue2_back(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -268,7 +274,7 @@ bool queue2_back(struct _queue* self, void* obj)
return true; return true;
} }
bool queue2_front(struct _queue* self, void* obj) static bool queue2_front(struct _queue* self, void* obj)
{ {
assert(self != NULL); assert(self != NULL);
if (self->empty(self)) if (self->empty(self))
@ -281,7 +287,7 @@ bool queue2_front(struct _queue* self, void* obj)
return true; return true;
} }
bool queue2_clear(struct _queue* self) static bool queue2_clear(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
self->_index_front = 0; self->_index_front = 0;
@ -290,25 +296,25 @@ bool queue2_clear(struct _queue* self)
return true; return true;
} }
bool queue2_full(struct _queue* self) static bool queue2_full(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
return self->size(self) == self->capacity(self); return self->size(self) == self->capacity(self);
} }
uint32_t queue2_capacity(struct _queue* self) static uint32_t queue2_capacity(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
return self->_capacity; return self->_capacity;
} }
void queue2_destory(struct _queue* self) static void queue2_destory(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
self->clear(self); self->clear(self);
} }
void queue2_print(struct _queue* self) static void queue2_print(struct _queue* self)
{ {
assert(self != NULL); assert(self != NULL);
uint32_t index = 0; uint32_t index = 0;
@ -328,14 +334,20 @@ void queue2_print(struct _queue* self)
bool queue_init2(struct _queue * queue, uint32_t obj_size, uint32_t capacity) bool queue_init2(struct _queue * queue, uint32_t obj_size, uint32_t capacity)
{ {
assert(queue != NULL); // assert(queue != NULL);
assert(obj_size > 0); // assert(obj_size > 0);
assert(capacity > 0); // assert(capacity > 0);
if(queue == NULL || obj_size == 0 || capacity == 0) if(queue == NULL || obj_size == 0 || capacity == 0)
{ {
return false; return false;
} }
// The queue is only initialized once
if(queue->_obj_size != 0)
{
return false;
}
// attribute init // attribute init
queue->_size = 0; queue->_size = 0;
queue->_obj_size = obj_size; queue->_obj_size = obj_size;

33
test/test_queue.c
View File

@ -19,6 +19,8 @@ static void test_queue_new(void)
queue_free(&queue); queue_free(&queue);
TEST_ASSERT_NULL(queue); TEST_ASSERT_NULL(queue);
TEST_ASSERT_NOT_NULL(&queue);
queue_free(&queue);
queue_free(NULL); queue_free(NULL);
} }
@ -28,17 +30,19 @@ static void test_queue_init(void)
// ------------------------------ // ------------------------------
queue = queue_new(); queue = queue_new();
TEST_ASSERT_TRUE(queue_init(queue, sizeof(int)));
TEST_ASSERT_FALSE(queue_init(NULL, sizeof(int))); TEST_ASSERT_FALSE(queue_init(NULL, sizeof(int)));
TEST_ASSERT_FALSE(queue_init(queue, 0)); TEST_ASSERT_FALSE(queue_init(queue, 0));
TEST_ASSERT_TRUE(queue_init(queue, sizeof(int)));
TEST_ASSERT_FALSE(queue_init(queue, sizeof(int))); // The queue is only initialized once
queue_free(&queue); queue_free(&queue);
// ------------------------------ // ------------------------------
queue = queue_new(); queue = queue_new();
TEST_ASSERT_TRUE(queue_init2(queue, sizeof(int), 1)); TEST_ASSERT_FALSE(queue_init2(NULL, sizeof(int), 1));
TEST_ASSERT_FALSE(queue_init2(NULL, sizeof(int),1 ));
TEST_ASSERT_FALSE(queue_init2(queue, 0, 1)); TEST_ASSERT_FALSE(queue_init2(queue, 0, 1));
TEST_ASSERT_FALSE(queue_init2(queue, sizeof(int), 0)); TEST_ASSERT_FALSE(queue_init2(queue, sizeof(int), 0));
TEST_ASSERT_TRUE(queue_init2(queue, sizeof(int), 1));
TEST_ASSERT_FALSE(queue_init2(queue, sizeof(int), 1)); // The queue is only initialized once
queue_free(&queue); queue_free(&queue);
} }
@ -55,6 +59,7 @@ static void test_queue_push(void)
// ------------------------------ // ------------------------------
queue = queue_new(); queue = queue_new();
queue_init(queue, sizeof(int)); queue_init(queue, sizeof(int));
TEST_ASSERT_TRUE(queue->empty(queue));
for(i = 0; i < len; i++) for(i = 0; i < len; i++)
{ {
TEST_ASSERT_TRUE(queue->push(queue, &data[i])); TEST_ASSERT_TRUE(queue->push(queue, &data[i]));
@ -65,12 +70,15 @@ static void test_queue_push(void)
TEST_ASSERT_TRUE(queue->back(queue, &temp)); TEST_ASSERT_TRUE(queue->back(queue, &temp));
TEST_ASSERT_EQUAL_INT(data[i], temp); TEST_ASSERT_EQUAL_INT(data[i], temp);
TEST_ASSERT_FALSE(queue->empty(queue));
} }
queue_free(&queue); queue_free(&queue);
// ------------------------------ // ------------------------------
queue = queue_new(); queue = queue_new();
queue_init2(queue, sizeof(int), len); queue_init2(queue, sizeof(int), len);
TEST_ASSERT_TRUE(queue->empty(queue));
for(i = 0; i < len; i++) for(i = 0; i < len; i++)
{ {
TEST_ASSERT_TRUE(queue->push(queue, &data[i])); TEST_ASSERT_TRUE(queue->push(queue, &data[i]));
@ -81,33 +89,34 @@ static void test_queue_push(void)
TEST_ASSERT_TRUE(queue->back(queue, &temp)); TEST_ASSERT_TRUE(queue->back(queue, &temp));
TEST_ASSERT_EQUAL_INT(data[i], temp); TEST_ASSERT_EQUAL_INT(data[i], temp);
TEST_ASSERT_FALSE(queue->empty(queue));
} }
queue_free(&queue); queue_free(&queue);
// ------------------------------ // ------------------------------
// if capacity is less than data len // if capacity is less than data len
uint32_t capacity = len - 1;
queue = queue_new(); queue = queue_new();
queue_init2(queue, sizeof(int), capacity); queue_init2(queue, sizeof(int), len - 2);
for(i = 0; i < len; i++) for(i = 0; i < len; i++)
{ {
if(i == capacity - 1) if(i < queue->capacity(queue))
{ {
TEST_ASSERT_FALSE(queue->full(queue));
TEST_ASSERT_TRUE(queue->push(queue, &data[i])); TEST_ASSERT_TRUE(queue->push(queue, &data[i]));
TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue)); TEST_ASSERT_EQUAL_INT(i + 1, queue->size(queue));
TEST_ASSERT_TRUE(queue->front(queue, &temp));
TEST_ASSERT_EQUAL_INT(data[0], temp);
TEST_ASSERT_TRUE(queue->back(queue, &temp));
TEST_ASSERT_EQUAL_INT(data[i], temp);
} }
else else
{ {
TEST_ASSERT_TRUE(queue->full(queue));
TEST_ASSERT_FALSE(queue->push(queue, &data[i]));
TEST_ASSERT_EQUAL_INT(queue->capacity(queue), queue->size(queue));
} }
} }
queue_free(&queue); queue_free(&queue);
// queue->empty(queue);
} }