在实际项目中，我们经常与各式各样的数据打交道。
例如：我们处理的是学生的数据。

struct student {
    int id; // 学号
    char name[20]; // 姓名
    int gender; // 性别
    int mark; // 成绩
};

学生数据使用一个结构体表示，该结构体拥有4个成员。分别为：

学号
姓名
性别
成绩

大多数情况下，数据的数量是不确定的，可能随着时间流逝而增加或减少。
例如：一开始有5个学生，后来增加到8个，再后来增加到15个。最后，减少到3个学生。
我们可以使用数组来盛放这些学生的数据，但是，声明数组时，声明一个长度为多少的数组，是一个需要考虑的问题。
如果我们能预知学生数量最多为15个，我们可以声明一个元素数量为15的结构体数组。

struct student arrStudent[15];

但是，大多数情况下，我们是不能预知数据到底有多少的。因此，最好是能够让数组的长度根据数据的多少自动增长。一种常用的数组增长策略是：当数组已经装满时，将数组长度增长到原来的两倍。
例如，数组的初始长度为5，当数组需要继续添加数据时，数组的长度增长为原来的两倍，即10个元素。若数组再次被装满，将数组的长度再次增加为原来的两倍，即20个元素。
为了实现上述的特性，我们可以借助于malloc与realloc函数。

void* malloc(size_t size);
void* realloc(void* ptr, size_t new_size);

malloc函数可以向系统申请size字节大小的内存空间。若申请成功，则返回这段内存空间的首地址。
relloc函数可以用于增长或缩短之前申请的内存空间。relloc函数的第一个参数是之前申请的内存空间的首地址，它会根据第二个参数，长度new_size增长或缩短之前申请的内存空间，并返回调整长度后的内存空间的首地址。

实现动态数组

下面我们来实现这个动态数组对象，我们将这个对象命名为vector。

struct vector {
    bool (*append)(struct vector* pVec, struct student data);
    struct student(*get)(struct vector* pVec, int index);
    void (*clear)(struct vector* pVec);
    void (*remove)(struct vector* pVec, int index);
    struct student* pData;
    int size;
    int capacity;
};

成员

这个对象有3个成员，它们分别是：

struct student* pData
int size
int capacity

pData用于记录数组的首元素指针。
size为数组中盛放的数据的长度。
capacity为整个数组拥有的元素个数，即数组的容量。

初始化

我们定义一个符号常量VECTOR_INIT_CAPACITY用来表示初始情况下，数组拥有的元素个数。为了方便测试，我们把这个数值定的小一点，暂时将数值设定为1。

#define VECTOR_INIT_CAPACITY 1

定义一个vectorInit函数，用于vector对象的初始化。初始情况下，使用malloc函数申请一个元素类型为struct student的数组，数组的元素数量为VECTOR_INIT_CAPACITY。保存这个数组的首元素指针到pData中。此时，数组拥有的元素个数为VECTOR_INIT_CAPACITY，盛放的数据长度为0。

void vectorInit(struct vector* pVec)
{
    pVec->pData = (struct student*)malloc(sizeof(struct student) * VECTOR_INIT_CAPACITY);
    pVec->size = 0;
    pVec->capacity = VECTOR_INIT_CAPACITY;
}

方法

接下来我们再来看vector对象的4个方法。

bool (*append)(struct vector* pVec, struct student data);
struct student(*get)(struct vector* pVec, int index);
void (*clear)(struct vector* pVec);
void (*remove)(struct vector* pVec, int index);

append方法用于向数组中添加一个struct student数据。如果添加成功返回true，否则返回false。
get方法用于从数组中获取一个struct student数据，index参数为需要获取的数组元素下标。
clear方法用于清除所有数组中盛放的数据，并将size复位为0，capacity复位为VECTOR_INIT_CAPACITY。
remove方法用于删除数组中下标为index的元素，并将size减1。

append方法

我们首先来实现append方法。

bool vectorAppend(struct vector* pVec, struct student data)
{
    // 是否超长
    if (pVec->size >= pVec->capacity)
    {
        // 加长到两倍
        struct student* newData = (struct student*)
            realloc(pVec->pData, pVec->capacity * sizeof(struct student) * 2);
        if (newData == NULL)
        {
            return false;
        }
        pVec->pData = newData;
        pVec->capacity = 2 * pVec->capacity;
    }
    pVec->pData[pVec->size] = data;
    pVec->size++;
    return true;
}

