C语言-动态数组结构体-一个文件

视频【C语言数据结构 培养架构师思维】 P4-P7内容
https://www.bilibili.com/video/BV1Pb411g7bU/?share_source=copy_web&vd_source=1f125f59acec416a3d726792acdc05fd

为什么动态数组指针要这样定义void** pAddr？？？
答：我们虽然不知道具体元素的类型，但是我们可以定义一个通用的指针类型（void*），指向我们的元素的地址即可。所以我们的元素就是地址。所以我们的元素类型就是void*。所以我们的数组指针就是void**类型
参考：http://t.csdnimg.cn/QpUlp

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

//动态数组结构体
struct DynamicArray
{
    void** pAddr;       //维护在堆区真实数组指针     
    int m_capacity;     //数组容量，指可以放多少     
    int m_size;     //数组大小，指实际使用多少
};

//初始化数组 
struct DynamicArray* Init_DynamicArray(int capacity)
{
    //判断容量是否正常
    if (capacity <= 0)
    {
        return NULL;
    }

    //创建一个动态数组，类型为struct DynamicArray*，最后return给用户     
    struct DynamicArray* array = malloc(sizeof(struct DynamicArray));

    //判断内存是否申请成功
    if(array ==NULL)
    {
        return NULL;
    }
    //设置容量
    array->m_capacity = capacity;
    //设置大小
    array->m_size = 0;
    //维护在堆区的数组的指针     
    array->pAddr = malloc(sizeof(void*)*array->m_capacity);

    return array;
}

//插入功能
void Insert_DynamicArray(struct DynamicArray*array, int pos, void* data )
{
    if(array == NULL)
    {
        return ;
    }

    //判断位置
    if(pos < 0 || pos > array->m_size-1)
    {
        //位置无效，进行尾插         
        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;

    }

    //插入新数据元素     
    //从最后一个数据开始，逐个往后移动，空出pos所在位置     
    for (int i = (array->m_size)-1; i >= pos; i--)
    {
        array->pAddr[i+1] = array->pAddr[i]; 
    }

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

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

//遍历数组
//为什么这样写:void(*myForeach)(void*)....
//因为typedef void(void*) a; a* myForeach;-->void(void*)(* myForeach)-->void(* myForeach)(void*)
void Foreach_DynamicArray(struct DynamicArray*array, void(*myForeach)(void*))
{
    if(array == NULL)
    {
        return;
    }

    if(myForeach ==NULL)
    {
        return;
    }

    for(int i=0; i < array->m_size; i++)
    {
        myForeach(array->pAddr[i]);
    }
}

//删除数组中的元素，按照位置删除 
void RemoveByPos_DynamicArray(struct DynamicArray*array, int pos)
{
    if(array == NULL)
    {
        return;
    }
    //判断位置
    if(pos < 0 || pos > array->m_size-1)
    {
        pos = array->m_size;
    }
 
    //从要删除的位置往后，逐个往前移动     
    for(int i=pos; i<array->m_size-1; i++)
    {
        array->pAddr[i] = array->pAddr[i+1];
    }

    //动态数组大小-1
    array->m_size--;
}



//删除数组中的元素，按照值来删除
void RemoveByValue_DynamicArray(struct DynamicArray*array, void* data, int(*mycompare)(void* data1, void* data2))
{
    if(array == NULL)
    {
        return;
    }

    if(data == NULL)
    {
        return;
    }    

    for(int i = 0; i<array->m_size; i++)
    {
        if(mycompare(array->pAddr[i], data))
        {
            RemoveByPos_DynamicArray(array, i);
            break;
        }
    }

}


//销毁数组 
void Destory_DynamicArray(struct DynamicArray*array)
{
    if(array == NULL)
    {
        return;
    }   

    if(array->pAddr != NULL)
    {
        free(array->pAddr);
        array->pAddr = NULL;
    }
    free(array);
    array = NULL;
}


struct Person
{
    char name[64];
    int age;
};

//输出函数，用于遍历 
void MyPrintf(void* data)
{
    struct Person* p = data;
    printf("姓名：%s    年龄：%d    \n", p->name, p->age);
}

//比较函数，用于对比数值，一致返回1,不一致返回0 
int MyComparePerson(void*data1, void* data2)
{
    struct Person* p1 = data1;
    struct Person* p2 = data2;

    return (strcmp(p1->name, p2->name) == 0) && (p1->age == p2->age);
}

//测试函数
void test01()
{
    //定义动态数组并初始化容量为5
    struct DynamicArray* arr = Init_DynamicArray(5);


    struct Person p1= {"小一", 11};
    struct Person p2= {"小二", 12};
    struct Person p3= {"小三", 13};
    struct Person p4 = {"小四", 14};
    struct Person p5 = {"小五",15};
    struct Person p6 = {"小六", 16};
    struct Person p7 = {"小三", 13};
    struct Person p8 = {"小八", 18};


    printf("插入前容量：%d\n", arr->m_capacity);
    printf("//\n");

    //插入
    Insert_DynamicArray(arr, 0, &p1 );
    Insert_DynamicArray(arr, 0, &p2 );
    Insert_DynamicArray(arr, 2, &p3 );
    Insert_DynamicArray(arr, 10, &p4 );
    Insert_DynamicArray(arr, 1, &p5 );
    Insert_DynamicArray(arr, 4, &p6 );
    
    //遍历输出动态数组     
    printf("插入后的数组：\n");
    Foreach_DynamicArray(arr, *MyPrintf);//理想顺序：小二     小五    小一    小三    小六    小四  

    printf("插入后容量：%d\n", arr->m_capacity);
    printf("//\n");

    //通过位置删除，并遍历
    RemoveByPos_DynamicArray(arr, 2);    
    printf("按位置删除后的数组：\n");
    Foreach_DynamicArray(arr, *MyPrintf);//理想顺序：小二     小五     小三    小六    小四 
    printf("//\n");

    //通过值来删除，并遍历
    RemoveByValue_DynamicArray(arr, &p7, *MyComparePerson);
    printf("按值删除后的数组：\n");
    Foreach_DynamicArray(arr, *MyPrintf);//理想顺序：小二     小五    小六    小四 

    //通过值来删除，并遍历
    RemoveByValue_DynamicArray(arr, &p8, *MyComparePerson);
    printf("按值删除后的数组：\n");
    Foreach_DynamicArray(arr, *MyPrintf);//理想顺序：小二     小五    小六    小四 

    //销毁动态数组     
    Destory_DynamicArray(arr);




}


int main()
{
    test01();
    
    return 0;
}