添加多种错误返回类型

更正函数名称
增加测试函数
2025-08-22 16:21:37 +08:00 · 2025-08-21 22:21:37 +08:00 · 2025-08-21 22:01:44 +08:00 · 2025-08-21 21:20:20 +08:00 · 2025-08-19 22:20:44 +08:00
4 changed files with 388 additions and 97 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,6 @@
 {
-    "C_Cpp.default.compilerPath": "/usr/bin/g++-14"
+    "C_Cpp.default.compilerPath": "/usr/bin/g++-14",
+    "files.associations": {
+        "stdio.h": "c"
+    }
 }
--- a/src/lib/vector/vector.c
+++ b/src/lib/vector/vector.c
@@ -11,6 +11,13 @@
 #include "vector.h"
 #include <stdlib.h>

+/**
+ * @brief 创建新的数组容器
+ * 
+ * @param elem_size 
+ * @param initial_capacity 
+ * @return vector_t* 
+ */
 vector_t *vector_create(size_t elem_size, size_t initial_capacity){
    vector_t *vec = malloc(sizeof(vector_t));
    if (!vec) return NULL;
@@ -21,72 +28,158 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
    vec->capacity = initial_capacity > 0 ? initial_capacity : 1;
    vec->data = malloc(vec->capacity * elem_size);
    if (!vec->data) {
-        free(vec);
+        free(vec);//内存初始化失败，释放vec
+        vec = NULL; // 确保vec为NULL以避免后续操作出现问题
        return NULL;
    }
-
    return vec;
 }

-bool vector_destroy(vector_t *vec) {
-    if (vec) {
-        if (!vec->data) {//虽然data指针可能为NULL，但内存可以被释放
-            free(vec);
-            return true;
+/**
+ * @brief 销毁容器
+ * 
+ * @param vec 
+ */
+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);
-        return true;
-    }
-    return false;
+    vec = NULL; // 确保vec为NULL以避免后续操作出现问题
+    return VECTOR_OK;
 }

+/**
+ * @brief 扩容
+ * 
+ * @param vec 
+ */
+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 VECTOR_ERR_NULL; // 内存分配失败
+
+    vec->data = new_data;
+    vec->capacity = new_capacity;
+    return VECTOR_OK; // 成功扩容
+}

 /**
- * @brief 向向量末尾添加元素
+ * @brief 向指定索引位置添加元素
+ * 
+ * @param vec 
+ * @param index 要添加的索引，索引从0开始
+ * @param elem 数据内容
+ */
+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) != VECTOR_OK) {
+            return VECTOR_ERR_MEMORY; // 扩容失败
+        }
+    }
+
+    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 VECTOR_OK; // 成功添加元素
+}
+
+/**
+ * @brief 交换指定索引位置的两个元素
+ * 
+ * @param vec 
+ * @param index1 
+ * @param index2 
+ */
+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 VECTOR_OK; // 如果索引相同，无需交换
+
+    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 VECTOR_OK; // 成功交换元素
+}
+
+/**
+ * @brief 删除指定索引位置的元素
+ * 
+ * @param vec 
+ * @param index 
+ */
+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 VECTOR_OK; // 成功删除元素
+}
+
+/**
+ * @brief 获取容器已使用的元素数量
+ * 
+ * @param vec 
+ * @return size_t 
+ */
+size_t vector_size(const vector_t *vec){
+    if (!vec) return 0; // 检查vec是否为NULL
+    return vec->size;
+}
+
+/**
+ * @brief 向容器末尾添加元素
 * 
 * @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) {
-        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) != 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 
+ * @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--;
+    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 && new_capacity > 0) return false; // 内存分配失败
+        if (!new_data) return VECTOR_ERR_MEMORY; // 内存分配失败
        vec->data = new_data;
        vec->capacity = new_capacity;
    }
-    return true; // 成功删除元素
+    return VECTOR_OK; // 成功删除元素

 }

@@ -97,7 +190,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); // 返回指定索引的元素指针
@@ -109,26 +202,24 @@ void *vector_get(const vector_t *vec, uint32_t index){
 * @param vec 
 * @param index 
 * @param elem 
- * @return true 
- * @return false 
 */
