From 4dd77b5042890d5f16259931102e6496243c9855 Mon Sep 17 00:00:00 2001
From: guishenking <guishenking@outlook.com>
Date: Thu, 21 Aug 2025 21:20:20 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=87=BD=E6=95=B0=E5=90=8D?=
 =?UTF-8?q?=EF=BC=8C=E5=8E=BB=E9=99=A4vector=5Fresize=E5=A4=9A=E4=BD=99?=
 =?UTF-8?q?=E7=9A=84=E6=95=B0=E6=8D=AE=E6=A3=80=E6=9F=A5,=E6=B7=BB?=
 =?UTF-8?q?=E5=8A=A0=E4=BB=A5=E4=B8=8B=E5=8A=9F=E8=83=BD=20=E6=8F=92?=
 =?UTF-8?q?=E5=85=A5=E5=85=83=E7=B4=A0=E5=88=B0=E6=8C=87=E5=AE=9A=E4=BD=8D?=
 =?UTF-8?q?=E7=BD=AE=20=E5=88=A0=E9=99=A4=E6=8C=87=E5=AE=9A=E4=BD=8D?=
 =?UTF-8?q?=E7=BD=AE=E7=9A=84=E5=85=83=E7=B4=A0=20=E4=BA=A4=E6=8D=A2?=
 =?UTF-8?q?=E4=B8=A4=E4=B8=AA=E5=85=83=E7=B4=A0=E7=9A=84=E4=BD=8D=E7=BD=AE?=
 =?UTF-8?q?=20=E8=8E=B7=E5=8F=96=E5=AE=B9=E5=99=A8=E7=9A=84=E5=AE=B9?=
 =?UTF-8?q?=E9=87=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

修改函数返回类型
新增数据对齐（四字节）
---
 src/lib/vector/vector.c | 206 +++++++++++++++++++++++++++++-----------
 src/lib/vector/vector.h |  33 ++++---
 2 files changed, 171 insertions(+), 68 deletions(-)

diff --git a/src/lib/vector/vector.c b/src/lib/vector/vector.c
index 56307d7..4170028 100755
--- a/src/lib/vector/vector.c
+++ b/src/lib/vector/vector.c
@@ -44,18 +44,107 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
  * @return false 
  */
 bool vector_destroy(vector_t *vec) {
-    if (vec) {
-        if (!vec->data) {//虽然data指针可能为NULL，但内存可以被释放
-            free(vec);
-            return true;
-        }
-        free(vec->data);
-        free(vec);
-        return true;
-    }
-    return false;
+    if (!vec) return false;
+    free(vec->data);
+    free(vec);
+    vec = NULL; // 确保vec为NULL以避免后续操作出现问题
+    return true;
 }
 
