结构设计

在堆区申请一个存放指针的数组，数组中的指针指向的元素就是实际的数据。

  1. typedef struct {
  2.     void** pArray;
  3.     int length;
  4.     int size;
  5. } DynamicArray;

初始化

初始化开辟一个结构体来记录动态数组的信息，之后我们通过结构体来使用和观察动态数组，利用 void* 来接受任意数据的指针。

  1. DynamicArray* init(int length) {
  2.     if (length <= 0) return NULL;
  3.     DynamicArray* array = (DynamicArray*)malloc(sizeof(DynamicArray));
  4.     if (array == NULL) return NULL;
  5.     array->pArray = (void**)malloc(sizeof(void*) * length);
  6.     if (array->pArray == NULL) return NULL;
  7.     array->length = length;
  8.     array->size = 0;
  9.     return array;
  10. }

插入

  1. void insert(DynamicArray* array, void* data, int index) {
  2.     if (array == NULL) return;
  3.     if (data == NULL) return;
  4.     if (index < 0 || index >(array->size)) index = array->size;
  6.     if (array->size >= array->length) {
  7.         int newLength = array->length * 2;
  8.         void** newpArray = (void**)malloc(sizeof(void*) * newLength);
  9.         if (newpArray == NULL) return;
  10.         memcpy(newpArray, array->pArray, sizeof(void*) * array->length);
  11.         free(array->pArray);
  12.         array->pArray = newpArray;
  13.         array->length = newLength;
  14.     }
  16.     for (int i = array->size - 1; i >= index; i--) {
  17.         array->pArray[i + 1] = array->pArray[i];
  18.     }
  20.     array->pArray[index] = data;
  21.     array->size += 1;
  22. }

遍历

对数组的每个元素执行一遍 callback 函数

  1. void travel(DynamicArray * array, void callback(void*)) {
  2.     if (array == NULL)return;
  3.     for (int i = 0; i < array->size; i++) {
  4.         callback(array->pArray[i]);
  5.     }
  6. }

写 callback 函数时，要对 data 进行类型转换，转换为数组元素的类型。

  1. void myPrintf(void* data) {
  2.     Persion* persion = (Persion*)data;
  3.     printf("%s,%d\n", persion->name, persion->age);
  4. }

删除

  1. void remove(DynamicArray* array, int index) {
  2.     if (array == NULL) return;
  3.     if (index < 0 || index > array->size) return;
  4.     for (int i = index; i < array->size; i++) {
  5.         array->pArray[i] = array->pArray[i + 1];
  6.     }
  7.     array->size -= 1;
  8. }

销毁

内部真实数据如果是在堆区建立的话那么由用户 travel 释放。不释放使用者建立的数据。

  1. void destory(DynamicArray* array) {
  2.     if (array == NULL) return;
  3.     if (array->pArray != NULL) {
  4.         free(array->pArray);
  5.         array->pArray = NULL;
  6.     }
  7.     free(array);
  8.     array = NULL;
  9. }

测试

  1. typedef struct {
  2.     char name[64];
  3.     int age;
  4. } Persion;
  6. void myPrintf(void* data) {
  7.     Persion* persion = (Persion*)data;
  8.     printf("%s,%d\n", persion->name, persion->age);
  9. }
  11. int main() {
  12.     DynamicArray * arr = init(2);
  13.     Persion p1 = {"AA", 11};
  14.     Persion p2 = { "BB", 22 };
  15.     Persion p3 = { "CC", 33 };
  16.     Persion p4 = { "DD", 44 };
  17.     Persion p5 = { "EE", 55 };
  18.     Persion p6 = { "FF", 66 };
  20.     insert(arr, &p1, 0);
  21.     insert(arr, &p2, 1);
  22.     insert(arr, &p3, 2);
  23.     insert(arr, &p4, 3);
  24.     insert(arr, &p5, 4);
  25.     insert(arr, &p6, 0);
  26.     travel(arr, myPrintf);
  28.     puts("remove index = 1");
  29.     remove(arr, 1);
  30.     travel(arr, myPrintf);
  32.     puts("insert index = 6 AA");
  33.     insert(arr, &p1, 6);
  34.     travel(arr, myPrintf);
  35. }
  1. FF,66
  2. AA,11
  3. BB,22
  4. CC,33
  5. DD,44
  6. EE,55
  8. remove index = 1
  10. FF,66
  11. BB,22
  12. CC,33
  13. DD,44
  14. EE,55
  16. insert index = 6 AA
  18. FF,66
  19. BB,22
  20. CC,33
  21. DD,44
  22. EE,55
  23. AA,11