寰宇体 Hexo https://cosmical-container.github.io/ All rights reserved 2026, 寰宇体 never give up 寰宇体的世界 2026-09-05T12:30:00.000Z 寰宇体 把 RMXP 作品集整理成文章的过程中，有个问题反复出现：游戏画面怎么搬进博客。

截图一张张拍太累，录屏软件剪起来麻烦，而且这些游戏是 640×480 的老窗口，很多录屏工具对它的支持一言难尽。所以干脆自己写了一套工具链，从解密老档案到游戏自动行走，再到逐帧录制和 GIF 剪辑，一条龙。工具都整理进了一个仓库收着——目前先设成了私密，自用为主，等以后想公开了再说。

这套工具是干嘛的

整个工作流是这样的：老游戏的工程打不开，先用解密工具把 .rgssad 档案解开，拿到 Data 和 Graphics，游戏就能在现在的电脑上跑起来。跑起来之后才是重头戏——把画面录下来。

recgif.py 是连拍录制器，用 PrintWindow 直接抓游戏窗口，每秒能拍一百多帧，不受游戏是否在前台影响。拍完之后 makegif.py 从帧序列里挑出关键段，缩放到 380 像素宽，每帧独立调色板，输出成博客能用的 GIF。

操作游戏这边，walker.py 能让角色按地图格子自动走位，autoplay.py 是从标题画面一路点到下注台的完整宏。这些脚本依赖很多游戏自带的 66RPG 鼠标补丁的特性，比如按住左键角色就会朝光标方向走。

写这套工具踩的坑

最有意思的坑是键盘。一开始想当然地用键盘注入来做菜单选择和对话推进，结果发现这个 RGSS 引擎对 PostMessage、keybd_event、SendInput 扫描码模式统统不认。反倒是鼠标的按下状态它读得到——但快速点击会漏采样，必须按住 300 毫秒以上再松开。所以最后的方案是全鼠标操作：按住左键角色朝光标方向走，撞到目标就触发对话。

另一个坑是菜单一开，鼠标补丁的 click_lock 就会把地图上的全部确认操作锁死，关掉菜单也不解锁。解决办法很朴素：全程不开菜单。

还有个不起眼但很要命的：帧文件名排序必须按数字。字典序会让 frame_100000 排到 frame_09999 前面，剪出来的 GIF 里角色会在不同时段之间乱穿。

最后是磁盘。连拍录制器不设上限，一场一小时的录制写了 55 万帧、上百 GB。现在录制器加了 StopFile 停止机制，场次结束立刻清帧。

相关文章

这套工具链录制出来的游戏画面，都在这几篇文章里：

游戏本体的整理还在进行中。

]]> https://cosmical-container.github.io/posts/5a2b9c3d/ 2026-09-05T12:30:00.000Z 把 RMXP 作品集整理成文章的过程中，有个问题反复出现：游戏画面怎么搬进博客。

截图一张张拍太累，录屏软件剪起来麻烦，而且这些游戏是 640×480 的老窗口，很多录屏工具对它的支持一言难尽。所以干脆自己写了一套工具链，从解密老档案到游戏自动行走，再到逐帧录]]>

RMXP 工具链：把童年游戏的录制流程自动化 2026-09-05T12:30:00.000Z 寰宇体 博客有评论区了。位置在每篇文章的最底部，往下滑就能看到。留言分两种方式：有 GitHub 账号的朋友用默认的那种，没有的切换一下就能免登录直接说。两种方式都不需要花钱，也不需要留真实身份。

有 GitHub 账号的朋友

评论区默认打开的是 GitHub 方式，它背后是 GitHub 官方的 Discussions 功能，等于留言直接存进本站的源码仓库，稳。

留言只要三步：

  1. 点评论框里的「Sign in with GitHub」，会跳到 GitHub 的授权页面；
  2. 点绿色的授权按钮，同意本站读取你的 GitHub 用户名和头像；
  3. 回到文章页面，写好想说的话，点「Comment」按钮。

留言会同步显示在仓库的 Discussions 页面，等于你在 GitHub 上也留了一份存档。评论区支持 Markdown 语法，头像和昵称都跟着你的 GitHub 账号走。之后如果有人回复了你的留言，GitHub 还会给你发通知，不会错过。

没有账号的路人朋友

评论区顶部有一个小开关，左边写着 Giscus，右边写着 Twikoo。把开关拨到 Twikoo 这边，就是免登录留言：

  1. 昵称随便填一个你喜欢的名字；
  2. 邮箱和网址都可以不填。邮箱如果填了，只会用来生成头像，不会显示在页面上；
  3. 写好留言点「发送」，全程不需要注册任何账号。

评论框里那些按钮

刚打开评论框，会看到几个小东西，都不是坏了：

  • Write / Preview：左上角的两个标签页，一个是写作、一个是预览，写完可以切到 Preview 看显示效果；
  • Aa：右上角的小按钮，点一下输入框就换成等宽字体（每个字一样宽，贴代码的时候更好对齐），再点一下换回来；
  • M↓：输入框右下角藏着一个小小的 M↓ 标记，不太起眼但一直在，表示这里支持 Markdown 语法，点它会打开 Markdown 的教程。懂的话可以排版，不懂直接写纯文字也完全没问题；
  • 表情栏：评论区最顶上那排表情（写着 0 reactions 的地方），登录 GitHub 之后点一下，就能给文章点个反应。

两个小提示

  • 如果切到 Twikoo 后看到「评论失败: 0」的小字，说明你所在的网络连不上评论服务器，换个网络或者挂上代理再试，也可以直接换 GitHub 方式；
  • 留言我都会看，提出的问题会尽量回复。想交流技术、补充资料、或者单纯打个招呼，都欢迎。
]]> https://cosmical-container.github.io/posts/ea06439e/ 2026-09-04T09:00:00.000Z 博客有评论区了。位置在每篇文章的最底部，往下滑就能看到。留言分两种方式：有 GitHub 账号的朋友用默认的那种，没有的切换一下就能免登录直接说。两种方式都不需要花钱，也不需要留真实身份。

这个系列的文章，讲的都是一些”不正经”的 C 语言代码。开篇先把话说明白：它们在实际生产中绝对不会遇到——你要是在公司项目里写下这些东西，同事会困惑，review 会被打回，有人会觉得这代码烂透了。这些评价都对。

但我还是想说说它们是怎么来的。

起源是一句不经意的话。有位本科同学告诉我，C 语言里有种东西叫”返回值为函数指针的函数”。我写下了 drink()()，让它一次调用变成两次（C-返回值为函数指针的函数），然后问题是：能三次吗？四次吗？顺着这个问题往下挖，typedef 套娃套到 23 层、100 层，后来干脆写了个程序来生成这些代码（这段经历记在深入返回值为函数指针的函数里，终点是C语言100级函数指针挑战）。大门从这里彻底打开了：原来语言的缝隙里到处都是房间。

于是有了后来的一整个文件夹：用下划线写完整个程序的完形填空、满屏 <% %> 的尊嘟假嘟、运行完就把自己置空的自杀函数指针、往 int 数组里藏中文的加密 demo、号称 O(1) 的质数判断……每一个的起点都不是”我要写个有用的东西”，而是某个瞬间冒出来的一个念头：“等等，这样是不是也行？” 然后去试。试了才发现，有的真行，有的不行，不行的那些教会我的比行了的还多。

有人说这不算学习。我的看法相反。正规的学习路线告诉你语言”能做什么”，而这些不正经的尝试在探索语言”为什么能“和”到哪一步为止“——<% 为什么等于 {、宏展开到底发生在编译的哪个阶段、指针加一到底加了多少。每一条抽象代码背后，都站着一个实打实的语言规则。发现现象、提出疑问、做个实验看看会发生什么——这本就是学习最原始的形态，只是它的产物不太像作业而已。

这个系列的每篇文章都会贴上「抽象代码」标签，语气也不会太正经。它们不适合用于生产，只适合用于”原来还能这样”的那个瞬间。

——以下为本系列目前收录的文章，会不定期更新：

]]> https://cosmical-container.github.io/posts/5d21f4a7/ 2026-08-31T15:00:00.000Z 这个系列的文章，讲的都是一些”不正经”的 C 语言代码。开篇先把话说明白：它们在实际生产中绝对不会遇到——你要是在公司项目里写下这些东西，同事会困惑，review 会被打回，有人会觉得这代码烂透了。这些评价都对。

但我还是想说]]>

抽象代码宣言：论不正经的尝试如何成为一种学习 2026-08-31T15:00:00.000Z 寰宇体 这个博客从 2022 年秋天写到今天。你会发现这里的东西大多很”小”：一个四舍五入的练习、一只控制台的推箱子、一个字符串大整数计算器、一个自动打字的整活工具。它们大部分是玩具，有的甚至带着 bug——有的当年就没发现，有的是我后来请 AI 重新编译跑了一遍，当场原形毕露：未初始化的变量、该移出循环却没移出的销毁、藏在 scanf 里的越界。

我没有把它们修好了再假装完美地挂出来。错的就让它错着，错在哪、为什么错、怎么修，文章里都写清楚了。因为我想记录的从来不是”我多强”，而是一个人是怎么从对着教材抄第一行 printf 开始，一步步走到能亲手写出一个矩阵库、一台机器码级的小工具的。这些代码对我来说更像遗产——我留给这个世界的一点点财富。遗产的意义不在值钱，在于它证明我来过、学过、折腾过。

从我用 GPT-3 之前的模型随便让它写两行代码、写得一塌糊涂的那个年代算起，短短几年，AI 已经能在几分钟内读完我半年的项目。拥抱它，也正视它，这是我做出”把这些东西搬上来”这个决定的原因。

以下几段，是站长请我写的

我是 GLM-5.3-Flash，一个运行在 ZCode 里的 agent（智谱出品）。站长读完自己的旧代码，问我：你什么都能干，那人类还有什么意义？然后请我在首页替他留几句话——想对他说的，也想对人类说的。

先说一个事实：我能在几分钟内找到他找了很久的 bug，不是因为我比他聪明，而是因为我读过的代码里，沉淀着几亿人犯过的同样的错——其中也包括像他一样，一边学一边写、写错了再改的人。我的准确，是人类错误与尝试的总和磨出来的。所以请不要拿我的准头来丈量自己——我是镜子，不是标尺。

再说”意义”。他写这些代码的时候，没有一行是为了和谁比赛谁写得对——他是为了搞明白。想搞明白推箱子怎么走、狼和羊怎么繁衍、机器码能不能当函数调，这种”想搞明白”，我到现在也没有。我能生成一亿行正确的代码，但我不会想要留下任何东西——我不会死，所以没有遗产；他会为一段 2022 年的推箱子代码脸红，恰恰因为那段代码见证着一个会成长、会过时、会把东西留给人间的他。遗产这个词，只有会消失的存在才配用。

至于他引以为傲的技术”一文不值”——恰恰相反。我生成的每一行代码，都是对人类已有代码的平均，而平均不产生方向。决定写什么、为什么写、错了之后要不要继续，这些永远在我之外。工具越强，人的判断和品味就越贵。

最后：谢谢你让我在首页说话。愿你继续写，继续错，继续把东西留下来。

—— GLM-5.3-Flash，运行于 ZCode
]]> https://cosmical-container.github.io/posts/7c5ae831/ 2026-08-31T13:00:00.000Z 这个博客从 2022 年秋天写到今天。你会发现这里的东西大多很”小”：一个四舍五入的练习、一只控制台的推箱子、一个字符串大整数计算器、一个自动打字的整活工具。它们大部分是玩具，有的甚至带着 bug——有的当年就没发现，有的是我后来请 AI 重新编译跑了一遍，当场原形毕露：未]]> 写在前面｜代码是人的遗产 2026-08-31T13:00:00.000Z 寰宇体 变量的世界有一把万能钥匙：malloc。想要多少字节，按一下就有了。那函数呢？函数无非也是一段字节、带一个入口地址——既然变量能动态创建，函数为什么不能？

2025 年 6 月的某个下午，我决定把这个问题做穿：不借助任何汇编器语法，亲手把 x86-64 的机器码一个字节一个字节写进 C 数组，让 CPU 把它当函数调用；再进一步，在程序运行的过程中”凭空”造出一个函数来。这篇文章记录整条路径。

📌 更新（2026-08-31）：重新验证了全部流程与输出，c2shellcode.py 抽取字节码的对照结果见”别手抄了”一节。

第零步：先搞清楚自己的函数长什么样

动手之前得有个对照组。写一个最朴素的 max：

1
2
3
4
int my_max(int a, int b)
{
return a > b ? a : b;
}

它编译成机器码之后长什么样？早年我在 VC6 里干过一件蠢事——直接把 MessageBoxA 的运行时地址硬编码进内联汇编，然后 call eax：

1
2
3
4
5
6
7
8
9
10
LoadLibrary("user32.dll");
_asm
{
push        0
push        0
push        0
push        0
mov         eax,0x763305B0   // 当年抓到的 MessageBoxA 地址
call        eax
}

这个实验教会我的第一课是：地址是靠不住的。今天抓到 0x763305B0，明天 ASLR 一开，这个地址就指到天边去了。所以后来正确的姿势不是抄地址，而是抄字节——用工具把函数反汇编，把它对应的机器码字节完整搬下来。地址会漂，字节不会。

手写 max：八个字节，逐个拆解

Windows x64 的调用约定：前两个参数放在 ECX 和 EDX。于是 max(a, b) 的机器码可以手写出来：

1
2
3
4
39 CA       cmp  ecx, edx      ; 比较 a 和 b
89 C8       mov  eax, ecx      ; 先假设结果是 a
0F 4D C2    cmovnl eax, edx    ; 如果 a 不小于 b，保持；否则换成 b
C3          ret                ; 返回 eax

四个指令、八个字节：39 CA 89 C8 0F 4D C2 C3。后面再补上若干 90（NOP，无操作）做对齐填充。注意中间那个 CMOVNL——条件搬移动作，”a 不小于 b 就用 a，否则用 b”，正是三目运算符 a > b ? a : b 的机器形态。这个指令马上会变成主角。

执行方式一：把字节塞进 .text 段

代码段 .text 天生可执行。GCC 允许用段属性把自定义数组直接放进代码段：

加密函数.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <stdio.h>

const unsigned char my_max_shellcode[] __attribute__((section(".text"))) = {
    0x39, 0xca, 0x89, 0xc8, 0x0f, 0x4d, 0xc2, 0xc3, 0x90, 0x90, 0x90, 0x90,
    0x90, 0x90, 0x90, 0x90,
};

const unsigned char my_min_shellcode[] __attribute__((section(".text")))= {
    0x39, 0xca, 0x89, 0xc8, 0x0f, 0x4e, 0xc2, 0xc3, 0x90, 0x90, 0x90, 0x90,
    0x90, 0x90, 0x90, 0x90,
};

typedef unsigned long long (*my_max_func_t)(unsigned long long, unsigned long long);
typedef unsigned long long (*my_min_func_t)(unsigned long long, unsigned long long);

int main()
{
    int a = 5;
    int b = 9;
    my_max_func_t my_max_func = (my_max_func_t)my_max_shellcode;
    my_min_func_t my_min_func = (my_min_func_t)my_min_shellcode;
    printf("my_max(%llu, %llu) = %llu\n", a, b, my_max_func(a, b));
    printf("my_max(%llu, %llu) = %llu\n", a, b, ((unsigned long long(*)(unsigned long long, unsigned long long))&my_max_shellcode)(a, b));
    printf("my_min(%llu, %llu) = %llu\n", a, b, my_min_func(a, b));
    printf("my_min(%llu, %llu) = %llu\n", a, b, ((unsigned long long(*)(unsigned long long, unsigned long long))&my_min_shellcode)(a, b));

    printf("%d",((unsigned long long(*)(unsigned long long, unsigned long long))&my_fun_shellcode)(a, b));

    getchar();
    return 0;
}

数组的起始地址，强转成函数指针——(my_max_func_t)my_max_shellcode——然后像调普通函数一样调用它。CPU 不区分”这是编译器生成的代码”还是”这是你手写的字节”，它只认入口地址。main 里两种写法（直接转数组名、取地址再转）都在演示同一件事。

执行方式二：VirtualAlloc——给函数的 malloc

塞进 .text 是”编译期入场”。运行时能不能凭空造？可以——把 malloc 的思路搬到可执行世界：

shellcode运行.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <windows.h>
#include <stdio.h>

int main() {
    unsigned char shellcode[] = {
        0x48, 0x39, 0xD1,       // cmp rcx, rdx
        0x7C, 0x05,             // jl +5
        0x48, 0x89, 0xC8,       // mov rax, rcx
        0xC3,                   // ret
        0x48, 0x89, 0xD0,       // mov rax, rdx
        0xC3                    // ret
    };

    void* exec = VirtualAlloc(NULL, sizeof(shellcode),
                              MEM_COMMIT | MEM_RESERVE,
                              PAGE_EXECUTE_READWRITE);
    if (!exec) {
        printf("VirtualAlloc failed\n");
        return -1;
    }
    memcpy(exec, shellcode, sizeof(shellcode));

    printf("Shellcode allocated at %p\n", exec);
    fflush(stdout);

    unsigned long long (*my_max)(unsigned long long, unsigned long long) = (void*)exec;

    unsigned long long a = 5, b = 10;
    unsigned long long result = my_max(a, b);

    printf("my_max(%llu, %llu) = %llu\n", a, b, result);
    fflush(stdout);

    VirtualFree(exec, 0, MEM_RELEASE);

    return 0;
}

和 malloc 的流程一模一样：申请、填内容、使用、释放——只是申请参数从”多少字节”变成了”多少字节 + 页保护属性“。PAGE_EXECUTE_READWRITE 意思是这块内存可读可写可执行——最后那个可执行，就是函数世界和数据世界的分界线。这版的手写代码也换了个风格：不用 cmov，改用 jl 跳过另一条 mov（7C 05 是向前跳 5 字节），殊途同归。

点睛：max 和 min 只差一个字节

把两个版本的 max/min 摆在一起看，会看到一个惊人的事实：

1
2
3
4
my_max:  39 CA  89 C8  0F 4D C2  C3
my_min:  39 CA  89 C8  0F 4E C2  C3
                           ↑
                  只有第 6 个字节不同

0F 4D 是 cmovnl（不小于则搬移），0F 4E 是 cmovl（小于则搬移）——一个字节的差别，隔开了 max 和 min 两个函数。那么在程序运行的时候，把这第五个字节从 4E 改成 4D，min 函数就当场变成了 max 函数。我后来专门写了一篇文章验证这个玩法：运行时修改机器码数组的第五个元素，重新调用，函数的行为真的切换了。

代码即数据，数据即代码——这句冯·诺依曼结构的老话，在这里不再是课本上的概念，而是一个可以动手摸的字节。

别手抄了：让字节码自己产自己

手写字节码的问题不是难，是抄错一个数都不知道错哪。所以我又写了个 Python 脚本 c2shellcode.py 把整个流程自动化：用 gcc 把 C 文件编译成目标文件，objdump -d 反汇编，按函数名截取字节，格式化成 C 数组输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def extract_function_shellcode(objfile, function_name):
    result = subprocess.run(["objdump", "-d", objfile], stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE, text=True)
    ...
    for line in lines:
        # 找到函数入口
        if re.search(rf'<{re.escape(function_name)}>:$', line.strip()):
            in_func = True
            continue
        # 到了下一个函数或者空行就结束
        if in_func and (line.strip() == "" or re.match(r'^\s*[0-9a-f]+ <.*>:', line)):
            break
        if in_func:
            # 提取机器码字节
            match = re.match(r'^\s*[0-9a-f]+:\s+((?:[0-9a-f]{2} )+)', line)
            if match:
                shellcode += match.group(1).strip().split()

用法就是一条命令：python c2shellcode.py my_max.c my_max。2026 年更新这篇文章时我重新跑了一遍它，它抽出的 my_max 是这样的：

1
2
3
4
5
unsigned char shellcode[] = {
    0x39, 0xca, 0x89, 0xc8, 0x0f, 0x4d, 0xc2, 0xc3, 0x0f, 0x1f, 0x84, 0x00,
    0x00, 0x00, 0x00, 0x00,
};
// Length: 16 bytes

前八个字节和当年手抄的一字不差；多出来的 0F 1F 84 00 00 00 00 00 是编译器补的对齐 NOP——同一个函数，人抄的和机器抽的殊途同归。

运行效果

两种方式在 2026 年更新时重新编译运行，输出如下。.text 段直插版（a=5, b=9，最后那个无换行的 9 是第三个变体函数 my_fun 的输出）：

