Con trỏ treo

int *p = malloc(sizeof *p);

if (p == NULL) return 1;

*p = 42;

free(p);        /* vùng nhớ đã trả lại, nhưng p VẪN giữ địa chỉ cũ */

printf("%d\n", *p);   /* hành vi không xác định */

char *s = malloc(64);

free(s);

strcpy(s, "abc");      /* ghi vào vùng đã trả lại */

/* Trường hợp tinh vi hơn: một con trỏ khác cùng trỏ vào đó */
char *a = malloc(64);
char *b = a;

free(a);
a = NULL;              /* a an toàn rồi */

b[0] = 'x';            /* nhưng b vẫn treo */

int *sai(void)
{
    int x = 42;

    return &x;      /* x chết khi hàm kết thúc */
}

/* Cũng vậy với mảng cục bộ */
char *ten_sai(void)
{
    char bo_dem[64];

    snprintf(bo_dem, sizeof bo_dem, "xin chao");

    return bo_dem;   /* bo_dem phân rã thành con trỏ, và nó chết ngay */
}

int *p;

{
    int a[5] = { 1, 2, 3, 4, 5 };

    p = a;
}                       /* a ra khỏi phạm vi, p thành con trỏ treo */

printf("%d\n", p[0]);

/* Biến thể trong vòng lặp */
int *q;

for (int i = 0; i < 3; ++i) {
    int tam = i;

    q = &tam;           /* tam mới mỗi lượt và chết mỗi lượt */
}

printf("%d\n", *q);

FILE *f = fopen("a.txt", "r");

fclose(f);

fgets(bo_dem, sizeof bo_dem, f);      /* f treo, cùng loại lỗi */

/* Và với chỉ số của cấu trúc dữ liệu */
size_t i = tim_vi_tri(ds, "abc");

ds_xoa(ds, 0);                        /* mọi phần tử dịch lên một chỗ */

dung(ds->phan_tu[i]);                 /* i giờ trỏ sai phần tử */

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

int main(void)
{
    int *p = malloc(sizeof *p);

    if (p == NULL) return 1;

    *p = 42;

    free(p);

    printf("%d\n", *p);      /* thường vẫn in ra 42 */

    int *q = malloc(sizeof *q);   /* rất có thể nhận lại đúng khối đó */

    *q = 99;

    printf("%d\n", *p);      /* giờ in 99, vì p và q cùng trỏ một chỗ */

    free(q);

    return 0;
}

free(p);
p = NULL;

/* Hoặc gói lại để không bao giờ quên */
#define GIAI_PHONG(p)  do { free(p); (p) = NULL; } while (0)

typedef struct {
    int   *du_lieu;
    size_t n, suc_chua;
} MangDong;

/* SAI: con trỏ hết hạn sau mỗi lần nới rộng */
int *p = &m.du_lieu[5];

md_them(&m, 42);

*p = 1;                    /* có thể treo */

/* ĐÚNG: chỉ số luôn hợp lệ */
size_t i = 5;

md_them(&m, 42);

m.du_lieu[i] = 1;          /* luôn đúng */

#include <stdlib.h>
#include <string.h>

typedef struct {
    size_t so_chu;      /* số nơi đang giữ con trỏ này */
    char   du_lieu[];   /* mảng thành viên linh hoạt */
} Chuoi;

Chuoi *chuoi_tao(const char *s)
{
    size_t n = strlen(s) + 1;
    Chuoi *c = malloc(sizeof *c + n);

    if (c == NULL) return NULL;

    c->so_chu = 1;
    memcpy(c->du_lieu, s, n);

    return c;
}

/* Nhận thêm một tham chiếu */
Chuoi *chuoi_giu(Chuoi *c)
{
    if (c != NULL) c->so_chu++;

    return c;
}

/* Trả lại tham chiếu. Chỉ giải phóng khi không còn ai giữ. */
void chuoi_tha(Chuoi *c)
{
    if (c == NULL) return;

    if (--c->so_chu == 0)
        free(c);
}

Chuoi *a = chuoi_tao("xin chao");
Chuoi *b = chuoi_giu(a);         /* so_chu thành 2 */

chuoi_tha(a);                    /* so_chu thành 1, chưa giải phóng */
a = NULL;

printf("%s\n", b->du_lieu);     /* vẫn hợp lệ */

chuoi_tha(b);                    /* so_chu thành 0, giải phóng thật */
b = NULL;