函数接口¶

char *strcpy(char *restrict dest, const char *restrict src);
char *strncpy(char *restrict dest, const char *restrict src, size_t n);

/**
 * @brief `strcpy` 简易实现. 将 `src` 复制到 `dest` 中, 并返回 `dest` 的指针.
 * 
 * @param dest 目标字符串的指针.
 * @param src 源字符串的指针.
 * @return `dest` 的指针, 便于链式调用.
 * @note 最简写法可将函数体压成三行: 先保存返回用的 dest, 再用
 *       `while ((*dest++ = *src++) != '\0');` 边拷边前进 —— 赋值表达式的值就是
 *       刚写入的字节, 写到 '\0' 时条件为假, 循环结束, 因而无需再单独补结尾.
 */
char *strcpy_sim(char *dest, const char *src)
{
    char *ret = dest;
    while (*src != '\0') {
        *dest++ = *src++;
    }
    *dest = '\0';

    // /* In simply */
    // char* ret = dest;
    // while ((*dest++ = *src++) != '\0');

    return ret;
}

char *shrink_space(char *dest, const char *src, size_t n);

#define IS_SPACE(c) ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r')

/**
 * @brief 将 `src` 中连续空白压缩后写入 `dest`, 接口语义类似 `strncpy`.
 * 
 * @note 这里的空白采用的是宏定义. 空白的求值必须采用「每次带入当前字符再求值」的
 *       形式 (宏或内联函数), 不能使用一个一次性的 bool 变量缓存起来(`int is_space = ...`):
 *       后者在 src 前进后不会更新, 会导致内层 while 死循环, 或漏掉串中间的空白段.
 *
 * @param dest 调用者提供的缓冲区, 至少 `n` 字节; 函数会改写其内容.
 * @param src  以 '\0' 结尾的源字符串; 只读.
 * @param n    最多写入 `dest` 的字节数. 若压缩结果不足 `n` 字节, 剩余位置
 *             填 '\0' (同 `strncpy`); 若恰好写满 `n` 字节, 不保证以 '\0' 结尾.
 * @return 原先的 `dest`, 便于当作表达式链式使用.
 *
 * @note 调用者须保证: `dest` 足够大、`src` 合法以 '\0' 结尾、二者指向的
 *       内存不重叠. 读写不越界是调用者的责任, 与 `strcpy` / `strncpy` 相同.
 */
char *shrink_space(char *dest, const char *src, size_t n)
{
    size_t i = 0;
    while (*src && i < n) {
        if (IS_SPACE(*src)) {
            while (IS_SPACE(*src)) {
                src++;
            }
            if (*src != '\0') {
                dest[i++] = ' ';
            }
        } else {
            dest[i++] = *src++;
        }
    }
    while (i < n) {
        dest[i++] = '\0';
    }

    return dest;
}

void *malloc(size_t size);  /* 失败返回 NULL; 成功返回对齐后的堆块首地址 */
void free(void *ptr);       /* free(NULL) 合法; 不可对同一指针 free 两次 */

void foo(void)
{
    char *p = malloc(10);
    /* 用完却忘记 free; 返回后局部指针 p 消失, 地址丢失 */
}

typedef struct {
    int number;
    char msg[20];
} unit_t;

void set_unit(unit_t *p)  /* 传出 */
{
    if (p == NULL)
        return;
    p->number = 3;
    strcpy(p->msg, "Hello World!");
}

int main(void)
{
    unit_t u;
    set_unit(&u);  /* 调用者提供对象的地址 */
    printf("%d %s\n", u.number, u.msg);
}

static const char *msg[] = {
    "Sunday", "Monday", "Tuesday", "Wednesday",
    "Thursday", "Friday", "Saturday"
};

void get_a_day(const char **pp)
{
    static int i = 0;
    *pp = msg[i % 7];
    i++;
}

const char *day = NULL;
get_a_day(&day);  /* day 被改成指向静态字符串 */