+/**
+ * @brief 扩容
+ * 
+ * @param vec 
+ * @return true 
+ * @return false 
+ */
+static bool _vector_extend_capacity_(vector_t *vec) {
+    if (!vec) return false; // 检查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; // 内存分配失败
+
+    vec->data = new_data;
+    vec->capacity = new_capacity;
+    return true; // 成功扩容
+}
+
+/**
+ * @brief 向指定索引位置添加元素
+ * 
+ * @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或索引越界
+
+    if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
+        if( _vector_extend_capacity_(vec) == false) {
+            return false; // 扩容失败
+        }
+    }
+
+    void *target = vec->data + (index * vec->elem_size);
+    memmove(target + vec->elem_size, target, (vec->size - index) * vec->elem_size); // 移动元素
+    memcpy(target, elem, vec->elem_size); // 插入新元素
+    vec->size++;
+    return true; // 成功添加元素
+}
+
+/**
+ * @brief 交换指定索引位置的两个元素
+ * 
+ * @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或索引越界
+
+    if (index1 == index2) return true; // 如果索引相同，无需交换
+
+    void *elem1 = (void *)vec->data + (index1 * vec->elem_size);// 获取第一个元素的指针
+    void *elem2 = (void *)vec->data + (index2 * vec->elem_size);// 获取第二个元素的指针
+    char temp[vec->elem_size]; // 临时存储空间
+    memcpy(temp, elem1, vec->elem_size);  // 交换元素
+    memcpy(elem1, elem2, vec->elem_size); // 
+    memcpy(elem2, temp, vec->elem_size);  // 
+    return true; // 成功交换元素
+}
+
+/**
+ * @brief 删除指定索引位置的元素
+ * 
+ * @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或索引越界
+
+    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; // 成功删除元素
+}
+
+/**
+ * @brief 获取容器已使用的元素数量
+ * 
+ * @param vec 
+ * @return size_t 
+ */
+size_t vector_used(const vector_t *vec){
+    if (!vec) return 0; // 检查vec是否为NULL
+    return vec->size;
+}
 
 /**
  * @brief 向容器末尾添加元素
@@ -68,12 +157,10 @@ bool vector_destroy(vector_t *vec) {
 bool vector_push_back(vector_t *vec, const void *elem){
     if (!vec || !elem) return false; // 检查vec和elem是否为NULL
 
-    if (vec->size >= vec->capacity) {
-        size_t new_capacity = vec->capacity * 2;
-        void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
-        if (!new_data) return false; // 内存分配失败
-        vec->data = new_data;
-        vec->capacity = new_capacity;
+    if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
+        if( _vector_extend_capacity_(vec) == false) {
+            return false; // 扩容失败
+        }
     }
 
     void *target = (char *)vec->data + (vec->size * vec->elem_size);
@@ -112,7 +199,7 @@ bool vector_pop_back(vector_t *vec){
  * @param index 索引从0开始 
  * @return void* 
  */
