const int *ptr1;       // Pointer to constant integer (không thay đổi giá trị được trỏ tới)
int * const ptr2;      // Constant pointer to integer (không thay đổi địa chỉ được trỏ tới)
const int * const ptr3; // Constant pointer to constant integer (cả hai đều không đổi)

int value1 = 10;
int value2 = 20;
 
const int *ptr1 = &value1;
// *ptr1 = 15;  // ❌ Lỗi: không thể thay đổi giá trị
ptr1 = &value2;  // ✅ OK: có thể thay đổi địa chỉ
 
int * const ptr2 = &value1;
*ptr2 = 15;      // ✅ OK: có thể thay đổi giá trị
// ptr2 = &value2; // ❌ Lỗi: không thể thay đổi địa chỉ

// 1. Static local variable
void counter() {
    static int count = 0;  // Chỉ khởi tạo 1 lần
    count++;
    printf("Count: %d\n", count);
}
 
// 2. Static global (file scope)
static int internal_var = 10;  // Chỉ visible trong file này
 
static void internal_func() {  // Chỉ gọi được trong file này
    // ...
}

// Hardware register
volatile uint32_t *GPIO_ODR = (uint32_t *)0x40020014;
 
// Shared với interrupt
volatile uint8_t flag = 0;
 
void interrupt_handler(void) {
    flag = 1;  // Set từ ISR
}
 
void main_loop(void) {
    while (flag == 0) {  // Compiler không optimize vì volatile
        // Wait...
    }
}

int global_init = 10;     // Data segment
int global_uninit;        // BSS segment
static int static_var;    // BSS segment
const int readonly = 5;   // Text segment (hoặc rodata)
 
void function() {
    int local;            // Stack
    static int s_local;   // Data/BSS segment
    int *ptr = malloc(4); // Heap
}

// malloc
int *arr1 = malloc(10 * sizeof(int));  // Giá trị random
if (arr1) {
    memset(arr1, 0, 10 * sizeof(int)); // Phải clear thủ công
}
 
// calloc
int *arr2 = calloc(10, sizeof(int));   // Đã = 0

// ❌ Memory leak
void bad_function() {
    char *buffer = malloc(1024);
    // ... xử lý ...
    // Quên free(buffer);
    return;  // buffer bị mất, không free được nữa
}
 
// ✅ Đúng cách
void good_function() {
    char *buffer = malloc(1024);
    if (!buffer) return;
    
    // ... xử lý ...
    
    free(buffer);
    buffer = NULL;
}

#define BIT(n) (1U << (n))
 
// Set bit
value |= BIT(3);        // Set bit 3
 
// Clear bit
value &= ~BIT(3);       // Clear bit 3
 
// Toggle bit
value ^= BIT(3);        // Toggle bit 3
 
// Check bit
if (value & BIT(3)) {   // Check bit 3 = 1
    // Bit is set
}

// STM32 GPIO example
#define GPIO_PIN_5  (1U << 5)
 
// Set pin 5 HIGH
GPIOA->ODR |= GPIO_PIN_5;
 
// Set pin 5 LOW
GPIOA->ODR &= ~GPIO_PIN_5;
 
// Toggle pin 5
GPIOA->ODR ^= GPIO_PIN_5;
 
// Check pin 5 state
if (GPIOA->IDR & GPIO_PIN_5) {
    // Pin is HIGH
}

bool is_power_of_2(unsigned int n) {
    return (n != 0) && ((n & (n - 1)) == 0);
}

is_power_of_2(8)   // true:  1000 & 0111 = 0000
is_power_of_2(16)  // true:  10000 & 01111 = 00000
is_power_of_2(10)  // false: 1010 & 1001 = 1000 (≠ 0)

struct MyStruct {
    int a;      // 4 bytes
    char b;     // 1 byte
    float c;    // 4 bytes
};  // Total: 12 bytes (với padding)
 
union MyUnion {
    int a;      // 4 bytes
    char b;     // 1 byte
    float c;    // 4 bytes
};  // Total: 4 bytes (largest member)

// Union để truy cập từng byte của uint32_t
union U32Bytes {
    uint32_t word;
    uint8_t bytes[4];
};
 
union U32Bytes data;
data.word = 0x12345678;
printf("Byte 0: 0x%02X\n", data.bytes[0]);  // 0x78 (little-endian)

// Khởi tạo watchdog (4 giây timeout)
void watchdog_init(void) {
    IWDG->KR = 0x5555;  // Enable register access
    IWDG->PR = 6;       // Prescaler
    IWDG->RLR = 4095;   // Reload value
    IWDG->KR = 0xCCCC;  // Start watchdog
}
 
// Main loop
void main(void) {
    watchdog_init();
    
    while(1) {
        // Xử lý task...
        
        IWDG->KR = 0xAAAA;  // Refresh watchdog (feed the dog)
        
        delay_ms(1000);
    }
}