int main() {
    // 声明一个容纳 3000 个整数的数组
    int my_array[3000];
}

// 首先定义一个常量，该常量表示 Vector 内部一个数组对象的初始大小。
#define VECTOR_INITIAL_CAPACITY 100


// 定义数据结构 Vector
typedef struct {
    int size;               // 数组在用长度
    int capacity;           // 数组最大可用长度
    int *data;              // 用来保存整数对象的数组对象
} Vector;

// 该函数负责初始化一个 Vector 对象，初始数组在用长度为 0，最大长度为 VECTOR_INITIAL_CAPACITY。
// 开辟适当的内存空间以供底层数组使用，空间大小为 vector->capacity * sizeof(int) 个字节。 
void vector_init(Vector *vector);

// 该函数负责追加整数型的成员到 vector 对象。如果底层的数组已满，则扩大底层数组容积来保存新成员。
void vector_append(Vector *vector, int value);

// 返回 vector 指定位置所保存的值。如果指定位置小于 0 或者大于 vector->size - 1，则返回异常。
int vector_get(Vector *vector, int index);

// 将指定值保存到指定位置，如果指定位置大于 vector->size，则自动翻倍 vector 内部的数组容积直到可以容纳指定多的位置。
// 扩大的数组中间使用 0 填满那些空位置。
void vector_set(Vector *vector, int index, int value);

// 将 vector 内部数组容积翻倍。
// 因为更改数组体积的开销是十分大的，采用翻倍的策略以免频繁更改数组体积。
void vector_double_capacity_if_full(Vector *vector);

// 释放 vector 内部数组所使用的内存空间。
void vector_free(Vector *vector);

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


void vector_init(Vector *vector) {
    // 初始化 size 和 capacity。
    vector->size = 0;
    vector->capacity = VECTOR_INITIAL_CAPACITY;

    // 为 vector 内部 data 数组对象申请内存空间
    vector->data = malloc(sizeof(int) * vector->capacity);
}

void vector_append(Vector *vector, int value) {
    // 确保当前有足够的内存空间可用。
    vector_double_capacity_if_full(vector);

    // 将整数追加到数组尾部。
    vector->data[vector->size++] = value;
}

int vector_get(Vector *vector, int index) {
    if (index >= vector->size || index < 0) {
        printf("Index %d out of bounds for vector of size %d\n", index, vector->size);
        exit(1);
    }   
    return vector->data[index];
}

void vector_set(Vector *vector, int index, int value) {
    // 使用 0 填充闲置在用内存空间。
    while (index >= vector->size) {
        vector_append(vector, 0); 
    }   

    // 在指定数组位置保存指定整数。
    vector->data[index] = value;
}

void vector_double_capacity_if_full(Vector *vector) {
    if (vector->size >= vector->capacity) {
        // 翻倍数组大小。
        vector->capacity *= 2;
        vector->data = realloc(vector->data, sizeof(int) * vector->capacity);
    }   
}

void vector_free(Vector *vector) {
    free(vector->data);
}

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


int main() {
    // 声明一个新的 Vector 对象，并初始化它。
    Vector vector;
    vector_init(&vector);

    // 初始化的 vector 内部数组最大保存 100 个整数。
    // 现在我们将保存 150 个整数到 vector 对象中。
    // vector 自动将内部数组容积扩大一倍达到最多可以保存 200 个整数，但实际只使用了 150 个位置。
    int i;
    for (i = 200; i > 50; i--) {
        vector_append(&vector, i); 
    }   

    // 我们指定在第 251 个位置保存一个整数 99999。
    // vector 自动再次翻倍内部数组容积到 400 个位置，并将 99999 放到第 251 个位置。
    // 另外将第 151 到 250 之间所有的位置用 0 进行填充。
    vector_set(&vector, 250, 99999);

    // 读取第 28 个位置的整数值，该位置的整数应该是 173。
    printf("Heres the value at 27: %d\n", vector_get(&vector, 27));

    // 遍历当前 vector 内部数组所有实际在用的位置。 
    for (i = 0; i < vector.size; i++) {
        printf("vector[%d] = %d\n", i, vector_get(&vector, i));
    }   
// 释放 vector 对象内部数组。
    vector_free(&vector);
}

$ gcc vector.c vector-usage.c 
$ ./a.out 
Heres the value at 27: 173
vector[0] = 200
vector[1] = 199
vector[2] = 198
...
vector[148] = 52
vector[149] = 51
vector[150] = 0
vector[151] = 0
...
vector[249] = 0
vector[250] = 99999