-bool vector_set(vector_t *vec, uint32_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;
 }

 /**
- * @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; // 返回当前元素数量
 }

 /**
@@ -137,13 +228,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
+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; // 内存分配失败
+        if (!new_data) return VECTOR_ERR_NULL; // 内存分配失败
        vec->data = new_data;
        vec->capacity = new_capacity;
    }
@@ -153,6 +244,7 @@ void vector_resize(vector_t *vec, uint32_t new_size){
    }

    vec->size = new_size; // 更新当前元素数量
+    return VECTOR_OK; // 成功调整大小
 }

 /**
@@ -160,11 +252,14 @@ void vector_resize(vector_t *vec, uint32_t new_size){
 * 
 * @param vec 
 */
-void vector_clear(vector_t *vec){
-    if (!vec) return; // 检查vec是否为NULL
+enum vector_error vector_clear(vector_t *vec){
+    if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
+
+    if (vec->size == 0) return VECTOR_OK; // 如果向量已经为空，直接返回

    vec->size = 0; // 清空向量
-    memset(vec->data, 0, vec->capacity * vec->elem_size); // 可选：将数据区域清零
+
+    return VECTOR_OK; // 成功清空向量
 }

 /**
@@ -172,16 +267,17 @@ void vector_clear(vector_t *vec){
 * 
 * @param vec 
 */
-void vector_shrink_to_fit(vector_t *vec){
-    if (!vec) return; // 检查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);
        if (new_data) {
            vec->data = new_data;
-            vec->capacity = vec->size; // 更新容量为当前元素数量
+            vec->capacity = vec->size; // 更新容量为当前元素数量b ve
        }
    }
+    return VECTOR_OK; // 成功调整内存大小
 }

 /**
@@ -190,8 +286,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小于当前元素数量
+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);
@@ -200,26 +296,33 @@ void vector_reserve(vector_t *vec, uint32_t new_capacity){
            vec->capacity = new_capacity; // 更新容量
        }
    }
+    return VECTOR_OK; // 成功保留数据并扩容
 }
+
 /**
 * @brief 排序容器中数据
 * 
 * @param vec 
 * @param compare 
 */
-void vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
-    if (!vec || !compare) return; // 检查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 VECTOR_OK; // 如果容器为空，直接返回
+    if (vec->size == 1) return VECTOR_OK; // 如果容器只有一个元素，直接返回
    qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序  
+    return VECTOR_OK; // 成功排序数据  
 }

 /**
- * @brief 
+ * @brief 反转容器中的数据
 * 
 * @param vec 
 */
