第10章 指针和动态容量

struct Student students[100];  // 固定大小的数组，最多存 100 条
int count = 0;                 // 当前已存入的学生数量

#include <stdio.h>

void swap(int a, int b)        // a、b 是 x、y 的副本，不是变量本身
{
    int tmp = a;               // 保存 a 的值
    a = b;                     // 改的是副本 a
    b = tmp;                   // 改的是副本 b，外面的 x、y 不变
}

int main(void)
{
    int x = 3, y = 7;
    swap(x, y);                // 传值：x 和 y 的值被复制给 a 和 b
    printf("x=%d, y=%d\n", x, y);
    return 0;
}

#include <stdio.h>

void swap(int *a, int *b)      // a、b 是指针，保存 x、y 的地址
{
    int tmp = *a;              // *a：顺着地址 a 读取 x 的值
    *a = *b;                   // *a：顺着地址 a 写入，即修改 x
    *b = tmp;                  // *b：顺着地址 b 写入，即修改 y
}

int main(void)
{
    int x = 3, y = 7;
    swap(&x, &y);              // &x：取 x 的地址传给函数
    printf("x=%d, y=%d\n", x, y);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>     // malloc, realloc, free
#include <string.h>     // snprintf

struct Student {
    int id;
    char name[32];
    int score;
};

struct StudentTable {
    struct Student *students;   // 指向堆上的数组
    int count;                  // 当前存了多少条
    int capacity;               // 数组能装多少条
};

// 初始化学生表
int table_init(struct StudentTable *t, int capacity)
{
    if (capacity <= 0) {
        t->students = NULL;
        t->count = 0;
        t->capacity = 0;
        return 0;
    }

    t->students = malloc(capacity * sizeof(*t->students));  // 在堆上分配空间
    if (t->students == NULL) {
        t->count = 0;
        t->capacity = 0;
        return 0;
    }
    t->count = 0;
    t->capacity = capacity;
    return 1;
}

// 添加一个学生，满了就扩容
void table_add(struct StudentTable *t, int id, const char *name, int score)
{
    if (t->count == t->capacity) {
        int new_cap = t->capacity > 0 ? t->capacity * 2 : 1;  // 容量翻倍
        struct Student *tmp = realloc(t->students,
                                      new_cap * sizeof(*t->students));
        if (tmp == NULL) {
            printf("Memory allocation failed\n");
            return;
        }
        t->students = tmp;
        t->capacity = new_cap;
    }

    struct Student *s = &t->students[t->count];
    s->id = id;
    snprintf(s->name, sizeof(s->name), "%s", name);
    s->score = score;
    t->count++;
}

// 打印所有学生
void table_print(struct StudentTable *t)
{
    printf("ID  Name      Score  (count=%d, capacity=%d)\n", t->count, t->capacity);
    for (int i = 0; i < t->count; i++) {
        printf("%-6d%-10s%d\n",
               t->students[i].id,
               t->students[i].name,
               t->students[i].score);
    }
}

// 释放内存
void table_free(struct StudentTable *t)
{
    free(t->students);      // 释放堆上的数组
    t->students = NULL;     // 避免悬空指针
    t->count = 0;
    t->capacity = 0;
}

int main(void)
{
    struct StudentTable table;
    if (!table_init(&table, 2)) {  // 初始容量只有 2
        printf("Memory allocation failed\n");
        return 1;
    }

    table_add(&table, 1, "Alice", 92);
    table_add(&table, 2, "Bob", 78);
    table_add(&table, 3, "Carol", 85);   // 第 3 个学生触发扩容
    table_add(&table, 4, "Dave", 90);
    table_add(&table, 5, "Eve", 88);     // 第 5 个学生又触发扩容

    table_print(&table);

    table_free(&table);     // 程序结束前释放内存
    return 0;
}

int main(void)
{
    struct StudentTable table;          // table 在 main 的栈空间里
    if (!table_init(&table, 2)) {       // 把 table 的地址传进去
        ...
    }
}

int table_init(struct StudentTable *t, int capacity)

t->count = 0;              // 顺着地址改 table.count
t->capacity = capacity;    // 同理，修改 main 里的 table.capacity

t = NULL;   // 只把参数 t（地址副本）置空，main 里的 table 不受影响

t->students = malloc(capacity * sizeof(*t->students));

for (int i = 0; i < t->count; i++) {   // 对
for (int i = 0; i < t->capacity; i++) { // 错：会读到没赋值的格子

if (t->count == t->capacity) {
    int new_cap = t->capacity > 0 ? t->capacity * 2 : 1;
    struct Student *tmp = realloc(
        t->students,
        new_cap * sizeof(*t->students)
    );

    if (tmp == NULL) {
        printf("Memory allocation failed\n");
        return;
    }

    t->students = tmp;
    t->capacity = new_cap;
}

void table_free(struct StudentTable *t)
{
    free(t->students);           // 释放堆上的数组
    t->students = NULL;          // 置空指针，避免悬空指针
    t->count = 0;
    t->capacity = 0;
}

void reset_pointer(struct StudentTable *t)
{
    t = NULL;        // 只改了参数 t 这份地址副本
}

t->students = malloc(capacity * sizeof(*t->students));
// 没检查 t->students 是否为 NULL
t->students[0].id = 1;   // 如果 malloc 失败，这里就是空指针解引用

if (t->students == NULL) {
    printf("Memory allocation failed\n");
    return;
}

t->students = realloc(t->students, new_size);   // 危险

struct Student *tmp = realloc(t->students, new_size);
if (tmp == NULL) {
    printf("Expansion failed, existing data retained\n");
    return;
}
t->students = tmp;

free(t->students);
t->students[0].id = 1;   // 未定义行为：内存已经还给系统了

malloc(capacity * sizeof(int));              // 错：要的是 Student，不是 int
malloc(capacity * sizeof(*t->students));   // 对

int table_find(struct StudentTable *t, int id)
{
    for (int i = 0; i < t->count; i++) {  // 只遍历 count 个有效元素，不用 capacity
        if (t->students[i].id == id) {    // 找到了
            return i;
        }
    }
    return -1;                             // 没找到
}