-void *vector_get(const vector_t *vec, uint32_t index){
+void *vector_get(const vector_t *vec, size_t index){
     if (!vec || index >= vec->size) return NULL; // 检查vec是否为NULL或索引越界
 
     return (void *)vec->data + (index * vec->elem_size); // 返回指定索引的元素指针
@@ -127,7 +214,7 @@ void *vector_get(const vector_t *vec, uint32_t index){
  * @return true 
  * @return false 
  */
-bool vector_set(vector_t *vec, uint32_t index, const void *elem){
+bool vector_set(vector_t *vec, size_t index, const void *elem){
     if (!vec || index >= vec->size || !elem) return false; // 检查vec是否为NULL、索引越界或elem为NULL
 
     void *target = (void *)vec->data + (index * vec->elem_size);// 计算目标元素的地址
@@ -137,13 +224,13 @@ bool vector_set(vector_t *vec, uint32_t index, const void *elem){
 }
 
 /**
- * @brief 获取向量当前元素数量
+ * @brief 获取向量容量
  * 
  * @param vec 
  * @return size_t 
  */
-size_t vector_size(const vector_t *vec){
-    return vec->size; // 返回当前元素数量
+size_t vector_get_capacity(const vector_t *vec){
+    return vec->capacity; // 返回当前元素数量
 }
 
 /**
@@ -152,13 +239,13 @@ size_t vector_size(const vector_t *vec){
  * @param vec 
  * @param new_size 
  */
-void vector_resize(vector_t *vec, uint32_t new_size){
-    if (!vec || new_size < 0) return; // 检查vec是否为NULL或new_size小于0
+bool vector_resize(vector_t *vec, size_t new_size){
+    if (!vec) return false; // 检查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; // 内存分配失败
+        if (!new_data) return false; // 内存分配失败
         vec->data = new_data;
         vec->capacity = new_capacity;
     }
@@ -168,6 +255,7 @@ void vector_resize(vector_t *vec, uint32_t new_size){
     }
 
     vec->size = new_size; // 更新当前元素数量
+    return true; // 成功调整大小
 }
 
 /**
@@ -175,11 +263,14 @@ void vector_resize(vector_t *vec, uint32_t new_size){
  * 
  * @param vec 
  */
-void vector_clear(vector_t *vec){
-    if (!vec) return; // 检查vec是否为NULL
+bool vector_clear(vector_t *vec){
+    if (!vec) return false; // 检查vec是否为NULL
+
+    if (vec->size == 0) return true; // 如果向量已经为空，直接返回
 
     vec->size = 0; // 清空向量
-    memset(vec->data, 0, vec->capacity * vec->elem_size); // 可选：将数据区域清零
+
+    return true; // 成功清空向量
 }
 
 /**
@@ -187,16 +278,17 @@ void vector_clear(vector_t *vec){
  * 
  * @param vec 
  */
-void vector_shrink_to_fit(vector_t *vec){
-    if (!vec) return; // 检查vec是否为NULL
+bool vector_shrink_to_fit(vector_t *vec){
+    if (!vec) return false; // 检查vec是否为NULL
 
     if (vec->size < vec->capacity) {
         void *new_data = realloc(vec->data, vec->size * vec->elem_size);
         if (new_data) {
             vec->data = new_data;
-            vec->capacity = vec->size; // 更新容量为当前元素数量
+            vec->capacity = vec->size; // 更新容量为当前元素数量b ve
         }
     }
+    return true; // 成功调整内存大小
 }
 
 /**
@@ -205,8 +297,8 @@ void vector_shrink_to_fit(vector_t *vec){
  * @param vec 
  * @param new_capacity 
  */
-void vector_reserve(vector_t *vec, uint32_t new_capacity){
-    if (!vec || new_capacity < vec->size) return; // 检查vec是否为NULL或new_capacity小于当前元素数量
+bool vector_reserve(vector_t *vec, size_t new_capacity){
+    if (!vec || new_capacity < vec->size) return false; // 检查vec是否为NULL或new_capacity小于当前元素数量
 
     if (new_capacity > vec->capacity) {
         void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
@@ -215,6 +307,7 @@ void vector_reserve(vector_t *vec, uint32_t new_capacity){
             vec->capacity = new_capacity; // 更新容量
         }
     }
+    return true; // 成功保留数据并扩容
 }
 /**
  * @brief 排序容器中数据
@@ -222,19 +315,24 @@ void vector_reserve(vector_t *vec, uint32_t new_capacity){
  * @param vec 
  * @param compare 
  */
-void vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
-    if (!vec || !compare) return; // 检查vec是否为NULL或compare函数是否为NULL
+bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
+    if (!vec || !compare) return false; // 检查vec是否为NULL或compare函数是否为NULL
 
-    qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序    
+    if (vec->size == 0) return true; // 如果容器为空，直接返回
+    if (vec->size == 1) return true; // 如果容器只有一个元素，直接返回
+    qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序  
+    return true; // 成功排序数据  
 }
 
 /**
- * @brief 
+ * @brief 反转容器中的数据
  * 
  * @param vec 
  */
-void vector_reverse(vector_t *vec){
-    if (!vec) return; // 检查vec是否为NULL
+bool vector_reverse(vector_t *vec){
+    if (!vec) return false; // 检查vec是否为NULL
+
+    if (vec->size == 0 || vec->size == 1) return true; // 如果容器为空或只有一个元素，直接返回
 
     size_t left = 0;
     size_t right = vec->size - 1;
@@ -256,34 +354,34 @@ void vector_reverse(vector_t *vec){
  * @param vec 
  * @param func 回调函数，接受一个void指针作为参数
  */
-void vector_for_each(const vector_t *vec, void (*func)(void *)){
-    if (!vec || !func) return; // 检查vec和func是否为NULL
+bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index)){
+    if (!vec || !func) return false; // 检查vec和func是否为NULL
 
     for (size_t i = 0; i < vec->size; i++) {
         void *elem = (void *)vec->data + (i * vec->elem_size);
-        func(elem); // 调用函数处理每个元素
+        func(elem, i); // 调用函数处理每个元素
     }
 }
 
 
 /**
- * @brief 删除第一个与 elem 匹配的元素（通过 compare 函数判断）。
+ * @brief 删除与 elem 匹配的元素（通过 compare 函数判断）。
  * 
  * @param vec 
  * @param elem 
  * @param compare 
  */
-void vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *)){
-    if (!vec || !elem || !compare) return; // 检查vec、elem和compare函数是否为NULL
+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
 
     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) { // 如果找到匹配的元素
             memmove(current_elem, (void *)current_elem + vec->elem_size, (vec->size - i - 1) * vec->elem_size);
             vec->size--; // 减少元素数量
-            return; // 找到并删除后退出
         }
     }
+    return true; // 找到并删除后退出
 }
 
 /**
@@ -294,17 +392,18 @@ void vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *,
  * @param compare 
  * @param index 
  */
-void vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), uint32_t *index){
-    if (!vec || !elem || !compare || !index) return; // 检查参数是否为NULL
+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
 
     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; // 找到后退出
+            return true; // 找到后退出
         }
     }
-    *index = -1; // 如果未找到，设置索引为-1
+    *index = 0; // 如果未找到，设置索引为-1
+    return false; // 未找到满足条件的元素
 }
 
 /**
@@ -314,15 +413,16 @@ void vector_find(const vector_t *vec, const void *elem, int (*compare)(const voi
  * @param predicate 
  * @param index 
  */
-void vector_find_if(const vector_t *vec, int (*predicate)(const void *), uint32_t *index){
-    if (!vec || !predicate || !index) return; // 检查参数是否为NULL
+bool vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index){
+    if (!vec || !predicate || !index) return false; // 检查参数是否为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; // 找到后退出
+            return true; // 找到后退出
         }
     }
-    *index = -1; // 如果未找到，设置索引为-1
+    *index = 0; // 如果未找到，设置索引为-1
+    return false; // 未找到满足条件的元素
 }
