From 820e4021f5d5e13ffcd6420479f8deddfefffb66 Mon Sep 17 00:00:00 2001
From: guishenking <guishenking@outlook.com>
Date: Fri, 22 Aug 2025 16:21:37 +0800
Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=A4=9A=E7=A7=8D=E9=94=99?=
 =?UTF-8?q?=E8=AF=AF=E8=BF=94=E5=9B=9E=E7=B1=BB=E5=9E=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/lib/vector/vector.c | 160 +++++++++++++++++++---------------------
 src/lib/vector/vector.h |  45 ++++++-----
 src/main.c              |   6 +-
 3 files changed, 106 insertions(+), 105 deletions(-)

diff --git a/src/lib/vector/vector.c b/src/lib/vector/vector.c
index a05c9e9..6aef8d0 100755
--- a/src/lib/vector/vector.c
+++ b/src/lib/vector/vector.c
@@ -32,7 +32,6 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
         vec = NULL; // 确保vec为NULL以避免后续操作出现问题
         return NULL;
     }
-
     return vec;
 }
 
@@ -40,34 +39,36 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
  * @brief 销毁容器
  * 
  * @param vec 
- * @return true 
- * @return false 
  */
-bool vector_destroy(vector_t *vec) {
-    if (!vec) return false;
+enum vector_error vector_destroy(vector_t *vec) {
+    if (!vec) return VECTOR_ERR_NULL;
+    if (vec->data == NULL) 
+    {
+        free(vec); // 如果vec->data为NULL，直接释放vec
+        vec = NULL; // 确保vec为NULL以避免后续操作出现问题
+        return VECTOR_OK;
+    }
     free(vec->data);
     free(vec);
     vec = NULL; // 确保vec为NULL以避免后续操作出现问题
-    return true;
+    return VECTOR_OK;
 }
 
 /**
  * @brief 扩容
  * 
  * @param vec 
- * @return true 
- * @return false 
  */
-static bool _vector_extend_capacity_(vector_t *vec) {
-    if (!vec) return false; // 检查vec是否为NULL
+static enum vector_error _vector_extend_capacity_(vector_t *vec) {
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
 
     size_t new_capacity = vec->capacity * 2; // 扩容为原来的两倍
     void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
-    if (!new_data) return false; // 内存分配失败
+    if (!new_data) return VECTOR_ERR_NULL; // 内存分配失败
 
     vec->data = new_data;
     vec->capacity = new_capacity;
-    return true; // 成功扩容
+    return VECTOR_OK; // 成功扩容
 }
 
 /**
@@ -76,15 +77,13 @@ static bool _vector_extend_capacity_(vector_t *vec) {
  * @param vec 
  * @param index 要添加的索引，索引从0开始
  * @param elem 数据内容
- * @return true 
- * @return false 
  */
-bool vector_add_at(vector_t *vec, size_t index, const void *elem){
-    if (!vec || !elem || index > vec->size) return false; // 检查vec、elem是否为NULL或索引越界
+enum vector_error vector_add_at(vector_t *vec, size_t index, const void *elem){
+    if (!vec || !elem || index > vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec、elem是否为NULL或索引越界
 
     if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
-        if( _vector_extend_capacity_(vec) == false) {
-            return false; // 扩容失败
+        if( _vector_extend_capacity_(vec) != VECTOR_OK) {
+            return VECTOR_ERR_MEMORY; // 扩容失败
         }
     }
 
@@ -92,7 +91,7 @@ bool vector_add_at(vector_t *vec, size_t index, const void *elem){
     memmove(target + vec->elem_size, target, (vec->size - index) * vec->elem_size); // 移动元素
     memcpy(target, elem, vec->elem_size); // 插入新元素
     vec->size++;
-    return true; // 成功添加元素
+    return VECTOR_OK; // 成功添加元素
 }
 
 /**
@@ -101,13 +100,11 @@ bool vector_add_at(vector_t *vec, size_t index, const void *elem){
  * @param vec 
  * @param index1 
  * @param index2 
- * @return true 
- * @return false 
  */
-bool vector_swap(vector_t *vec, size_t index1, size_t index2){
-    if (!vec || index1 >= vec->size || index2 >= vec->size) return false; // 检查vec是否为NULL或索引越界
+enum vector_error vector_swap(vector_t *vec, size_t index1, size_t index2){
+    if (!vec || index1 >= vec->size || index2 >= vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或索引越界
 
-    if (index1 == index2) return true; // 如果索引相同，无需交换
+    if (index1 == index2) return VECTOR_OK; // 如果索引相同，无需交换
 
     void *elem1 = (void *)vec->data + (index1 * vec->elem_size);// 获取第一个元素的指针
     void *elem2 = (void *)vec->data + (index2 * vec->elem_size);// 获取第二个元素的指针
@@ -115,7 +112,7 @@ bool vector_swap(vector_t *vec, size_t index1, size_t index2){
     memcpy(temp, elem1, vec->elem_size);  // 交换元素
     memcpy(elem1, elem2, vec->elem_size); // 
     memcpy(elem2, temp, vec->elem_size);  // 
-    return true; // 成功交换元素
+    return VECTOR_OK; // 成功交换元素
 }
 
 /**
@@ -123,16 +120,14 @@ bool vector_swap(vector_t *vec, size_t index1, size_t index2){
  * 
  * @param vec 
  * @param index 
- * @return true 
- * @return false 
  */
-bool vector_remove_at(vector_t *vec, size_t index){
-    if (!vec || index >= vec->size) return false; // 检查vec是否为NULL或索引越界
+enum vector_error vector_remove_at(vector_t *vec, size_t index){
+    if (!vec || index >= vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或索引越界
 
     void *target = vec->data + (index * vec->elem_size);
     memmove(target, target + vec->elem_size, (vec->size - index - 1) * vec->elem_size); // 移动元素
     vec->size--;
-    return true; // 成功删除元素
+    return VECTOR_OK; // 成功删除元素
 }
 
 /**
@@ -151,44 +146,40 @@ size_t vector_size(const vector_t *vec){
  * 
  * @param vec 
  * @param elem 
- * @return true 
- * @return false 
  */
-bool vector_push_back(vector_t *vec, const void *elem){
-    if (!vec || !elem) return false; // 检查vec和elem是否为NULL
+enum vector_error vector_push_back(vector_t *vec, const void *elem){
+    if (!vec || !elem) return VECTOR_ERR_NULL; // 检查vec和elem是否为NULL
 
     if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
-        if( _vector_extend_capacity_(vec) == false) {
-            return false; // 扩容失败
+        if( _vector_extend_capacity_(vec) != VECTOR_OK) {
+            return VECTOR_ERR_MEMORY; // 扩容失败
         }
     }
 
     void *target = (char *)vec->data + (vec->size * vec->elem_size);
     memcpy(target, elem, vec->elem_size);
     vec->size++;
-    return true; // 成功添加元素
+    return VECTOR_OK; // 成功添加元素
 }
 
 /**
  * @brief 从容器尾部删除元素
  * 
  * @param vec 
- * @return true 
- * @return false 
  */
-bool vector_pop_back(vector_t *vec){
-    if (!vec || vec->size == 0) return false; // 检查vec是否为NULL或空
+enum vector_error vector_pop_back(vector_t *vec){
+    if (!vec || vec->size == 0) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或空
 
     vec->size--; // 减少元素数量
     if (vec->size < vec->capacity / 4) {
         size_t new_capacity = vec->capacity / 2;
         if (new_capacity < 1) new_capacity = 1; // 确保容量至少为1
         void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
-        if (!new_data) return false; // 内存分配失败
+        if (!new_data) return VECTOR_ERR_MEMORY; // 内存分配失败
         vec->data = new_data;
         vec->capacity = new_capacity;
     }
-    return true; // 成功删除元素
+    return VECTOR_OK; // 成功删除元素
 
 }
 
@@ -211,16 +202,14 @@ void *vector_get(const vector_t *vec, size_t index){
  * @param vec 
  * @param index 
  * @param elem 
- * @return true 
- * @return false 
  */
-bool vector_set(vector_t *vec, size_t index, const void *elem){
-    if (!vec || index >= vec->size || !elem) return false; // 检查vec是否为NULL、索引越界或elem为NULL
+enum vector_error vector_set(vector_t *vec, size_t index, const void *elem){
+    if (!vec || index >= vec->size || !elem) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL、索引越界或elem为NULL
 
     void *target = (void *)vec->data + (index * vec->elem_size);// 计算目标元素的地址
-    if (!target) return false; // 检查目标地址是否有效
+    if (!target) return VECTOR_ERR_NULL; // 检查目标地址是否有效
     memcpy(target, elem, vec->elem_size); // 将elem的值复制到指定索引的元素位置
-    return true;
+    return VECTOR_OK;
 }
 
 /**
@@ -239,13 +228,13 @@ size_t vector_get_capacity(const vector_t *vec){
  * @param vec 
  * @param new_size 
  */
-bool vector_resize(vector_t *vec, size_t new_size){
-    if (!vec) return false; // 检查vec是否为NULL或new_size小于0
+enum vector_error vector_resize(vector_t *vec, size_t new_size){
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL或new_size小于0
 
     if (new_size > vec->capacity) {
         size_t new_capacity = new_size > vec->capacity * 2 ? new_size : vec->capacity * 2;
         void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
-        if (!new_data) return false; // 内存分配失败
+        if (!new_data) return VECTOR_ERR_NULL; // 内存分配失败
         vec->data = new_data;
         vec->capacity = new_capacity;
     }
@@ -255,7 +244,7 @@ bool vector_resize(vector_t *vec, size_t new_size){
     }
 
     vec->size = new_size; // 更新当前元素数量
-    return true; // 成功调整大小
+    return VECTOR_OK; // 成功调整大小
 }
 
 /**
@@ -263,14 +252,14 @@ bool vector_resize(vector_t *vec, size_t new_size){
  * 
  * @param vec 
  */
-bool vector_clear(vector_t *vec){
-    if (!vec) return false; // 检查vec是否为NULL
+enum vector_error vector_clear(vector_t *vec){
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
 
-    if (vec->size == 0) return true; // 如果向量已经为空，直接返回
+    if (vec->size == 0) return VECTOR_OK; // 如果向量已经为空，直接返回
 
     vec->size = 0; // 清空向量
 
-    return true; // 成功清空向量
+    return VECTOR_OK; // 成功清空向量
 }
 
 /**
@@ -278,8 +267,8 @@ bool vector_clear(vector_t *vec){
  * 
  * @param vec 
  */
-bool vector_shrink_to_fit(vector_t *vec){
-    if (!vec) return false; // 检查vec是否为NULL
+enum vector_error vector_shrink_to_fit(vector_t *vec){
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
 
     if (vec->size < vec->capacity) {
         void *new_data = realloc(vec->data, vec->size * vec->elem_size);
@@ -288,7 +277,7 @@ bool vector_shrink_to_fit(vector_t *vec){
             vec->capacity = vec->size; // 更新容量为当前元素数量b ve
         }
     }
-    return true; // 成功调整内存大小
+    return VECTOR_OK; // 成功调整内存大小
 }
 
 /**
@@ -297,8 +286,8 @@ bool vector_shrink_to_fit(vector_t *vec){
  * @param vec 
  * @param new_capacity 
  */
-bool vector_reserve(vector_t *vec, size_t new_capacity){
-    if (!vec || new_capacity < vec->size) return false; // 检查vec是否为NULL或new_capacity小于当前元素数量
+enum vector_error vector_reserve(vector_t *vec, size_t new_capacity){
+    if (!vec || new_capacity < vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或new_capacity小于当前元素数量
 
     if (new_capacity > vec->capacity) {
         void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
@@ -307,7 +296,7 @@ bool vector_reserve(vector_t *vec, size_t new_capacity){
             vec->capacity = new_capacity; // 更新容量
         }
     }
-    return true; // 成功保留数据并扩容
+    return VECTOR_OK; // 成功保留数据并扩容
 }
 
 /**
@@ -316,13 +305,13 @@ bool vector_reserve(vector_t *vec, size_t new_capacity){
  * @param vec 
  * @param compare 
  */
-bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
-    if (!vec || !compare) return false; // 检查vec是否为NULL或compare函数是否为NULL
+enum vector_error vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
+    if (!vec || !compare) return VECTOR_ERR_NULL; // 检查vec是否为NULL或compare函数是否为NULL
 
-    if (vec->size == 0) return true; // 如果容器为空，直接返回
-    if (vec->size == 1) return true; // 如果容器只有一个元素，直接返回
+    if (vec->size == 0) return VECTOR_OK; // 如果容器为空，直接返回
+    if (vec->size == 1) return VECTOR_OK; // 如果容器只有一个元素，直接返回
     qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序  
-    return true; // 成功排序数据  
+    return VECTOR_OK; // 成功排序数据  
 }
 
 /**
@@ -330,10 +319,10 @@ bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
  * 
  * @param vec 
  */
-bool vector_reverse(vector_t *vec){
-    if (!vec) return false; // 检查vec是否为NULL
+enum vector_error vector_reverse(vector_t *vec){
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
 
-    if (vec->size == 0 || vec->size == 1) return true; // 如果容器为空或只有一个元素，直接返回
+    if (vec->size == 0 || vec->size == 1) return VECTOR_OK; // 如果容器为空或只有一个元素，直接返回
 
     size_t left = 0;
     size_t right = vec->size - 1;
@@ -347,7 +336,7 @@ bool vector_reverse(vector_t *vec){
         left++;
         right--;
     }
-    return true; // 成功反转数据
+    return VECTOR_OK; // 成功反转数据
 }
 
 /**
@@ -356,13 +345,14 @@ bool vector_reverse(vector_t *vec){
  * @param vec 
  * @param func 回调函数，接受一个void指针作为参数
  */
-bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index)){
-    if (!vec || !func) return false; // 检查vec和func是否为NULL
+enum vector_error vector_for_each(const vector_t *vec, void (*func)(void *,size_t index)){
+    if (!vec || !func) return VECTOR_ERR_NULL; // 检查vec和func是否为NULL
 
     for (size_t i = 0; i < vec->size; i++) {
         void *elem = (void *)vec->data + (i * vec->elem_size);
         func(elem, i); // 调用函数处理每个元素
     }
+    return VECTOR_OK; // 成功遍历所有元素
 }
 
 /**
@@ -372,8 +362,8 @@ bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index)){
  * @param elem 
  * @param compare 
  */
-bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *)){
-    if (!vec || !elem || !compare) return false; // 检查vec、elem和compare函数是否为NULL
+enum vector_error vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *)){
+    if (!vec || !elem || !compare) return VECTOR_ERR_NULL; // 检查vec、elem和compare函数是否为NULL
 
     for (size_t i = 0; i < vec->size; i++) {
         void *current_elem = (void *)vec->data + (i * vec->elem_size);
@@ -382,7 +372,7 @@ bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *,
             vec->size--; // 减少元素数量
         }
     }
-    return true; // 找到并删除后退出
+    return VECTOR_OK; // 找到并删除后退出
 }
 
 /**
@@ -393,18 +383,18 @@ bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *,
  * @param compare 
  * @param index 
  */
-bool vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), size_t *index){
-    if (!vec || !elem || !compare || !index) return false; // 检查参数是否为NULL
+enum vector_error vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), size_t *index){
+    if (!vec || !elem || !compare || !index) return VECTOR_ERR_MULTIPLE; // 检查参数是否为NULL
 
     for (size_t i = 0; i < vec->size; i++) {
         void *current_elem = (void *)vec->data + (i * vec->elem_size);
         if (compare(current_elem, elem) == 0) { // 如果找到匹配的元素 条件可以为 > < ==
             *index = i; // 设置索引
-            return true; // 找到后退出
+            return VECTOR_OK; // 找到后退出
         }
     }
     *index = 0; // 如果未找到，设置索引为-1
-    return false; // 未找到满足条件的元素
+    return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
 }
 
 /**
@@ -414,16 +404,16 @@ bool vector_find(const vector_t *vec, const void *elem, int (*compare)(const voi
  * @param predicate 
  * @param index 
  */
-bool vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index){
-    if (!vec || !predicate || !index) return false; // 检查参数是否为NULL
+enum vector_error vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index){
+    if (!vec || !predicate || !index) return VECTOR_ERR_MULTIPLE; // 检查参数是否为NULL
 
     for (size_t i = 0; i < vec->size; i++) {
         void *current_elem = (void *)vec->data + (i * vec->elem_size);
         if (predicate(current_elem)) { // 如果满足条件
             *index = i; // 设置索引
-            return true; // 找到后退出
+            return VECTOR_OK; // 找到后退出
         }
     }
     *index = 0; // 如果未找到，设置索引为-1
-    return false; // 未找到满足条件的元素
+    return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
 }
\ No newline at end of file
diff --git a/src/lib/vector/vector.h b/src/lib/vector/vector.h
index 00a1781..634e1b1 100755
--- a/src/lib/vector/vector.h
+++ b/src/lib/vector/vector.h
@@ -21,49 +21,60 @@ typedef struct  vector{
     size_t capacity; // 总容量
     size_t elem_size;// 单个元素大小
 } vector_t;
+#pragma pack()
 
+#pragma pack(1)
+enum vector_error {
+    VECTOR_OK = 0,          // 成功
+    VECTOR_ERR_NULL,       // 空指针错误
+    VECTOR_ERR_OUT_OF_BOUNDS, // 索引越界错误
+    VECTOR_ERR_MEMORY,     // 内存分配错误
+    VECTOR_ERR_INVALID_SIZE, // 无效大小错误
+    VECTOR_ERR_MULTIPLE, // 多重定义错误
+    VECTOR_ERR_NOT_MATCH // 未找到错误
+};
 #pragma pack()
 
 vector_t *vector_create(size_t elem_size, size_t initial_capacity);
 
-bool vector_destroy(vector_t *vec);
+enum vector_error vector_destroy(vector_t *vec);
 
-bool vector_add_at(vector_t *vec, size_t index, const void *elem);
+enum vector_error vector_add_at(vector_t *vec, size_t index, const void *elem);
 
-bool vector_swap(vector_t *vec, size_t index1, size_t index2);
+enum vector_error vector_swap(vector_t *vec, size_t index1, size_t index2);
 
-bool vector_remove_at(vector_t *vec, size_t index);
+enum vector_error vector_remove_at(vector_t *vec, size_t index);
 
 size_t vector_size(const vector_t *vec);
 
-bool vector_push_back(vector_t *vec, const void *elem); 
+enum vector_error vector_push_back(vector_t *vec, const void *elem); 
 
-bool vector_pop_back(vector_t *vec);
+enum vector_error vector_pop_back(vector_t *vec);
 
 void *vector_get(const vector_t *vec, size_t index);
 
-bool vector_set(vector_t *vec, size_t index, const void *elem);   
+enum vector_error vector_set(vector_t *vec, size_t index, const void *elem);   
 
 size_t vector_get_capacity(const vector_t *vec);
 
-bool vector_resize(vector_t *vec, size_t new_size);
+enum vector_error vector_resize(vector_t *vec, size_t new_size);
 
-bool vector_clear(vector_t *vec);
+enum vector_error vector_clear(vector_t *vec);
 
-bool vector_shrink_to_fit(vector_t *vec);   
+enum vector_error vector_shrink_to_fit(vector_t *vec);   
 
-bool vector_reserve(vector_t *vec, size_t new_capacity);  
+enum vector_error vector_reserve(vector_t *vec, size_t new_capacity);  
 
-bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
+enum vector_error vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
 
-bool vector_reverse(vector_t *vec);
+enum vector_error vector_reverse(vector_t *vec);
 
-bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index));
+enum vector_error vector_for_each(const vector_t *vec, void (*func)(void *,size_t index));
 
-bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
+enum vector_error vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
 
-bool vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), size_t *index);
+enum vector_error vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), size_t *index);
 
-bool vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index);
+enum vector_error vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index);
 
 #endif // _GSK_VECTOR_H
\ No newline at end of file
diff --git a/src/main.c b/src/main.c
index 8016b8a..6f6cb0b 100755
--- a/src/main.c
+++ b/src/main.c
@@ -119,7 +119,7 @@ int main() {
     // 测试 vector_find
     printf("\n11. 测试 vector_find...\n");
     size_t index;
-    if (vector_find(students, &s1, compare_students, &index)) {
+    if (vector_find(students, &s1, compare_students, &index) == VECTOR_OK) {
         printf("找到ID为%d的学生在索引%zu\n", s1.id, index);
     } else {
         printf("未找到ID为%d的学生\n", s1.id);
@@ -127,7 +127,7 @@ int main() {
     
     // 测试 vector_find_if
     printf("\n12. 测试 vector_find_if...\n");
-    if (vector_find_if(students, is_high_score, &index)) {
+    if (vector_find_if(students, is_high_score, &index)== VECTOR_OK) {
         Student *high_score = (Student *)vector_get(students, index);
         printf("找到高分学生: %s (%.1f)\n", high_score->name, high_score->score);
     } else {
@@ -166,7 +166,7 @@ int main() {
     
     // 测试 vector_destroy
     printf("\n18. 测试 vector_destroy...\n");
-    if (vector_destroy(students)) {
+    if (vector_destroy(students) == VECTOR_OK) {
         printf("销毁成功\n");
     } else {
         printf("销毁失败\n");