重构

Foundation/c_Array.c

@@ -1,114 +1,70 @@
 #include <c_Array.h>
-#include <c_Memory.h>
 
-c_err_t c_Array_Init(c_Array_t* array, c_size_t length, c_size_t size) {
-    if (!array) return C_ERR_PARAM;
+c_err_t c_Array_Init(c_Array_t* self, c_size_t item_size, c_size_t size, c_Allocator_t* allocator) {
+    if (!self || item_size == 0 || size == 0) return C_ERR_PARAM;
 
-    array->length = length;
-    array->size = size;
-    if (length>0) {
-        array->array = C_CALLOC(length, size);
-        if (!array->array) {
-            return C_ERR_NOMEM;
-        }
-    }else {
-        array->array = NULL;
+    // 内部绑定：如果传入 NULL，无缝降级为系统默认分配器
+    self->allocator = (allocator != NULL) ? *allocator : c_DefaultAllocator;
+    self->item_size = item_size;
+    self->size = size;
+
+    // 通过内部绑定的分配器，一次性开辟完全密集且等长的字节存储空间
+    self->array = c_Allocator_Alloc(&self->allocator, self->size * self->item_size);
+    if (!self->array) return C_ERR_NOMEM;
+
+    // 默认执行干净抹零
+    memset(self->array, 0, self->size * self->item_size);
+    return C_ERR_OK;
+}
+
+// 销毁固定数组资源
+void c_Array_Destroy(c_Array_t* self) {
+    if (!self) return;
+    if (self->array) {
+        c_Allocator_Free(&self->allocator, self->array);
+        self->array = NULL;
     }
+    self->size = 0;
+}
+
+// 定点安全写入 (深度值复制)
+c_err_t c_Array_Write(c_Array_t* self, c_size_t index, const void* item) {
+    // 强御级边界防御：拦截一切非法越界或空域写入
+    if (!self || !item || index >= self->size) return C_ERR_PARAM;
+
+    // 计算精准的物理坑位物理地址并执行覆写
+    char* target = (char*)self->array + (index * self->item_size);
+    memcpy(target, item, self->item_size);
 
     return C_ERR_OK;
 }
 
-void c_Array_Destroy(c_Array_t* array) {
-    if (!array) return;
-    C_FREE(array->array);
-    array->size = 0;
-    array->length = 0;
-}
+// 定点安全读取 (安全拷出副本)
+c_err_t c_Array_Read(const c_Array_t* self, c_size_t index, void* out_item) {
+    if (!self || !out_item || index >= self->size) return C_ERR_PARAM;
 
-c_Array_t* c_Array_New(c_size_t length, c_size_t size) {
-    c_Array_t* array;
-    C_NEW(array);
-    if (!array) {
-        return NULL;
-    }
-    c_Array_Init(array, length, size);
-    return array;
-}
+    const char* source = (const char*)self->array + (index * self->item_size);
+    memcpy(out_item, source, self->item_size);
 
-void c_Array_Delete(c_Array_t** array) {
-    if (!array || !*array) return;
-    C_FREE((*array)->array);
-    C_FREE(*array);
-}
-
-c_size_t c_Array_Size(c_Array_t* array) {
-    if (!array) return 0;
-    return array->size;
-}
-
-c_size_t c_Array_Length(c_Array_t* array) {
-    if (!array) return 0;
-    return array->length;
-}
-
-c_err_t c_Array_Get(c_Array_t* array, c_size_t index, void** data) {
-    if (!array || (index >= array->length) || !data) return C_ERR_PARAM;
-    *data = array->array + index * array->size;
     return C_ERR_OK;
 }
 
-c_err_t c_Array_Put(c_Array_t* array, c_size_t index, void* value) {
-    if (!array || !value || (index>=array->length)) return C_ERR_PARAM;
-    memcpy(array->array + index * array->size, value, array->size);
+// 只读原位窥探指针 (注意：因为大小固定，该指针在数组生命周期内绝对不可变、不跑飞，极度安全)
+void* c_Array_Get(const c_Array_t* self, c_size_t index) {
+    if (!self || index >= self->size) return NULL;
+    return (char*)self->array + (index * self->item_size);
+}
+
+// 全局高速批量刷值填充 (常用于初始化状态、重置音频轨等)
+c_err_t c_Array_Fill(c_Array_t* self, const void* item) {
+    if (!self || !item) return C_ERR_PARAM;
+
+    // 利用连续线性空间的特点，高速循环平铺拷贝
+    char* target = (char*)self->array;
+    for (c_size_t i = 0; i < self->size; i++) {
+        memcpy(target, item, self->item_size);
+        target += self->item_size;
+    }
+
     return C_ERR_OK;
 }
-
-c_err_t c_Array_Resize(c_Array_t* array, c_size_t length) {
-    if (!array) return C_ERR_PARAM;
-    if (length==0) {
-        C_FREE(array->array);
-    }else if (array->length==0) {
-        array->array = C_ALLOC(length*array->size);
-        if (!array->array) {
-            return C_ERR_NOMEM;
-        }
-    }else {
-        array->array = C_REALLOC(array->array, length*array->size);
-        if (!array->array) {
-            return C_ERR_NOMEM;
-        }
-    }
-    array->length = length;
-    return C_ERR_OK;
-}
-
-c_Array_t* c_Array_Copy(c_Array_t* array, c_size_t length) {
-    if (!array || length==0) return NULL;
-    c_Array_t* result;
-    C_NEW(result);
-    if (!result) {
-        return NULL;
-    }
-    c_Array_Init(result, length, array->size);
-
-    if (result->length >= array->length && array->length > 0) {
-        memcpy(result->array, array->array, array->length * array->size);
-    }else if (array->length > result->length && result->length > 0) {
-        memcpy(result->array, array->array, result->length * array->size);
-    }
-
-    return result;
-}
-
-c_err_t c_Array_CopyTo(const c_Array_t* array, c_Array_t* copy) {
-    if (!array || !copy) return C_ERR_PARAM;
-    if (copy->length >= array->length && array->length > 0) {
-        memcpy(copy->array, array->array, array->length * array->size);
-        return C_ERR_OK;
-    }else if (array->length > copy->length && copy->length > 0) {
-        memcpy(copy->array, array->array, copy->length * array->size);
-        return C_ERR_OK;
-    }
-    return C_ERR_FAIL;
-}
-