Rò rỉ bộ nhớ

void ro_ri(void)
{
    int *a = malloc(1000 * sizeof *a);

    if (a == NULL) return;

    a[0] = 42;

    /* Hàm kết thúc. Biến a chết theo ngăn xếp.
       4000 byte kia vẫn nằm đó, và không ai còn biết địa chỉ của chúng. */
}

for (int i = 0; i < 1000000; ++i)
    ro_ri();      /* rò rỉ 4 gigabyte */

char *doc_file(const char *duong_dan)
{
    FILE *f = fopen(duong_dan, "r");

    if (f == NULL) return NULL;

    char *bo_dem = malloc(4096);

    if (bo_dem == NULL) {
        fclose(f);
        return NULL;
    }

    /* ... đọc ... */

    fclose(f);

    return bo_dem;      /* người gọi phải free, và họ hay quên */
}

doc_file("a.txt");      /* giá trị trả về bị vứt: rò rỉ 4 KB */

char *s = malloc(100);

s = malloc(200);      /* 100 byte đầu tiên rò rỉ ngay lập tức */

/* Cùng vấn đề với realloc viết sai, xem Bài 14.8 */
s = realloc(s, 300);  /* nếu thất bại, mất luôn con trỏ cũ */

/* Và trong vòng lặp */
for (int i = 0; i < 1000; ++i)
    s = doc_dong(f);  /* mỗi lượt rò rỉ dòng của lượt trước */

typedef struct Nut {
    char       *ten;
    struct Nut *tiep;
} Nut;

/* SAI: chỉ giải phóng danh sách, quên trường ten của từng nút */
void huy_sai(Nut *dau)
{
    while (dau != NULL) {
        Nut *tiep = dau->tiep;

        free(dau);          /* rò rỉ mọi chuỗi ten */
        dau = tiep;
    }
}

/* ĐÚNG */
void huy_dung(Nut *dau)
{
    while (dau != NULL) {
        Nut *tiep = dau->tiep;

        free(dau->ten);     /* giải phóng phần bên trong trước */
        free(dau);
        dau = tiep;
    }
}

int xu_ly(void)
{
    char *bo_dem = malloc(4096);

    if (bo_dem == NULL) return -1;

    int kq = lam_viec(bo_dem, 4096);

    free(bo_dem);      /* cùng hàm cấp thì cùng hàm giải phóng */

    return kq;
}

int lam_viec(const char *duong_dan)
{
    int    ma_loi = -1;
    char  *bo_dem = NULL;
    int   *bang   = NULL;
    FILE  *f      = NULL;

    bo_dem = malloc(4096);
    if (bo_dem == NULL) goto don_dep;

    bang = calloc(256, sizeof *bang);
    if (bang == NULL) goto don_dep;

    f = fopen(duong_dan, "r");
    if (f == NULL) goto don_dep;

    if (doc(f, bo_dem, 4096) < 0) goto don_dep;
    if (tinh(bo_dem, bang) < 0)   goto don_dep;

    ma_loi = 0;

don_dep:
    if (f != NULL) fclose(f);
    free(bang);
    free(bo_dem);

    return ma_loi;
}

typedef struct {
    char  *ten;
    int   *diem;
    size_t n;
} SinhVien;

/* Tạo: hoặc thành công hoàn toàn, hoặc thất bại và không để lại gì. */
SinhVien *sv_tao(const char *ten, size_t n)
{
    SinhVien *sv = calloc(1, sizeof *sv);

    if (sv == NULL) return NULL;

    sv->ten = malloc(strlen(ten) + 1);

    if (sv->ten == NULL) { sv_huy(sv); return NULL; }

    strcpy(sv->ten, ten);

    sv->diem = calloc(n, sizeof *sv->diem);

    if (sv->diem == NULL) { sv_huy(sv); return NULL; }

    sv->n = n;

    return sv;
}

/* Hủy: gọi được với NULL, và gọi được với đối tượng tạo dở. */
void sv_huy(SinhVien *sv)
{
    if (sv == NULL) return;

    free(sv->ten);
    free(sv->diem);
    free(sv);
}

/* Trả về chuỗi mới. Người gọi PHẢI gọi free.
   Trả về NULL nếu không đủ bộ nhớ. */
char *tao_ban_sao(const char *s);

/* Trả về con trỏ vào chính chuỗi đầu vào. KHÔNG được free.
   Chỉ hợp lệ khi chuỗi đầu vào còn sống. */
const char *tim_duoi(const char *ten_file);

/* Ghi vào bộ đệm do người gọi cấp. Không cấp phát gì. */
size_t dinh_dang(char *ra, size_t co, int n);