函数一开始检查数组中盛放的数据长度size是否已经大于或等于数组的容量capacity。如果数组已装满，那么把数组使用relloc增长为原来长度的两倍。若relloc函数成功将数组增长，那么它将返回增长后的数组首地址。若失败，那么它将返回NULL。如果失败，让函数返回fasle。成功之后，使用新的数组首元素指针newData更新pData。现在数组长度增加到了原来的2倍，capacity赋值
为2 * capacity。下面，可以将data放入数组了。并且，将数组中已盛放的数据长度size增加1。

get方法

我们再来实现get方法。

struct student vectorGet(struct vector* pVec, int index)
{
    return pVec->pData[index];
}

get方法很简单，就是返回下标为index的数组元素的数据。

remove方法

remove方法，用于删除数组中下标为index的元素。

void vectorRemove(struct vector* pVec, int index)
{
    for (int i = index; i < pVec->size - 1; i++)
        pVec->pData[i] = pVec->pData[i + 1];
    pVec->size -= 1;
}

删除数组元素是一个老生常谈的话题了，从index开始，依次使用后续元素覆盖前驱元素，直到覆盖完倒数第二个元素为止。若index已经是最后一个元素，那么不进行处理。最后，将数组已盛放的数据长度size减1。

clear方法

clear方法用于将所有数组中盛放的数据清空，并将数组的容量缩短为初始容量。

void vectorClear(struct vector* pVec)
{
    if (pVec->pData != NULL)
        free(pVec->pData);
    pVec->pData = (struct student*)malloc(sizeof(struct student) * VECTOR_INIT_CAPACITY);
    pVec->size = 0;
    pVec->capacity = VECTOR_INIT_CAPACITY;
}

若pData不为NULL就释放pData，并重新申请容量为VECTOR_INIT_CAPACITY的数组，并将首元素指针保存到pData。size重置为0，capacity重置为VECTOR_INIT_CAPACITY。

销毁数组

void vectorDestroy(struct vector* pVec)
{
    if (pVec->pData == NULL)
        return;
    free(pVec->pData);
    pVec->pData = NULL;
    pVec->size = 0;
    pVec->capacity = 0;
}

如果我们不再使用vector可以调用vectorDestroy将数组销毁。若pData不为空，则释放pData，并且把pData赋值为NULL。size与capacity设置为0。

初始化方法

别忘了初始化时，我们仅仅初始化了对象的成员，没有初始化对象的方法。现在，把初始化对象的方法的语句加入到函数vectorInit当中。

void vectorInit(struct vector* pVec)
{
    pVec->get = vectorGet;
    pVec->append = vectorAppend;
    pVec->remove = vectorRemove;
    pVec->clear = vectorClear;
    pVec->pData = (struct student*)malloc(sizeof(struct student) * VECTOR_INIT_CAPACITY);
    pVec->size = 0;
    pVec->capacity = VECTOR_INIT_CAPACITY;
}

使用数组

初始化及append方法