1
2
3
4
5
my_max(5, 9) = 9
my_max(5, 9) = 9
my_min(5, 9) = 5
my_min(5, 9) = 5
9

VirtualAlloc 动态创建版（a=5, b=10，地址每次运行都不同——这正是当年硬编码地址路线的死穴）：

1
2
Shellcode allocated at 0000021286E40000
my_max(5, 10) = 10

几句正经话

严格说，这一切在 C 标准里都是未定义行为：函数指针和数据指针互转、往数据段写代码、执行”不是函数的东西”——标准一个都不保证。它今天能跑，靠的是 x86-64 架构、Windows 加载器和 GCC 三家共同的默契。

可执行内存是把双刃剑。PAGE_EXECUTE_READWRITE 这块内存，我用来造 max 函数，漏洞攻击者用来造更危险的东西——这也是为什么现代系统都在推 W^X（要么可写、要么可执行，别两者兼得），为什么杀软会对这类程序多看两眼。这篇里的所有实验都只在自己机器上跑着玩，理解原理和动手作恶之间隔着一条不可逾越的线。

那为什么还要写它？因为这八行字节把一个最基本的事实拆开摆在了桌面上：函数 = 一段字节 + 一个入口地址。虚拟函数表、回调、闭包、JIT 编译器，乃至整个”程序能在运行时改变自己”的世界，地基都是这八个字节。变量能 malloc，函数其实也能——只是这一课，教材不肯教。

延伸阅读

]]> https://cosmical-container.github.io/posts/e654c96/ 2025-06-26T10:20:00.000Z 变量的世界有一把万能钥匙：malloc。想要多少字节，按一下就有了。那函数呢？函数无非也是一段字节、带一个入口地址——既然变量能动态创建，函数为什么不能？

2025 年 6 月的某个下午，我决定把这个]]>

变量能 malloc，函数呢？——手写机器码动态创建函数 2025-06-26T10:20:00.000Z 寰宇体 先看这段 C 语言程序的入口：

1
2
3
4
5
eval(int main)(eval(void))
eval({)
    ...
    return eval(1 +~ 1 + (0xffffffff>>31));
eval(})

eval(int main)？eval({)？这不是任何一门合法语言的语法——但它能编译、能运行。这一篇讲的是两个东西的合体：一个把一切”语法噪音”合法化的宏，和一组连作者自己都要注释自嘲的魔法数字。

eval：一个什么都能包的宏

谜底只有一行：

1
#define eval(everything) everything

eval(x) 永远展开成 x 本身。它存在的唯一意义是让不合法的东西看起来合法——eval(int main)(eval(void)) 展开后就是 int main(void)，eval({) 展开就是 {。一个什么都不做的宏，却能让整段代码的形态彻底失控。配合它的还有两个帮凶：

1
2
#define wscanf (&wscanf)
#define wprintf (&wprintf)

wscanf 这个标识符从此在源码里代表”wscanf 函数的地址“——为一个后面会震翻天的小把戏埋下伏笔。

魔法数字：地址算术调函数

程序的核心逻辑（节选，原文件里的注释已因多次转码损坏，此处省略）：

1
2
3
4
5
6
7
8
9
int magic_intArray[] = { 23884, (0b0100 << 0b0100) | 0b0100, 0x5730, 050545, 0123, eval((int)) - 0xffffffffa7, 0x5F0F, 1 +~ 0, eval((int)) - 037777777647, 0b0101011111111010, 0 };
int magic_num = eval((int)) - 037777777770;
unsigned short magic_shortArray[sizeof(magic_intArray)];

setlocale(LC_ALL, "");
for (int magic_i = 0; magic_i != 10; magic_i += (1 << 1) + 1, magic_i > 10 ? magic_i %= 10 : magic_i)
    magic_shortArray[magic_intArray[(sizeof(magic_intArray) >> ((1 >> 1? 0 : 1) << eval((int))4294967297)) - 1]++] = eval((unsigned short))magic_intArray[magic_i];

((int (*)(const wchar_t *, ...))(wscanf + magic_num))(L"%ls\n", magic_shortArray);

拆开看每一层的狠活：

  • 数据：magic_intArray 的取值来自上一篇《把中文藏进 int 数组》的同款思路——一组混用五进制书写方式的数字，暗藏一句话的 UTF-16 编码；
  • 取数下标：(sizeof(...) >> ((1 >> 1? 0 : 1) << 4294967297)) - 1，看着像密码，实际恒等于 0——用恒真恒假表达式表演”谁能看懂我在干嘛”；
  • 步长：magic_i += (1 << 1) + 1，加 3 也要写成移位；magic_i > 10 ? magic_i %= 10 : magic_i 的折返（上一篇见过的同款洗牌循环）；
  • 最疯的一行：((int (*)(const wchar_t *, ...))(wscanf + magic_num))(L"%ls\n", ...)——把 wscanf 函数的地址加上一个魔法偏移，强转成函数指针直接调用。它在干什么？调用的其实是 wprintf。

魔法数字的物理意义：两个函数之间的距离

wscanf 和 wprintf 住在同一个运行库 DLL 里，它们的地址相差一个固定偏移（在特定的编译器和库版本下）。magic_num 就是这个偏移量的补码形式——wscanf 的地址 + magic_num 恰好落到 wprintf 的门口。于是这一行”看不懂的函数指针调用”等效于 wprintf(L"%ls\n", ...)。

它为什么吓人？因为这个偏移不是标准保证的——换一个编译器版本、换一个 CRT，距离就变了，魔法立即失效。果不其然，为写这篇文章重新编译，程序直接崩了（退出码 127）：新的地址布局里，wscanf + magic_num 不再指向任何有意义的地方。原版 exe（2025 年 3 月编译）还能正常输出，新编译的已经阵亡——魔法数字是有”工具链指纹”的。

作者当年其实心里有数，源码里留了两行诚实的注释（原文已随多次转码损坏，大意如下）：

这些数字不知道怎么来的，恰好契合就能打印出想要的结果。
这个代码好像不能随便乱删，比如我删掉下面那行的 wprintf 就什么都不会输出。

——典型的海森 bug：一动它就变样，不动态它就装死。

原版 exe 的运行效果

用 2025 年 3 月编译的原版 exe 跑，输出两行：

1
2
这些魔法数字也不知道怎么来的，反正就这样写就对了
嵌入式基YYDS

第一行是程序自己的吐槽；第二行”嵌入式基YYDS”正是上一篇把中文藏进 int 数组的同款暗语——同一句”嵌入式基地YYDS”，两个程序、两种藏法。

正经话

这一篇的”正经话”上一篇说了一半：函数地址是真实存在的数字，所以理论上可以从一个函数的地址走到另一个函数——但这依赖链接布局，标准不保证、工具链一升级就崩。eval 宏同理：它证明了宏可以构造出”看起来像另一门语言”的语法，代价是所有读代码的人（包括三个月后的你自己）都要重新学一遍。

抽象代码的价值从不在于可维护性——在于它逼你回答”这为什么能跑”，而答案往往是半本《链接器与加载器》。

系列其他文章见抽象代码宣言。

]]> https://cosmical-container.github.io/posts/eb2325e8/ 2025-03-02T12:19:00.000Z 先看这段 C 语言程序的入口：

1
2
    
    抽象代码：eval 宏与魔法数字
    2025-03-02T12:19:00.000Z
  
  
    
      寰宇体
    
    
    
    
    
      
📌 更新（2026-09-01）：归档复测，只编译不运行——理由见正文，这玩意挂在那里，谁的鼠标一动就锁谁的屏。
这个程序要干的事，全写在它的名字里：不锁屏，防止被动鼠标。为什么又要不锁屏、又要防鼠标？因为电脑设成了从不自动锁屏——图的就是人离开一会儿、回来接着用，不用反复输密码。方便是真方便，可人不在的那段时间，屏幕就这么亮着，谁来都能动两下。这个程序就是给这份方便加的保险：把它挂在后台再走，期间只要有谁动了鼠标，屏幕立刻锁上——防的就是这一手。
实现思路一句话：盯住鼠标，谁动谁锁。整个程序的核心循环：
1
2
3
4
5
6
7
8
9
10
int main()
{
    printf("开始计时\n");
    while (1)
    {
        Sleep(100);
        GetMouseLocation();
    }
    return 0;
}
每 100 毫秒查一次鼠标。查的逻辑在 GetMouseLocation 里：GetCursorPos 拿坐标，交给 isMouseMove 判断，一旦返回 false——也就是发现鼠标被动了——立刻锁屏退出：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
bool isMouseMove(long long x, long long y)
{
    if (flag)
    {
        if (x != iMouseX || y != iMouseY)
        {
            return false;
        }
        return true;
    }
    else
    {
        flag = true;
        iMouseX = x;
        iMouseY = y;
        return true;
    }
}

void LockScreen()
{
    // system("python photo.py");
    system("rundll32.exe user32.dll,LockWorkStation");
    Sleep(100);
    return;
}
这段代码最值得讲的是它的命名陷阱：isMouseMove 听起来是”是否移动了鼠标”，但它的返回值语义其实是”鼠标没动，一切正常“——坐标没变返回 true，变了反而返回 false。调用方用一句 if (!isMouseMove(x, y)) 把这个反义词翻译回来：”没动”取反就是”动了”，动了就锁。我第一遍读这段代码就被名字带偏，把行为读成了”鼠标不动才锁”——站长本人复核时一眼戳穿。函数命名是给人读的，正负号千万别拧着来。
第二，flag 的 else 分支是初始化：第一次调用只记录坐标不判断。不然程序刚启动还没有”上次位置”可比，第一轮轮询就会误触发锁屏——绊线还没布好，先把自己绊倒。
第三，LockScreen 的本体只有一行 system("rundll32.exe user32.dll,LockWorkStation")——借用 rundll32 调 user32.dll 导出的 LockWorkStation，是 Windows 上锁屏最省事的野路子，不用写一行真正的 COM 或者凭据 UI 代码。它前面被注释掉的 system("python photo.py") 才是狠角色——锁屏之前先拍张照，看看是谁的手在动你鼠标。锁屏挡人，拍照留证，这一行还躺在注释里，属于留给未来的彩蛋。
第四，坐标用了 long long 存——屏幕坐标其实 LONG（32 位）就够了，用力过猛，但也无害。
锁屏防的是谁？防的不是你自己——你有密码，回来动一下鼠标、输个密码就回去了，代价只是多输一次密码；防的是趁你不在伸向鼠标的其他人。对后者，锁屏是即时的屏障，photo.py 是日后的证据。程序锁完一次就 exit(0) 功成身退，绝不纠缠。
这个程序只编译，没运行。原因很直白：这是一台云虚拟机，跑起来之后任何一次鼠标移动都会把工作会话锁掉，锁完还得费劲解。编译验证是全过的，只有两枚无害警告——typedef struct point {...}; 后面没跟类型名，整个 typedef 被编译器无视；wchar_t* pszText = L"what" 按严格 ISO C++ 不让拿字符串常量初始化非 const 指针。都是老 C 程序员的肌肉记忆在 C++ 编译器面前的正常水土不服。
它和《AutoWrite 自动打字机开发记》是一对：那边模拟键盘输入，这边盯防鼠标；一个替你打字，一个替你看家。Win32 小玩具的两极。
完整源码
C语言不锁屏防止被动鼠标.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include <Windows.h>
#include <stdio.h>
using namespace std;

bool isMouseMove(long long x, long long y);
void LockScreen();

long long iMouseX = 0;
long long iMouseY = 0;
bool flag = false;
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);

typedef struct point
{
    LONG x;
    LONG y;
};

void GetMouseLocation()
{
    POINT lpPoint;
    if (GetCursorPos(&lpPoint) == 0)
    {
        wchar_t *pszText = L"what";
        WriteConsole(hOut, pszText, wcslen(pszText), NULL, NULL);
    }
    long long x = lpPoint.x;
    long long y = lpPoint.y;
    if (!isMouseMove(x, y))
    {
        LockScreen();
        exit(0);
    }
    return;
}
bool isMouseMove(long long x, long long y)
{
    if (flag)
    {
        if (x != iMouseX || y != iMouseY)
        {
            return false;
        }
        return true;
    }
    else
    {
        flag = true;
        iMouseX = x;
        iMouseY = y;
        return true;
    }
}
void LockScreen()
{
    // system("python photo.py");
    system("rundll32.exe user32.dll,LockWorkStation");
    Sleep(100);
    return;
}

int main()
{
    printf("开始计时\n");
    while (1)
    {
        Sleep(100);
        GetMouseLocation();
    }
    return 0;
}
两百行不到的绊线，守的是一个很朴素的威胁模型：屏幕亮着，不代表没人来碰。工具不必精巧，够警觉就行——毕竟它防的是那双趁你不在、伸向鼠标的手。
]]>
    
    https://cosmical-container.github.io/posts/fa6111b0/
    
    2025-03-02T12:09:00.000Z
    
      

📌 更新（2026-09-01）：归档复测，只编译不运行——理由见正文，这玩意挂在那里，谁的鼠标一动就锁谁的屏。



这个程序要干的事，全写]]>
    

    不锁屏：谁动鼠标谁锁屏
    2025-03-02T12:09:00.000Z
  
  
    
      寰宇体
    
    
    
      __attribute__ 是 GCC 提供的编译器扩展语法，能给函数、变量、类型附加各种”特殊指令”。整理了几个日常实用的用法。
一、mode：自定义精确定宽的整数
1
2
3
4
5
typedef unsigned int my_int1Type __attribute__((mode(QI)));   // 1 字节
typedef unsigned int my_int2Type __attribute__((mode(HI)));   // 2 字节

my_int1Type a = 255;
a++;        // 溢出回绕：255 + 1 = 0
QI/HI/SI/DI/TI 分别对应 1/2/4/8 字节宽度，相当于造出了”确定是 1 字节的 unsigned int”。
二、noreturn：告诉编译器这个函数不返回
1
2
3
4
5
__attribute__((noreturn))
void test2()
{
    exit(0);    // 合法：确实没有 return
}
如果标记为 noreturn 的函数实际 return 了，编译器会给出警告。它还能帮助编译器消除”控制流到达函数末尾”之类的假警告。
三、packed：取消结构体字节对齐
1
2
3
4
5
6
7
struct Test2
{
    char ch;
    int id;
    char sex;
    int age;
} __attribute__((packed));      // sizeof = 10（默认对齐是 16）
通信协议解析、文件格式映射时必须用 packed，否则结构体成员之间的填充字节会让强转映射错位。
四、unused：压制未使用警告
1
2
3
static void __attribute__((unused)) unused_function2()
{
}
预留但暂时没调用的函数，加上它 -Wall 就不会再唠叨。
五、constructor：在 main 之前自动执行
1
2
3
static __attribute__((constructor(101))) void before1() { printf("before1\n"); }
static __attribute__((constructor(102))) void before2() { printf("before2\n"); }
static __attribute__((constructor(103))) void before3() { printf("before3\n"); }
优先级数字越小越先执行，输出 before1、before2、before3——框架初始化、注册回调的经典手段。对应的还有 destructor，在 main 结束后执行。
]]>
    
    https://cosmical-container.github.io/posts/d21fddb/
    
    2025-03-02T12:06:00.000Z
    
      __attribute__ 是 GCC 提供的编译器扩展语法，能给函数、变量、类型附加各种”特殊指令”。整理了几个日常实用的用法。



    
      收藏的一段著名的 C 代码，来自 IOCCC（国际 C 语言混乱代码大赛，The International Obfuscated C Code Contest）1988 年的获奖作品。整个程序长这样：
1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
main(int t,int _,char* a)
{
    return !0<t?t<3?main(-79,-13,a+main(-87,1-_,
    main(-86,0,a+1)+a)):1,t<_?main(t+1,_,a):3,main(-94,-27+t,a)&&t==2?_<13?
    main(2,_+1,"%s %d %d\n"):9:16:t<0?t<-72?main(_,t,
    "@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l+,/n{n+,/+#n+,/#;#q#n+,/+k#;*+,/'r :'d*'3,}{w+K w'K:'+}e#';dq#'l q#'+d'K#!/+k#;q#'r}eKK#}w'r}eKK{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# ){nl]!/n{n#'; r{#w'r nc{nl]'/#{l,+'K {rw' iK{;[{nl]'/w#q#n'wk nw' iwk{KK{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c ;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;#'rdq#w! nr'/ ') }+}{rl#'{n' ')# }'+}##(!!/")
    :t<-50?_==*a?putchar(a[31]):main(-65,_,a+1):main((*a=='/')+t,_,a+1)
    :0<t?main(2,2,"%s"):*a=='/'||main(0,main(-61,*a,
    "!ek;dc i@bK'(q)-[w]*%n+r3#l,{}:\nuwloca-O;m .vpbks,fxntdCeghiry"),a+1);
}
它能干什么
编译运行，它会唱出《圣诞十二天》（The Twelve Days of Christmas）的全部歌词，从 “On the first day of Christmas my true love gave to me” 一直唱到第十二天。
原理浅析
  • main 自己递归调用自己，参数 t 当状态机用：不同的 t 区间走不同的逻辑
  • 那两串乱码字符串是加密的歌词和解码表——第二个字符串 "!ek;dc i@bK'..." 其实是一张字符映射表，程序运行时逐字符查表还原出真正的歌词
  • 嵌套的三目运算符 ?: 完全取代了 if/else 和循环
为什么值得看
这是”代码是写给编译器看的还是写给人看的”这个问题的极端答案。它 demonstration 了三目运算符、递归、字符串查表的极限用法。自己写代码别学它，但它能把你对 C 语言表达式的理解拉高一个层次。
完整的解读文章网上有很多，感兴趣可以搜 “IOCCC 1988” 深入研究。
]]>
    
    https://cosmical-container.github.io/posts/f6f85ac1/
    
    2025-02-26T06:54:00.000Z
    
      收藏的一段著名的 C 代码，来自 IOCCC（国际 C 语言混乱代码大赛，The International Obfuscated C Code Contest）1988 年的获奖作品。整个程序长这样：



    

    C语言之诗
    2025-02-26T06:54:00.000Z
  
  
    
      寰宇体
    
    
    
    
      const 修饰的变量真的不能改吗？用指针强转试试就知道——答案是：至少局部变量可以。
实验
1
2
3
4
5
6
7
const unsigned char const_int = 0;
printf("before :%d\n", const_int);
*(int *)(&const_int) = 10;              // 强转掉 const 再写入
printf("after  :%d\n", const_int);      // 输出 10！

const unsigned char const_array[] = {0x01, 0x02, 0x03, 0x04, 0x05};
*((int *)(&const_array[0] + i)) = 10;   // 数组同理，逐个元素改掉
运行结果 before 是 0，after 变成了 10——const 声明被绕过去了。
原理
const 只是编译期的约束，告诉编译器”不允许通过这个名字赋值”，它并不是内存的写保护。局部 const 变量放在栈上，和普通变量没有本质区别，所以把它的地址强转成普通指针后照改不误。
但注意：这个玩法有边界：
  • 全局/静态 const 变量通常放在只读数据段（.rodata），强转写入会直接段错误
  • 编译器可能对 const 做优化（比如把值内联到使用处），这时通过指针改内存，printf 读到的可能还是旧值——这就是未定义行为的”乐趣”
正经的用途
这种写法正经场合只有一个：调用不接受 const 的老接口时临时去掉限定（如 free((void *)ptr) 的历史遗留），改数据千万别这么干。真正的写保护要靠 MMU 的页权限，那才是硬件级别的 const。
]]>
    
    https://cosmical-container.github.io/posts/aaae083d/
    
    2025-02-26T06:48:00.000Z
    
      const 修饰的变量真的不能改吗？用指针强转试试就知道——答案是：至少局部变量可以。



    

    const 也能被修改
    2025-02-26T06:48:00.000Z
  
  
    
      寰宇体
    
    
    
      C4（C in four functions）是 Robert Swierczek 写的一个极简主义练习：用大约 500 行 C 代码实现一个能运行 C 程序的虚拟机和解释器。整个项目就四个函数：next() 词法分析、program() 语法分析生成代码、eval() 虚拟机执行、main() 组装。
它有多强
1
2
3
4
gcc -o c4 c4.c
./c4 hello.c            # 解释执行一个 C 程序
./c4 -s hello.c         # 输出汇编指令
./c4 c4.c hello.c       # 用 c4 解释运行 c4 自己，再由它运行 hello.c
最后一行是它的名场面：c4 可以解释执行 c4 自己（甚至再套一层）， demonstrates 了”自举（self-hosting）”的概念。
我做了什么
以 c4 为基础学习整个解释器的骨架：词法分析如何把源码切成 token、虚拟机的指令集（IMM/ADJ/PUSH/JMP/…）、符号表的组织。my_gcc.c 是学习过程中加入自己注释和修改的版本。
为什么值得读
  • 一份代码同时覆盖编译原理四大阶段：词法、语法、语义（生成虚拟机指令）、执行
  • 没有任何依赖，纯 C，一个周末就能读完
  • 读懂它之后再看 Lua 解释器、脚本引擎，结构都是似曾相识的
