C语言实现C++中＜vector.h＞的函数

正文：

         本文章展示内函数使用方法

        若想要系统性学习如何用C语言实现，请前往我的另一篇文章：

        https://blog.csdn.net/ChaoJihtd/article/details/144517626?spm=1001.2014.3001.5501

        因为展示，所以只用int型数组，若想学习，请前往上面的链接

        若想看展示的函数，请翻到最底部

 

#include 
#include 

typedef struct 
{
    int *A_INT;
    size_t length;
    size_t capacity;
} DTFP;

void RE(DTFP *v) 
{
    v->A_INT = NULL;
    v->length = 0;
}

void pop_back(DTFP *v) 
{
    v->length--;
    v->A_INT = (int *)realloc(v->A_INT, v->length * sizeof(int));
}

void emplace_back(DTFP *v , int input)
{
    v->A_INT[v->length - 1] = input;
}

int front(DTFP *v)
{
    return v->A_INT[0];
}

int back(DTFP *v)
{
    return v->A_INT[v->length - 1];
}

void push_back(DTFP *v , int input)
{
    v->length++;
    v->A_INT = (int *)realloc(v->A_INT, v->length * sizeof(int));
    v->A_INT[v->length - 1] = input;
}

void INT_ARR(DTFP *v, const int *A, size_t INT_A_LEN) 
{
    v->length = INT_A_LEN;
    v->A_INT = (int *)malloc(INT_A_LEN * sizeof(int));
    for (size_t i = 0; i < INT_A_LEN; i++)
        v->A_INT[i] = A[i];
}

void empty(DTFP *v)
{
    if (v->length == 0)
    {
        printf("数组空啦！\n");
    }
    else
    {
        printf("数组有这么长：%d\n" , v->length);
    }
}

void capacity(DTFP *v)
{
    printf("数组容量为：%d哦!\n" , v->length);
}

void max_size(DTFP *v)
{
    printf("能填充最大元素数量为：%d哦!\n" , v->length);
}

void insert(DTFP *v , int input , int input_num)
{
    v->length++;
    v->A_INT = (int *)realloc(v->A_INT, v->length * sizeof(int));
    for (int i = v->length - 1; i > input; i--)
    {
        v->A_INT[i] = v->A_INT[i - 1];
    }
    v->A_INT[input - 1] = input_num;
}

void reserve(DTFP *v, size_t new_capacity)
{
    if (new_capacity > v->capacity) 
    {
        int *new_A_INT = (int *)realloc(v->A_INT, new_capacity * sizeof(int));
        v->A_INT = new_A_INT;
        v->capacity = new_capacity;
    }
}

void at(DTFP *v , int input)
{
    if (input - 1 > v->length)
        fprintf(stderr , "越界啦！！！\n");
}

void size(DTFP *v)
{
    int count = 0;

    for (int i = 0; i < v->length; i++)
    {
        if (v->A_INT[i] != NULL)
        {
            count++;
        }
        else
            break;
    }

    printf("数组中有%d个元素哦!\n" , count);
}

void free_DTFP(DTFP *v) 
{
    free(v->A_INT);
    RE(v);
}

void swap_DTFP(DTFP *a, DTFP *b) 
{
    int *temp_A_INT = a->A_INT;
    size_t temp_length = a->length;

    a->A_INT = b->A_INT;
    b->A_INT = temp_A_INT;

    a->length = b->length;
    b->length = temp_length;
}

void resize(DTFP *v, size_t new_length)
{
    if (new_length <= v->length) 
    {
        v->length = new_length;
        return;
    }

    if (new_length > v->capacity) 
    {
        size_t new_capacity = new_length;
        int *new_A_INT = (int *)realloc(v->A_INT, new_capacity * sizeof(int));
        v->A_INT = new_A_INT;
        v->capacity = new_capacity;
    }

    v->length = new_length;
}

void add_1(DTFP *v, int ele) 
{
    v->A_INT = (int *)realloc(v->A_INT, (v->length + 1) * sizeof(int));
    v->A_INT[v->length] = ele;
    v->length++;
}

void erase(DTFP *v, int start, int end) 
{
    start = start - 1;
    end = end - 1;

    int len = end - start + 1;

    for (int i = start; i <= (int)v->length - len - 1; i++)
        v->A_INT[i] = v->A_INT[i + len];

    v->length -= len;

    v->A_INT = (int *)realloc(v->A_INT, v->length * sizeof(int));
}

void clear(DTFP *v)
{
    free_DTFP(v);
}

void DTFP_OUT(DTFP *v) 
{
    int num;
    while (scanf("%d", &num) == 1) 
    {
        add_1(v, num);
        int c;
        while ((c = getchar()) != '\n' && c != EOF && c != ' ' && c != '\t');
        if (c == '\n') break;
    }
}

int compare_arr(const DTFP *a, const DTFP *b) 
{
    if (a->length == 0 && b->length == 0) 
    {
        return 0;
    }
    if (a->length == 0) 
    {
        return -1;
    }
    if (b->length == 0) 
    {
        return 1;
    }

    if (a->length < b->length) 
    {
        return -1;
    }
    if (a->length > b->length) 
    {
        return 1;
    }

    for (size_t i = 0; i < a->length; i++) 
    {
        if (a->A_INT[i] < b->A_INT[i]) 
        {
            return -1;
        }
        if (a->A_INT[i] > b->A_INT[i]) 
        {
            return 1;
        }
    }
    return 0;
}