struct vector vec;
vectorInit(&vec);
struct student s1 = { 1, "小明", 1, 90 };
vec.append(&vec, s1);
for (int i = 0; i < vec.size; i++)
{
    struct student s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

首先声明一个vector对象，调用函数vectorInit将其初始化。声明一个struct student结构体s1，将s1初始化为小明的数据。调用vector的append方法将小明的数据s1添加到数组当中。之后，使用循环遍历整个vector，循环的次数为vec.size。循环内部，调用vector的get方法，可以得到数组中的各个数据，并将其打印在控制台上。
打印vector的size与capacity，它们都为1。

测试append追加

接下来，向vector中再追加一个元素，小红的数据s2。遍历整个vector，可以得到小明和小红的数据。
打印vector的size与capacity，现在它们都增加为2了。

struct student s2 = { 2, "小红", 0, 95 };
vec.append(&vec, s2);
for (int i = 0; i < vec.size; i++)
{
    struct student s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

测试remove

vec.remove(&vec, 0);
for (int i = 0; i < vec.size; i++)
{
    struct student s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

调用remove方法，将下标为0的小明的数据删除。遍历整个vector，只能得到小红的数据。
打印vector的size与capacity，size为1，capacity为2。

测试clear

调用clear方法，清空所有数据，将size复位为0，将capacity复位为VECTOR_INIT_CAPACITY。遍历整个vector，已经没有数据了。

vec.clear(&vec);
for (int i = 0; i < vec.size; i++)
{
    struct student s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

打印vector的size与capacity，size为1，capacity为1。

销毁数组

最后，别忘记调用vectorDestroy将vector销毁。

vectorDestroy(&vec);

现阶段代码

#include <stdlib.h>
#include <stdio.h>
struct student {
    int id; // 学号
    char name[20]; // 姓名
    int gender; // 性别
    int mark; // 成绩
};
#define VECTOR_INIT_CAPACITY 1
struct vector {
    bool (*append)(struct vector* pVec, struct student data);
    struct student(*get)(struct vector* pVec, int index);
    void (*clear)(struct vector* pVec);
    void (*remove)(struct vector* pVec, int index);
    struct student* pData;
    int size;
    int capacity;
};
bool vectorAppend(struct vector* pVec, struct student data)
{
    // 是否超长
    if (pVec->size >= pVec->capacity)
    {
        // 加长到两倍
        struct student* newData = (struct student*)
            realloc(pVec->pData, pVec->capacity * sizeof(struct student) * 2);
        if (newData == NULL)
        {
            return false;
        }
        pVec->pData = newData;
        pVec->capacity = 2 * pVec->capacity;
    }
    pVec->pData[pVec->size] = data;
    pVec->size++;
    return true;
}
struct student vectorGet(struct vector* pVec, int index)
{
    return pVec->pData[index];
}
void vectorRemove(struct vector* pVec, int index)
{
    for (int i = index; i < pVec->size - 1; i++)
        pVec->pData[i] = pVec->pData[i + 1];
    pVec->size -= 1;
}
void vectorClear(struct vector* pVec)
{
    if (pVec->pData != NULL)
        free(pVec->pData);
    pVec->pData = (struct student*)malloc(sizeof(struct student) * VECTOR_INIT_CAPACITY);
    pVec->size = 0;
    pVec->capacity = VECTOR_INIT_CAPACITY;
}
void vectorInit(struct vector* pVec)
{
    pVec->get = vectorGet;
    pVec->append = vectorAppend;
    pVec->remove = vectorRemove;
    pVec->clear = vectorClear;
    pVec->pData = (struct student*)malloc(sizeof(struct student) * VECTOR_INIT_CAPACITY);
    pVec->size = 0;
    pVec->capacity = VECTOR_INIT_CAPACITY;
}
void vectorDestroy(struct vector* pVec)
{
    if (pVec->pData == NULL)
        return;
    free(pVec->pData);
    pVec->pData = NULL;
    pVec->size = 0;
    pVec->capacity = 0;
}
int main()
{
    struct vector vec;
    vectorInit(&vec);
    struct student s1 = { 1, "小明", 1, 90 };
    vec.append(&vec, s1);
    for (int i = 0; i < vec.size; i++)
    {
        struct student s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();
    struct student s2 = { 2, "小红", 0, 95 };
    vec.append(&vec, s2);
    for (int i = 0; i < vec.size; i++)
    {
        struct student s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();
    vec.remove(&vec, 0);
    for (int i = 0; i < vec.size; i++)
    {
        struct student s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();
    vec.clear(&vec);
    for (int i = 0; i < vec.size; i++)
    {
        struct student s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s.id, s.name, s.gender, s.mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();
    vectorDestroy(&vec);
    return 0;
}

通用数组元素

目前，vector对象只能用于盛放struct student类型的数据。我们可以将所有的struct student改为void *，让其可以盛放任意数据类型的指针。
此外，我们在函数中，再多做一些参数检查。
在append方法内，对参数指针进行判空检查。
在get方法内，检查index是否超出已盛放的数据size的大小。若超出大小，则返回NULL。
接下来，我们把vector对象的代码拆分成vector.h与vector.cpp两个文件。
vector.h中，有符号常量VECTOR_INIT_CAPACITY的定义，vector对象的声明。以及初始化函数和销毁函数的声明。

vector.h文件如下：

#pragma once
#define VECTOR_INIT_CAPACITY 10
struct vector {
    bool (*append)(vector* pVec, void* data);
    void* (*get)(vector* pVec, int index);
    void (*clear)(vector* pVec);
    void (*remove)(vector* pVec, int index);
    void** pData;
    int size;
    int capacity;
};
void vectorInit(vector*);
void vectorDestroy(vector* pVec);

vector.cpp文件如下：

#include "vector.h"
#include <stdlib.h>
bool vectorAppend(vector* pVec, void* data)
{
    if (pVec == NULL || data == NULL)
        return false;
    // 是否超长
    if (pVec->size >= pVec->capacity)
    {
        // 加长到两倍
        void** newData = (void**)realloc(pVec->pData, pVec->capacity * sizeof(void*) * 2);
        if (newData == NULL)
        {
            return false;
        }
        pVec->pData = newData;
        pVec->capacity = 2 * pVec->capacity;
    }
    pVec->pData[pVec->size] = data;
    pVec->size++;
    return true;
}
void* vectorGet(vector* pVec, int index)
{
    if (index >= pVec->size)
        return NULL;
    return pVec->pData[index];
}
void vectorRemove(vector* pVec, int index)
{
    for (int i = index; i < pVec->size - 1; i++)
        pVec->pData[i] = pVec->pData[i + 1];
    pVec->size -= 1;
}
void vectorClear(vector* pVec)
{
    if (pVec->pData != NULL)
        free(pVec->pData);
    pVec->pData = (void**)malloc(sizeof(void*) * VECTOR_INIT_CAPACITY);
    pVec->capacity = VECTOR_INIT_CAPACITY;
    pVec->size = 0;
}
void vectorInit(vector* pVec)
{
    pVec->get = vectorGet;
    pVec->append = vectorAppend;
    pVec->remove = vectorRemove;
    pVec->clear = vectorClear;
    // 初始情况下申请VECTOR_INIT_CAPACITY个element
    pVec->pData = (void**)malloc(sizeof(void*) * VECTOR_INIT_CAPACITY);
    pVec->capacity = VECTOR_INIT_CAPACITY;
    pVec->size = 0;
}
void vectorDestroy(vector* pVec)
{
    if (pVec->pData == NULL)
        return;
    free(pVec->pData);
    pVec->pData = NULL;
    pVec->size = 0;
    pVec->capacity = 0;
}

测试通用数组

现在，vector数组可以用于盛放任意类型数据对象的指针。让我们使用它，用于盛放struct student *。

初始化与append

struct vector vec;
vectorInit(&vec);
struct student* s1 = (struct student*)malloc(sizeof(struct student));
s1->id = 1;
strcpy(s1->name, "小明");
s1->gender = 1;
s1->mark = 90;
vec.append(&vec, s1);
for (int i = 0; i < vec.size; i++)
{
    struct student* s = (struct student*)vec.get(&vec, i);
    printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

这里我们使用malloc申请一个struct student结构体，申请成功后，将其赋值为小明的数据。之后，将结构体struct student的指针s1，添加进入vector。遍历vector可以拿到我们之前放置进去的数据的指针，但是它是void*类型的，我们将其转换为struct student*类型，并赋值到s，使用这个指针，可以打印出小明数据的各项详情。

测试append追加

struct student* s2 = (struct student*)malloc(sizeof(struct student));
s2->id = 2;
strcpy(s2->name, "小红");
s2->gender = 0;
s2->mark = 95;
vec.append(&vec, s2);
for (int i = 0; i < vec.size; i++)
{
    struct student* s = (struct student*)vec.get(&vec, i);
    printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

再次使用malloc申请一个struct student结构体，申请成功后，将其赋值为小红的数据。之后，将结构体struct student的指针，追加进入vector。遍历vector可以拿到小明、小红数据的指针。

测试remove

// 别忘记销毁小明的数据
free(vec.get(&vec, 0));
vec.remove(&vec, 0);
for (int i = 0; i < vec.size; i++)
{
    struct student* s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

现在，我们将小明的数据删除，注意一定要free掉小明的数据。仅仅remove小明数据的指针是不行的，小明的数据是由malloc申请的，必须调用free销毁。

测试clear

for (int i = 0; i < vec.size; i++)
{
    struct student* s = vec.get(&vec, i);
    free(s);
}
vec.clear(&vec);
for (int i = 0; i < vec.size; i++)
{
    struct student* s = vec.get(&vec, i);
    printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
}
printf("size:%d\n", vec.size);
printf("capacity:%d\n", vec.capacity);

使用循环，获取所有数据的指针，调用free将这些数据都销毁。其后，我们就可以安全地清空vector数组了。

销毁数组

最后别忘记销毁vector本身。

vectorDestroy(&vec);

刚刚我们为了测试把数组初始长度设置得很短，实际中，可以设置稍微长一点，比如初始数组长度为10。

#define VECTOR_INIT_CAPACITY 10

最后代码

vector.h

#pragma once

#include <stdbool.h>

#define VECTOR_INIT_CAPACITY 10

struct vector {
    bool (*append)(struct vector* pVec, void* data);
    void* (*get)(struct vector* pVec, int index);
    void (*clear)(struct vector* pVec);
    void (*remove)(struct vector* pVec, int index);

    void** pData;
    int size;
    int capacity;
};

void vectorInit(struct vector*);
void vectorDestroy(struct vector* pVec);

main.c

#define _CRT_SECURE_NO_WARNINGS

#include "vector.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct student {
    int id;         //  学号
    char name[20];  //  姓名
    int gender;     //  性别
    int mark;       //  成绩
};

int main()
{
    struct vector vec;
    vectorInit(&vec);

    //  append
    struct student* s1 = (struct student*)malloc(sizeof(struct student));
    s1->id = 1;
    strcpy(s1->name, "小明");
    s1->gender = 1;
    s1->mark = 90;
    vec.append(&vec, s1);

    for (int i = 0; i < vec.size; i++)
    {
        struct student* s = (struct student*)vec.get(&vec, i);
        printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
    }

    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();

    //  append追加
    struct student* s2 = (struct student*)malloc(sizeof(struct student));
    s2->id = 2;
    strcpy(s2->name, "小红");
    s2->gender = 0;
    s2->mark = 95;
    vec.append(&vec, s2);

    for (int i = 0; i < vec.size; i++)
    {
        struct student* s = (struct student*)vec.get(&vec, i);
        printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
    }

    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();

    //  remove
    //  别忘记销毁小明的数据
    free(vec.get(&vec, 0));
    vec.remove(&vec, 0);

    for (int i = 0; i < vec.size; i++)
    {
        struct student* s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);

    for (int i = 0; i < vec.size; i++)
    {
        struct student* s = vec.get(&vec, i);
        free(s);
    }
    getchar();

    //  clear
    vec.clear(&vec);

    for (int i = 0; i < vec.size; i++)
    {
        struct student* s = vec.get(&vec, i);
        printf("%d %s %d %d\n", s->id, s->name, s->gender, s->mark);
    }
    printf("size:%d\n", vec.size);
    printf("capacity:%d\n", vec.capacity);
    getchar();

    //  销毁数组
    vectorDestroy(&vec);
    
    return 0;
}

vector.c

#include "vector.h"
#include <stdlib.h>

bool vectorAppend(struct vector* pVec, void* data)
{
    if (pVec == NULL || data == NULL)
        return false;

    //  是否超长
    if (pVec->size >= pVec->capacity)
    {
        //  加长到两倍
        void** newData = (void**)realloc(pVec->pData, pVec->capacity * sizeof(void*) * 2);
        if (newData == NULL)
        {
            return false;
        }
        pVec->pData = newData;
        pVec->capacity = 2 * pVec->capacity;
    }

    pVec->pData[pVec->size] = data;
    pVec->size++;
    return true;
}

void* vectorGet(struct vector* pVec, int index)
{
    if (index >= pVec->size)
        return NULL;
    return pVec->pData[index];
}

void vectorRemove(struct vector* pVec, int index)
{
    for (int i = index; i < pVec->size - 1; i++)
        pVec->pData[i] = pVec->pData[i + 1];
    pVec->size -= 1;
}

void vectorClear(struct vector* pVec)
{
    if (pVec->pData != NULL)
        free(pVec->pData);

    pVec->pData = (void**)malloc(sizeof(void*) * VECTOR_INIT_CAPACITY);
    pVec->capacity = VECTOR_INIT_CAPACITY;
    pVec->size = 0;
}

void vectorInit(struct vector* pVec)
{
    pVec->get = vectorGet;
    pVec->append = vectorAppend;
    pVec->remove = vectorRemove;
    pVec->clear = vectorClear;

    //  初始情况下申请VECTOR_INIT_CAPACITY个element
    pVec->pData = (void**)malloc(sizeof(void*) * VECTOR_INIT_CAPACITY);
    pVec->capacity = VECTOR_INIT_CAPACITY;
    pVec->size = 0;
}

void vectorDestroy(struct vector* pVec)
{
    if (pVec->pData == NULL)
        return;
    free(pVec->pData);
    pVec->pData = NULL;
    pVec->size = 0;
    pVec->capacity = 0;
}

C动态数组

实现动态数组

成员

初始化

方法

append方法

get方法

remove方法

clear方法

销毁数组

初始化方法

使用数组

初始化及append方法

测试append追加

测试remove

测试clear

销毁数组

现阶段代码

通用数组元素

测试通用数组

初始化与append

测试append追加

测试remove

测试clear

销毁数组

最后代码

vector.h

main.c

vector.c

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C动态数组

实现动态数组

成员

初始化

方法

append方法

get方法

remove方法

clear方法

销毁数组

初始化方法

使用数组

初始化及append方法

测试append追加

测试remove

测试clear

销毁数组

现阶段代码

通用数组元素

测试通用数组

初始化与append

测试append追加

测试remove

测试clear

销毁数组

最后代码

vector.h

main.c

vector.c

热门文章

最新文章

相关电子书