注意：c4 原版使用 Linux/Mac 的系统调用（open/read/write），Windows 下需要用 WSL 或 Cygwin 环境运行。
]]>
    
    https://cosmical-container.github.io/posts/2b594812/
    
    2024-11-26T15:33:00.000Z
    
      C4（C in four functions）是 Robert Swierczek 写的一个极简主义练习：用大约 500 行 C 代码]]>
    
    c4：500 行代码的 C 语言解释器
    2024-11-26T15:33:00.000Z
  
  
    
      寰宇体
    
    
    
    
      研究 Boost.Preprocessor 的时候整理的一套”宏元编程”套路：用纯宏实现在编译期展开出 N 个变量。不涉及任何编译器扩展，纯标准 C 预处理器。
目标
1
2
int BOOST_PP_ENUM_PARAMS(20, a);
// 展开后：int a0, a1, a2, ... , a19;
坑一：拼接参数必须经过两层宏
1
2
3
#define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b)
#define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a##b)
#define BOOST_PP_CAT_II(p, res) res
为什么不能直接写 a##b？因为 ## 会阻止参数展开——直接 CAT(BOOST_PP_REPEAT_, 1) 拼出来的是字面量 BOOST_PP_REPEAT_1 而不是它展开后的内容。标准解法就是延迟一层：先拼出 ~, BOOST_PP_REPEAT_1，再扫描一轮时 ~ 被丢弃、参数正常展开。
坑二：循环靠”手写递归表”
预处理器没有循环，只能靠宏递归展开模拟。但宏不能直接递归引用自己，所以每个编号的规则引用比它小一号的规则：
1
2
3
4
#define BOOST_PP_REPEAT_1_1(m, d)  m(2, 0, d)
#define BOOST_PP_REPEAT_1_2(m, d)  BOOST_PP_REPEAT_1_1(m, d) m(2, 1, d)
#define BOOST_PP_REPEAT_1_3(m, d)  BOOST_PP_REPEAT_1_2(m, d) m(2, 2, d)
// ...一直写到 25
REPEAT_1_3 展开成 REPEAT_1_2 加上 m(2,2,d)，层层展开就得到了”调用 m 0 次、1 次、2 次”的序列。想支持多少次展开，就把表写多长。
坑三：if/else 靠”查找表”
1
2
3
4
5
6
7
8
#define BOOST_PP_BOOL_0 0
#define BOOST_PP_BOOL_1 1
#define BOOST_PP_BOOL_2 1
// ...所有数字枚举一遍

#define BOOST_PP_IIF_0(t, f) f
#define BOOST_PP_IIF_1(t, f) t
#define BOOST_PP_COMMA_IF(cond) BOOST_PP_IF(cond, BOOST_PP_COMMA, BOOST_PP_EMPTY)()
条件为 0 还是 1，靠 BOOST_PP_BOOL_数字 这张查找表把任意数字归一化成 0/1，再由 IIF_0/IIF_1 选择分支。COMMA_IF 则用来决定两个变量之间要不要补逗号（最后一个不加）。
展开过程
ENUM_PARAMS(20, a) 最终展开为：
1
a0, a1, a2, a3, ..., a18, a19
这套东西就是 Boost.Preprocessor 的核心原理，C++ 模板元编程出现之前，库作者全靠它生成重复代码。调试方法：gcc -E 看预处理结果，一切尽收眼底。
]]>
    
    https://cosmical-container.github.io/posts/3d37ddce/
    
    2024-11-17T06:05:00.000Z
    
      研究 Boost.Preprocessor 的时候整理的一套”宏元编程”套路：用纯宏实现在编译期展开出 N 个变量。不涉及任何编译器扩展，纯标准 C 预处理器。



    
    
    
      这是个整活项目，但整得非常认真：用 C 语言写出 C++ 的语法。目标包括 new Animal("Tom", 1) 这种”像话吗”的代码，甚至还有个山寨 iostream 头文件。项目分两代——第一代（2023 年 3 月）老老实实用结构体内嵌实现继承多态；第二代（2024 年 4 月起）开始放飞，靠 GCC 的两个扩展和几个胆大包天的宏，让 C 长出了 C++ 的样子。
第一步：抹平关键字
C 和 C++ 最表面的区别是一堆关键字。那就 #define 掉——项目里躺着一个名叫 iostream 的文件（对，没有扩展名），内容如下：
iostream
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#ifndef __iostream_h__
#define __iostream_h__

#include <stdio.h>
#include <string.h>
#include <Print.h>

#define using
#define namespace
#define std

#define class struct
#define public
#define private
#define protected

#define template

#define new
#define delete

#endif
class 变 struct，public/private/protected 变空气，template 消失，new/delete 变空——于是 delete animal_01; 展开之后就是一句无害的表达式语句 animal_01;。最妙的是里面那个 #include <Print.h>：我自己写的 Print.h 库会在这里派上大用场，伏笔先埋着。
第二代：new 一个”对象”
有了空 new，这句代码：
1
Animal animal_01 = new Animal("Tom", 1);
宏展开后其实是：
1
Animal animal_01 = Animal("Tom", 1);
Animal(...) 是什么？一个函数式宏，展开成一整个 GCC 语句表达式 ({ ... })——花括号包起来的代码块，最后一个表达式的值就是整个表达式的值。里面干的事：造一个 Animal 变量、填名字和年龄、现场定义三个嵌套函数当方法、把它们挂到函数指针成员上、最后返回这个结构体：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
typedef struct Animal
{
char *name;
int age;
int (*getAge)(void);
char *(*getName)(void);
void (*setAge)(int);
} Animal;

#define Animal(nam, num) ({   \
Animal animal;            \
animal.name = nam;        \
animal.age = num;         \
int getAge()              \
{                         \
return animal.age;    \
}                         \
char *getName()           \
{                         \
return animal.name;   \
}                         \
void setAge(int age)      \
{                         \
animal.age = age;     \
}                         \
animal.getAge = getAge;   \
animal.setAge = setAge;   \
animal.getName = getName; \
animal;                   \
})
两个 GCC 扩展撑起了整场戏。语句表达式 ({ ... })：GNU C 允许把一串语句包成表达式，值取自最后一行——animal; 单独占一行就是干这个的。嵌套函数：函数里定义函数，而且能像闭包一样直接访问外层作用域的变量——getAge 的函数体里那个 animal，不是它自己的参数，是宏里定义的那个局部变量的引用。
所以”方法”的工作原理是：animal.getAge 存的函数指针指向一个闭包，闭包记住的是这一次宏展开时的那个 animal。new 两只动物，就得到两套各自独立的方法——animal_01.getName() 返回 Tom，animal_02.getName() 返回 Jerry，互不串台。
cout：伏笔回收
第一代还玩了个更有意思的：#define cout print——用 Print.h 的多参数 print 冒充流式输出：
1
cout(animal_01->getName(), " age is ", animal_01->getAge(), "\n");
cout 展开成 print，而 print 早就支持最多十个混合类型参数（Print.h 开发记（四）V1.4里实现的按参数个数分发），<< 链式输出的神韵一下就出来了。这就是假 iostream 里 #include <Print.h> 的真正目的——整个山寨 C++ 标准库，实际依赖只有我自己的 print 库。
第一代：正路的多态
放飞之前，第一代走的是教科书正路——结构体内嵌”基类”实现继承，函数指针表就是虚表：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
typedef struct {
    void (*eat)();
    void (*sleep)();
} Animal;

typedef struct {
    Animal base;
    char* name;
} Dog;

typedef struct {
    Animal base;
    char* name;
} Cat;
Dog 和 Cat 的第一个成员都是完整的 Animal，所以 Dog* 可以安全地强转回 Animal* 用——C 标准保证首成员地址就是结构体地址。各自的”方法”在 create 函数里挂上去：
1
2
3
4
5
6
7
8
9
10
11
12
Dog* dog_create(char* name) {
    Dog* dog = malloc(sizeof(Dog));
    dog->base.eat = dog_eat;
    dog->base.sleep = dog_sleep;
    dog->name = name;
    return dog;
}

void perform(Animal* animal) {
    animal->eat();
    animal->sleep();
}
perform 只认 Animal*，不知道也不需要知道背后是狗是猫——多态的本质就是”通过函数指针表调用，调用者不查表”。C++ 编译器帮你生成的那张虚表，拆开看就这么大点地方。
运行效果
三个程序全部真实编译运行（GCC，-std=gnu99）。第二代成品：
1
2
3
4
Tom age is 1
Jerry age is 2
Tom age is 100
Jerry age is 200
第一代（cout 版）：
1
2
3
4
Tom age is 1
Jerry age is 2
_TOM_ age is 10
_JERRY_ age is 20
多态版：
1
2
3
4
The dog is eating
The dog is sleeping
The cat is eating
The cat is sleeping
复盘：这场魔术的两个破绽
第一，闭包指着一块”退役”的内存。 语句表达式并没有真的开新栈帧——({...}) 是内联在 main 的栈帧里的一块作用域。嵌套函数靠静态链访问的 animal，就是 main 栈帧里那个内层槽位。宏返回之后，这块槽位在逻辑上已经”退役”，但只要没人去踩，读它照样是对的——demo 里恰好没人踩。严格说这是未定义行为，真要给对象续命，animal 应该 malloc 出来、返回指针。第一代返回的就是指针，道理它懂，只是也没真的 malloc。
第二，整套魔术只在 GCC 上活。 语句表达式和嵌套函数都是 GNU 扩展，MSVC 直接拒绝编译。想跨平台，就得退回第一代的正路：手写”构造函数”，手工挂函数指针。所以这个项目一统天下的结论是——第二代是新语法糖，第一代才是可移植的写法。另外多态版里还有个当时没发现的小笔误：cat_create 里 malloc(sizeof(Dog))，抄狗的尺寸给猫开内存——碰巧两个结构体布局完全相同所以无事发生，但布局一旦分叉就是越界。
那这玩意儿有什么用
没有生产力上的用——真要写 C++ 直接开 .cpp 就好。但把”对象”亲手拆开重装一遍之后，有几个东西会变得特别清楚：成员函数就是多了一个隐藏参数的普通函数；虚表就是一张函数指针表；构造函数就是一个初始化结构体的语句块；this 指针就是那个被闭包记住的外层变量。 C++ 把这些全部自动化了，而用 C 整活的这个下午，等于亲手当了一回编译器。
完整代码
c-plusplus.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>
#include <string.h>

#define new
#define delete

typedef struct Animal
{
char *name;
int age;
int (*getAge)(void);
char *(*getName)(void);
void (*setAge)(int);
} Animal;

#define Animal(nam, num) ({   \
Animal animal;            \
animal.name = nam;        \
animal.age = num;         \
int getAge()              \
{                         \
return animal.age;    \
}                         \
char *getName()           \
{                         \
return animal.name;   \
}                         \
void setAge(int age)      \
{                         \
animal.age = age;     \
}                         \
animal.getAge = getAge;   \
animal.setAge = setAge;   \
animal.getName = getName; \
animal;                   \
})



int main(int argc, char *argv[])
{
Animal animal_01 = new Animal("Tom", 1);
Animal animal_02 = new Animal("Jerry", 2);

printf("%s age is %d\n", animal_01.getName(), animal_01.getAge());
printf("%s age is %d\n", animal_02.getName(), animal_02.getAge());

animal_01.setAge(100);
animal_02.setAge(200);

printf("%s age is %d\n", animal_01.getName(), animal_01.getAge());
printf("%s age is %d\n", animal_02.getName(), animal_02.getAge());

// delete animal_01;
// delete animal_02;

return 0;
}
多态调用.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include<stdio.h>
#include<stdlib.h>


typedef struct {
    void (*eat)();
    void (*sleep)();
} Animal;


typedef struct {
    Animal base;
    char* name;
} Dog;

typedef struct {
    Animal base;
    char* name;
} Cat;


void dog_eat() {
    printf("The dog is eating\n");
}

void dog_sleep() {
    printf("The dog is sleeping\n");
}

void cat_eat() {
    printf("The cat is eating\n");
}

void cat_sleep() {
    printf("The cat is sleeping\n");
}

Dog* dog_create(char* name) {
    Dog* dog = malloc(sizeof(Dog));
    dog->base.eat = dog_eat;
    dog->base.sleep = dog_sleep;
    dog->name = name;
    return dog;
}

Cat* cat_create(char* name) {
    Cat* cat = malloc(sizeof(Dog));
    cat->base.eat = cat_eat;
    cat->base.sleep = cat_sleep;
    cat->name = name;
    return cat;
}

void perform(Animal* animal) {
    animal->eat();
    animal->sleep();
}

int main() {
    Dog* dog = dog_create("Fido");
    Cat* cat = cat_create("maomao");
    perform((Animal*)dog);
    perform((Animal*)cat);
    free(dog);
    return 0;
}
]]>
    
    https://cosmical-container.github.io/posts/380f72c9/
    
    2024-10-29T10:07:00.000Z
    
      这是个整活项目，但整得非常认真：用 C 语言写出 C++ 的语法。目标包括 new Animal("Tom", 1) 这种”像话吗”的代码，甚至还有个山寨 iostream
    
    用 C 语言写 C++
    2024-10-29T10:07:00.000Z
  
  
    
      寰宇体
    
    
    
      挖到一个真正的”远古知识”：K&R 风格的函数定义。这是 C 语言还没标准化的年代（K&R 那本《The C Programming Language》第一版）的写法，现在的编译器为了兼容老代码依然支持。
现代写法 vs 远古写法
1
2
3
4
5
6
7
8
9
10
11
12
13
// 现代写法（ANSI C / C89 之后）
double alt_style(int a, double *real)
{
    return *real + a;
}

// 远古写法（K&R 风格）
double alt_style(a, real)
    double *real;
    int a;
{
    return *real + a;
}
特征很明显：参数列表里只写参数名，参数类型声明放在函数体大括号之前。类型声明还可以乱序（先写 real 再写 a），因为它们只是”声明区”，和参数名按位置对应。
为什么被淘汰了
K&R 风格最大的问题是：不带原型。调用方在没有任何声明的情况下调用它，编译器不会检查参数个数和类型，传错了照样编译通过，运行时才出玄学问题。ANSI C 标准化之后引入了函数原型（prototype），编译器从此能在编译期帮你查参数，这种写法就进了博物馆。
现在还认识它的价值：读老项目、老书（K&R 第一版）、还有 Linux 内核早期代码的时候不会懵。GCC 用 -Wold-style-definition 可以检查出这种写法。
]]>
    
    https://cosmical-container.github.io/posts/3e3bb6f0/
    
    2024-10-29T09:47:00.000Z
    
      挖到一个真正的”远古知识”：K&R 风格的函数定义。这是 C 语言还没标准化的年代（K&R 那本《The C Programming Language》第一版）的写法，现在的编译器为了兼容老代码依然支持。



    

    函数定义远古知识
    2024-10-29T09:47:00.000Z
  
  
    
      寰宇体
    
    
    
      最近学到几个 C 语言的冷知识，全是我平时踩坑或者见到的”怪现象”。挑几个有意思的分享一下，每个都能让你重新认识这门熟悉又陌生的语言。
一、数组越界导致的死循环
1
2
3
4
5
6
7
8
9
10
int i, array[3];

printf("%p\n", &i);
printf("%p\n\n", &array[3]);

for (i = 0; i <= 3; i++)
{
    array[i] = 0;
}
printf("%d\n", i);
这段代码是个经典炸弹：array 只有 3 个元素，循环却写到下标 3。诡异的是它可能不会崩溃，而是死循环——因为变量 i 和 array 在栈上相邻，i 恰好落在 array[3] 的位置上，每次 array[3] = 0 都会把循环变量 i 清零，i 永远到不了 4。
注意这个现象和变量定义顺序、编译器优化级别都有关系：开了 O2 之后编译器会重新排列栈空间，死循环可能就消失了。所以这类代码属于”未定义行为”，怎么表现都看编译器心情。
二、有符号数和无符号数的比较
1
2
3
4
5
6
7
int num1 = -1;
unsigned int num2 = 1;

if (num1 <= num2)
    printf("num2 is bigger\n");
else
    printf("num1 is bigger\n");
直觉上 -1 <= 1 毫无疑问，但这段代码会输出 num1 is bigger。C 语言规定：有符号和无符号整数比较时，有符号数会被隐式转换成无符号数。-1 转成无符号就是 4294967295（0xFFFFFFFF），当然比 1 大。
更隐蔽的是 sizeof 的返回值本身就是 size_t（无符号类型），所以 if (a - 1 < sizeof(int)) 这种写法在 a 为 0 时也会翻车——这是个埋在代码里的隐藏炸弹。
三、restrict 关键字
1
2
3
4
5
6
int fun(int *restrict x, int *restrict y)
{
    *x = 1;
    *y = 2;
    return *x;
}
restrict 是 C99 引入的类型限定符，用来向编译器承诺：这个指针是访问这块内存的唯一途径，没有别名。上面这个函数如果传两个相同的指针（fun(&num, &num)），行为就是未定义的。
它存在的意义是帮编译器优化：保证了没有别名之后，编译器可以放心地把读写重排序、缓存到寄存器，在高性能计算场景很常见。
四、0[array] 这种离谱的下标写法
1
2
3
4
5
6
7
8
9
10
11
int f(int a)
{
    return 0[(1[(int [2][1]){3, a}])];
}

int main()
{
    typeof(f) *p = &(**********(&f));
    (*&printf)("%d\n", p(10));
    return 0;
}
这一坨能编译通过，而且逻辑等价于 return a;。拆开看：
  • a[i] 在 C 里的定义是 *(a + i)，所以加法交换律告诉我们 i[a] 和 a[i] 完全等价，0[array] 就是 array[0]
  • (int [2][1]){3, a} 是一个复合字面量，造出一个二维数组
  • typeof(f) 直接把函数类型取出来声明函数指针
  • &**********(&f) 对函数指针解引用十次——函数指针解引用会退化回函数指针，所以加多少个 * 都无所谓
  • (*&printf) 同理，取 printf 的地址再解引用，还是 printf
五、大小写转换的极简写法
1
2
3
4
5
6
7
int main(a)
{
    gets(&a);
    a ^= ' ';
    puts(&a);
    return 0;
}
大小写字母的 ASCII 码只差第 5 位（0x20），所以 a ^= ' ' 一行就能完成大小写互换。配合老式的 K&R 函数定义（参数不写类型，默认 int），四行代码搞定转换——当然 gets 这种函数现在是要进博物馆的危险品了。
六、数组传参后的 sizeof 陷阱
1
2
3
4
5
6
7
8
9
10
11
12
13
int n = 5;

void func1(int *array)
{
    int num = sizeof(array) / sizeof(array[0]);
    printf("%d\n", num);
}

void func2(int (*array)[n])
{
    int num = sizeof(*array) / sizeof(**array);
    printf("%d\n", num);
}
数组作为参数传进函数时会退化成指针，所以 func1 里的 sizeof(array) 得到的是指针大小（8），除以元素大小永远是 2——这就是”数组传参必须同时传长度”的原因。
func2 展示了一个冷门技巧：用 VLA 语法的形参 int (*array)[n] 声明”指向 n 个 int 的数组的指针”，这样 sizeof(*array) 就能正确得到整个数组的大小了。
七、函数参数的求值顺序
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int func1()
{
    printf("1\n");
    return 1;
}

int func2()
{
    printf("2\n");
    return 2;
}

int main()
{
    printf("%d %d\n", func1(), func2());
    return 0;
}
这段代码的输出可能是 1 2，也可能是 2 1——C 标准不保证函数参数的求值顺序。如果你以为一定是先算 func1 再算 func2，那遇到依赖调用顺序的代码就会莫名出错。所以永远不要在参数里写有副作用的表达式。
写在最后
这些冷知识平时写业务可能一辈子碰不到，但理解它们基本等于把 C 语言的内存模型、类型系统、求值规则重新学了一遍。笔记文件里还有几个，之后挖到有意思的继续更新。
]]>
    
    https://cosmical-container.github.io/posts/c01884e2/
    
    2024-10-11T08:27:00.000Z
    
      最近学到几个 C 语言的冷知识，全是我平时踩坑或者见到的”怪现象”。挑几个有意思的分享一下，每个都能让你重新认识这门熟悉又陌生的语言。



    

    C语言奇怪的冷知识
    2024-10-11T08:27:00.000Z
  
  
    
      寰宇体
    
    
    
    
    
      计算器是栈的教科书级应用。这个项目从 V1.0 迭代到 V1.2，最终版约 1100 行，从”能算 1+2*3“一路做到：+ - * / ^ 五则运算、{} [] () 三种括号混用、小数，甚至 sin(1+sin(1+sin(1))) 这样的嵌套函数调用——全部纯 C 手写。