void sort(DTFP *v)
{
    int i , j , key;
    for (int i = 1; i < v->length; i++)
    {
        key = v->A_INT[i];
        j = i - 1;
        while (j >= 0 && v->A_INT[j] > key)
        {
            v->A_INT[j + 1] = v->A_INT[j];
            j = j - 1;
        }
        v->A_INT[j + 1] = key;
    }
}

void reverse(DTFP *v)
{
    int i , j , key;
    for (int i = 1; i < v->length; i++)
    {
        key = v->A_INT[i];
        j = i - 1;
        while (j >= 0 && v->A_INT[j] < key)
        {
            v->A_INT[j + 1] = v->A_INT[j];
            j = j - 1;
        }
        v->A_INT[j + 1] = key;
    }
}

int compare(const DTFP *a, const DTFP *b)
{
    int result = compare_arr(a , b);

    if (result == 0) 
    {
        printf("两个向量相等\n");
    } 
    else if (result < 0) 
    {
        printf("向量 A 小于向量 B\n");
    } 
    else 
    {
        printf("向量 A 大于向量 B\n");
    }
}

void print_out(DTFP *v)
{
    for (size_t i = 0; i < v->length; i++) 
        printf("%d ", v->A_INT[i]);
    printf("\n");
}

int main()
{
/*展示初始化数组*/
    DTFP A = {NULL, 0}; //初始化

/*展示输入数据*/
    DTFP_OUT(&A); // 输入数据
    print_out(&A); // 打印出所有数组中数据
    printf("//打印了所有数据\n\n");

/*展示push_back()*/
    push_back(&A , 10); // 向末尾添加一个元素10
    print_out(&A); // 打印出所有数组中数据
    printf("//在末尾添加了数据10\n\n");


/*展示emplace_back()*/
    emplace_back(&A , 20); // 把末尾数字构造为20
    print_out(&A); // 打印出所有数组中数据
    printf("//把末尾数字直接构造为20\n\n");

/*展示insert()*/
    insert(&A , 2 , 66); // 在第二个位置添加数字66
    print_out(&A); // 打印出所有数组中数据
    printf("//添加了数字66并放在了第二位\n\n");

/*展示下标[]获取元素*/
    int getnum = A.A_INT[3]; // 获取第4位元素
    printf("%d " , getnum);
    printf("//获取了第4位元素值\n\n");

/*展示at()*/
    at(&A , 3); // 检查第3位元素是否越界

/*展示front()*/
    getnum = front(&A); // 获取数组第一位数据
    printf("%d " , getnum);
    printf("//获取了第1位元素值\n\n");

/*展示back()*/
    getnum = back(&A); // 获取刷组最后一位数据
    printf("%d " , getnum);
    printf("//获取了最后一位元素值\n\n");

/*展示pop_back()*/
    pop_back(&A); // 删除数组最后一个元素 
    print_out(&A); // 打印出所有数组中数据
    printf("//删除了末尾数据\n\n");

/*展示erase()*/
    erase(&A , 2 , 4); // 删除第2到4位元素，包括2到4位
    print_out(&A);
    printf("//删除了第2到4位元素 ,包括2到4位\n\n");

/*展示clear()*/
    clear(&A); // 清空整个数组
    printf("//清空了整个数组\n\n");

/*展示empty()*/
    empty(&A); // 检测数组是否位空
    printf("//上面这句话是函数发出的\n\n");

/*展示定义数组*/
    int arr1[] = {1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10}; // 这三行用来定义arr数组中有1-10这些数
    size_t INT_A_LEN = sizeof(arr1) / sizeof(arr1[0]);
    INT_ARR(&A , arr1 ,  INT_A_LEN);
    print_out(&A);
    printf("//定义了1-10这些数\n\n");

/*展示empty()*/
    empty(&A); // 检测数组是否位空
    printf("//上面这句话是函数发出的\n\n");

/*展示size()*/
    size(&A); // 检测数组中有几个元素，不是检测数组长度
    printf("//上面这句话是函数发出的\n\n");

/*展示capacity()*/
    capacity(&A); // 用于检测数组容量
    printf("//上面这句话是函数发出的\n\n");

/*展示max)size()*/
    max_size(&A); // 用于检测能填充最大元素数量
    printf("//上面这句话是函数发出的\n\n");

/*展示resize()*/
    resize(&A , 7); // 将数组容量调为7
    print_out(&A);
    printf("//将数组容量调成了7\n\n");

/*展示reserve()*/
    reserve(&A , 10); // 为数组预留了10个空间
    print_out(&A);
    printf("//为数组预留了10个空间\n\n");

/*展示swap_DTFP()*/
    DTFP B = {NULL, 0}; // 初始化数组B
    int arr2[] = {10, 20, 30, 40, 50, 60, 70}; // 这三行初始化了数组B中的元素
    size_t arr2_len = sizeof(arr2) / sizeof(arr2[0]);
    INT_ARR(&B, arr2, arr2_len);
    print_out(&B); // 打印数组B
    printf("//打印了数组B中所有元素\n\n");
    swap_DTFP(&A , &B); // 交换数组A，B，元素和长度都换
    printf("//交换了数组A,B的内容\n\n");
    print_out(&A);
    printf("//打印了数组A\n\n");
    print_out(&B);
    printf("//打印了数组B\n\n");

/*展示compare()*/
    compare(&A , &B); // 比较两个数组
    printf("//上面这句话是函数发出的\n\n");

/*展示sort()*/
    sort(&A);
    print_out(&B); // 打印数组
    printf("//对数组进行了排序\n\n");

/*展示reverse()*/
    reverse(&B); // 逆序排序了数组
    print_out(&B);
    printf("//对数组进行了逆序排序");

    free_DTFP(&A);
    free_DTFP(&B);
    return 0;
}