-void vector_reverse(vector_t *vec){
-    if (!vec) return; // 检查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 VECTOR_OK; // 如果容器为空或只有一个元素，直接返回

    size_t left = 0;
    size_t right = vec->size - 1;
@@ -233,6 +336,7 @@ void vector_reverse(vector_t *vec){
        left++;
        right--;
    }
+    return VECTOR_OK; // 成功反转数据
 }

 /**
@@ -241,34 +345,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
+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); // 调用函数处理每个元素
+        func(elem, i); // 调用函数处理每个元素
    }
+    return VECTOR_OK; // 成功遍历所有元素
 }

-
 /**
- * @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
+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);
        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 VECTOR_OK; // 找到并删除后退出
 }

 /**
@@ -279,17 +383,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
+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) { // 如果找到匹配的元素
+        if (compare(current_elem, elem) == 0) { // 如果找到匹配的元素 条件可以为 > < ==
            *index = i; // 设置索引
-            return; // 找到后退出
+            return VECTOR_OK; // 找到后退出
        }
    }
-    *index = -1; // 如果未找到，设置索引为-1
+    *index = 0; // 如果未找到，设置索引为-1
+    return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
 }

 /**
@@ -299,15 +404,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
+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; // 找到后退出
+            return VECTOR_OK; // 找到后退出
        }
    }
-    *index = -1; // 如果未找到，设置索引为-1
+    *index = 0; // 如果未找到，设置索引为-1
+    return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
 }
--- a/src/lib/vector/vector.h
+++ b/src/lib/vector/vector.h
@@ -8,51 +8,73 @@
 * @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;     // 当前元素数量
    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_push_back(vector_t *vec, const void *elem); 
+enum vector_error vector_add_at(vector_t *vec, size_t index, const void *elem);

-bool vector_pop_back(vector_t *vec);
+enum vector_error vector_swap(vector_t *vec, size_t index1, size_t index2);

-void *vector_get(const vector_t *vec, uint32_t index);
-
-bool vector_set(vector_t *vec, uint32_t index, const void *elem);   
+enum vector_error vector_remove_at(vector_t *vec, size_t index);

 size_t vector_size(const vector_t *vec);

-void vector_resize(vector_t *vec, uint32_t new_size);
+enum vector_error vector_push_back(vector_t *vec, const void *elem); 

-void vector_clear(vector_t *vec);
+enum vector_error vector_pop_back(vector_t *vec);

-void vector_shrink_to_fit(vector_t *vec);   
+void *vector_get(const vector_t *vec, size_t index);

-void vector_reserve(vector_t *vec, uint32_t new_capacity);  
+enum vector_error vector_set(vector_t *vec, size_t index, const void *elem);   

-void vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
+size_t vector_get_capacity(const vector_t *vec);

-void vector_reverse(vector_t *vec);
+enum vector_error vector_resize(vector_t *vec, size_t new_size);

-void vector_for_each(const vector_t *vec, void (*func)(void *));
+enum vector_error vector_clear(vector_t *vec);

-void vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
+enum vector_error vector_shrink_to_fit(vector_t *vec);   

-void vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, const void *), uint32_t *index);
+enum vector_error vector_reserve(vector_t *vec, size_t new_capacity);  

-void vector_find_if(const vector_t *vec, int (*predicate)(const void *), uint32_t *index);
+enum vector_error vector_sort(vector_t *vec, int (*compare)(const void *, const void *));
+
+enum vector_error vector_reverse(vector_t *vec);
+
+enum vector_error vector_for_each(const vector_t *vec, void (*func)(void *,size_t index));
+
+enum vector_error vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *, const void *));
+
+enum vector_error vector_find(const vector_t *vec, const void *elem, int (*compare)(const void *, 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
--- a/src/main.c
+++ b/src/main.c
@@ -8,10 +8,170 @@
 * @copyright Copyright (c) 2025
 * 
 */
-#include <stdio.h>
 #include "lib/vector/vector.h"