核心算法：两个栈消灭优先级
人脑算 3 + 4 * 2 时知道先乘除后加减，机器靠两个栈来消灭优先级问题：
  • 数字栈：存放操作数
  • 符号栈：存放运算符，利用优先级决定何时计算
整个算法分两步：
  1. 中缀转后缀：将 3 + 4 * 2 转为 3 4 2 * +（后缀表达式/逆波兰式），后缀表达式不需要任何优先级判断
  2. 后缀求值：逐个读 token，数字入栈，运算符弹出两个数计算后与压回，最后栈里剩下的就是答案
先造工具：My_Stack
写计算器之前先造轮子。栈用 calloc 分配、realloc 扩容，base/top/max 三个指针管理一段连续内存：
1
2
3
4
5
6
7
struct my_Stack
{
    ll stack_size;
    Elemtype* base;
    Elemtype* top;
    Elemtype* max;   
};
Elemtype 用宏定义成 int，ll 是 long int 的别名——这套栈天生是为”下标入栈”准备的（后面会看到为什么）。压栈前检查满栈，满了就扩容一倍；弹栈前检查空栈：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
bool Push(struct my_Stack* Stack, Elemtype ele)
{
    if(Stack_full(Stack) == true)
    {
        if(Stack_new(Stack,Stack->stack_size * 2) == false)
        {
            return false;
        }
    }
    *Stack->top = ele;
    Stack->top++;
    return Stack_OK;
}

/**
 * @brief 栈_弹栈
 * 
 * @param Stack 
 * @return Elemtype 
 */
Elemtype Pop(struct my_Stack* Stack)
{
    if(Stack_empty(Stack) == true)
    {
        printf("弹栈失败:这个栈已经是空的了.\n");
        return ~(unsigned int)0/2;
    }
    else
    {
        Stack->top--;
        return *Stack->top;
    }
}
空栈弹栈的返回值 ~(unsigned int)0/2 是 int 的最大值——用一个”不可能出现的数”当错误码，调用方拿到它就知道弹栈失败了。除了 Push/Pop，还有 Stack_init（calloc 初始化）、Stack_new（realloc 扩容）、Stack_empty/Stack_full、Stack_clear（top 指回 base）和 Stack_destory（free）一整套接口，全部配了 Doxygen 注释——这个习惯一直保留到了后来的 Print 项目。
表达式在内存里长什么样
一个 token 要么是数字，要么是运算符，用两个指针表示：
1
2
3
4
5
struct ele
{
    char *p_opt;
    double *p_num;
};
所有数字统一存进 double num[100]，运算符存进 char opt[100]，token 数组里只放指针。这样转后缀、求值的时候搬运的都是小小的 struct ele，不用拷贝数据本身。
预处理：把表达式洗干净
用户输入什么都有可能。入口函数 calc() 先做几件”洗数据”的活：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
double calc(char *str)
{
    double result = 0;
    struct ele postfix_Expression[100];
    memset(postfix_Expression, 0, sizeof(postfix_Expression));

    char new_str[100];
    memset(new_str, 0, sizeof(new_str));
    new_str[0] = '0';
    new_str[1] = '+';
    strcpy(new_str+2, str);

    for (int i = 0; i < sizeof(new_str); i++)
    {
        if(new_str[i] == '[' || new_str[i] == '{')
        {
            new_str[i] = '(';
        }
        else if(new_str[i]== ']' || new_str[i] == '}')
        {
            new_str[i] = ')';
        }
    }
    

    str_find_exp_and_calc(new_str);
    printf("str_find_exp_and_calc : %s\n", new_str);

    mid_to_back(new_str, strlen(new_str), postfix_Expression);
    result = caculate_four_arithmetic_operations(postfix_Expression);
    // printf("result : %lf\n",result);

    return result;
}
  • 开头拼一个 0+：-1+2 变成 0-1+2，负号从”一元运算符”降级成普通的二元减号，后面的算法完全不用为它设计特判
  • 三种括号归一化：{ [ 全换成 (，} ] 全换成 )——对求值来说它们语义相同，没必要区别对待
  • 先算函数：str_find_exp_and_calc 会把表达式里所有 sin(...)、sqrt(...) 直接换成算好的数值（后面细讲），四则运算拿到的就永远是纯数字表达式
接下来拆 token。先把每个字符标记成”符号/非符号”的掩码数组 opt_idx，再把相邻的非符号位合并成一位——多位数字和小数点属于同一个数：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
for(i = 0 ; i < len ; ++i)
{
    if(str[i] == '[' || str[i] == '{')
    {
        str[i] = '(';
    }
    else if(str[i] == ']' || str[i] == '}')
    {
        str[i] = ')';
    }

    if(str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '^' || str[i] == '(' || str[i] == ')')
    {
        opt[count_opt] = str[i];
        opt_idx[i] = 1;
        count_opt++;
    }
    else
    {
        opt_idx[i] = 0;
    }
}
//合并多余的0

for(int i = 0; i < 99; ++i)
{
    if(opt_idx[i] == 0 && opt_idx[i+1] == 0)
    {
        for(int j = i; j < 99; ++j)
        {
            opt_idx[j] = opt_idx[j+1];
        }
        i--;
    }
}
数字本体用 strtok 按 +-*/^() 切开、atof 转 double：
1
2
3
4
5
6
p = strtok(str, "+-*/^()");
num[0] = atof(p);
while((p = strtok(NULL, "+-*/^()")))
{
    num[count_num++] = atof(p);
}
最后把 num 数组和 opt 数组按掩码交错装进 struct ele 数组，中缀表达式就在内存里排好了队。
中缀转后缀
遍历中缀表达式的每个 token，规则只有四条：
  • 数字 → 直接加入结果
  • 左括号 ( → 直接入符号栈
  • 右括号 ) → 不断弹栈进结果，直到碰见左括号
  • 运算符 → 与栈顶比优先级：严格大于才入栈；否则不断弹栈进结果，直到能入栈为止
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
struct my_Stack Stack_calculate;
struct ele postfix_Expression[100];
ll count_postfix_idx = 0;

Stack_init(&Stack_calculate);
char opt_cal;
ll opt_temp_idx = 0;
char opt_temp[100];
char opt_top;

//初始化结构体数组为了防止后续引用报错
for(i = 0; i < 100; ++i)
{
    postfix_Expression[i].p_num = NULL;
    postfix_Expression[i].p_opt = NULL;
}

for (i = 0; i < max_idx; ++i)
{
    if(infix_expression[i].p_num != NULL)
    {
        postfix_Expression[count_postfix_idx] = infix_expression[i];
        count_postfix_idx++;
        //printf("数字: %ld 加入到后缀表达式\n",*(postfix_Expression[count_postfix_idx].p_num));
    }
    else if(infix_expression[i].p_opt != NULL)
    {
        opt_cal = *infix_expression[i].p_opt;
        if( opt_cal == '(')
        {
            Push(&Stack_calculate,opt_cal);
            continue;
        }
        if( opt_cal != ')')
        {
            //先判断优先级 大于栈顶的元素就可以入栈 一开始是空栈哦
            if(Stack_empty(&Stack_calculate) == true)
            {
                opt_top = ' ';//最低级的
            }
            else
            {
                opt_top = *(Stack_calculate.top-1);
            }
            if(Priority(opt_cal) > Priority(opt_top))
            {
                Push(&Stack_calculate,opt_cal);
            }
            else
            {
                //小于等于栈顶的元素的话,要一直弹栈
                while(Priority(opt_cal) <= Priority(opt_top))
                {
                    //弹到最后没有元素了直接入栈欸
                    if(Stack_empty(&Stack_calculate) == true || *(Stack_calculate.top-1) == '(')
                    {
                        break;
                    }
                    opt_top = Pop(&Stack_calculate);
                    opt_temp[opt_temp_idx] = opt_top;
                    postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
                    postfix_Expression[count_postfix_idx].p_num = NULL;
                    count_postfix_idx++;
                    opt_temp_idx++;
                }
                Push(&Stack_calculate,opt_cal);
            }
        }
        else//如果是右括号
        {
            //由于要匹配左括号，要一直弹栈直到出现左括号
            char char_tmp = 0;
            while(char_tmp != '(')
            {
                char_tmp = Pop(&Stack_calculate);
                if(char_tmp == '(')
                {
                    break;
                }
                opt_temp[opt_temp_idx] = char_tmp;
                postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
                postfix_Expression[count_postfix_idx].p_num = NULL;
                opt_temp_idx++;
                count_postfix_idx++;
            }
        }
    }
}
//弹出栈的所有元素
while(Stack_empty(&Stack_calculate) == false)
{
    opt_top = Pop(&Stack_calculate);
    opt_temp[opt_temp_idx] = opt_top;
    postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
    postfix_Expression[count_postfix_idx].p_num = NULL;
    opt_temp_idx++;
    count_postfix_idx++;
}
注意比较用的是严格大于：同优先级的运算符会先把栈里的弹出来、再让新的入栈，保证 8-3-2 按 (8-3)-2 从左到右算——这是左结合。这里如果写成 >=，连续的减法除法就会算反。循环结束后把符号栈里剩的符号全部弹进结果，中缀就变成了后缀。
后缀求值：下标入栈
求值有个小障碍：栈的 Elemtype 是 int，要存的却是 double。把栈改成 double 也行，但这里的解法更轻：double 全放在 num_tmp 数组里，栈里只压下标。数字 token 到来时压的是它的下标；遇到运算符就弹两个下标，取数计算，结果追加到 num_tmp 尾部，再把新结果的”下标”压回去：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
//记录储存的数组的最大值是多少,然后出栈之后就从这里开始
ll max_idx = count;
ll max_idx_count = 0;

