C_Base_lib/vector
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: C_Base_lib:4dd77b5042890d5f16259931102e6496243c9855
Branches Tags
C_Base_lib:main
...
compare: C_Base_lib:main
Branches Tags
C_Base_lib:main

3 Commits
4dd77b5042 ... main

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
4 changed files with 277 additions and 104 deletions
Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@@ -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"
}
} }

165
src/lib/vector/vector.c
View File

@@ -32,7 +32,6 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
vec = NULL; // 确保vec为NULL以避免后续操作出现问题 vec = NULL; // 确保vec为NULL以避免后续操作出现问题
return NULL; return NULL;
} }
return vec; return vec;
} }
@@ -40,34 +39,36 @@ vector_t *vector_create(size_t elem_size, size_t initial_capacity){
* @brief 销毁容器 * @brief 销毁容器
* *
* @param vec * @param vec
* @return true
* @return false
*/ */
bool vector_destroy(vector_t *vec) { enum vector_error vector_destroy(vector_t *vec) {
if (!vec) return false; 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->data);
free(vec); free(vec);
vec = NULL; // 确保vec为NULL以避免后续操作出现问题 vec = NULL; // 确保vec为NULL以避免后续操作出现问题
return true; return VECTOR_OK;
} }
/** /**
* @brief 扩容 * @brief 扩容
* *
* @param vec * @param vec
* @return true
* @return false
*/ */
static bool _vector_extend_capacity_(vector_t *vec) { static enum vector_error _vector_extend_capacity_(vector_t *vec) {
if (!vec) return false; // 检查vec是否为NULL if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
size_t new_capacity = vec->capacity * 2; // 扩容为原来的两倍 size_t new_capacity = vec->capacity * 2; // 扩容为原来的两倍
void *new_data = realloc(vec->data, new_capacity * vec->elem_size); 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->data = new_data;
vec->capacity = new_capacity; vec->capacity = new_capacity;
return true; // 成功扩容 return VECTOR_OK; // 成功扩容
} }
/** /**
@@ -76,15 +77,13 @@ static bool _vector_extend_capacity_(vector_t *vec) {
* @param vec * @param vec
* @param index 要添加的索引，索引从0开始 * @param index 要添加的索引，索引从0开始
* @param elem 数据内容 * @param elem 数据内容
* @return true
* @return false
*/ */
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){
if (!vec || !elem || index > vec->size) return false; // 检查vec、elem是否为NULL或索引越界 if (!vec || !elem || index > vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec、elem是否为NULL或索引越界
if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容 if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
if( _vector_extend_capacity_(vec) == false) { if( _vector_extend_capacity_(vec) != VECTOR_OK) {
return false; // 扩容失败 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); // 移动元素 memmove(target + vec->elem_size, target, (vec->size - index) * vec->elem_size); // 移动元素
memcpy(target, elem, vec->elem_size); // 插入新元素 memcpy(target, elem, vec->elem_size); // 插入新元素
vec->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 vec
* @param index1 * @param index1
* @param index2 * @param index2
* @return true
* @return false
*/ */
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){
if (!vec || index1 >= vec->size || index2 >= vec->size) return false; // 检查vec是否为NULL或索引越界 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 *elem1 = (void *)vec->data + (index1 * vec->elem_size);// 获取第一个元素的指针
void *elem2 = (void *)vec->data + (index2 * 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(temp, elem1, vec->elem_size); // 交换元素
memcpy(elem1, elem2, vec->elem_size); // memcpy(elem1, elem2, vec->elem_size); //
memcpy(elem2, temp, 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 vec
* @param index * @param index
* @return true
* @return false
*/ */
bool vector_remove_at(vector_t *vec, size_t index){ enum vector_error vector_remove_at(vector_t *vec, size_t index){
if (!vec || index >= vec->size) return false; // 检查vec是否为NULL或索引越界 if (!vec || index >= vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或索引越界
void *target = vec->data + (index * vec->elem_size); void *target = vec->data + (index * vec->elem_size);
memmove(target, target + vec->elem_size, (vec->size - index - 1) * vec->elem_size); // 移动元素 memmove(target, target + vec->elem_size, (vec->size - index - 1) * vec->elem_size); // 移动元素
vec->size--; vec->size--;
return true; // 成功删除元素 return VECTOR_OK; // 成功删除元素
} }
/** /**
@@ -141,7 +136,7 @@ bool vector_remove_at(vector_t *vec, size_t index){
* @param vec * @param vec
* @return size_t * @return size_t
*/ */
size_t vector_used(const vector_t *vec){ size_t vector_size(const vector_t *vec){
if (!vec) return 0; // 检查vec是否为NULL if (!vec) return 0; // 检查vec是否为NULL
return vec->size; return vec->size;
} }
@@ -151,44 +146,40 @@ size_t vector_used(const vector_t *vec){
* *
* @param vec * @param vec
* @param elem * @param elem
* @return true
* @return false
*/ */
bool vector_push_back(vector_t *vec, const void *elem){ enum vector_error vector_push_back(vector_t *vec, const void *elem){
if (!vec || !elem) return false; // 检查vec和elem是否为NULL if (!vec || !elem) return VECTOR_ERR_NULL; // 检查vec和elem是否为NULL
if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容 if (vec->size >= vec->capacity) {// 如果当前容量不足，尝试扩容
if( _vector_extend_capacity_(vec) == false) { if( _vector_extend_capacity_(vec) != VECTOR_OK) {
return false; // 扩容失败 return VECTOR_ERR_MEMORY; // 扩容失败
} }
} }
void *target = (char *)vec->data + (vec->size * vec->elem_size); void *target = (char *)vec->data + (vec->size * vec->elem_size);
memcpy(target, elem, vec->elem_size); memcpy(target, elem, vec->elem_size);
vec->size++; vec->size++;
return true; // 成功添加元素 return VECTOR_OK; // 成功添加元素
} }
/** /**
* @brief 从容器尾部删除元素 * @brief 从容器尾部删除元素
* *
* @param vec * @param vec
* @return true
* @return false
*/ */
bool vector_pop_back(vector_t *vec){ enum vector_error vector_pop_back(vector_t *vec){
if (!vec || vec->size == 0) return false; // 检查vec是否为NULL或空 if (!vec || vec->size == 0) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或空
vec->size--; // 减少元素数量 vec->size--; // 减少元素数量
if (vec->size < vec->capacity / 4) { if (vec->size < vec->capacity / 4) {
size_t new_capacity = vec->capacity / 2; size_t new_capacity = vec->capacity / 2;
if (new_capacity < 1) new_capacity = 1; // 确保容量至少为1 if (new_capacity < 1) new_capacity = 1; // 确保容量至少为1
void *new_data = realloc(vec->data, new_capacity * vec->elem_size); 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->data = new_data;
vec->capacity = new_capacity; 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 vec
* @param index * @param index
* @param elem * @param elem
* @return true
* @return false
*/ */
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){
if (!vec || index >= vec->size || !elem) return false; // 检查vec是否为NULL、索引越界或elem为NULL if (!vec || index >= vec->size || !elem) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL、索引越界或elem为NULL
void *target = (void *)vec->data + (index * vec->elem_size);// 计算目标元素的地址 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的值复制到指定索引的元素位置 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 vec
* @param new_size * @param new_size
*/ */
bool vector_resize(vector_t *vec, size_t new_size){ enum vector_error vector_resize(vector_t *vec, size_t new_size){
if (!vec) return false; // 检查vec是否为NULL或new_size小于0 if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL或new_size小于0
if (new_size > vec->capacity) { if (new_size > vec->capacity) {
size_t new_capacity = new_size > vec->capacity * 2 ? new_size : vec->capacity * 2; 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); 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->data = new_data;
vec->capacity = new_capacity; vec->capacity = new_capacity;
} }
@@ -255,7 +244,7 @@ bool vector_resize(vector_t *vec, size_t new_size){
} }
vec->size = 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 * @param vec
*/ */
bool vector_clear(vector_t *vec){ enum vector_error vector_clear(vector_t *vec){
if (!vec) return false; // 检查vec是否为NULL if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
if (vec->size == 0) return true; // 如果向量已经为空，直接返回 if (vec->size == 0) return VECTOR_OK; // 如果向量已经为空，直接返回
vec->size = 0; // 清空向量 vec->size = 0; // 清空向量
return true; // 成功清空向量 return VECTOR_OK; // 成功清空向量
} }
/** /**
@@ -278,8 +267,8 @@ bool vector_clear(vector_t *vec){
* *
* @param vec * @param vec
*/ */
bool vector_shrink_to_fit(vector_t *vec){ enum vector_error vector_shrink_to_fit(vector_t *vec){
if (!vec) return false; // 检查vec是否为NULL if (!vec) return VECTOR_ERR_NULL; // 检查vec是否为NULL
if (vec->size < vec->capacity) { if (vec->size < vec->capacity) {
void *new_data = realloc(vec->data, vec->size * vec->elem_size); 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 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 vec
* @param new_capacity * @param new_capacity
*/ */
bool vector_reserve(vector_t *vec, size_t new_capacity){ enum vector_error vector_reserve(vector_t *vec, size_t new_capacity){
if (!vec || new_capacity < vec->size) return false; // 检查vec是否为NULL或new_capacity小于当前元素数量 if (!vec || new_capacity < vec->size) return VECTOR_ERR_MULTIPLE; // 检查vec是否为NULL或new_capacity小于当前元素数量
if (new_capacity > vec->capacity) { if (new_capacity > vec->capacity) {
void *new_data = realloc(vec->data, new_capacity * vec->elem_size); void *new_data = realloc(vec->data, new_capacity * vec->elem_size);
@@ -307,21 +296,22 @@ bool vector_reserve(vector_t *vec, size_t new_capacity){
vec->capacity = new_capacity; // 更新容量 vec->capacity = new_capacity; // 更新容量
} }
} }
return true; // 成功保留数据并扩容 return VECTOR_OK; // 成功保留数据并扩容
} }
/** /**
* @brief 排序容器中数据 * @brief 排序容器中数据
* *
* @param vec * @param vec
* @param compare * @param compare
*/ */
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 *)){
if (!vec || !compare) return false; // 检查vec是否为NULL或compare函数是否为NULL if (!vec || !compare) return VECTOR_ERR_NULL; // 检查vec是否为NULL或compare函数是否为NULL
if (vec->size == 0) return true; // 如果容器为空，直接返回 if (vec->size == 0) return VECTOR_OK; // 如果容器为空，直接返回
if (vec->size == 1) return true; // 如果容器只有一个元素，直接返回 if (vec->size == 1) return VECTOR_OK; // 如果容器只有一个元素，直接返回
qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序 qsort(vec->data, vec->size, vec->elem_size, compare); // 使用qsort对数据进行排序
return true; // 成功排序数据 return VECTOR_OK; // 成功排序数据
} }
/** /**
@@ -329,10 +319,10 @@ bool vector_sort(vector_t *vec, int (*compare)(const void *, const void *)){
* *
* @param vec * @param vec
*/ */
bool vector_reverse(vector_t *vec){ enum vector_error vector_reverse(vector_t *vec){
if (!vec) return false; // 检查vec是否为NULL 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 left = 0;
size_t right = vec->size - 1; size_t right = vec->size - 1;
@@ -346,6 +336,7 @@ bool vector_reverse(vector_t *vec){
left++; left++;
right--; right--;
} }
return VECTOR_OK; // 成功反转数据
} }
/** /**
@@ -354,16 +345,16 @@ bool vector_reverse(vector_t *vec){
* @param vec * @param vec
* @param func 回调函数，接受一个void指针作为参数 * @param func 回调函数，接受一个void指针作为参数
*/ */
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)){
if (!vec || !func) return false; // 检查vec和func是否为NULL if (!vec || !func) return VECTOR_ERR_NULL; // 检查vec和func是否为NULL
for (size_t i = 0; i < vec->size; i++) { for (size_t i = 0; i < vec->size; i++) {
void *elem = (void *)vec->data + (i * vec->elem_size); void *elem = (void *)vec->data + (i * vec->elem_size);
func(elem, i); // 调用函数处理每个元素 func(elem, i); // 调用函数处理每个元素
} }
return VECTOR_OK; // 成功遍历所有元素
} }
/** /**
* @brief 删除与 elem 匹配的元素（通过 compare 函数判断）。 * @brief 删除与 elem 匹配的元素（通过 compare 函数判断）。
* *
@@ -371,8 +362,8 @@ bool vector_for_each(const vector_t *vec, void (*func)(void *,size_t index)){
* @param elem * @param elem
* @param compare * @param compare
*/ */
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 *)){
if (!vec || !elem || !compare) return false; // 检查vec、elem和compare函数是否为NULL if (!vec || !elem || !compare) return VECTOR_ERR_NULL; // 检查vec、elem和compare函数是否为NULL
for (size_t i = 0; i < vec->size; i++) { for (size_t i = 0; i < vec->size; i++) {
void *current_elem = (void *)vec->data + (i * vec->elem_size); void *current_elem = (void *)vec->data + (i * vec->elem_size);
@@ -381,7 +372,7 @@ bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *,
vec->size--; // 减少元素数量 vec->size--; // 减少元素数量
} }
} }
return true; // 找到并删除后退出 return VECTOR_OK; // 找到并删除后退出
} }
/** /**
@@ -392,18 +383,18 @@ bool vector_remove(vector_t *vec, const void *elem, int (*compare)(const void *,
* @param compare * @param compare
* @param index * @param index
*/ */
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){
if (!vec || !elem || !compare || !index) return false; // 检查参数是否为NULL if (!vec || !elem || !compare || !index) return VECTOR_ERR_MULTIPLE; // 检查参数是否为NULL
for (size_t i = 0; i < vec->size; i++) { for (size_t i = 0; i < vec->size; i++) {
void *current_elem = (void *)vec->data + (i * vec->elem_size); void *current_elem = (void *)vec->data + (i * vec->elem_size);
if (compare(current_elem, elem) == 0) { // 如果找到匹配的元素 if (compare(current_elem, elem) == 0) { // 如果找到匹配的元素 条件可以为 > < ==
*index = i; // 设置索引 *index = i; // 设置索引
return true; // 找到后退出 return VECTOR_OK; // 找到后退出
} }
} }
*index = 0; // 如果未找到，设置索引为-1 *index = 0; // 如果未找到，设置索引为-1
return false; // 未找到满足条件的元素 return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
} }
/** /**
@@ -413,16 +404,16 @@ bool vector_find(const vector_t *vec, const void *elem, int (*compare)(const voi
* @param predicate * @param predicate
* @param index * @param 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){
if (!vec || !predicate || !index) return false; // 检查参数是否为NULL if (!vec || !predicate || !index) return VECTOR_ERR_MULTIPLE; // 检查参数是否为NULL
for (size_t i = 0; i < vec->size; i++) { for (size_t i = 0; i < vec->size; i++) {
void *current_elem = (void *)vec->data + (i * vec->elem_size); void *current_elem = (void *)vec->data + (i * vec->elem_size);
if (predicate(current_elem)) { // 如果满足条件 if (predicate(current_elem)) { // 如果满足条件
*index = i; // 设置索引 *index = i; // 设置索引
return true; // 找到后退出 return VECTOR_OK; // 找到后退出
} }
} }
*index = 0; // 如果未找到，设置索引为-1 *index = 0; // 如果未找到，设置索引为-1
return false; // 未找到满足条件的元素 return VECTOR_ERR_NOT_MATCH; // 未找到满足条件的元素
} }

47
src/lib/vector/vector.h
View File

@@ -21,41 +21,60 @@ typedef struct vector{
size_t capacity; // 总容量 size_t capacity; // 总容量
size_t elem_size;// 单个元素大小 size_t elem_size;// 单个元素大小
} vector_t; } 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() #pragma pack()
vector_t *vector_create(size_t elem_size, size_t initial_capacity); 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);
enum vector_error vector_remove_at(vector_t *vec, size_t index);
size_t vector_size(const vector_t *vec);
enum vector_error vector_push_back(vector_t *vec, const void *elem);
enum vector_error vector_pop_back(vector_t *vec);
void *vector_get(const vector_t *vec, size_t index); 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); 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 #endif // _GSK_VECTOR_H

164
src/main.c
View File

@@ -8,10 +8,170 @@
* @copyright Copyright (c) 2025 * @copyright Copyright (c) 2025
* *
*/ */
#include <stdio.h>
#include "lib/vector/vector.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() { 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; return 0;
} }