realloc

#include <stdlib.h>

void *realloc(void *p, size_t co_moi);

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

int main(void)
{
    size_t n = 5;
    int   *a = malloc(n * sizeof *a);

    if (a == NULL) return 1;

    for (size_t i = 0; i < n; ++i)
        a[i] = (int)i;

    /* Nới rộng lên 10 phần tử */
    size_t n_moi = 10;
    int   *tam = realloc(a, n_moi * sizeof *tam);

    if (tam == NULL) {
        fprintf(stderr, "Khong noi rong duoc\n");
        free(a);           /* a vẫn hợp lệ, phải tự giải phóng */
        return 1;
    }

    a = tam;               /* chỉ gán khi đã chắc chắn thành công */

    for (size_t i = n; i < n_moi; ++i)
        a[i] = (int)i;     /* phần mới chứa rác, phải tự điền */

    for (size_t i = 0; i < n_moi; ++i)
        printf("%d ", a[i]);

    printf("\n");

    free(a);

    return 0;
}

int *a = NULL;
size_t suc_chua = 0;

/* Không cần trường hợp đặc biệt cho lần đầu tiên */
for (size_t i = 0; i < 100; ++i) {
    if (i >= suc_chua) {
        suc_chua = suc_chua ? suc_chua * 2 : 4;

        int *tam = realloc(a, suc_chua * sizeof *tam);

        if (tam == NULL) { free(a); return 1; }

        a = tam;
    }

    a[i] = (int)i;
}

free(a);

char *bo_dem = malloc(4096);

/* Đọc dữ liệu, hóa ra chỉ dùng 100 byte */
size_t da_dung = doc_du_lieu(bo_dem, 4096);

char *tam = realloc(bo_dem, da_dung + 1);

if (tam != NULL) bo_dem = tam;      /* nếu thất bại thì giữ khối lớn, vẫn dùng được */

#include <stdint.h>
#include <stdlib.h>

typedef struct {
    int   *du_lieu;
    size_t n;          /* số phần tử đang dùng */
    size_t suc_chua;   /* số phần tử chứa được */
} MangDong;

/* Khởi tạo trạng thái rỗng, không cấp phát gì. */
void md_khoi_tao(MangDong *m)
{
    m->du_lieu  = NULL;
    m->n        = 0;
    m->suc_chua = 0;
}

/* Bảo đảm chứa được ít nhất can phần tử. Trả về 0 nếu ổn. */
static int md_bao_dam(MangDong *m, size_t can)
{
    if (can <= m->suc_chua) return 0;

    size_t moi = m->suc_chua ? m->suc_chua : 4;

    while (moi < can) {
        if (moi > SIZE_MAX / 2) return -1;      /* tránh tràn */

        moi *= 2;
    }

    if (moi > SIZE_MAX / sizeof *m->du_lieu) return -1;

    int *tam = realloc(m->du_lieu, moi * sizeof *tam);

    if (tam == NULL) return -1;                 /* du_lieu cũ vẫn nguyên */

    m->du_lieu  = tam;
    m->suc_chua = moi;

    return 0;
}

/* Thêm một phần tử vào cuối. Trả về 0 nếu ổn. */
int md_them(MangDong *m, int gia_tri)
{
    if (md_bao_dam(m, m->n + 1) != 0) return -1;

    m->du_lieu[m->n++] = gia_tri;

    return 0;
}

/* Giải phóng và đưa về trạng thái rỗng, gọi nhiều lần vẫn an toàn. */
void md_huy(MangDong *m)
{
    free(m->du_lieu);
    md_khoi_tao(m);
}

#include <stdio.h>

int main(void)
{
    MangDong m;

    md_khoi_tao(&m);

    for (int i = 0; i < 1000; ++i)
        if (md_them(&m, i * i) != 0) {
            fprintf(stderr, "Het bo nho tai i = %d\n", i);
            md_huy(&m);
            return 1;
        }

    printf("n = %zu, suc chua = %zu\n", m.n, m.suc_chua);
    printf("phan tu cuoi = %d\n", m.du_lieu[m.n - 1]);

    md_huy(&m);

    return 0;
}

/* Nếu chỉ còn dùng một phần tư sức chứa thì thu về một nửa.
   Ngưỡng một phần tư chứ không phải một nửa, để tránh trường hợp
   thêm rồi xóa liên tục quanh ngưỡng làm realloc chạy mãi. */
int md_xoa_cuoi(MangDong *m)
{
    if (m->n == 0) return -1;

    --m->n;

    if (m->suc_chua > 8 && m->n < m->suc_chua / 4) {
        size_t moi = m->suc_chua / 2;
        int   *tam = realloc(m->du_lieu, moi * sizeof *tam);

        if (tam != NULL) {          /* thu nhỏ thất bại thì bỏ qua */
            m->du_lieu  = tam;
            m->suc_chua = moi;
        }
    }

    return 0;
}