/*
 * 函数名：my_memmove
 * 功能：在内存区域之间安全拷贝数据   uint16_t  arr[4];  my_memmove(&arr[1], &arr[2], sizeof(arr)/2-2);
 * 参数：
 *   dest - 目标内存起始地址
 *   src  - 源内存起始地址
 *   n    - 需要拷贝的字节数
 * 返回值：
 *   返回目标内存起始地址           
 *//*void* my_memmove(void* dst, const void* src, size_t n) {
    char* d = (char*)dst;
    const char* s = (const char*)src;
     // A:d.........d+n
    //         s................s+n                  //正向 *d++ = *s++;
    //B:                              d.........d+n  //正向 *d++ = *s++;
    //                      d.........d+n              //反向 *（--d)=*（--s）
    if (d < s ||d > s+n) {
        // 正向拷贝 
       // for (size_t i = 0; i < n; ++i)  d[i] = s[i];
        *d++ = *s++;
    } else //if (d > s) 
    {
        // 反向拷贝，防止覆盖
        //for (size_t i = n; i-- > 0; )  d[i] = s[i];
        d +=n-1;s+=n-1; while(n--)*(d--) = *(s--);
    }      
    return dst;
}*/

#include <stdint.h> // 用于 uintptr_t 类型 
 
void* my_memmove(void* dst, const void* src, size_t n) {
    if (n == 0) return dst; // 处理 n=0 的边界情况 
 
    char* d = (char*)dst;
    const char* s = (const char*)src;
    uintptr_t d_addr = (uintptr_t)d;
    uintptr_t s_addr = (uintptr_t)s;
 
    // 判断是否需要反向拷贝（内存重叠且目标地址在源地址后方）
    if (d_addr >= s_addr && d_addr < s_addr + n) {
        d += n - 1; // 指向目标区域末尾 
        s += n - 1; // 指向源区域末尾 
        while (n--) {
            *d-- = *s--; // 从后向前逐字节拷贝 
        }
    } else {
        while (n--) {
            *d++ = *s++; // 正向拷贝 
        }
    }
    return dst;
}