泛型動態(tài)數(shù)組.jpg

泛型實現(xiàn)思路：萬能指針void *
動態(tài)數(shù)組實現(xiàn)思路：動態(tài)進行數(shù)組內存的擴容 realloc

泛型動態(tài)數(shù)組

數(shù)組可以存放C語言中任意數(shù)據(jù)類型的數(shù)據(jù)，包括自定義的結構體數(shù)據(jù)，數(shù)組容量會自動動態(tài)分配。

注:本文使用的IDE為Xcode,若別的IDE運行有問題，請自行稍加修改。

附上源碼: 泛型動態(tài)數(shù)組源碼
https://github.com/chenfanfang/data_structure

array.h 頭文件

//
//  array.h
//  data_structure
//
//  Created by chenfanfang on 2019/8/27.
//  Copyright ? 2019 chenfanfang. All rights reserved.
//

#ifndef array_h
#define array_h


#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

typedef struct array array;


//創(chuàng)建數(shù)組
array *array_create(void);

//判斷數(shù)組是否為空數(shù)組
bool array_is_empty(array *arr);

//獲取數(shù)組的長度
int array_length(array *arr);

//獲取數(shù)組中指定下標的元素
void *array_get_value_of_index(array *arr, int index);

//獲取數(shù)組中第一個元素
void *array_get_first_value(array *arr);

//獲取數(shù)組中最后一個元素
void *array_get_last_value(array *arr);

//往數(shù)組中添加元素【添加至尾部】
void array_add_value(array *arr, void *const data);

//往數(shù)組中指定位置插入元素
void array_insert_value_at_index(array *arr, int index, void *const data);

//移除數(shù)組中指定位置的元素
void array_remove_at_index(array *arr, int index);

//銷毀數(shù)組、釋放內存
void array_destroy(array *arr);


#endif /* array_h */

array.c 函數(shù)實現(xiàn)

//
//  array.c
//  data_structure
//
//  Created by chenfanfang on 2019/8/27.
//  Copyright ? 2019 chenfanfang. All rights reserved.
//

#include "array.h"
#include <assert.h>
#include <stdbool.h>
#include <string.h>


struct array{
    
    unsigned int capacity; //數(shù)組的容量，不夠可以自動進行擴容
    unsigned int length;   //當前數(shù)組中擁有數(shù)據(jù)的個數(shù)
    void **elements;
};

//判斷數(shù)組是否需要擴容
void array_judge_capacity_is_enough(array *arr) {
    
    if (arr->length == arr->capacity) {
        arr->capacity = arr->capacity * 1.5;
        arr->elements = realloc(arr->elements, arr->capacity * sizeof(void *));
    }
}

//判斷下標的合法性
void array_check_index(array *arr, int index) {
    
    if (index < 0 || index > arr->length - 1) {
        if (arr->length == 0) {
            printf("\n\n空數(shù)組越界:index:%d\n\n",index);
        }
        else {
            printf("\n\n數(shù)組越界 index:%d  range:[0  %d]\n\n",index, arr->length - 1);
        }
        
        assert(false);
    }
}

array *array_create(void) {
    
    array *array = calloc(1, sizeof(array));
    array->capacity = 10;
    array->length = 0;
    array->elements = calloc(array->capacity, sizeof(void *));
    return array;
}

bool array_is_empty(array *arr) {
    return arr->length == 0;
}

int array_length(array *arr) {
    return arr->length;
}

void *array_get_value_of_index(array *arr, int index) {
    array_check_index(arr, index);
    return arr->elements[index];
}

void *array_get_first_value(array *arr) {
    return array_get_value_of_index(arr, 0);
}

void *array_get_last_value(array *arr) {
    
    return array_get_value_of_index(arr, arr->length - 1);
}

void array_add_value(array *arr, void *const data) {
    
    array_insert_value_at_index(arr, arr->length, data);
}

void array_insert_value_at_index(array *arr, int index, void *const data) {
    
    array_judge_capacity_is_enough(arr);
    
    if (index != arr->length) {
        array_check_index(arr, index);
    }
    
    arr->length = arr->length + 1;
    for (int i = arr->length - 1; i > index; i--) {
        arr->elements[i] = arr->elements[i - 1];
    }
    
    arr->elements[index] = data;
}

void array_remove_at_index(array *arr, int index) {
    
    array_check_index(arr, index);
    
    void *element = arr->elements[index];
    free(element);
    
    for (int i = index; i < arr->length - 1; i++) {
        arr->elements[i] = arr->elements[i + 1];
    }
    
    arr->length = arr->length - 1;
    
}

void array_destroy(array *arr) {
    for (int i = 0; i < arr->length; i++) {
        free(arr->elements[i]);
    }
    free(arr->elements);
    free(arr);
}

測試用例1

//測試：數(shù)組存放自定義結構體
void test_array_struct(void) {
    
    struct custom_data {
        int value;
    };
    
    size_t custom_data_size = sizeof(struct custom_data);
    
    array *arr = array_create();
    
    //=======================
    //       添加元素
    //=======================
    for (int i = 0; i < 21; i++) {
        struct custom_data *data = malloc(custom_data_size);
        data->value = i;
        array_add_value(arr, data);
    }
    //0、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20、
    
    
    //=======================
    //       插入元素
    //=======================
    struct custom_data *insert_data = malloc(custom_data_size);
    insert_data->value = 999;
    array_insert_value_at_index(arr, 1, insert_data);
    // 0、999、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20
    
    
    //=======================
    //       移除元素
    //=======================
    array_remove_at_index(arr, 0);
    //999、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20
    
    
    //=======================
    //       獲取元素
    //=======================
    printf("test_array_struct\n\n");
    for (int i = 0; i < array_length(arr); i++) {
        
        struct custom_data *data = array_get_value_of_index(arr, i);
        printf("%d、",data->value);
    }
    
    printf("\n\n");
    array_destroy(arr);
    
}

測試用例2

//測試：數(shù)組存放基本數(shù)據(jù)類型 int
void test_array_int(void) {
    
    size_t int_size = sizeof(int);
    
    array *arr = array_create();
    
    //=======================
    //       添加元素
    //=======================
    for (int i = 0; i < 21; i++) {
        int *data = malloc(int_size);
        *data = i;
        array_add_value(arr, data);
    }
    //0、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20、
    
    
    //=======================
    //       插入元素
    //=======================
    int *insert_data = malloc(int_size);
    *insert_data = 999;
    array_insert_value_at_index(arr, 1, insert_data);
    // 0、999、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20
    
    
    //=======================
    //       移除元素
    //=======================
    array_remove_at_index(arr, 0);
    //999、1、2、3、4、5、6、7、8、9、10、11、12、13、14、15、16、17、18、19、20
    
    
    //=======================
    //       獲取元素
    //=======================
    printf("test_array_int\n\n");
    for (int i = 0; i < array_length(arr); i++) {
        
        int *data = array_get_value_of_index(arr, i);
        printf("%d、",*data);
    }
    
    printf("\n\n");
    array_destroy(arr);
}