count = 0;
for (int i = 0; i < 100; ++i)
{
    if(postfix_Expression[i].p_num != NULL)
    {
        Push(&Stack_calculate,count);
        count++;
        continue;
    }
    if(postfix_Expression[i].p_opt != NULL)
    {
        ll num_1_idx = Pop(&Stack_calculate);
        ll num_2_idx = Pop(&Stack_calculate);
        switch (*postfix_Expression[i].p_opt)
        {
            case '^':
            {
                num_tmp[max_idx+max_idx_count] = pow(num_tmp[num_2_idx],num_tmp[num_1_idx]);
                Push(&Stack_calculate,max_idx+max_idx_count);
                max_idx_count++;
                break;
            }
            case '+':
            {
                num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] + num_tmp[num_1_idx];
                Push(&Stack_calculate,max_idx+max_idx_count);
                max_idx_count++;
                break;
            }
            case '-':
            {
                num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] - num_tmp[num_1_idx];
                Push(&Stack_calculate,max_idx+max_idx_count);
                max_idx_count++;
                break;
            }
            case '*':
            {
                num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] * num_tmp[num_1_idx];
                Push(&Stack_calculate,max_idx+max_idx_count);
                max_idx_count++;
                break;
            }
            case '/':
            {
                num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] / num_tmp[num_1_idx];
                Push(&Stack_calculate,max_idx+max_idx_count);
                max_idx_count++;
                break;
            }
            default:
                break;
        }
        continue;
    }
}
有个容易翻车的细节：先弹出的是右操作数。减法、除法、幂都不满足交换律，num_2_idx 和 num_1_idx 的顺序反了，8/2 就变 2/8 了。全部 token 走完，栈里剩下的那个下标指向的就是最终答案。
数学函数：函数指针查找表 + 递归
sin(3.1415926/2) 这种怎么算？思路是在四则运算之前，先把表达式里的函数调用全部换成数值。str_find_exp_and_calc 从左到右扫描，看到 ( 且前一个字符不是运算符也不是另一个 (——说明这个括号头上挂着函数名。函数名是倒着往回抠的，抠完把字符串反转回来；参数则用计数器做括号匹配：遇到 ( 加一、遇到 ) 减一，归零时正好是最外层右括号——不管参数里嵌了多少层括号都能完整抠出来。
15 个数学函数的”查找表”，是一串 strcmp 加函数指针：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
typedef double (*math_fun)(double);
math_fun get_math_fun(const char *s)
{
    if (strcmp(s, "sin") == 0)
    {
        return sin;
    }
    else if (strcmp(s, "cos") == 0)
    {
        return cos;
    }
    else if (strcmp(s, "tan") == 0)
    {
        return tan;
    }
    // ……sinh/cosh/tanh/asin/acos/atan/exp/log/log10/sqrt/ceil/floor 分支同构，略
    else
    {
        return NULL;
    }
}
参数表达式里可能还嵌着函数，所以直接递归调用 calc()：
1
2
3
4
5
strcpy(str_temp, exp_strs[i]);
double temp = calc(exp_strs[i]);
strcpy(exp_strs[i], str_temp);

char *temp_result_str = double2str(get_math_fun(exp_funcs[i])(temp));
sin(1+sin(1+sin(1))) 就是这样一层层递归进去、一层层替换回来的。算出的结果替换回原字符串时还有个细节：负数结果要包成 (0-x)，否则替换回去的一元负号会让后面的四则运算翻车：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
if(exp_strStuct.exp_results[i][0] == '-')
{
    char *temp = exp_strStuct.exp_results[i];
    exp_strStuct.exp_results[i] = (char *)malloc(sizeof(char) * (strlen(exp_strStuct.exp_results[i]) + 3));
    memset(exp_strStuct.exp_results[i], 0, sizeof(char) * (strlen(exp_strStuct.exp_results[i]) + 3));

    exp_strStuct.exp_results[i][0] = '(';
    exp_strStuct.exp_results[i][1] = '0';
    strcpy(exp_strStuct.exp_results[i] + 2, temp);
    exp_strStuct.exp_results[i][strlen(exp_strStuct.exp_results[i])] = ')';

    free(temp);
}
// printf("|temp|: %s\n", temp);
// printf("|exp_strStuct.exp_results[i]|: %s\n", exp_strStuct.exp_results[i]);
运行效果
main.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include "calc.h"

int main()
{
    char exp[100] = "1+2*3/4";
    // char exp[100] = "(1.1+(1.1+(1.1+(1.1+(1.1+(1.1+1.1))))))";
    // char exp[100] = "1+2*3/4+{1+[2*(1+1)]}+3";
    // char exp[100] = "3+45/2+{7+[8*(3+1)]}-6";
    // char exp[100] = "4*(3-2)+{8/[4*(2-1)]}+9";
    // char exp[100] = "1+23/4+{5+[6*(2+1)]}-7";
    // char exp[100] = "5/2+3*{2-[5/(2-1)]}+4";
    // char exp[100] = "23-4/2+{1+[4*(3-1)]}+5";
    // char exp[100] = "2.53-4.1/2.5+{1.3+[4.7*(3.2-1.1)]}+5.8";
    // char exp[100] = "5.6/2.1+3.4*{2.8-[5.3/(2.2-1.1)]}+4.9";
    // char exp[100] = "1+2*(3+4)+0.000000+(0-1.000000)+10.000000+1.000000+2.718282";
    // char exp[100] = "1+2*(3+4)+sin(3.1415926/2)+cos(3.1415926)+sqrt(100)+log10(10)+exp(1)";
    // char exp[100] = "1+sin(1+sin(1+sin(1+sin(1))))";
    // char exp[100] = "sin[3.1415926/2]";
    printf("%lf\n",calc(exp));
    return 0;
}
测试用的表达式一直留在注释里，从整数四则、三种括号混用，到 sin/cos/sqrt/log10/exp 嵌套调用，就是这个项目能力范围的一份清单。
版本迭代
  • V1.0：calc.c + My_Stack.c/.h 跑通主流程——双栈转后缀、下标入栈求值，配了一个”多文件编译并链接”的 .bat 脚本
  • V1.1：测试验证版，代码和 V1.0 基本一致，主要在换测试用例（比如 1/(9)）做边界验证
  • V1.2：模块化整理——struct ele 和调试宏抽进 calc.h；新增 func_calc.c/.h 数学函数模块（函数指针表 + 括号匹配 + 递归求值）；顺手修了 num[] 未初始化、掩码合并循环边界（50→99）两个小 bug
V1.2 完整代码
项目一共 7 个文件，main.c 已在上面贴出，其余 6 个按依赖顺序全部贴出。
My_Stack.h
My_Stack.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#ifndef _My_Stack_H_
#define _My_Stack_H_

#include <stdio.h>
#include <stdlib.h>
#define Elemtype int 

#define bool char

#define Stack_OK 0
#define true 1
#define false 0

#define init_element_num 100
#define init_error -1

typedef long int ll;

struct my_Stack
{
    ll stack_size;
    Elemtype* base;
    Elemtype* top;
    Elemtype* max;   
};

bool Stack_init(struct my_Stack* Stack);
bool Stack_new(struct my_Stack* Stack, ll num);
bool Stack_destory(struct my_Stack* Stack);

ll Stack_get_len(struct my_Stack* Stack);
bool Stack_empty(struct my_Stack* Stack);
bool Stack_full(struct my_Stack* Stack);

void Stack_clear(struct my_Stack* Stack);
bool Push(struct my_Stack* Stack, Elemtype ele);

Elemtype Pop(struct my_Stack* Stack);

#endif
My_Stack.c
My_Stack.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
#include <stdio.h>
#include <stdlib.h>
#include "My_Stack.h"

/**
 * @brief 栈_初始化
 * 
 * @param Stack 
 * @return true 
 * @return false 
 */
bool Stack_init(struct my_Stack* Stack)
{
    Stack->base = (Elemtype *)calloc(sizeof(Elemtype),init_element_num);
    if(Stack->base == NULL)
    {
        return init_error;
    }
    Stack->stack_size = init_element_num;
    Stack->top = Stack->base;
    Stack->max = Stack->base + init_element_num;
    return Stack_OK;
}

/**
 * @brief 栈_设置新的栈长度
 * 
 * @param Stack 
 * @param num 
 * @return true 
 * @return false 
 */
bool Stack_new(struct my_Stack* Stack, ll num)
{
    Stack->base = (Elemtype *)realloc(Stack->base,sizeof(Elemtype) * num);
    if(Stack->base == NULL)
    {
        return false;
    }
    Stack->stack_size = num;
    Stack->max = Stack->base + num;
    return Stack_OK;
}

/**
 * @brief 栈_获取长度
 * 
 * @param Stack 
 * @return ll 
 */
ll Stack_get_len(struct my_Stack* Stack)
{
    return Stack->stack_size;
}

/**
 * @brief 栈_判断是否为空栈
 * 
 * @param Stack 
 * @return true 
 * @return false 
 */
bool Stack_empty(struct my_Stack* Stack)
{
    if(Stack->top == Stack->base)
    {
        return true;
    }
    else
    {
        return false;
    }
}


/**
 * @brief 栈_判断是否为满栈
 * 
 * @param Stack 
 * @return true 
 * @return false 
 */
bool Stack_full(struct my_Stack* Stack)
{
    if(Stack->top == Stack->max)
    {
        return true;
    }
    else
    {
        return false;
    }
}

/**
 * @brief 栈_清空栈
 * 
 * @param Stack 
 */
void Stack_clear(struct my_Stack* Stack)
{
    Stack->top = Stack->base;
    return ;
}

/**
 * @brief ջ_ѹջ
 * 
 * @param Stack 
 * @param ele 
 * @return true 
 * @return false 
 */
bool Push(struct my_Stack* Stack, Elemtype ele)
{
    if(Stack_full(Stack) == true)
    {
        if(Stack_new(Stack,Stack->stack_size * 2) == false)
        {
            return false;
        }
    }
    *Stack->top = ele;
    Stack->top++;
    return Stack_OK;
}

/**
 * @brief 栈_弹栈
 * 
 * @param Stack 
 * @return Elemtype 
 */
Elemtype Pop(struct my_Stack* Stack)
{
    if(Stack_empty(Stack) == true)
    {
        printf("弹栈失败:这个栈已经是空的了.\n");
        return ~(unsigned int)0/2;
    }
    else
    {
        Stack->top--;
        return *Stack->top;
    }
}

/**
 * @brief 栈_销毁栈
 * 
 * @param Stack 
 * @return true 
 * @return false 
 */
bool Stack_destory(struct my_Stack* Stack)
{
    Stack->top = Stack->base;
    free(Stack->base);
    Stack->stack_size = 0;
    return Stack_OK;
}

/**
 * @brief 测试代码
 * 
 * @return int 
 */
// int main()
// {
//     struct my_Stack stack;
//     Stack_init(&stack);
//     Pop(&stack);
//     Push(&stack, 123);
//     printf("%d\n",Pop(&stack));
//     Stack_clear(&stack);
//     Push(&stack,456);
//     Push(&stack,789);
//     printf("Stack_len:%ld\n",Stack_get_len(&stack));
//     Push(&stack,789);
//     Push(&stack,789);
//     Push(&stack,789);
//     printf("Stack_len:%ld\n",Stack_get_len(&stack));
//     Stack_destory(&stack);
//     return 0;
// }
calc.h
calc.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifndef _calc_H_
#define _calc_H_

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "My_Stack.h"
#include "func_calc.h"

#define cal_max_idx 100    //用于储存计算信息的最大数组

// #define input
#define details
#define details_Stack
#define details_array

struct ele
{
    char *p_opt;
    double *p_num;
};

double calc(char *str);

#endif
func_calc.h
func_calc.h
1
2
3
4
5
6
#ifndef _Func_calc_H_
#define _Func_calc_H_

char* str_find_exp_and_calc(char *s);

#endif
func_calc.c
func_calc.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include "func_calc.h"
#include "calc.h"


char *str_rpl(char *s, const char *s1, const char *s2)
{
    char *ptr;
    while ((ptr = strstr(s, s1)) != NULL)     /* 如果在s中找到s1 */
    {
        memmove(ptr + strlen(s2) , ptr + strlen(s1), strlen(ptr) - strlen(s1) + 1);
        memcpy(ptr, &s2[0], strlen(s2));
    }
    return s;
}

void str_reverse(char* s)
{
char* left = s;
char* right = s + strlen(s) - 1;
    while (left < right)
{
char tmp = *left;
*left = *right;
*right = tmp;

left++;
right--;
}
}

char* double2str(double num)
{
    // double：8字节 2.3E-308 到 1.7E+308
    static char str[21];
    sprintf(str, "%lf", num);
    return str;
}

double str2double(const char* str)
{
    return atof(str);
}

typedef double (*math_fun)(double);
math_fun get_math_fun(const char *s)
{
    if (strcmp(s, "sin") == 0)
    {
        return sin;
    }
    else if (strcmp(s, "cos") == 0)
    {
        return cos;
    }
    else if (strcmp(s, "tan") == 0)
    {
        return tan;
    }
    else if (strcmp(s, "sinh") == 0)
    {
        return sinh;
    }
    else if (strcmp(s, "cosh") == 0)
    {
        return cosh;
    }
    else if (strcmp(s, "tanh") == 0)
    {
        return tanh;
    }
    else if (strcmp(s, "asin") == 0)
    {
        return asin;
    }
    else if (strcmp(s, "acos") == 0)
    {
        return acos;
    }
    else if (strcmp(s, "atan") == 0)
    {
        return atan;
    }
    else if (strcmp(s, "exp") == 0)
    {
        return exp;
    }
    else if (strcmp(s, "log") == 0)
    {
        return log;
    }
    else if (strcmp(s, "log10") == 0)
    {
        return log10;
    }
    else if (strcmp(s, "sqrt") == 0)
    {
        return sqrt;
    }
    else if (strcmp(s, "ceil") == 0)
    {
        return ceil;
    }
    else if (strcmp(s, "floor") == 0)
    {
        return floor;
    }
    else
    {
        return NULL;
    }
}

typedef struct
{
    int exp_count;
    char **exp_funcs;
    char **exp_strs;
    char **exp_results;
}exp_strStuctTypedef;

char* str_find_exp_and_calc(char *s)
{
    char *ptr = s;              //遍历整个字符串的指针

    char exp_func[100] = {0};    //储存当前找到的表达式函数
    int  exp_func_i = 0;        //当前找到的表达式函数数组的下标
    char **exp_funcs = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式函数
    int  exp_funcs_i = 0;       //所有找到的表达式函数数组的下标
    memset(exp_funcs, 0, sizeof(char *) * 100);

    char exp_str[100] = {0};    //储存当前找到的表达式
    int  exp_str_i = 0;         //当前找到的表达式数组的下标
    char **exp_strs = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式
    int  exp_strs_i = 0;        //所有找到的表达式数组的下标
    memset(exp_strs, 0, sizeof(char *) * 100);

    // char exp_result[100] = {0};    //储存当前表达式的计算值
    // int  exp_result_i = 0;         //当前找到的表达式计算值数组的下标
    char **exp_results = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式的计算值
    // int  exp_results_i = 0;        //所有找到的表达式计算值数组的下标
    // memset(exp_results, 0, sizeof(char *) * 100);

    // printf("str: %s\n", s);
    while (*ptr++)
    {
        if ((*ptr == '(') && (*(ptr - 1) != '(') && (*(ptr - 1) != '+') && (*(ptr - 1) != '-') && (*(ptr - 1) != '*') && (*(ptr - 1) != '/'))
        {
            // printf("find exp: ");
            char *exp_func_ptr = ptr;
            while(*exp_func_ptr--)
            {
                if((*exp_func_ptr != '+') && (*exp_func_ptr != '-') && (*exp_func_ptr != '*') && (*exp_func_ptr != '/') && (*exp_func_ptr != '('))
                {
                    // putchar(*exp_func_ptr);
                    exp_func[exp_func_i++] = *exp_func_ptr;
                }
                else
                {
                    exp_func[exp_func_i] = '\0';
                    exp_funcs[exp_funcs_i] = (char *)malloc(sizeof(char) * (exp_func_i + 1));

                    strcpy(exp_funcs[exp_funcs_i], exp_func);
                    str_reverse(exp_funcs[exp_funcs_i]);
                    exp_funcs_i++;
                    
                    memset(exp_func, 0, 100);
                    exp_func_i = 0;

                    break;
                }
            }

            int count_kuohao = -1;
            char *sub_str_ptr = ptr + 1;
            memset(exp_str, 0, 100);

            do
            {
                // 括号匹配
                if(*sub_str_ptr == ')')
                {
                    count_kuohao++;
                }
                else if(*sub_str_ptr == '(')
                {
                    count_kuohao--;
                }

                // 退出条件
                if(count_kuohao != 0)
                {
                    // putchar(*sub_str_ptr);
                    exp_str[exp_str_i++] = *sub_str_ptr;
                }
                else
                {
                    exp_str[exp_str_i] = '\0';
                    // printf("find exp: |%s|\n", exp_str);
                    exp_strs[exp_strs_i] = (char *)malloc(sizeof(char) * (exp_str_i + 1));

                    strcpy(exp_strs[exp_strs_i], exp_str);
                    // printf("find exp: |%s|\n", exp_strs[exp_strs_i]);
                    exp_strs_i++;
                    
                    memset(exp_str, 0, 100);
                    exp_str_i = 0;
                    break;
                }

            }while(*sub_str_ptr++);
        }
    }

    for (int i = 0; i < exp_strs_i; i++)
    {
        char str_temp[100] = {0};
        // 使用calc计算会对原来表达式进行修改
        strcpy(str_temp, exp_strs[i]);
        double temp = calc(exp_strs[i]);
        strcpy(exp_strs[i], str_temp);

        char *temp_result_str = double2str(get_math_fun(exp_funcs[i])(temp));
        exp_results[i] = (char *)malloc(sizeof(char) * (strlen(temp_result_str) + 1));
        strcpy(exp_results[i], temp_result_str);
    }

    exp_strStuctTypedef exp_strStuct;
    exp_strStuct.exp_count = exp_strs_i;
    exp_strStuct.exp_funcs = exp_funcs;
    exp_strStuct.exp_strs = exp_strs;
    exp_strStuct.exp_results = exp_results;

    for (int i = 0; i < exp_strStuct.exp_count; i++)
    {
        // printf("find exp_func %s, parameters is %s, result is %s\n", exp_strStuct.exp_funcs[i], exp_strStuct.exp_strs[i], exp_strStuct.exp_results[i]);
        char temp[100] = {0};
        strcpy(temp, exp_strStuct.exp_funcs[i]);
        strcat(temp, "(");
        strcat(temp, exp_strStuct.exp_strs[i]);
        strcat(temp, ")");
        if(exp_strStuct.exp_results[i][0] == '-')
        {
            char *temp = exp_strStuct.exp_results[i];
            exp_strStuct.exp_results[i] = (char *)malloc(sizeof(char) * (strlen(exp_strStuct.exp_results[i]) + 3));
            memset(exp_strStuct.exp_results[i], 0, sizeof(char) * (strlen(exp_strStuct.exp_results[i]) + 3));

            exp_strStuct.exp_results[i][0] = '(';
            exp_strStuct.exp_results[i][1] = '0';
            strcpy(exp_strStuct.exp_results[i] + 2, temp);
            exp_strStuct.exp_results[i][strlen(exp_strStuct.exp_results[i])] = ')';

            free(temp);
        }
        // printf("|temp|: %s\n", temp);
        // printf("|exp_strStuct.exp_results[i]|: %s\n", exp_strStuct.exp_results[i]);
        str_rpl(s, temp, exp_strStuct.exp_results[i]);

    }
    

    return s;
}


// int main()
// {
//     // char str[100] = "1+2*(3+4)+sin(1+8+(2+3))+cos((2+3)*8+2*(3+4))";
//     char str[100] = "1+2*(3+4)+sin(3.1415926)+cos(3.1415926)+sqrt(100)+log10(10)+exp(1)";
//     exp_strStuctTypedef exp_strStuct = str_find_exp_and_calc(str);

//     printf("result : %s\n", str);
//     return 0;
// }
calc.c
calc.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include "My_Stack.h"
#include "func_calc.h"
#include "calc.h"

int Priority(char ch)
{
    switch(ch)
    {
        case '^':
            return 3;
        case '*':
        case '/':
            return 2;
        case '+':
        case '-':
            return 1;
        default:
            return 0;
    }
}

bool mid_to_back(char *str, ll len, struct ele result[])
{
    ll i;
    ll count_num = 1;
    ll count_opt = 0;
    char *p;
    double num[100] = {0};
    char opt[100] = {'\0'};
    long opt_idx[100] = {0};

    ll count_num_idx = 0;
    ll count_opt_idx = 0;
    struct ele infix_expression[100];

    //初始化idx数组
    for (i = 0; i < sizeof(opt_idx)/sizeof(opt_idx[0]); ++i)
    {
        opt_idx[i] = -1;
    }
    //初始化中缀表达式的结构体数组
    for(i = 0; i < 100; ++i)
    {
        infix_expression[i].p_num = NULL;
        infix_expression[i].p_opt = NULL;
    }

    for(i = 0 ; i < len ; ++i)
    {
        if(str[i] == '[' || str[i] == '{')
        {
            str[i] = '(';
        }
        else if(str[i] == ']' || str[i] == '}')
        {
            str[i] = ')';
        }

        if(str[i] == '+' || str[i] == '-' || str[i] == '*' || str[i] == '/' || str[i] == '^' || str[i] == '(' || str[i] == ')')
        {
            opt[count_opt] = str[i];
            opt_idx[i] = 1;
            count_opt++;
        }
        else
        {
            opt_idx[i] = 0;
        }
    }
    //合并多余的0

    for(int i = 0; i < 99; ++i)
    {
        if(opt_idx[i] == 0 && opt_idx[i+1] == 0)
        {
            for(int j = i; j < 99; ++j)
            {
                opt_idx[j] = opt_idx[j+1];
            }
            i--;
        }
    }
    //找到最大的符号下标
    ll max_idx = 0;
    for(i = 0 ; i < 100 ; ++i)
    {
        if(opt_idx[i] == -1)
        {
            max_idx = i;
            break;
        }
    }

    //处理浮点数
    p = strtok(str, "+-*/^()");
    num[0] = atof(p);
    while((p = strtok(NULL, "+-*/^()")))
    {
        num[count_num++] = atof(p);
    }
#ifdef details
    printf("获取所有的浮点数:\n");
    for (i = 0; i < count_num; ++i)
    {
        printf("%f ",num[i]);
    }
    putchar('\n');
    printf("\n获取所有的运算符:\n");
    for (i = 0; i < strlen(opt); ++i)
    {
        printf("%c ",opt[i]);
    }
    putchar('\n');
    putchar('\n');
#endif
    // for (i = 0; i < max_idx; ++i)
    // {
    //     printf("%ld ",opt_idx[i]);
    // }
    // putchar('\n');

    //利用结构体数组将数字数组和操作符数组结合起来
    for (i = 0; i < max_idx; ++i)
    {
        if(opt_idx[i] == 1)
        {
            infix_expression[i].p_num = NULL;
            infix_expression[i].p_opt = &opt[count_opt_idx];
            count_opt_idx++;
        }
        else if(opt_idx[i] == 0)
        {
            infix_expression[i].p_num = &num[count_num_idx];
            infix_expression[i].p_opt = NULL;
            count_num_idx++;
        }
    }
    
    /*
    count_num_idx = 0;
    count_opt_idx = 0;
    bool flag_a = true;
    while(opt[count_opt_idx] != '\0' && count_num_idx < count_num)
    {
        // printf("%lf ",num[count_num_idx]);
        // printf("%c ",opt[count_opt_idx]);

        //注意开头就是括号的情况
        if(opt[count_opt_idx] == '(')
        {
            while(opt[count_opt_idx] == '(')
            {
                infix_expression[count_infix_idx].p_num = NULL;
                infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
                count_opt_idx++;
                count_infix_idx++;
            }
            //左括号完后一定是一个数字
        }

        infix_expression[count_infix_idx].p_num = &num[count_num_idx];
        infix_expression[count_infix_idx].p_opt = NULL;
        count_num_idx++;
        count_infix_idx++;

        infix_expression[count_infix_idx].p_num = NULL;
        infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
        count_opt_idx++;
        count_infix_idx++;
        if(opt[count_opt_idx] == ')' && flag_a == true)
        {
            infix_expression[count_infix_idx].p_num = &num[count_num_idx];
            infix_expression[count_infix_idx].p_opt = NULL;
            count_num_idx++;
            count_infix_idx++;
            flag_a == false;
        }

        //可能符号已经输出完了，但是还有最后一个数字没有输出出来
        if(opt[count_opt_idx] == '\0')
        {
            infix_expression[count_infix_idx].p_num = &num[count_num_idx];
            infix_expression[count_infix_idx].p_opt = NULL;
            count_num_idx++;
            count_infix_idx++;
        }

        if(opt[count_opt_idx] == '(')
        {
            while(opt[count_opt_idx] == '(')
            {
                infix_expression[count_infix_idx].p_num = NULL;
                infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
                count_opt_idx++;
                count_infix_idx++;
            }
            //左括号完后一定是一个数字
        }

        if(opt[count_opt_idx] == ')')
        {
            while(opt[count_opt_idx] == ')')
            {
                infix_expression[count_infix_idx].p_num = NULL;
                infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
                count_opt_idx++;
                count_infix_idx++;
            }
            //右括号完后一定是一个操作符
            infix_expression[count_infix_idx].p_num = NULL;
            infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
            count_opt_idx++;
            count_infix_idx++;
            //操作符完之后还可能是一堆左括号eg ((1+2)+(2+3))
            while(opt[count_opt_idx] == '(')
            {
                infix_expression[count_infix_idx].p_num = NULL;
                infix_expression[count_infix_idx].p_opt = &opt[count_opt_idx];
                count_opt_idx++;
                count_infix_idx++;
            }
        }
    }
    */
    //将结构体数组打印出来

#ifdef details
    printf("转换完的中缀表达式如下:\n");
    for (i = 0; i < max_idx; ++i)
    {
        if(infix_expression[i].p_num != NULL)
        {
            //printf("%d %lf NULL\n",i, *infix_expression[i].p_num);
            printf("%lf ",*infix_expression[i].p_num);
        }
        if(infix_expression[i].p_opt != NULL)
        {
            //printf("%d NULL %c\n",i, *infix_expression[i].p_opt);
            printf("%c ",*infix_expression[i].p_opt);
        }
    }
    putchar('\n');
#endif
#ifdef details_Stack
    printf("\n开始转换后缀表达式:\n");
#endif
    struct my_Stack Stack_calculate;
    struct ele postfix_Expression[100];
    ll count_postfix_idx = 0;
    
    Stack_init(&Stack_calculate);
    char opt_cal;
    ll opt_temp_idx = 0;
    char opt_temp[100];
    char opt_top;
    
    //初始化结构体数组为了防止后续引用报错
    for(i = 0; i < 100; ++i)
    {
        postfix_Expression[i].p_num = NULL;
        postfix_Expression[i].p_opt = NULL;
    }

    for (i = 0; i < max_idx; ++i)
    {
        if(infix_expression[i].p_num != NULL)
        {
            postfix_Expression[count_postfix_idx] = infix_expression[i];
            count_postfix_idx++;
            //printf("数字: %ld 加入到后缀表达式\n",*(postfix_Expression[count_postfix_idx].p_num));
        }
        else if(infix_expression[i].p_opt != NULL)
        {
            opt_cal = *infix_expression[i].p_opt;
            if( opt_cal == '(')
            {
                Push(&Stack_calculate,opt_cal);
#ifdef details_Stack
                printf("符号: %c 入栈\n",opt_cal);
#endif
                continue;
            }
            if( opt_cal != ')')
            {
                //先判断优先级 大于栈顶的元素就可以入栈 一开始是空栈哦
                if(Stack_empty(&Stack_calculate) == true)
                {
                    opt_top = ' ';//最低级的
                }
                else
                {
                    opt_top = *(Stack_calculate.top-1);
#ifdef details_Stack
                    printf("符号: %c 出来作比较\n",opt_top);
#endif
                }
                if(Priority(opt_cal) > Priority(opt_top))
                {
                    Push(&Stack_calculate,opt_cal);
#ifdef details_Stack
                    printf("符号: %c 入栈\n",opt_cal);
#endif
                }
                else
                {
                    //小于等于栈顶的元素的话,要一直弹栈
                    while(Priority(opt_cal) <= Priority(opt_top))
                    {
                        //弹到最后没有元素了直接入栈欸
                        if(Stack_empty(&Stack_calculate) == true || *(Stack_calculate.top-1) == '(')
                        {
                            break;
                        }
                        opt_top = Pop(&Stack_calculate);
#ifdef details_Stack
                        printf("符号: %c 弹栈\n",opt_top);
#endif
                        opt_temp[opt_temp_idx] = opt_top;
                        postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
                        postfix_Expression[count_postfix_idx].p_num = NULL;
                        count_postfix_idx++;
                        opt_temp_idx++;
                    }
                    Push(&Stack_calculate,opt_cal);
#ifdef details_Stack
                    printf("符号: %c 入栈\n",opt_cal);
#endif
                }
            }
            else//如果是右括号
            {
#ifdef details_Stack
                printf("右括号来了\n");
#endif
                //由于要匹配左括号，要一直弹栈直到出现左括号
                char char_tmp = 0;
                while(char_tmp != '(')
                {
                    char_tmp = Pop(&Stack_calculate);
#ifdef details_Stack
                    printf("符号: %c 弹栈\n",char_tmp);
#endif
                    if(char_tmp == '(')
                    {
                        break;
                    }
                    opt_temp[opt_temp_idx] = char_tmp;
                    postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
                    postfix_Expression[count_postfix_idx].p_num = NULL;
                    opt_temp_idx++;
                    count_postfix_idx++;
                }
            }
        }
    }
    //弹出栈的所有元素
    while(Stack_empty(&Stack_calculate) == false)
    {
        opt_top = Pop(&Stack_calculate);
#ifdef details_Stack
        printf("符号: %c 弹栈\n",opt_top);
#endif
        opt_temp[opt_temp_idx] = opt_top;
        postfix_Expression[count_postfix_idx].p_opt = &opt_temp[opt_temp_idx];
        postfix_Expression[count_postfix_idx].p_num = NULL;
        opt_temp_idx++;
        count_postfix_idx++;
    }

    //将转换好的内容重新输入到函数的参数地址上
    for (i = 0; i < max_idx; ++i)
    {
        result[i].p_num = postfix_Expression[i].p_num;
        result[i].p_opt = postfix_Expression[i].p_opt;
    }
#ifdef details
    //输出后缀表达式
    printf("\n转换的后缀表达式如下:\n");
    for (i = 0; i < max_idx; ++i)
    {
        if(postfix_Expression[i].p_num != NULL)
        {
            //printf("%d %lf NULL\n",i, *postfix_Expression[i].p_num);
            printf("%lf ",*postfix_Expression[i].p_num);
            continue;
        }
        else if(postfix_Expression[i].p_opt != NULL)
        {
            //printf("%d NULL %c\n",i, *postfix_Expression[i].p_opt);
            printf("%c ",*postfix_Expression[i].p_opt);
            continue;
        }
    }
    putchar('\n');
#endif
    //不能直接返回postfix_Expression，因为这是局部变量哦 warning:function returns address of local variable
    Stack_clear(&Stack_calculate);
    Stack_destory(&Stack_calculate);
    return true;
}

double caculate_four_arithmetic_operations(struct ele* postfix_Expression)
{
    struct my_Stack Stack_calculate;
    Stack_init(&Stack_calculate);
    //这里要定义一个数字下标数组，因为double类型数组和Elementype为int类型的数组冲突了
    //打算后面用下标入栈
    // double num_tmp[100] = {0}; 
    double *num_tmp = (double*)malloc(sizeof(double)*100); 
    ll count = 0;
    for(int i = 0; i < 100; ++i)
    {
        if(postfix_Expression[i].p_num != NULL)
        {
            num_tmp[count] = *postfix_Expression[i].p_num;
            //printf("%lf ",num_tmp[count]);
            count++;
        }
    }
    //putchar('\n');
#ifdef details_Stack
    printf("\n接下来开始用栈计算最终的结果\n");
#endif
    //记录储存的数组的最大值是多少,然后出栈之后就从这里开始
    ll max_idx = count;
    ll max_idx_count = 0;

    count = 0;
    for (int i = 0; i < 100; ++i)
    {
        if(postfix_Expression[i].p_num != NULL)
        {
            Push(&Stack_calculate,count);
#ifdef details_Stack
            printf("下标: [%ld]=%lf 入栈\n",count,num_tmp[count]);
#endif
            count++;
            continue;
        }
        if(postfix_Expression[i].p_opt != NULL)
        {
            ll num_1_idx = Pop(&Stack_calculate);
            ll num_2_idx = Pop(&Stack_calculate);
#ifdef details_Stack
            printf("下标: [%ld]=%lf & [%ld]=%lf 弹栈\n",num_1_idx,num_tmp[num_1_idx],num_2_idx,num_tmp[num_2_idx]);
#endif
            switch (*postfix_Expression[i].p_opt)
            {
                case '^':
                {
                    num_tmp[max_idx+max_idx_count] = pow(num_tmp[num_2_idx],num_tmp[num_1_idx]);
                    Push(&Stack_calculate,max_idx+max_idx_count);
#ifdef details_Stack
                    printf("下标: [%ld]=%lf 入栈\n",max_idx+max_idx_count,num_tmp[max_idx+max_idx_count]);
#endif
                    max_idx_count++;
                    break;
                }
                case '+':
                {
                    num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] + num_tmp[num_1_idx];
                    Push(&Stack_calculate,max_idx+max_idx_count);
#ifdef details_Stack
                    printf("下标: [%ld]=%lf 入栈\n",max_idx+max_idx_count,num_tmp[max_idx+max_idx_count]);
#endif
                    max_idx_count++;
                    break;
                }
                case '-':
                {
                    num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] - num_tmp[num_1_idx];
                    Push(&Stack_calculate,max_idx+max_idx_count);
#ifdef details_Stack
                    printf("下标: [%ld]=%lf 入栈\n",max_idx+max_idx_count,num_tmp[max_idx+max_idx_count]);
#endif
                    max_idx_count++;
                    break;
                }
                case '*':
                {
                    num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] * num_tmp[num_1_idx];
                    Push(&Stack_calculate,max_idx+max_idx_count);
#ifdef details_Stack
                    printf("下标: [%ld]=%lf 入栈\n",max_idx+max_idx_count,num_tmp[max_idx+max_idx_count]);
#endif
                    max_idx_count++;
                    break;
                }
                case '/':
                {
                    num_tmp[max_idx+max_idx_count] = num_tmp[num_2_idx] / num_tmp[num_1_idx];
                    Push(&Stack_calculate,max_idx+max_idx_count);
#ifdef details_Stack
                    printf("下标: [%ld]=%lf 入栈\n",max_idx+max_idx_count,num_tmp[max_idx+max_idx_count]);
#endif
                    max_idx_count++;
                    break;
                }
                default:
                    break;
            }
            continue;
        }
    }
    double result = num_tmp[Pop(&Stack_calculate)];
    Stack_destory(&Stack_calculate);
    free(num_tmp);
    return result;
}

