使用结构体实现一维动态数组

#define _CRT_SECURE_NO_WARINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>

// 使用结构体实现一维动态数组
struct dynamicArray
{
    void** pAddr; //维护在内存堆区该结构体的真实数据的数组指针
    int m_capacity; // 数组容量
    int m_size; //数组大小
};

// 初始化数组(生成一个新的结构体)
struct dynamicArray* init_dynamicArray(int capacity)
{
    if (capacity <= 0) {
        return NULL;
    }
    struct dynamicArray* array = malloc(sizeof(struct dynamicArray)); //开辟堆，创建结构体
    // 判断内存是否申请成功
    if (NULL == array)
    {
        return;
    }

    array->m_capacity = capacity; //设置容量
    array->m_size = 0; //设置大小
    //维护在堆区数组的指针，该指针指向数组首元素，数组大小=元素大小*元素数目
    array->pAddr = malloc(sizeof(void*) * array->m_capacity);

    return array;
}

// 插入功能 pos是从0开始的
void insert_dynamicArray(struct dynamicArray* array, int pos, void* data)
{
    if (NULL == array) {
        return;
    }
    if (NULL == data) {
        return;
    }
    if (pos < 0 || pos > array->m_size) {
        // 无效位置 自动变为尾插
        pos = array->m_size;
    }

    // 先判断是否已经满载，如果满载，动态开辟
    if (array->m_size >= array->m_capacity) {
        // 1. 申请一个更大的内存空间 
        int newCapacity = array->m_capacity * 2;
        // 2. 创建新空间
        void** newSpace = malloc(sizeof(void*) * newCapacity);
        // 3. 将原有数据 拷贝到新空间下
        memcpy(newSpace, array->pAddr, sizeof(void*) * array->m_capacity);
        // 4. 释放原空间
        free(array->pAddr);
        // 5.更改指针指向
        array->pAddr = newSpace;
        // 6.更新容量大小
        array->m_capacity = newCapacity;
    }

    // 插入新数据元素
    // 从最后一个位置开始，依次移动数据  后移

    for (int i = array->m_size - 1; i >= pos; i--) {
        array->pAddr[i + 1] = array->pAddr[i];
    }

    // 将新元素插入到指定位置
    array->pAddr[pos] = data;

    // 更新大小
    array->m_size++;

}

// 遍历数组 第二个参数myForeach是void类型的函数指针,用来打印数组中的数据(不同的数据类型打印方式不同)
void foreach_dynamicArray(struct dynamicArray* array, void(*myForeach)(void*))
{
    if (NULL == array) {
        return;
    }
    if (NULL == myForeach) {
        return;
    }
    for (int i = 0; i < array->m_size; i++) {
        myForeach(array->pAddr[i]);
    }
}
// 测试的一个结构体
struct Person
{
    char name[64];
    int age;
};

void myPrintPerson(void* data) {
    struct Person* p = data;
    printf("姓名：%s 年龄：%d\n", p->name, p->age);
}

void test01()
{
    // 创建动态数组
    struct dynamicArray* arr = init_dynamicArray(5);
    // 准备5个数据 和一个多余的数据，超过了初始capacity 5
    struct Person p1 = { "亚瑟1", 18 };
    struct Person p2 = { "亚瑟2", 181 };
    struct Person p3 = { "亚瑟3", 182 };
    struct Person p4 = { "亚瑟44", 183 };
    struct Person p5 = { "亚瑟5", 184 };
    struct Person p6 = { "亚瑟6", 185 };


    // 将数据插入到动态数组中
    insert_dynamicArray(arr, 0, &p1);
    insert_dynamicArray(arr, -1, &p2);
    insert_dynamicArray(arr, -1, &p3);
    insert_dynamicArray(arr, 0, &p4);
    insert_dynamicArray(arr, 6, &p5);
    insert_dynamicArray(arr, 0, &p6);

    // 遍历动态数组
    foreach_dynamicArray(arr, myPrintPerson);
}


int main() {
    test01();
    system("pause");
    return EXIT_SUCCESS;
}