+#include <stdio.h>
+#include <string.h>
+
+// 测试用的结构体
+typedef struct {
+    int id;
+    char name[20];
+    float score;
+} Student;
+
+// 比较函数
+int compare_students(const void *a, const void *b) {
+    const Student *sa = (const Student *)a;
+    const Student *sb = (const Student *)b;
+    return sa->id - sb->id;
+}
+
+// 谓词函数
+int is_high_score(const void *a) {
+    const Student *s = (const Student *)a;
+    return s->score >= 90.0f;
+}
+
+// 遍历打印函数
+void print_student(void *elem, size_t index) {
+    Student *s = (Student *)elem;
+    printf("[%zu] ID: %d, Name: %s, Score: %.1f\n", 
+           index, s->id, s->name, s->score);
+}

 int main() {
-    vector_t *vec = vector_create(sizeof(int), 10);
+    printf("=== 开始测试 vector 实现 ===\n\n");
+    
+    // 测试 vector_create
+    printf("1. 测试 vector_create...\n");
+    vector_t *students = vector_create(sizeof(Student), 2);
+    if (!students) {
+        printf("创建 vector 失败!\n");
+        return -1;
+    }
+    printf("创建成功, 初始容量: %zu\n", vector_get_capacity(students));
+    
+    // 测试 vector_push_back
+    printf("\n2. 测试 vector_push_back...\n");
+    Student s1 = {101, "Alice", 85.5f};
+    Student s2 = {102, "Bob", 92.0f};
+    Student s3 = {103, "Charlie", 78.5f};
+    Student s4 = {104, "David", 95.0f};
+    
+    vector_push_back(students, &s1);
+    vector_push_back(students, &s2);
+    vector_push_back(students, &s3);  // 这里应该触发扩容
+    printf("添加3个学生后, 容量: %zu, 大小: %zu\n", 
+           vector_get_capacity(students), vector_size(students));
+    
+    // 测试 vector_get
+    printf("\n3. 测试 vector_get...\n");
+    Student *ps = (Student *)vector_get(students, 1);
+    printf("索引1的学生: ID=%d, Name=%s\n", ps->id, ps->name);
+    
+    // 测试 vector_set
+    printf("\n4. 测试 vector_set...\n");
+    strcpy(s2.name, "Robert");
+    vector_set(students, 1, &s2);
+    ps = (Student *)vector_get(students, 1);
+    printf("修改后索引1的学生: Name=%s\n", ps->name);
+    
+    // 测试 vector_add_at
+    printf("\n5. 测试 vector_add_at...\n");
+    vector_add_at(students, 1, &s4);
+    printf("在索引1插入新学生后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_remove_at
+    printf("\n6. 测试 vector_remove_at...\n");
+    vector_remove_at(students, 0);
+    printf("删除索引0后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_swap
+    printf("\n7. 测试 vector_swap...\n");
+    vector_swap(students, 0, 1);
+    printf("交换索引0和1后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_pop_back
+    printf("\n8. 测试 vector_pop_back...\n");
+    vector_pop_back(students);
+    printf("弹出最后一个元素后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_sort
+    printf("\n9. 测试 vector_sort...\n");
+    vector_push_back(students, &s1);
+    vector_push_back(students, &s3);
+    printf("排序前:\n");
+    vector_for_each(students, print_student);
+    vector_sort(students, compare_students);
+    printf("按ID排序后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_reverse
+    printf("\n10. 测试 vector_reverse...\n");
+    vector_reverse(students);
+    printf("反转后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_find
+    printf("\n11. 测试 vector_find...\n");
+    size_t 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);
+    }
+    
+    // 测试 vector_find_if
+    printf("\n12. 测试 vector_find_if...\n");
+    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 {
+        printf("未找到高分学生\n");
+    }
+    
+    // 测试 vector_remove
+    printf("\n13. 测试 vector_remove...\n");
+    vector_remove(students, &s1, compare_students);
+    printf("删除ID为%d的学生后:\n", s1.id);
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_resize
+    printf("\n14. 测试 vector_resize...\n");
+    vector_resize(students, 5);
+    printf("调整大小为5后:\n");
+    vector_for_each(students, print_student);
+    
+    // 测试 vector_clear
+    printf("\n15. 测试 vector_clear...\n");
+    vector_clear(students);
+    printf("清空后大小: %zu\n", vector_size(students));
+    
+    // 测试 vector_shrink_to_fit
+    printf("\n16. 测试 vector_shrink_to_fit...\n");
+    vector_push_back(students, &s1);
+    vector_push_back(students, &s2);
+    printf("添加2个学生后, 容量: %zu\n", vector_get_capacity(students));
+    vector_shrink_to_fit(students);
+    printf("shrink_to_fit后, 容量: %zu\n", vector_get_capacity(students));
+    
+    // 测试 vector_reserve
+    printf("\n17. 测试 vector_reserve...\n");
+    vector_reserve(students, 10);
+    printf("预留10个容量后, 容量: %zu\n", vector_get_capacity(students));
+    
+    // 测试 vector_destroy
+    printf("\n18. 测试 vector_destroy...\n");
+    if (vector_destroy(students) == VECTOR_OK) {
+        printf("销毁成功\n");
+    } else {
+        printf("销毁失败\n");
+    }
+    
+    printf("\n=== 测试完成 ===\n");
    return 0;
 }
Author	SHA1	Message	Date
guishenking	820e4021f5	添加多种错误返回类型	2025-08-22 16:21:37 +08:00
guishenking	1b0063f090	更正函数名称增加测试函数	2025-08-21 22:21:37 +08:00
guishenking	b139803461	移除多余判断条件。	2025-08-21 22:01:44 +08:00
guishenking	4dd77b5042	修改函数名，去除vector_resize多余的数据检查,添加以下功能插入元素到指定位置删除指定位置的元素交换两个元素的位置获取容器的容量修改函数返回类型新增数据对齐（四字节）	2025-08-21 21:20:20 +08:00
guishenking	34b6a52d5d	优化容器创建逻辑	2025-08-19 22:20:44 +08:00