double calc(char *str)
{
    double result = 0;
    struct ele postfix_Expression[100];
    memset(postfix_Expression, 0, sizeof(postfix_Expression));

    char new_str[100];
    memset(new_str, 0, sizeof(new_str));
    new_str[0] = '0';
    new_str[1] = '+';
    strcpy(new_str+2, str);

    for (int i = 0; i < sizeof(new_str); i++)
    {
        if(new_str[i] == '[' || new_str[i] == '{')
        {
            new_str[i] = '(';
        }
        else if(new_str[i]== ']' || new_str[i] == '}')
        {
            new_str[i] = ')';
        }
    }
    

    str_find_exp_and_calc(new_str);
    printf("str_find_exp_and_calc : %s\n", new_str);

    mid_to_back(new_str, strlen(new_str), postfix_Expression);
    result = caculate_four_arithmetic_operations(postfix_Expression);
    // printf("result : %lf\n",result);

    return result;
}
]]>
    
    https://cosmical-container.github.io/posts/f1369abc/
    
    2024-10-06T04:33:00.000Z
    
      计算器是栈的教科书级应用。这个项目从 V1.0 迭代到 V1.2，最终版约 1100 行，从”能算 1+2*3“一路做到：+ - * / ^ 五则运算、{} [] () 三种括号混用、小数，甚至]]>
    
    用栈实现四则运算计算器
    2024-10-06T04:33:00.000Z
  
  
    
      寰宇体
    
    
    
    
      一个有意思的小工具：给它一个字符串，比如 "sin(1+1)+max(2,3)" 这种形式，它能自动找出里面的数学函数调用、解析括号里的表达式，然后调用对应的库函数把结果算出来。全程纯 C，核心用了三个技术点。
一、函数指针”查找表”
C 没有反射，怎么把字符串 "sin" 变成 sin() 函数？答案是字符串比较 + 函数指针：
1
2
3
4
5
6
7
8
9
10
11
12
typedef double (*math_fun)(double);

math_fun get_math_fun(const char *s)
{
    if (strcmp(s, "sin") == 0)  return sin;
    if (strcmp(s, "cos") == 0)  return cos;
    if (strcmp(s, "tan") == 0)  return tan;
    if (strcmp(s, "sqrt") == 0) return sqrt;
    if (strcmp(s, "floor") == 0) return floor;
    // ... exp、log、asin、atanh 等十几math个
    return NULL;
}
typedef double (*math_fun)(double) 定义了”接收 double 返回 double”的函数指针类型，数学库里这一族函数签名完全一致，正好统一管理。
二、括号匹配扫描
要从字符串里截出 sin(1+cos(2)) 的完整参数部分，不能简单找第一个 )——参数里可能嵌套括号。经典解法是计数器匹配：
1
2
3
4
5
6
7
8
9
10
11
int count_kuohao = -1;
do
{
    if (*sub_str_ptr == ')') count_kuohao++;   // 遇到闭包 +1
    else if (*sub_str_ptr == '(') count_kuohao--; // 遇到开括 -1

    if (count_kuohao != 0)
        exp_str[exp_str_i++] = *sub_str_ptr;   // 还没配平，继续收集
    else
        break;                                  // 配平，参数截取完成
} while (*sub_str_ptr);
嵌套多少层都能正确处理。函数名的提取则是从 ( 往前回溯，直到碰上 + - * / 等运算符为止。
三、字符串替换的坑
工具函数 str_rpl 实现替换时用 memmove 挪动后面那段内存——注意必须用 memmove 而不是 memcpy，因为源和目标区域有重叠，memcpy 对重叠区间的行为是未定义的：
1
2
3
4
5
while (ptr = strstr(s, s1))     /* 在 s 中找到 s1 */
{
    memmove(ptr + strlen(s2), ptr + strlen(s1), strlen(ptr) - strlen(s1) + 1);
    memcpy(ptr, s2, strlen(s2));
}
写在最后
这个玩具麻雀虽小：函数指针表、括号匹配、memmove 搬移内存，C 语言字符串处理的三板斧都在里面。缺点也很明显——固定 100 字节的缓冲区、魔法数字偏多，算是个”能用但可以重构”的状态。之后可以试试改成递归下降解析器，那就是正经的表达式引擎了。
完整代码
表达式函数查找并计算.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

char *str_rpl(char *s, const char *s1, const char *s2)
{
    char *ptr;
    while (ptr = strstr(s, s1))     /* 如果在s中找到s1 */
    {
        memmove(ptr + strlen(s2) , ptr + strlen(s1), strlen(ptr) - strlen(s1) + 1);
        memcpy(ptr, &s2[0], strlen(s2));
    }
    return s;
}

void str_reverse(char* s)
{
char* left = s;
char* right = s + strlen(s) - 1;
    while (left < right)
{
char tmp = *left;
*left = *right;
*right = tmp;

left++;
right--;
}
}

char* double2str(double num)
{
    // double：8字节 2.3E-308 到 1.7E+308
    static char str[21];
    sprintf(str, "%lf", num);
    return str;
}

double str2double(const char* str)
{
    return atof(str);
}

typedef double (*math_fun)(double);
math_fun get_math_fun(const char *s)
{
    if (strcmp(s, "sin") == 0)
    {
        return sin;
    }
    else if (strcmp(s, "cos") == 0)
    {
        return cos;
    }
    else if (strcmp(s, "tan") == 0)
    {
        return tan;
    }
    else if (strcmp(s, "sinh") == 0)
    {
        return sinh;
    }
    else if (strcmp(s, "cosh") == 0)
    {
        return cosh;
    }
    else if (strcmp(s, "tanh") == 0)
    {
        return tanh;
    }
    else if (strcmp(s, "asin") == 0)
    {
        return asin;
    }
    else if (strcmp(s, "acos") == 0)
    {
        return acos;
    }
    else if (strcmp(s, "atan") == 0)
    {
        return atan;
    }
    else if (strcmp(s, "exp") == 0)
    {
        return exp;
    }
    else if (strcmp(s, "log") == 0)
    {
        return log;
    }
    else if (strcmp(s, "log10") == 0)
    {
        return log10;
    }
    else if (strcmp(s, "sqrt") == 0)
    {
        return sqrt;
    }
    else if (strcmp(s, "ceil") == 0)
    {
        return ceil;
    }
    else if (strcmp(s, "floor") == 0)
    {
        return floor;
    }
    else
    {
        return NULL;
    }
}

typedef struct
{
    int exp_count;
    char **exp_funcs;
    char **exp_strs;
    char **exp_results;
}exp_strStuctTypedef;

exp_strStuctTypedef str_find_exp_and_calc(char *s)
{
    char *ptr = s;              //遍历整个字符串的指针

    char exp_func[100] = {0};    //储存当前找到的表达式函数
    int  exp_func_i = 0;        //当前找到的表达式函数数组的下标
    char **exp_funcs = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式函数
    int  exp_funcs_i = 0;       //所有找到的表达式函数数组的下标
    memset(exp_funcs, 0, sizeof(char *) * 100);

    char exp_str[100] = {0};    //储存当前找到的表达式
    int  exp_str_i = 0;         //当前找到的表达式数组的下标
    char **exp_strs = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式
    int  exp_strs_i = 0;        //所有找到的表达式数组的下标
    memset(exp_strs, 0, sizeof(char *) * 100);

    char exp_result[100] = {0};    //储存当前表达式的计算值
    int  exp_result_i = 0;         //当前找到的表达式计算值数组的下标
    char **exp_results = (char **)malloc(sizeof(char *) * 100); //储存所有找到的表达式的计算值
    int  exp_results_i = 0;        //所有找到的表达式计算值数组的下标
    memset(exp_results, 0, sizeof(char *) * 100);

    printf("str: %s\n", s);
    while (*ptr++)
    {
        if (*ptr == '(' && (*(ptr - 1) != '(') && (*(ptr - 1) != '+') && (*(ptr - 1) != '-') && (*(ptr - 1) != '*') && (*(ptr - 1) != '/'))
        {
            // printf("find exp: ");
            char *exp_func_ptr = ptr;
            while(*exp_func_ptr--)
            {
                if((*exp_func_ptr != '+') && (*exp_func_ptr != '-') && (*exp_func_ptr != '*') && (*exp_func_ptr != '/'))
                {
                    // putchar(*exp_func_ptr);
                    exp_func[exp_func_i++] = *exp_func_ptr;
                }
                else
                {
                    exp_func[exp_func_i] = '\0';
                    exp_funcs[exp_funcs_i] = malloc(sizeof(char) * (exp_func_i + 1));

                    strcpy(exp_funcs[exp_funcs_i], exp_func);
                    str_reverse(exp_funcs[exp_funcs_i]);
                    exp_funcs_i++;
                    
                    memset(exp_func, 0, 100);
                    exp_func_i = 0;

                    break;
                }
            }

            int count_kuohao = -1;
            char *sub_str_ptr = ptr + 1;
            memset(exp_str, 0, 100);

            do
            {
                // 括号匹配
                if(*sub_str_ptr == ')')
                {
                    count_kuohao++;
                }
                else if(*sub_str_ptr == '(')
                {
                    count_kuohao--;
                }

                // 退出条件
                if(count_kuohao != 0)
                {
                    // putchar(*sub_str_ptr);
                    exp_str[exp_str_i++] = *sub_str_ptr;
                }
                else
                {
                    exp_str[exp_str_i] = '\0';
                    exp_strs[exp_strs_i] = malloc(sizeof(char) * (exp_str_i + 1));

                    strcpy(exp_strs[exp_strs_i], exp_str);
                    exp_strs_i++;
                    
                    memset(exp_str, 0, 100);
                    exp_str_i = 0;
                    break;
                }

            }while(*sub_str_ptr++);
        }
    }

    for (int i = 0; i < exp_strs_i; i++)
    {
        char *temp_result_str = double2str(get_math_fun(exp_funcs[i])(str2double(exp_strs[i])));
        exp_results[i] = malloc(sizeof(char) * (strlen(temp_result_str) + 1));
        strcpy(exp_results[i], temp_result_str);
    }

    exp_strStuctTypedef exp_strStuct;
    exp_strStuct.exp_count = exp_strs_i;
    exp_strStuct.exp_funcs = exp_funcs;
    exp_strStuct.exp_strs = exp_strs;
    exp_strStuct.exp_results = exp_results;

    return exp_strStuct;
}
]]>
    
    https://cosmical-container.github.io/posts/6125e204/
    
    2024-10-05T14:58:00.000Z
    
      一个有意思的小工具：给它一个字符串，比如 "sin(1+1)+max(2,3)" 这种形式，它能自动找出里面的数学函数调用、解析括号里的表达式，然后调用对应的库函数把结果算出来。全程纯 C，核心用了三个技术点。


    
    字符串公式求值器
    2024-10-05T14:58:00.000Z
  
  
    
      寰宇体
    
    
    
    
      
系列导航：上一篇：Print.h 开发记（六）V1.6
系列最终篇：V1.7 加入字体效果，V1.8 修掉遗留问题并支持无参调用——print 库到此定稿。
V1.7：字体宏
除了颜色，ANSI 转义序列还能控制字体效果：
1
2
3
4
5
6
7
8
9
10
11
12
// 原始字体宏
#define NONE(str)          str"\033[m"
// 高亮文字
#define HIGHTLIGHT(str)    "\033[1m"NONE(str)
// 斜体文字
#define ITALIC(str)        "\033[3m"NONE(str)
// 下划线文字
#define _(str)             "\033[4m"NONE(str)
// 闪烁文字
#define FLASGING(str)      "\033[5m"NONE(str)
// 反显文字 - 交换前景色和背景色
#define Reversedisplay(str) "\033[7m"NONE(str)
高亮、斜体、下划线、闪烁、反显，五种效果随意组合使用。
V1.7 还修了一个多文件包含冲突的问题：多个 .c 文件同时包含 Print.h 时，头文件里的函数体会被编译两次，链接时报”函数重复定义”。解决方式是给所有函数加上 static inline——static 让函数只在当前编译单元可见，inline 允许把函数体直接写在头文件里：
1
2
static inline void print_char(char num) { printf("%c", num); }
static inline const char* str_comb(const char *str1, const char *str2) { /* ... */ }
这正是 V1.0 埋下的那个伏笔，到这里才正式填上。
V1.8：无参打印
V1.8 重写了 PrintMacroArgCount 宏，让它能正确处理”没有参数”的情况：
1
2
print();        // 打印空白
println();      // 打印一个换行
之前的参数计数宏在空参数时会展开出错，重写后 print() 和 println() 都能正常工作，系列的最新版本就此定稿。
系列完结
从 V1.0 的 _Generic 单参数打印，到 debug 宏、颜色、字体、多参数、无参调用——一个 print 库的完整进化史写完了。所有源码都在 GitHub 项目里，每个版本的 Print.h 都保留着，想看某个版本的完整实现直接翻历史即可。
V1.7/V1.8 完整代码
Print.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
/**
 * @file Print.h
 * @author Cosmical Containter
 * @emile 联系方式已隐去 
 * @github https://github.com/COSMICAL-CONTAINER
 * @brief Print anything you want!
 * @version 1.8
 * @date 2024-07-15
 * 
 * @copyright Copyright (c) 2024
 * 
 * @see
 * V1.0 
 * 完成基础功能，实现对基础类型char、short int、int、float、double、const char *、char *的打印
 * 
 * V1.1
 * 修复bug
 * 
 * V1.2
 * 加入unsigned long long 的打印格式
 * 加入打印数组功能，可以自选数组中每两个元素的打印格式
 * 加入不支持的格式错误处理
 * 加入颜色打印代码
 *
 * V1.3
 * 拓展颜色打印宏，现在可以支持输入字符串或变量了
 *
 * V1.4
 * 拓展print与println宏，以前只能输出1个参数，现在可以输入最多10个参数了，做到了重载
 *
 * V1.5
 * 实现对大部分基础类型的打印
 * 完善注释
 * 
 * V1.6
 * 加入debug宏，可以打印变量名以及变量的值
 * 加入WARN_IF、ERR_IF、ERR_EXIT_IF宏，可以根据条件来测试打印
 * 
 * V1.7
 * 修复多个文件同时包含Print.h时，函数冲突的问题
 * 加入字体宏，可以高亮、斜体、下划线、闪烁、反显文字
 * 
 * V1.8
 * 修复字体宏高亮、斜体、下划线、闪烁、反显文字打印变量时报错
 * 重写PrintMacroArgCount宏，现在可以获取没有参数的情况了，实现print()、println(),不传递参数默认打印空白或换行
 */

#ifndef __Print_H__
#define __Print_H__

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

#define PRINTMAXSTRLEN 1000

// 颜色宏代码
// #define NONE(str)          str"\033[m"
// #define RED(str)           "\033[0;32;31m"NONE(str)
// #define LIGHT_RED(str)     "\033[1;31m"NONE(str)
// #define GREEN(str)         "\033[0;32;32m"NONE(str)
// #define LIGHT_GREEN(str)   "\033[1;32m"NONE(str)
// #define BLUE(str)          "\033[0;32;34m"NONE(str)
// #define LIGHT_BLUE(str)    "\033[1;34m"NONE(str)
// #define DARY_GRAY(str)     "\033[1;30m"NONE(str)
// #define CYAN(str)          "\033[0;36m"NONE(str)
// #define LIGHT_CYAN(str)    "\033[1;36m"NONE(str)
// #define PURPLE(str)        "\033[0;35m"NONE(str)
// #define LIGHT_PURPLE(str)  "\033[1;35m"NONE(str)
// #define YELLOW(str)        "\033[0;33m"NONE(str)
// #define LIGHT_YELLOW(str)  "\033[1;33m"NONE(str)
// #define LIGHT_GRAY(str)    "\033[0;37m"NONE(str)
// #define WHITE(str)         "\033[1;37m"NONE(str)

// // 原始字体宏
// #define NONE(str)          str"\033[m"
// // 高亮文字
// #define HIGHTLIGHT(str)    "\033[1m"NONE(str)
// // 斜体文字
// #define ITALIC(str)        "\033[3m"NONE(str)
// // 下划线文字
// #define _(str)             "\033[4m"NONE(str)
// // 闪烁文字
// #define FLASGING(str)      "\033[5m"NONE(str)
// // 反显文字 - 交换前景色和背景色
// #define Reversedisplay(str)      "\033[7m"NONE(str)