\ No newline at end of file
diff --git a/src/lib/vector/vector.h b/src/lib/vector/vector.h
index 0b7b213..ee3ad43 100755
--- a/src/lib/vector/vector.h
+++ b/src/lib/vector/vector.h
@@ -8,12 +8,13 @@
  * @copyright Copyright (c) 2025
  * 
  */
-#ifndef _GSK_VECTOR_H
-#define _GSK_VECTOR_H
+#ifndef _GSK_VECTOR_H_
+#define _GSK_VECTOR_H_
 #include <stdint.h>
 #include <string.h>
 #include <stdbool.h>
 
+#pragma pack(1)
 typedef struct  vector{
     void *data;      // 数据指针
     size_t size;     // 当前元素数量
@@ -21,6 +22,8 @@ typedef struct  vector{
     size_t elem_size;// 单个元素大小
 } vector_t;
 
+#pragma pack()
+
 vector_t *vector_create(size_t elem_size, size_t initial_capacity);
 
 bool vector_destroy(vector_t *vec);
@@ -29,30 +32,30 @@ bool vector_push_back(vector_t *vec, const void *elem);
 
 bool vector_pop_back(vector_t *vec);
 
-void *vector_get(const vector_t *vec, uint32_t index);
+void *vector_get(const vector_t *vec, size_t index);
 
-bool vector_set(vector_t *vec, uint32_t index, const void *elem);   
+bool vector_set(vector_t *vec, size_t index, const void *elem);   
 
-size_t vector_size(const vector_t *vec);
+size_t vector_get_capacity(const vector_t *vec);
 
-void vector_resize(vector_t *vec, uint32_t new_size);
+bool vector_resize(vector_t *vec, size_t new_size);
 
-void vector_clear(vector_t *vec);
+bool vector_clear(vector_t *vec);
 
-void vector_shrink_to_fit(vector_t *vec);   
+bool vector_shrink_to_fit(vector_t *vec);   
 
-void vector_reserve(vector_t *vec, uint32_t new_capacity);  
+bool vector_reserve(vector_t *vec, size_t new_capacity);  
 
-void vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
+bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
 
-void vector_reverse(vector_t *vec);
+bool vector_reverse(vector_t *vec);
 
-void vector_for_each(const vector_t *vec, void (*func)(void *));
+bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index));
 
-void vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
+bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
 
-void vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), uint32_t *index);
+bool vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), size_t *index);
 
-void vector_find_if(const vector_t *vec, int (*predicate)(const void *), uint32_t *index);
+bool vector_find_if(const vector_t *vec, int (*predicate)(const void *), size_t *index);
 
 #endif // _GSK_VECTOR_H
\ No newline at end of file