Tràn số và cách kiểm tra đúng

#include <limits.h>
#include <stdbool.h>

/* Cong */
bool cong_tran(int a, int b) {
    if (b > 0 && a > INT_MAX - b) return true;
    if (b < 0 && a < INT_MIN - b) return true;
    return false;
}

/* Tru */
bool tru_tran(int a, int b) {
    if (b < 0 && a > INT_MAX + b) return true;
    if (b > 0 && a < INT_MIN + b) return true;
    return false;
}

/* Nhan */
bool nhan_tran(int a, int b) {
    if (a == 0 || b == 0) return false;
    if (a == -1) return b == INT_MIN;
    if (b == -1) return a == INT_MIN;

    if (a > 0) {
        if (b > 0) return a > INT_MAX / b;
        return b < INT_MIN / a;
    }
    if (b > 0) return a < INT_MIN / b;
    return a < INT_MAX / b;
}

/* Chia */
bool chia_tran(int a, int b) {
    return b == 0 || (a == INT_MIN && b == -1);
}

bool __builtin_add_overflow(a, b, ket_qua);
bool __builtin_sub_overflow(a, b, ket_qua);
bool __builtin_mul_overflow(a, b, ket_qua);

/* Chung la macro tong quat: nhan moi kieu so nguyen, ke ca hai
   toan hang khac kieu nhau. Tra ve true neu TRAN, va van ghi
   ket qua quan vong vao *ket_qua. */

int r;

if (__builtin_mul_overflow(so_phan_tu, co_phan_tu, &r)) {
    return -1;                    /* tran, tu choi cap phat */
}

void *p = malloc((size_t)r);

#include <stdbool.h>
#include <limits.h>

#if defined(__GNUC__) || defined(__clang__)

#define CONG_TRAN(a, b, r) __builtin_add_overflow((a), (b), (r))
#define NHAN_TRAN(a, b, r) __builtin_mul_overflow((a), (b), (r))

#else

static inline bool CONG_TRAN(int a, int b, int *r) {
    if (b > 0 && a > INT_MAX - b) return true;
    if (b < 0 && a < INT_MIN - b) return true;
    *r = a + b;
    return false;
}

static inline bool NHAN_TRAN(int a, int b, int *r) {
    long long t = (long long)a * b;
    if (t > INT_MAX || t < INT_MIN) return true;
    *r = (int)t;
    return false;
}

#endif

/* Neu ban co kieu rong gap doi thi cach nay don gian nhat: */

int32_t a, b;
int64_t t = (int64_t)a * b;        /* KHONG the tran: 32 x 32 lot trong 64 */

if (t > INT32_MAX || t < INT32_MIN) return -1;

int32_t r = (int32_t)t;

/* Chu y ep kieu o VE PHAI cua phep nhan, khong phai o ket qua: */

int64_t sai  = a * b;              /* SAI: a * b tinh o 32 bit ROI moi mo rong.
                                      Da tran truoc khi gan */

int64_t dung = (int64_t)a * b;     /* DUNG: a duoc mo rong truoc,
                                      nen ca phep nhan lam o 64 bit */

unsigned int u = 0;
u = u - 1;                /* HOP LE: quan vong thanh UINT_MAX = 4294967295 */

size_t n = 0;
n = n - 1;                /* HOP LE: SIZE_MAX */

/* Khong co UB. Nhung ket qua gan nhu chac chan KHONG phai
   thu ban muon. */

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

void *cap_mang(size_t so, size_t co) {
    /* 1. Chan nhan tran */
    if (co != 0 && so > SIZE_MAX / co) return NULL;

    size_t tong = so * co;

    /* 2. Chan cap phat vo ly lon, thuong la dau hieu du lieu vao hong */
    if (tong > 64u * 1024u * 1024u) return NULL;

    /* 3. calloc tu kiem tra tran mot lan nua, va quet sach bo nho */
    return calloc(so, co);
}

/* Chuan bat buoc calloc phai tra ve NULL neu so * co tran.
   malloc thi khong co bao dam do, vi no chi nhan MOT doi so.

   Do la mot ly do rat tot de dung calloc cho mang. */

long long lon = 5000000000LL;

int nho = (int)lon;       /* implementation-defined truoc C23,
                             xac dinh tu C23: quan vong theo bu hai.
                             Gia tri o day la 705032704 */

/* Trinh bien dich khong canh bao vi ban da ep TUONG MINH.
   Bat -Wconversion de no canh bao cac ep NGAM: */

int a = lon;              /* warning: conversion from 'long long int'
                             to 'int' may change value [-Wconversion] */

/* Cach dung: kiem tra truoc khi thu hep. */

#include <limits.h>

if (lon > INT_MAX || lon < INT_MIN) return -1;

int nho = (int)lon;