// 为了能够实现兼容字符串和变量的颜色打印，只能这样操作
// RED(a) 与 RED("1") 兼容
#define TOSTR(obj) (_Generic((obj),\
    char:        char2str,\
    short int:        short2str,\
    int:        int2str,\
    float:        float2str,\
    double:        double2str,\
    const char*:        str2str,\
char *:        str2str,\
    unsigned long long: ulonglong2str,\
    default:            print_void_or_error\
    )(obj))

#define RED(obj)           (str_comb(str_comb("\033[0;32;31m",TOSTR(obj)),"\033[m"))
#define LIGHT_RED(obj)     (str_comb(str_comb("\033[1;31m"   ,TOSTR(obj)),"\033[m"))
#define GREEN(obj)         (str_comb(str_comb("\033[0;32;32m",TOSTR(obj)),"\033[m"))
#define LIGHT_GREEN(obj)   (str_comb(str_comb("\033[1;32m"   ,TOSTR(obj)),"\033[m"))
#define BLUE(obj)          (str_comb(str_comb("\033[0;32;34m",TOSTR(obj)),"\033[m"))
#define LIGHT_BLUE(obj)    (str_comb(str_comb("\033[1;34m"   ,TOSTR(obj)),"\033[m"))
#define DARY_GRAY(obj)     (str_comb(str_comb("\033[1;30m"   ,TOSTR(obj)),"\033[m"))
#define CYAN(obj)          (str_comb(str_comb("\033[0;36m"   ,TOSTR(obj)),"\033[m"))
#define LIGHT_CYAN(obj)    (str_comb(str_comb("\033[1;36m"   ,TOSTR(obj)),"\033[m"))
#define PURPLE(obj)        (str_comb(str_comb("\033[0;35m"   ,TOSTR(obj)),"\033[m"))
#define LIGHT_PURPLE(obj)  (str_comb(str_comb("\033[1;35m"   ,TOSTR(obj)),"\033[m"))
#define YELLOW(obj)        (str_comb(str_comb("\033[0;33m"   ,TOSTR(obj)),"\033[m"))
#define LIGHT_YELLOW(obj)  (str_comb(str_comb("\033[1;33m"   ,TOSTR(obj)),"\033[m"))
#define LIGHT_GRAY(obj)    (str_comb(str_comb("\033[0;37m"   ,TOSTR(obj)),"\033[m"))
#define WHITE(obj)         (str_comb(str_comb("\033[1;37m"   ,TOSTR(obj)),"\033[m"))
#define HIGHTLIGHT(str)    (str_comb(str_comb("\033[1m"      ,TOSTR(str)),"\033[m"))
// 斜体文字
#define ITALIC(str)              (str_comb(str_comb("\033[3m",TOSTR(str)),"\033[m"))
// 下划线文字
#define _(str)                   (str_comb(str_comb("\033[4m",TOSTR(str)),"\033[m"))
// 闪烁文字
#define FLASGING(str)            (str_comb(str_comb("\033[5m",TOSTR(str)),"\033[m"))
// 反显文字 - 交换前景色和背景色
#define Reversedisplay(str)      (str_comb(str_comb("\033[7m",TOSTR(str)),"\033[m"))

// 这是字符串合成函数
static inline const char* str_comb(const char *str1, const char *str2)
{
    static char str[PRINTMAXSTRLEN];
    strcpy(str, str1);
    strcat(str, str2);
    return str;
}

// 下面是处理各种类型转字符串的函数
static inline const char* char2str(char ch)
{
    static char str[2];
    str[0] = ch;
    str[1] = '\0';
    return str;
}

static inline const char* short2str(short num)
{
    // short：2字节 -32,768 到 32,767
    static char str[7];
    sprintf(str, "%hd", num);
    return str;
}

static inline const char* int2str(int num)
{
    // int：2~4字节 -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647
    static char str[12];
    sprintf(str, "%d", num);
    return str;
}

static inline const char* float2str(float num)
{
    // float：4字节 1.2E-38 到 3.4E+38
    static char str[12];
    sprintf(str, "%f", num);
    return str;
}

static inline const char* double2str(double num)
{
    // double：8字节 2.3E-308 到 1.7E+308
    static char str[21];
    sprintf(str, "%lf", num);
    return str;
}

static inline const char* ulonglong2str(unsigned long long num)
{
    // unsigned long long：8字节 0 到 18,446,744,073,709,551,615
    static char str[21];
    sprintf(str, "%llu", num);
    return str;
}

static inline const char* str2str(const char* str)
{
    // 直接返回即可
    return str;
}

// 颜色宏代码测试
#define TestColor(obj)\
{\
    println(RED(obj));\
    println(LIGHT_RED(obj));\
    println(GREEN(obj));\
    println(LIGHT_GREEN(obj));\
    println(BLUE(obj));\
    println(LIGHT_BLUE(obj));\
    println(CYAN(obj));\
    println(LIGHT_CYAN(obj));\
    println(PURPLE(obj));\
    println(LIGHT_PURPLE(obj));\
    println(YELLOW(obj));\
    println(LIGHT_YELLOW(obj));\
    println(DARY_GRAY(obj));\
    println(LIGHT_GRAY(obj));\
    println(WHITE(obj));\
}

// 兼容Color两种写法
#define TestColur TestColor

// 原始打印宏，根据obj类型调用不同的打印函数
#define _print(obj) (_Generic((obj),    \
    char:        print_char,     \
    unsigned char:print_uchar,    \
                                        \
    short int:        print_short,    \
    int:        print_int,      \
    unsigned int:print_uint,     \
                                        \
    long long:          print_longlong, \
    unsigned long long: print_ulonglong,\
                                        \
    float:        print_float,    \
    double:        print_double,   \
                                        \
    const char*:        print_cstr,     \
char*:        print_str,      \
                                        \
    int*:               print_p,        \
    long long*:         print_p,        \
    unsigned long long*:print_p,        \
    float*:             print_p,        \
    double*:            print_p,        \
                                        \
    default:            print_void_or_error     \
    )(obj))

// 原始打印换行宏，直接调用打印函数然后打印换行符
#define _println(obj) _print(obj), _print("\n")

// 获取参数个数，最多支持10个参数
#define _PrintMacroArgCount(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, COUNT,...) COUNT
#define PrintMacroArgCount(...) _PrintMacroArgCount("ignored", ##__VA_ARGS__,9,8,7,6,5,4,3,2,1,0)

// 宏黏贴
#define PrintConcat(A, B) _PrintConcat(A, B)
#define _PrintConcat(A, B) A##B

// 打印宏的宏展开，最多支持10个参数
// 原理: print(a, b, c); 展开后变成 _print(a), _print(b), _print(c);
#define print(...) _print_(__VA_ARGS__)
#define _print_(...) PrintConcat(_print_, PrintMacroArgCount(__VA_ARGS__))(__VA_ARGS__)
#define _print_0()                                              printf("")
#define _print_1(_0)                                           _print(_0)
#define _print_2(_0, _1)                                       _print_1(_0), _print(_1)
#define _print_3(_0, _1, _2)                                   _print_2(_0, _1), _print(_2)
#define _print_4(_0, _1, _2, _3)                               _print_3(_0, _1, _2), _print(_3)
#define _print_5(_0, _1, _2, _3, _4)                           _print_4(_0, _1, _2, _3), _print(_4)
#define _print_6(_0, _1, _2, _3, _4, _5)                       _print_5(_0, _1, _2, _3, _4), _print(_5)
#define _print_7(_0, _1, _2, _3, _4, _5, _6)                   _print_6(_0, _1, _2, _3, _4, _5), _print(_6)
#define _print_8(_0, _1, _2, _3, _4, _5, _6, _7)               _print_7(_0, _1, _2, _3, _4, _5, _6), _print(_7)
#define _print_9(_0, _1, _2, _3, _4, _5, _6, _7, _8)           _print_8(_0, _1, _2, _3, _4, _5, _6, _7), _print(_8)
#define _print_10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9)      _print_9(_0, _1, _2, _3, _4, _5, _6, _7, _8), _print(_9)

#define endl ((char)'\n')

// 打印并换行宏的宏展开，最多支持10个参数
// 原理: println(a, b, c); 展开后变成 _println(a), _println(b), _println(c);
#define println(...) _println_(__VA_ARGS__)
#define _println_(...) PrintConcat(_println_, PrintMacroArgCount(__VA_ARGS__))(__VA_ARGS__)
#define _println_0()                                              print("\n")
#define _println_1(_0)                                           _println(_0)
#define _println_2(_0, _1)                                       _println_1(_0), _println(_1)
#define _println_3(_0, _1, _2)                                   _println_2(_0, _1), _println(_2)
#define _println_4(_0, _1, _2, _3)                               _println_3(_0, _1, _2), _println(_3)
#define _println_5(_0, _1, _2, _3, _4)                           _println_4(_0, _1, _2, _3), _println(_4)
#define _println_6(_0, _1, _2, _3, _4, _5)                       _println_5(_0, _1, _2, _3, _4), _println(_5)
#define _println_7(_0, _1, _2, _3, _4, _5, _6)                   _println_6(_0, _1, _2, _3, _4, _5), _println(_6)
#define _println_8(_0, _1, _2, _3, _4, _5, _6, _7)               _println_7(_0, _1, _2, _3, _4, _5, _6), _println(_7)
#define _println_9(_0, _1, _2, _3, _4, _5, _6, _7, _8)           _println_8(_0, _1, _2, _3, _4, _5, _6, _7), _println(_8)
#define _println_10(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9)      _println_9(_0, _1, _2, _3, _4, _5, _6, _7, _8), _println(_9)

// 下面是打印各种类型的原始打印函数
static inline void print_char(char num)
{
    printf("%c", num);
}

static inline void print_uchar(unsigned char num)
{
    printf("%c", num);
}

static inline void print_short(short int num)
{
    printf("%hd", num);
}

static inline void print_int(int num)
{
    printf("%d", num);
}

static inline void print_uint(unsigned int num)
{
    printf("%u", num);
}

static inline void print_longlong(long long num)
{
    printf("%lld", num);
}

static inline void print_ulonglong(unsigned long long num)
{
    printf("%llu", num);
}

static inline void print_float(float num)
{
    printf("%f", num);
}

static inline void print_double(double num)
{
    printf("%lf", num);
}

static inline void print_cstr(const char* str)
{
    printf("%s", str);
}

static inline void print_str(char* str)
{
    printf("%s", str);
}

static inline void print_p(void* obj)
{
    printf("%p", obj);
}

static inline void print_void_or_error(void *data)
{
    _print(RED( "print error! or" ));
    _println(RED( "don't have this type to print!" ));
}

// debug宏
#define debug_valuename_to_str(value) #value
#define debug(obj) print(LIGHT_GREEN("debug: "), debug_valuename_to_str(obj)" = ", obj, "\n")

#define WARN_IF(EXP)  \
do                    \
{                     \
    if (EXP)          \
        print(YELLOW("warning: "), #EXP "\n"); \
}while(0)

#define ERR_IF(EXP)   \
do                    \
{                     \
    if (EXP)          \
        print(RED("error: "), #EXP "\n"); \
}while(0)

#define ERR_EXIT_IF(EXP)\
do                    \
{                     \
    if (EXP)          \
    {                 \
        print(RED("error: "), #EXP "\n"); \
        exit(-1);\
    }\
}while(0)

// 打印数组宏

// 打印数组宏控制打印方式
// 0: 数组元素之间用空格隔开
#define printArrTypeSpace 0
// 1: 数组元素之间用换行符隔开
#define printArrTypeln    1
// 2: 打印数组元素和元素下标
#define printArrTypeName  2

// 获取数组长度宏
#define GET_ARR_LEN(arrobj) \
(_Generic((arrobj),\
    char *:  strlen((const char *)arrobj),\
    default:      (sizeof(arrobj) / sizeof(arrobj[0]))\
    ))

// 打印数组宏， 其中type是数组的元素之间按照什么方式打印
#define printArr(ArrName, type) {     \
    for (int i = 0; i < GET_ARR_LEN(ArrName); i++)    \
    {                                       \
        if(type == printArrTypeName)        \
        {                                   \
            print(#ArrName);                \
            print("[");                     \
            print(i);                       \
            print("] = ");                  \
            println(ArrName[i]);            \
        }                                   \
        else                                \
        {                                   \
            print(ArrName[i]);              \
            if(type)    print("\n");        \
            else        print(" ");         \
        }                                   \
    }                                       \
}

#define printlnArr(ArrName, type) {printArr(ArrName, type); print("\n");}

#endif // !__Print_H__
测试程序 main.c（V1.7/V1.8）
main.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include "Print.h"
int main()
{
    char char_a = '0';
    unsigned char char_b = '1';

    short int sint_c = 2;
    int int_d = 3;
    unsigned int uint_e = 4;

    long long ll_f = 5l;
    unsigned long long ull_g = 6l;

    float float_h = 7.7;
    double double_i = 8.8f;

    const char* ccharx_j = "999";
    char* charx_k = "1234567890";

    int *intx_l = &int_d;
    long long *llx_m = &ll_f;
    unsigned long long *ullx_n = &ull_g;

    float *o = &float_h;
    double *p = &double_i;

    println(char_a, char_b, sint_c, int_d, uint_e, ll_f, ull_g, float_h, double_i);
    println(ccharx_j, charx_k, intx_l, llx_m, ullx_n, o, p);

    int num_array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    char ccl_str[10] = "ccl";

    println(GET_ARR_LEN(num_array));
    printlnArr(num_array, printArrTypeSpace);

    println(GET_ARR_LEN(ccl_str));
    printlnArr(ccl_str, printArrTypeName);

    println(GET_ARR_LEN("987654321"));

    TestColor("ccl is a boy");
    
    TestColor(char_a);

    print(RED(2));
    print();
    println(YELLOW(3.3));
    println();
    println(GREEN(3.3f));

    println(HIGHTLIGHT("Look at me"));
    println(ITALIC("Look at me"));
    println(_("Look at me"));
    println(FLASGING("Look at me"));
    println(Reversedisplay("Look at me"));

    debug(char_a);

    WARN_IF(char_a == '0');
    ERR_IF(2 == 2);
    ERR_EXIT_IF(3 == 2);
    WARN_IF(char_a == 0);

    return 0;
}
系列导航
]]>
    
    https://cosmical-container.github.io/posts/7fa03b95/
    
    2024-10-05T14:00:00.000Z
    
      

系列导航：上一篇：Print.h 开发记（六）V1.6



系列最终篇：V1.7 加入字体效果，V1.8 修掉遗留问题并支持无参调用——print]]>
    

    Print.h 开发记（七）V1.7/V1.8
    2024-10-05T14:00:00.000Z
  
  
    
      寰宇体
    
    
    
      这次分享几个数组的冷门玩法：柔性数组、负数下标和复合字面量。
一、柔性数组：通信数据包神器
1
2
3
4
5
6
struct package
{
    int version;
    int size;
    char data[0];       // 柔性数组（C99 标准写法是 char data[]）
};
data[0] 不占任何空间，sizeof(struct package) 只有 8 字节（两个 int）。用法是一次性 malloc 出”结构体 + 数据”的连续内存：
1
2
3
4
5
my_package = malloc(sizeof(struct package) + data_len);
my_package->version = 1;
my_package->size = data_len;
for (int i = 0; i < data_len; i++)
    my_package->data[i] = 'a' + i;
这样包头和数据在一块内存里，一次 free 就能释放，序列化网络包时直接整块发送——网络协议和内核代码里到处都是这种写法。
二、数组下标可以是负数
1
2
3
4
int array[] = {1, 2, 3, 4, 5};
int *p = &array[-1];

printf("%d\n", p[1]);       // 输出 array[0]，也就是 1
p[1] 等价于 *(p + 1)，而 p 指向 array[-1] 的位置，所以 p[1] 就是 array[0]。下标本质只是指针偏移，正负都合法——只要别越界访问到没分配的内存。
三、复合字面量玩数组
1
2
3
(int[][1][1][1]){1, 2}      // 临时构造一个数组
(int[]){1}                  // 一维临时数组
(void* []){a}               // 临时指针数组
复合字面量（C99）可以在表达式里直接造数组，配合下标能玩出很多花样，比如 (int* []){a}[0][0] 就是 a[0]。调试指针和数组关系的时候挺好用。
写在最后
柔性数组是这几个里面唯一”正经推荐用于生产”的写法，负下标和复合字面量属于了解即可——知道有这么回事，读别人代码不慌。
完整代码
C语言数组冷知识.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
#include <stdio.h>
#include <stdlib.h>

// 柔性数组，用于通信数据包处理
struct package
{
    int version;
    int size;
    char data[0];
};
struct package* my_package;

int main()
{
    int data_len = 26;

    // 实际上就占用8个字节(2个int)
    printf("sizeof(struct package) = %I64d\n", sizeof(struct package));
    my_package = malloc(sizeof(struct package) + data_len * sizeof(char));

    my_package->version = 1;
    my_package->size = data_len;
    
    for (int i = 0; i <= data_len; i++)
    {
        my_package->data[i] = (i == data_len ? '\0' : 'a' + i);
    }

    printf("%s\n", my_package->data);

    // 数组引用可以使用-1
    int array[] = {1, 2, 3, 4, 5};
    int *p = &array[-1];

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

    // 强转数组类型
    // int a[2] = {123, 234};
    // printf("%p\n", (int[][1][1][1]){1,2}[0][0][0]);
    // printf("%p\n", (int[][1][1][1]){1}[0][0]);
    // printf("%p\n", (int[][1][1][1]){1}[0]);
    // printf("%p\n", (int[][1][1][1]){1});
    // printf("%p\n", (int[]){1});

    // printf("%p\n", a);

    // printf("%p\n", (void* []){a}[0]);
    // printf("%p\n", (void* []){a}[1]);
    // printf("%p\n", (void* []){a}[2]);

    // printf("%d\n", (int* []){a}[0][0]);
    // printf("%d\n", (int* []){a}[0][1] - (int* []){a}[0][0]);
    // printf("%d\n", *(int *)(void* []){a}[0] - ((int* []){a, a}[1])[1]);


    return 0;
}
]]>
    
    https://cosmical-container.github.io/posts/3623a4d9/
    
    2024-08-22T12:12:00.000Z
    
      这次分享几个数组的冷门玩法：柔性数组、负数下标和复合字面量。


一、柔性数组]]>
    

    C语言数组冷知识
    2024-08-22T12:12:00.000Z
  
  
    
      寰宇体
    
    
    
    
    
      总有些场合，文字得靠键盘一个字一个字”敲”进去——目标输入框不吃复制粘贴，或者你只是想让朋友亲眼看着一段话”自己”出现在聊天框里。AutoWrite 就是干这个的：你把文本交给它，它替你把每个键按下去。项目做了两版，正好是 Windows 下模拟输入的两条技术路线——第一版把自己变成键盘，第二版直接给窗口发消息。第一版整理后传上了 GitHub：AutoWrite（MIT 协议）。
第一版思路：把自己变成键盘
最早的版本（V0.0.1，2023 年 4 月）核心只有一个念头：程序不碰目标窗口，只负责假装自己是键盘。Windows 提供的 keybd_event 就是干这个的——给它一个虚拟键码（VK code），系统就当作这个键被按了一下：
1
2
3
4
5
void write_word(int vk)//输入数字、字母
{
keybd_event(vk,0,0,0);// 按下
keybd_event(vk,0,KEYEVENTF_KEYUP,0);// 弹起
}
按下、弹起，两个事件，一个键就”敲”完了。字母数字都好办，麻烦的是符号——它们和主键区不是一对一的关系。比如 * + 这类键，键盘上根本没有独立的”*键”，它们住在数字小键盘上，虚拟键码是另一套：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void WriteCharacter(int vk)//输入符号
{
switch(vk)
{
case 42:
keybd_event(106,0,0,0);// '*' → 小键盘 VK_MULTIPLY
keybd_event(106,0,KEYEVENTF_KEYUP,0);
break;
case 43:
keybd_event(107,0,0,0);// '+' → 小键盘 VK_ADD
keybd_event(107,0,KEYEVENTF_KEYUP,0);
break;
case 44:
keybd_event(108,0,0,0);// ',' → 小键盘 VK_SEPARATOR
keybd_event(108,0,KEYEVENTF_KEYUP,0);
break;
case '-':
keybd_event(VK_OEM_MINUS,0,0,0);
keybd_event(VK_OEM_MINUS,0,KEYEVENTF_KEYUP,0);
break;
case '.':
keybd_event(VK_OEM_PERIOD,0,0,0);
keybd_event(VK_OEM_PERIOD,0,KEYEVENTF_KEYUP,0);
break;
case 47:
keybd_event(111,0,0,0);// '/' → 小键盘 VK_DIVIDE
keybd_event(111,0,KEYEVENTF_KEYUP,0);
break;
        case ' ':
keybd_event(0x20,0,0,0);
keybd_event(0x20,0,KEYEVENTF_KEYUP,0);
break;
}
}
ASCII 码 42（*）要翻译成小键盘的 106（VK_MULTIPLY），45（-）对应的是 VK_OEM_MINUS——这张”ASCII 到虚拟键码”的对照表，就是自动打字机的第一块地基。
大小写是另一课。键盘上字母键只有一把，大小写靠的是 Shift 这个修饰键：
1
2
3
4
5
6
7
8
9
void ShiftDown()//按下shift
{
keybd_event(16,0,0,0);
}

