C语言之数组的实现

#include <stdio.h>
#include <stdlib.h> //包含了malloc
#include <stdlib.h> //包含了exit

#define bool int

struct Arr {
    int *pBase; //数组第一个元素的地址
    int len; //元素个数
    int cnt; //当前数组有效元素的个数
//    int increment; //自动增长因子
};

void init_arr(struct Arr *array, int len);
bool append_arr(struct Arr *array, int value);
bool insert_arr(struct Arr *array, int pos, int value);
bool delete_arr(struct Arr *array, int pos, int *pValue);
//bool get();
bool is_empty(struct Arr *array);
bool is_full(struct Arr *array);
//void sort_arr();
void show_arr(struct Arr * pArr);
void inversion_arr(struct Arr *array);



int main(int argc, const char * argv[]) {
    
    //定义一个结构体变量
    struct Arr arr;
    //把结构体变量的地址赋值
    init_arr(&arr, 6);
    printf("%d\n", arr.len);
    printf("%p\n", arr.pBase);
    printf("%d\n", arr.cnt);
    show_arr(&arr);
    append_arr(&arr, 1);
    append_arr(&arr, 2);
    append_arr(&arr, 3);
    append_arr(&arr, 4);
    append_arr(&arr, 5);
//    insert_arr(&arr, 3, 99);
    show_arr(&arr);
    inversion_arr(&arr);
    show_arr(&arr);
    int value;
    if (delete_arr(&arr, 1, &value)) {
        printf("删除成功！");
        printf("删除的元素是%d\n", value);
        show_arr(&arr);
    }else {
        printf("删除失败");
    }
    
    return 0;
}

void init_arr(struct Arr * parray, int length) {
//    (*parray).len = 99;
    //动态分配内存， 如果失败则返回NULL， malloc函数返回的是一个泛型， 就是不知道要返回什么类型，泛型可以代表任何类型
    parray->pBase = (int *)malloc(sizeof(int) * length);
    if (NULL == parray->pBase) {
        printf("动态内存分配失败");
        exit(-1);
    }else {
        parray->len = length;
        parray->cnt = 0;
    }
    return;
}

bool is_empty(struct Arr *pArr) {
    if (pArr->cnt == 0) {
        return 1;
    }else {
        return 0;
    }
}

bool is_full(struct Arr *pArr) {
    if (pArr->len == pArr->cnt) {
        return 1;
    }
    return 0;
}
void show_arr(struct Arr *pArr) {
    if (is_empty(pArr)) {
        printf("空数组\n");
    }else {
        for (int i = 0; i < pArr->cnt; ++i) {
            printf("%d ", pArr->pBase[i]);
        }
        printf("\n");
    }
}

bool append_arr(struct Arr *pArr, int value) {
    if (is_full(pArr)) {
        return 0;
    }else {
        pArr->pBase[pArr->cnt] = value;
        (pArr->cnt)++;
        return 1;
    }
}

bool insert_arr(struct Arr *pArr, int pos, int value) {
    int i;
    if (is_full(pArr)) {
        return 0;
    }
    if (pos < 1 || pos > pArr->cnt+1) {
        return 0;
    }
    //[1, 2]
    for (i = pArr->cnt - 1; i > pos - 2; i--) {
        printf("%d, index = %d\n", pArr->pBase[i], i);
        pArr->pBase[i + 1] = pArr->pBase[i];
        printf(" %d\n", pArr->pBase[i + 1]);
    }
    
    pArr->pBase[pos - 1] = value;
    (pArr->cnt)++;
    return 0;
}


bool delete_arr(struct Arr *array, int pos, int *pValue) {
    int i;
    if (is_full(array)) {
        return 0;
    }
    if (pos<1 || pos>array->cnt) {
        return 0;
    }
    
    *pValue = array->pBase[pos - 1];
    for (i = pos; i < array->cnt; i++) {
        array->pBase[i - 1] = array->pBase[i];
    }
    array->cnt--;
    
    return 1;
}


void inversion_arr(struct Arr *array) {
    int i = 0;
    int j = array->cnt - 1;
    int t;
    
    while (i < j) {
        t = array->pBase[i];
        array->pBase[i] = array->pBase[j];
        array->pBase[j] = t;
        i++;
        j--;
    }
}