void alloc_unit(unit_t **pp)
{
    unit_t *p = malloc(sizeof(unit_t));
    if (p == NULL) { /* 处理失败 */ return; }
    p->number = 3;
    p->msg = malloc(20);
    strcpy(p->msg, "Hello World!");
    *pp = p;  /* 写回调用方的 unit_t * */
}

void free_unit(unit_t *p)
{
    free(p->msg);
    free(p);
}

char *get_a_day(int idx)
{
    static char buf[20];
    strcpy(buf, msg[idx]);
    return buf;
}

printf("%s %s\n", get_a_day(0), get_a_day(1));
/* Sunday Sunday, 而不是 Sunday Monday */

unit_t *alloc_unit(void)
{
    unit_t *p = malloc(sizeof(unit_t));
    /* 初始化... */
    return p;  /* 返回一层指针即可: 返回值本身会写进调用方的变量 */
}

unit_t *p = alloc_unit();
/* 使用后 */ free_unit(p); p = NULL;

typedef void (*callback_t)(void *);

void repeat_three_times(callback_t f, void *para)
{
    f(para);
    f(para);
    f(para);
}

void say_hello(void *str)
{
    printf("Hello %s\n", (const char *)str);
}

repeat_three_times(say_hello, "Guys");

/**
 * @brief 折半「插入点」查找的回调类型.
 *
 * 指向的函数应在有序区间 array[lo..hi] 上查找 key 应插入的下标,
 * 而不是「找到则下标、找不到则 -1」的精确查找.
 *
 * @param array 有序数组 (只读).
 * @param lo    查找区间左端 (含).
 * @param hi    查找区间右端 (含).
 * @param key   待插入关键字.
 * @return 插入下标 pos, 使得将 key 放在 pos 后 [lo..hi] 仍有序.
 *
 * @note 回调指针类型应与函数接口一致.
 */
typedef int (*bsearch_fn)(const int *array, int lo, int hi, int key);

/**
 * @brief 在有序区间 array[lo..hi] 上折半查找 key 的插入位置.
 *
 * @param array 有序数组 (只读).
 * @param lo    左端下标 (含).
 * @param hi    右端下标 (含).
 * @param key   待插入关键字.
 * @return 插入下标. 循环结束时的 lo; 相等元素插到右侧, 排序稳定.
 *
 * @note 用 `array[mid] <= key` 时 lo 右移, 故相等键不会插到已有相等元素左边.
 */
int binary_search_insert(const int *array, int lo, int hi, int key)
{
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;

        if (array[mid] <= key)
            lo = mid + 1;
        else
            hi = mid - 1;
    }
    return lo;
}

/**
 * @brief 折半插入排序: 通过回调在有序区中定位插入点.
 *
 * @param bsearch 折半查找插入点的函数指针, 类型见 `bsearch_fn`.
 * @param array   哨兵数组: array[1..n] 为待排序数据, array[0] 作暂存, 调用者须预留.
 * @param n       元素个数 (有效下标 1..n).
 *
 * @note 排序流程固定, 「如何找插入点」交给回调, 体现回调思想:
 *       库负责外层循环与搬移, 调用者只提供查找行为.
 */
void binary_insert_sort(bsearch_fn bsearch, int *array, int n)
{
    int i, j, pos;

    for (i = 2; i <= n; i++) {
        array[0] = array[i];

        /* 回调获取插入位置 */
        pos = bsearch(array, 1, i - 1, array[0]);

        /* 执行插入并后移元素 */
        for (j = i - 1; j >= pos; j--)
            array[j + 1] = array[j];
        array[pos] = array[0];
    }
}

#include <stdarg.h>

void printf_sim(const char *format, ...)
{
    va_list ap;
    char c;

    va_start(ap, format);
    while ((c = *format++)) {
        switch (c) {
        case 'c': {
            /* char 经 ... 时提升为 int */
            char ch = (char)va_arg(ap, int);
            putchar(ch);
            break;
        }
        case 's': {
            char *p = va_arg(ap, char *);
            fputs(p, stdout);
            break;
        }
        default:
            putchar(c);
        }
    }
    va_end(ap);
}