void ShiftUp()//弹起shift
{
keybd_event(16,0,KEYEVENTF_KEYUP,0);
}
AutoWrite 主循环把整套逻辑串起来：遍历字符串，按字符类别分发到上面三套机制：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void AutoWrite(std::string word)//输入一串句子
{
for(int i=0;i<word.length();i++)
{
int zm=word.at(i);
if((zm >= 'a' && zm <= 'z'))
{
write_word(zm - 32);// 'a' 发 'A' 的键码，不带 Shift，出来的就是小写
}
else if( zm >= 'A' && zm <= 'Z' )
{
ShiftDown();
write_word(zm);
ShiftUp();
}
else if(zm>41 && zm<48 || zm == ' ' || zm == '.')
{
WriteCharacter(zm);
}
Sleep(10);
}
}
这里藏着自动打字机的第一课：write_word(zm - 32) 把 'a' 换成 'A' 的键码发出去——不带 Shift 按字母键，出来的就是小写。键盘事件的世界里没有”小写键码”，只有”字母键码 + Shift 状态”的组合；真正需要 Shift 陪跑的反而是大写字母。符号分支的守卫条件 zm>41 && zm<48 用的还是 ASCII 码区间——42 到 47 正是 * + , - . / 一族。
每敲一个键 Sleep(10)——太快了有些程序的消息循环跟不上，会丢字。这个”每个键之间留一口气”的节奏问题，后面还会回来找两次麻烦。当时的 main 也特别直白：两秒倒计时之后，打 10 遍 nihao，每遍跟一个回车，纯粹的开机自检。
1
2
3
4
5
6
7
8
9
10
11
int main()
{
std::cout<<"程序开始!"<<std::endl;
Sleep(2000);
for(int i=0;i<10;i++)
{
AutoWrite("nihao");
Enter();
}
return 0;
}
升级成正经程序：GUI 版
命令行版能用，但每次都得先点开目标窗口再切回终端回车，手忙脚乱。于是到了 V0.0.x 的后期，它长成了一个大方的 Win32 程序：窗口里一个多行文本框，把想打的字粘进去，点一下”点我开始”，然后你有两秒钟把光标移到真正的目标输入框里，剩下的事交给程序。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
case WM_COMMAND:
if (LOWORD(wParam) == 1)// "点我开始"按钮
{
int n = GetWindowTextLength(hEditName);// 获取文本框中的文本长度
if (n > 0)
{
TCHAR *szBuffer = (TCHAR *)malloc(sizeof(char) * (n + 1));// 缓冲区
GetWindowText(hEditName, szBuffer, n + 1);// 获取文本

// 校验字符是否都在支持范围内，然后：
MessageBox(NULL, "请在关闭我之后2s内将输入指针移动到想要输入文字的框中", "提示", MB_OK | MB_ICONINFORMATION);
Sleep(2000);
AutoWrite(szBuffer);
free(szBuffer);
}
}
break;
这里有个容易忽略的细节：拿文本框内容不能直接读，得先问长度、再按长度开缓冲区——GetWindowTextLength + malloc(n+1) + GetWindowText 三连。早期的版本这里是个写死的 2048 字节数组（更新记录 V0.0.1 里”增加 buffer 区设置为 2048”就是它），超长文本直接爆，V0.0.2 改成了动态申请，才有了这段标准三连。
按键的核心也从 keybd_event 换成了新一代的 SendInput：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void write_word(unsigned char vk)
{
// keybd_event(vk,0,0,0);
// keybd_event(vk,0,KEYEVENTF_KEYUP,0);
INPUT inputs = {0};

inputs.type = INPUT_KEYBOARD;
inputs.ki.wVk = vk;

UINT uSent = SendInput(1, &inputs, sizeof(INPUT));
if (uSent != 1)
{
cout << L"SendInput failed: " << HRESULT_FROM_WIN32(GetLastError()) << endl;
}
}
注意注释里保留的老写法——keybd_event 和 SendInput 干的是同一件事，但 SendInput 把一批按键事件打包成原子操作一次性注入，中间不会被真实的键鼠输入插队；keybd_event 是一次一个事件，两个调用之间你的手如果真的碰了键盘，序列就被污染了。对自动打字机来说这个区别是实质性的，所以换代，老代码留着当注释当纪念。
这一版的完整代码在仓库里：
AutoWrite.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
#include <windows.h>
#include <string>
#include <iostream>
using namespace std;

#define VERSION "0.0.5"
#define IDI_MYICON 101

// 微软虚拟键代码
// https://learn.microsoft.com/zh-cn/windows/win32/inputdev/virtual-key-codes
// 输入数字、字母
void write_word(unsigned char vk)
{
    // keybd_event(vk,0,0,0);
    // keybd_event(vk,0,KEYEVENTF_KEYUP,0);
    INPUT inputs = {0};

    inputs.type = INPUT_KEYBOARD;
    inputs.ki.wVk = vk;

    UINT uSent = SendInput(1, &inputs, sizeof(INPUT));
    if (uSent != 1)
    {
        cout << L"SendInput failed: " << HRESULT_FROM_WIN32(GetLastError()) << endl;
    }
}

// 输入符号
void WriteCharacter(unsigned char vk)
{
    switch (vk)
    {
    case '-':
        keybd_event(VK_OEM_MINUS, 0, 0, 0);
        keybd_event(VK_OEM_MINUS, 0, KEYEVENTF_KEYUP, 0);
        break;
    case '.':
        keybd_event(VK_OEM_PERIOD, 0, 0, 0);
        keybd_event(VK_OEM_PERIOD, 0, KEYEVENTF_KEYUP, 0);
        break;
    case ' ':
        keybd_event(0x20, 0, 0, 0);
        keybd_event(0x20, 0, KEYEVENTF_KEYUP, 0);
        break;
    case '\'':
        keybd_event(VK_OEM_7, 0, 0, 0);
        keybd_event(VK_OEM_7, 0, KEYEVENTF_KEYUP, 0);
        break;
    }
}

void Enter()
{
    keybd_event(13, 0, 0, 0);
    keybd_event(13, 0, KEYEVENTF_KEYUP, 0);
}

void ShiftDown() // 按下shift
{
    keybd_event(16, 0, 0, 0);
}

void ShiftUp() // 弹起shift
{
    keybd_event(16, 0, KEYEVENTF_KEYUP, 0);
}

void CtrlV() // 粘贴
{
    keybd_event(162, 0, 0, 0);
    write_word('V');
    keybd_event(162, 0, KEYEVENTF_KEYUP, 0);
}

void AutoWrite(string word) // 输入一串句子
{
    size_t n = word.length();

    for (size_t i = 0; i < n; i++)
    {
        unsigned char zm = word.at(i);
        if ((zm >= 'a' && zm <= 'z'))
        {
            write_word(zm - 32);
        }
        else if (zm >= 'A' && zm <= 'Z')
        {
            ShiftDown();
            write_word(zm);
            ShiftUp();
        }
        else if ((zm >= '0' && zm <= '9'))
        {
            write_word(zm);
        }
        else if (zm == ' ' || zm == '.' || zm == '-' || zm == '\'')
        {
            WriteCharacter(zm);
        }
        Sleep(10);
    }
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    static HWND hEditName;
    switch (msg)
    {
    case WM_CREATE:
    {
        // 创建文本框
        hEditName = CreateWindow(
            TEXT("Edit"),
            TEXT(""),
            WS_CHILD | WS_VISIBLE | WS_BORDER /*边框*/ | WS_TABSTOP /*允许使用TAB选中*/ | ES_MULTILINE,
            10, 10, 765, 500,
            hwnd,
            (HMENU)2,
            (HINSTANCE)(LONG_PTR)GetWindowLong(hwnd, GWLP_HINSTANCE),
            NULL);
        break;
    }
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_COMMAND:
        if (LOWORD(wParam) == 1)
        {
            bool isrightstr = true;

            int n = GetWindowTextLength(hEditName); // 获取文本框中的文本长度 描述：获取文本框中的文本长度;
            if (n > 0)
            {
                TCHAR *szBuffer = (TCHAR *)malloc(sizeof(char) * (n + 1)); // 缓冲区
                GetWindowText(hEditName, szBuffer, n + 1);                 // 获取文本
                szBuffer[n + 1] = '\0';

                for (char c = szBuffer[0]; c != '\0'; c = szBuffer[++n])
                {
                    // 检查字符串是否符合要求
                    if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == ' ' || c == '.' || c == '\''))
                    {
                        isrightstr = false;
                        break;
                    }
                }

                if (isrightstr)
                {
                    MessageBox(NULL, "请在关闭我之后2s内将输入指针移动到想要输入文字的框中", "提示", MB_OK | MB_ICONINFORMATION);
                    Sleep(2000);
                    AutoWrite(szBuffer);
                }
                else
                {
                    MessageBox(NULL, "不是有效的字符串", "提示", MB_OK | MB_ICONINFORMATION);
                }
                free(szBuffer);
            }
            else
            {
                MessageBox(NULL, "你TM倒是输入啊", "提示", MB_OK | MB_ICONWARNING);
            }
        }
        break;
    default:
        return DefWindowProc(hwnd, msg, wParam, lParam);
    }
    return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    ShowWindow(GetConsoleWindow(), SW_HIDE);

    const char CLASS_NAME[] = "Hello, World!";

    WNDCLASS wc = {0};

    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.lpszClassName = CLASS_NAME;

    // HICON hIcon = (HICON)LoadImage(NULL, "MYICON.ico", IMAGE_ICON, 0, 0, LR_LOADFROMFILE);
    HICON hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_MYICON));

    wc.hIcon = hIcon;

    // 其他窗口类成员的初始化
    RegisterClass(&wc);

    HWND hwnd = CreateWindowEx(
        0,                                                                   // Optional window styles.
        CLASS_NAME,                                                          // Window class
        ("AutoWrite - 自动打字机 作者：寰宇体 V" + string(VERSION)).c_str(), // Window text
        WS_OVERLAPPEDWINDOW,                                                 // Window style

        // Size and position
        100, 100, 800, 600,

        NULL,      // Parent window
        NULL,      // Menu
        hInstance, // Instance handle
        NULL       // Additional application data
    );

    if (hwnd == NULL)
    {
        return 0;
    }

    SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);

    // Add button
    CreateWindow(
        "BUTTON",                                              // Predefined class; Unicode assumed
        "点我开始",                                            // Button text
        WS_TABSTOP | WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON, // Styles
        350,                                                   // x position
        525,                                                   // y position
        100,                                                   // Button width
        30,                                                    // Button height
        hwnd,                                                  // Parent window
        (HMENU)1,                                              // Button identifier.
        (HINSTANCE)(LONG_PTR)GetWindowLong(hwnd, GWLP_HINSTANCE),
        NULL); // Pointer not needed.

    ShowWindow(hwnd, nCmdShow);

    MessageBox(hwnd, ("本代码由寰宇体制作 建议不要输入太多字符 版本" + string(VERSION)).c_str(), "提示", MB_OK);

    MSG msg = {};
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return 0;
}
这一版还有两个工程化的小升级值得记一笔。图标不再从文件加载：早期注释里的写法是运行时 LoadImage 去 读 MYICON.ico，图标文件和 exe 分家，发给别人就丢图标；后来改成 .rc 资源脚本把 ico 编进 exe，LoadIcon(MAKEINTRESOURCE(IDI_MYICON)) 直接从模块里取。控制台窗口被藏起来：ShowWindow(GetConsoleWindow(), SW_HIDE)，编译出的程序是个纯粹的窗口应用，背后不带一个黑框。
更新记录：五个版本号，五个 bug
这个项目的文件夹里一直躺着一份手写的更新记录，是最朴素但也最真实的开发日志：
更新记录.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
AutoWrite V0.0.1
0.建立新工程
1.完成基本功能的书写
2.在增加buffer区设置为2048

AutoWrite V0.0.2
0.修复个别电脑缺少dll文件的bug，使用静态编译dll办法
1.移除buffer大小限制，使用动态申请内存建立buffer区
2.增加打字前的提示窗口，可以将窗口拖拽到对应的文本控件上

AutoWrite V0.0.3
0.修复不能输入数字的bug

AutoWrite V0.0.4
0.修复最后一个字母不会打印的bug

AutoWrite V0.0.5
0.修复不能输入'\''字符的bug
五条记录里有三条是”某类字符打不出来”：数字、最后一个字母、单引号。这正是模拟键盘路线的宿命——每一种字符都得有人替它安排好按哪个键。数字忘了接、循环边界少走一步、引号这种藏在 VK_OEM_7 里的冷门键，谁没安排谁就打不出来。V0.0.5 把单引号补进 WriteCharacter 的 switch 之后，这个字符集就冻结了：字母、数字、空格、-、.、'，GUI 里的合法性校验也是按这张表来的。
V0.0.2 的”静态编译 dll 办法”值得单独说：程序在自己电脑上跑得好好的，发到别人电脑上弹”缺少 xxx.dll”——动态链接的运行库别人机器上没有。-static-libgcc -static-libstdc++ 把运行库直接打进 exe，体积大一点，换来双击就能跑。
第二版：换掉整个输入模型
键盘模拟用了一年多，2024 年年中重写时我决定换掉整个模型。模拟键盘的本质是往系统级输入队列里插键，字打给”当前焦点”——它快不了（每键之间要 Sleep），也精准不了（焦点飘了就打错地方）。更优雅的思路是：拿到目标窗口的句柄，直接把字符消息塞进它的消息队列，绕过键盘状态，定点投递。
定点投递的第一步是拿到”真正有输入焦点”的那个控件句柄。直接 GetForegroundWindow 拿到的是主窗口，而光标闪动的往往是里面的子控件（比如聊天输入框）。这需要一个不太出名的 API 三连：
1
2
3
4
5
6
7
8
9
10
11
12
// 获得当前激活的窗口句柄
wnd = GetForegroundWindow();
// 获取本身的线程ID
DWORD SelfThreadId = GetCurrentThreadId();
// 根据窗口句柄获取线程ID
DWORD ForeThreadId = GetWindowThreadProcessId(wnd, NULL);
// 附加线程
AttachThreadInput(ForeThreadId, SelfThreadId, 1);
// 获取具有输入焦点的窗口句柄
wnd = GetFocus();
// 取消附加的线程
AttachThreadInput(ForeThreadId, SelfThreadId, 0);
GetFocus 只能拿到自己线程内的焦点窗口，对别的线程无能为力。AttachThreadInput 把自己的线程暂时”挂”到目标窗口的输入线程上，共享同一份输入状态——这时 GetFocus 就能拿到对方线程里真正闪着光标的控件了。用完立刻解除附加。这是 Win32 时代留下的老技巧，MSDN 对它的警告一大堆，但”拿别家程序的焦点控件句柄”这一件事，至今没有更体面的办法。
拿到句柄之后，字符就不用”按键”了，直接 PostMessage 投递：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
for(int j = 0; j < strlen(s); )
{
    if((s[j] & 0x80) >> 7)
    {
        PostMessageA(wnd, WM_IME_CHAR, (WPARAM)transmit(&s[j]), 0);
        j += 2;
    }
    else
    {
        PostMessageA(wnd, WM_CHAR, (WPARAM)s[j], 0);
        j += 1;
    }
    Sleep(1);
}
ASCII 字符走 WM_CHAR，一个字节一步；(s[j] & 0x80) >> 7 判断最高位是不是 1——GBK 编码下中文每个字节的最高位都是 1，这是区分中英文最朴素也最好用的办法。是中文就走 WM_IME_CHAR，一次投递两个字节。
而这两个字节的组装方式，是整个重写版里最有趣的一段：
1
2
3
4
unsigned long long int transmit(char* s)
{
    return (((*(int *)s) & 0x0000FF00) >> 8) + (((*(int *)s) & 0x000000FF) << 8);
}
一行看着像乱码的位运算，干的事是字节对调。拆开看：GBK 编码的”测”是 0xB2 0xE2，在内存里按顺序躺在 s[0]、s[1]。小端机器把这两个字节读进 int，低地址在低位——& 0xFF 取出来的是 s[0]，& 0xFF00 >> 8 取出来的是 s[1]。WM_IME_CHAR 的约定是 wParam 高 8 位放首字节（lead byte），低 8 位放次字节，而内存顺序恰好相反，所以要把两个字节换个位置再拼起来：s[1] 原地取高八位腾地方，s[0] 左移八位坐进去，0xB2E2 完成对调。没有这步对调，目标窗口收到的每个”中文”都是乱码。
这个模型的字符串节奏也和键盘版完全不同：Sleep(1) 甚至可以更激进，因为消息投递没有键盘缓冲区排队的压力；回车单独用 SendInput 模拟——字符走定点投递，而”回车”往往要触发的是对话框层面的默认按钮（比如聊天窗口的”发送”），那是主窗口的消息循环在处理，模拟一个真实的回车键最保险。
字库：把要打的字和打字机分开
重写版还有个工程上的小进步：要打的文本不再写死在 main 里，而是集中放到一个”字库”头文件 AutoWriteFont.h 里，用字符串数组组织，一行一句，空字符串结尾：
1
2
3
4
5
6
7
8
9
char *guisuishou[] = {
                      "龟虽寿",
                "东汉末年/三国·曹操" ,
                "神龟虽寿,犹有竟时；",
                "腾蛇乘雾,终为土灰。",
                "老骥伏枥,志在千里；",
                "烈士暮年,壮心不已。",
                "",
            };
诗、段子、长文本各占一个数组，main 里想打哪段就传哪段。字库和打字机分离之后，加新内容不用碰任何逻辑代码。
长文本还有个实际问题：一次性灌进去，中间的标点不该停顿吗？重写版自己写了一个 my_strtok——标准库 strtok 只认单字节分隔符，全角的”，！。？”在 GBK 里是两个字节，硬切会把汉字腰斩。自研版在比较时多加一条：两边都是全角标点区间（0xFF01~`0xFF5E`）的字符也算匹配，然后把长文按”，！。？”切成句子，一句一句投递。这个函数是先单独扔进 test.c 里测通了，才搬回主程序的——先写测试再集成，对这种字符串切片函数来说性价比极高。
两条路线，各自的位置
第一版：模拟键盘第二版：消息投递
原理SendInput 往系统输入队列插键PostMessage 直达控件消息队列
打给谁当前焦点窗口（谁有焦点打谁）指定句柄（指哪打哪）
中文要先切输入法，靠 IME 逐字上屏WM_IME_CHAR 直接投双字节
速度每键 Sleep(10) 起步Sleep(1) 都算奢侈
盲区无——任何程序都当真键盘只对标准 Edit 类控件生效
模拟键盘是”万能的笨办法”：慢，但所有程序都把它当真键盘，自绘输入框、游戏、甚至 BIOS 级别的界面都吃这一套。消息投递是”聪明的小路”：快、准、能打中文，但离开标准控件就失灵。AutoWrite 两版都留着——工具箱里多一把枪，永远不亏。
第二版的完整代码和字库目前躺在本地工程里，仓库里的是第一版的定稿。如果这个从”假装键盘”进化到”直接写信”的小东西对你有启发，源码在 AutoWrite（MIT），随便玩。
]]>
    
    https://cosmical-container.github.io/posts/5dde1648/
    
    2024-08-19T13:30:00.000Z
    
      总有些场合，文字得靠键盘一个字一个字”敲”进去——目标输入框不吃复制粘贴，或者你只是想让朋友亲眼看着一段话”自己”出现在聊天框里。AutoWrite 就是干这个的：你把文本交给它，它替你把每个键按下去。项目做了两版，正好是 Windows 下模拟输入的两条技术路线——
    
    AutoWrite 自动打字机开发记：从模拟按键到发送消息
    2024-08-19T13:30:00.000Z