<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>C&#43;&#43; on 菜菜博士</title>
    <link>https://microcai.org/tags/c&#43;&#43;.html</link>
    <description>Recent content in C&#43;&#43; on 菜菜博士</description>
    <generator>Hugo</generator>
    <language>zh-cn</language>
    <lastBuildDate>Mon, 25 May 2026 00:00:00 +0800</lastBuildDate>
    <atom:link href="https://microcai.org/tags/c++/feed.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>异步电机控制何以复杂</title>
      <link>https://microcai.org/2026/05/25/IM-motor-is-hard.html</link>
      <pubDate>Mon, 25 May 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/05/25/IM-motor-is-hard.html</guid>
      <description>&lt;p&gt;一言以蔽之：因为有两个控制维度。&lt;/p&gt;
&lt;h1 id=&#34;控制维度&#34;&gt;控制维度&lt;/h1&gt;
&lt;p&gt;在自动控制系统里，系统通过传感器观察被控对象，然后通过执行器施加控制。
传感器的输入，被称为 被控量，而传递给执行器的命令，叫控制量。&lt;/p&gt;
&lt;p&gt;当一个被控量可以用多个控制量影响的时候，这个控制量的数量，就是控制维度。&lt;/p&gt;
&lt;p&gt;绝大多数时候，我们都喜欢一维控制。
为何呢？&lt;/p&gt;
&lt;h2 id=&#34;一维控制&#34;&gt;一维控制&lt;/h2&gt;
&lt;p&gt;还是拿电机举例。先举例直流有刷电机。&lt;/p&gt;
&lt;p&gt;被控量是电机转速，控制量是 电压，或者占空比。&lt;/p&gt;
&lt;p&gt;控制器要影响电机的转速，唯一能控制的量，就是自己输出给电机的电压。&lt;/p&gt;
&lt;p&gt;有的人说是电流？但是电流也是电压的结果。控制电流大小归根结底也是通过控制输出电压实现的。&lt;/p&gt;
&lt;p&gt;如果把有刷电机，换成无刷电机。&lt;/p&gt;
&lt;p&gt;看似执行机构变了， MOS 管数量从4个变成了 6个。&lt;/p&gt;
&lt;p&gt;但是，实际上控制器最终能控制的量，也只有唯一的一个：电压。&lt;/p&gt;
&lt;p&gt;因为对于无刷电机来说，控制器输出的是三相平衡交流电。&lt;/p&gt;
&lt;p&gt;三相平衡的交流电，实际上有2个自由度：电压和频率。
因为是三相平衡的，因此3条线的电压，实际上只有一个自由度，而不是3个。&lt;/p&gt;
&lt;p&gt;看似控制器可以控制电压和频率2个量，实际上控制器只能控制电压。&lt;/p&gt;
&lt;p&gt;因为对于永磁同步电机来说，输入的交流电的频率和相位，必须和转子同步。
意味着，频率或者相位，并不是一个可选的自由度，必须跟随转子同步。&lt;/p&gt;
&lt;p&gt;控制器唯一能控制的量，就剩下了一个：电压。&lt;/p&gt;
&lt;p&gt;这也是为何永磁同步电机，或者说无刷电机，大受欢迎。因为控制起来和直流有刷电机是一模一样的，都是唯一一个电压这个控制量。&lt;/p&gt;
&lt;h2 id=&#34;二维控制&#34;&gt;二维控制&lt;/h2&gt;
&lt;p&gt;但是，如果电机换成了异步电机，情况就发生了翻天覆地的变化。&lt;/p&gt;
&lt;p&gt;因为，异步电机是“异步”的。控制器输出的三相电，频率，还真就有了自由度。他不必跟随转子同步。甚至绝对不能和转子同步。还必须有个差。&lt;/p&gt;
&lt;p&gt;更要命的是，增加电压和提高频率，二者都可以提高电机转速： 也就是说，如果电机转速（被控制量）和实际目标有偏差，控制器有2个自由度实施校正：它可以改变电压，也可以改变频率。&lt;/p&gt;
&lt;p&gt;2个控制自由度，看似 “灵活” 实则给控制算法摆出了一个天大的难题。&lt;/p&gt;
&lt;h2 id=&#34;异步电机的矢量控制&#34;&gt;异步电机的矢量控制&lt;/h2&gt;
&lt;p&gt;电机控制，控制的是磁场。异步电机的运行原理和同步电机并没有本质区别：定子磁场带着转子磁场运动。&lt;/p&gt;
&lt;p&gt;无非是，同步电机的转子磁场被转子物理锁定，转子磁场和转子本身没有相对运动。
而异步电机的转子磁场和转子本身有一个漂移运动。&lt;/p&gt;
&lt;p&gt;如果先无视这个漂移运动呢？那么就可以使用和无刷电机一模一样的算法来控制定子磁场了。&lt;/p&gt;
&lt;p&gt;于是这个2个控制自由度，就下降为一个了。&lt;/p&gt;
&lt;p&gt;真的吗？&lt;/p&gt;
&lt;p&gt;异步电机的矢量控制，本质上是把异步电机这一个整体，看成了 一个同步电机+液力变矩器。液力变矩器的输入和输出之间，有一个转速差，所传递的扭矩大小，正比于这个转速差。&lt;/p&gt;
&lt;p&gt;但是，困难的地方在于，这个同步电机无法安装传感器，传感器只能安装在液力变矩器的输出端。&lt;/p&gt;
&lt;p&gt;于是这个（虚拟的）同步电机的转子，其磁场的真正朝向，就只能靠“猜”了。&lt;/p&gt;
&lt;p&gt;而要猜，就必须依靠电机的电动力学方程。要求解，就必须带入电机参数。&lt;/p&gt;
&lt;p&gt;恰恰这个“电机参数”，是非常难以精确获得的。他随着工况会随时变化。&lt;/p&gt;
&lt;p&gt;哪怕我们忽略这部分的困难，还有另一个问题：&lt;/p&gt;
&lt;p&gt;这个液力变矩器对扭矩的传递，也有控制量！&lt;/p&gt;
&lt;p&gt;因此，实际上还是有2个控制自由度。完全没有下降。&lt;/p&gt;
&lt;p&gt;对于一个控制偏差，算法既可以调整（虚拟的）同步电机的转速来修正，也可以通过调节液力变矩器的传递效率（扭矩增益）进行修正。&lt;/p&gt;
&lt;p&gt;因此， 异步电机的矢量控制，实际上它的控制量也是两个，
不是  电压+频率， 而是 电压+液力变矩器的扭矩增益。&lt;/p&gt;
&lt;p&gt;自由度实际上完全没有下降。&lt;/p&gt;
&lt;p&gt;还带来了这个 （虚拟的）同步电机 转子位子本身的猜测困难问题。&lt;/p&gt;
&lt;p&gt;哪怕加了传感器，还是需要电机参数，还需要“猜”转子磁场位置。&lt;/p&gt;
&lt;p&gt;传感器加了一个寂寞。&lt;/p&gt;
&lt;p&gt;要知道，在永磁同步电机控制里，物理上的传感器可以让控制器完全抛弃电机参数。只有无传感器控制才依赖电机参数去猜转子的位置。&lt;/p&gt;
&lt;p&gt;因此，矢量控制放到异步电机上，其实就是死路一条。&lt;/p&gt;
&lt;h2 id=&#34;转差频率控制&#34;&gt;转差频率控制&lt;/h2&gt;
&lt;p&gt;在 转差频率控制 里，我们认为，异步电机的扭矩 = 转差频率*励磁电流。&lt;/p&gt;</description>
    </item>
    <item>
      <title>异步电机控制</title>
      <link>https://microcai.org/2026/05/10/closeloop-vfd.html</link>
      <pubDate>Sun, 10 May 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/05/10/closeloop-vfd.html</guid>
      <description>&lt;h1 id=&#34;超越开环&#34;&gt;超越开环&lt;/h1&gt;
&lt;p&gt;要不怎么说， AI 极大的促进了知识的传播。&lt;/p&gt;
&lt;p&gt;我很多年前，就做了一个变频器。&lt;/p&gt;
&lt;p&gt;但是，一直都是使用 V/F 开环控制。&lt;/p&gt;
&lt;p&gt;使用开环控制，简单，好用，便宜。&lt;/p&gt;
&lt;p&gt;但是，如何进行闭环控制呢？&lt;/p&gt;
&lt;h1 id=&#34;滑差频率控制&#34;&gt;滑差频率控制&lt;/h1&gt;
&lt;p&gt;我第一时间就想到了控制滑差率。&lt;/p&gt;
&lt;p&gt;一开始，我的想法是这样的：&lt;/p&gt;
&lt;p&gt;假设控制目标是一个转速。转速 S 是控制目标。&lt;/p&gt;
&lt;p&gt;直接输出 S+转差 是不行的。
所以，需要几个 PID 控制环。&lt;/p&gt;
&lt;p&gt;我最初的设想是这样的，如果是一台直流电机，做闭环转速控制是怎么做的？&lt;/p&gt;
&lt;p&gt;答案是  转速环-》扭矩环（电流环）-》PWM 占空比。&lt;/p&gt;
&lt;p&gt;或者，可以一步到位，转速环-》PWM 占空比。&lt;/p&gt;
&lt;p&gt;转速高了，就降低 pwm 占空比，低了，就提高占空比。占空比本质上是控制电压。&lt;/p&gt;
&lt;p&gt;于是，我在异步电机这里，这么设计：&lt;/p&gt;
&lt;p&gt;转速环-》电压。&lt;/p&gt;
&lt;p&gt;然后根据转差率，直接确定输出频率。频率不用一个闭环进行控制，而是通过测量转速，直接乘上一个转差率，得到输出频率。&lt;/p&gt;
&lt;p&gt;这个转差率，由当前的负载情况，可以直接计算出一个最优转差率。所谓最优转差率，就是效率最高的转差率。低了，铁损增加，高了，铜损增加。&lt;/p&gt;
&lt;p&gt;然后，我遇到了一个很现实的问题：就是转速环一开始就会输出一个很高的电压！&lt;/p&gt;
&lt;p&gt;但是，我认为，可以加入一个恒流恒压控制。只要设定了最大电流，电压就自动被控制住了。&lt;/p&gt;
&lt;p&gt;然而，现实的情况是，这种限制最大电流的模式，其实并不适用。这意味着启动的时候电机会一直处于磁通饱和状态。而且这种饱和状态，还使用个屁的最佳转差率，根本就破坏了最佳转差率的存在前提嘛。&lt;/p&gt;
&lt;p&gt;经过和 AI 的反复沟通，推翻了各种方案，最终我确定了以下方案：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;转速环（输出扭矩参考）-》扭矩环（输出频率）&lt;/li&gt;
&lt;li&gt;电流环（维持励磁电流）-》输出电压&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;电流环是独立运行的一个控制环，他控制输出电压，以维持在当前频率下的励磁电流为一个定值。&lt;/p&gt;
&lt;p&gt;扭矩环接受转速环（或者位置环）的输出，根据转子转速直接确定输出频率。&lt;/p&gt;
&lt;p&gt;这个频率的确定方式是：输出频率 = 转子频率 + 扭矩参考*最大转差频率。&lt;/p&gt;
&lt;p&gt;扭矩参考是一个 [-1,1] 的数值。最大转差频率是和电机有关的一个参数，计算方式是：最大转差频率 = 转子的电阻 ÷ (2π × 转子的电感)&lt;/p&gt;
&lt;h2 id=&#34;滑差频率控制的底层物理原理&#34;&gt;滑差频率控制的底层物理原理&lt;/h2&gt;
&lt;p&gt;为啥是这个频率呢？因为异步电机的扭矩，说到底是定子磁场*转子磁场*攻角。&lt;/p&gt;
&lt;p&gt;而转子磁场，就是由 转差频率 供电的。
当转子的电阻和电抗相等的时候，转子电流出现最大值。继续提高转差频率，转子电抗会增加导致电流下降。因此，使转子的电阻和电抗相等的频率，就是最大转差频率。&lt;/p&gt;
&lt;p&gt;更进一步的来说，电机扭矩 = 定子磁场矢量 叉乘 转子磁场矢量。
这对任何电机都是成立的。&lt;/p&gt;</description>
    </item>
    <item>
      <title>编译期构造只读容器</title>
      <link>https://microcai.org/2026/04/22/compile-time-container.html</link>
      <pubDate>Wed, 22 Apr 2026 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2026/04/22/compile-time-container.html</guid>
      <description>&lt;p&gt;我在设计变频器的红外遥控处理的时候，定义了一个 map 容器。
这个容器很简单，就是一个 int 对 int 的映射。&lt;/p&gt;
&lt;p&gt;把 红外遥控器的按键ID, 映射到我内部定义的一个 枚举命令id 上。&lt;/p&gt;
&lt;p&gt;这样只要修改这个 map 容器，就可以适配多种红外遥控。&lt;/p&gt;
&lt;p&gt;但是，我发现，这个 map 容器哪怕定义为 const 变量也没用，他依旧是分配在内存里的。而且是分配在宝贵的堆内存里。&lt;/p&gt;
&lt;p&gt;不仅仅如此，这个 map 容器的构造还会在运行时分配大量的细碎内存块。&lt;/p&gt;
&lt;p&gt;除了占用运行时内存，他对单片机flash的占用并不消失。因为构造这个map所需的原始数据还是需要躺在 .rodata 段里。&lt;/p&gt;
&lt;p&gt;既然这个 map 容器是只读的，那么为啥我需要在运行时分配这么多的内存？
直接在编译期就构造好一个map，然后在运行时直接使用，岂不更好？&lt;/p&gt;
&lt;p&gt;我试着给 std::map 前面添加一个 constexpr 修饰符，结果编译失败。
看来 std.map 并不能简单的通过 constexpr 变成编译期构造。&lt;/p&gt;
&lt;p&gt;由于 单片机的内存有 8KB 之巨，很长一段时间里我都没有遇到内存不足问题。直到最近为了缩减代码体积，把一些本该无栈协程实现的代码替换成了有栈协程。编译后能缩减数个KB的体积。
结果遇到莫名其妙的硬件错误。调试了许久才发现原来是内存分配失败导致的。&lt;/p&gt;
&lt;p&gt;于是想在其他地方扣点内存出来，于是重新盯上了这个 map 容器。&lt;/p&gt;
&lt;p&gt;我最初的做法本来是想自己手搓一个。
但是，如此需求，难道真只有我有吗？&lt;/p&gt;
&lt;p&gt;如果并不是我独有的需求，应该已经有前人已经实现过了。不能动不动就重复发明轮子呀！&lt;/p&gt;
&lt;p&gt;于是我找啊找，找到了这个 &lt;a href=&#34;https://github.com/serge-sans-paille/frozen&#34;&gt;frozen&lt;/a&gt;  库。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code class=&#34;language-cpp++&#34; data-lang=&#34;cpp++&#34;&gt;
#include &amp;lt;map&amp;gt;

static const std::map&amp;lt;ir_command, UserCommand&amp;gt; ir_command_map = {
	{0x0002000D, UserCommand::speed_0},
    ...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;这样的代码，被替换成了&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code class=&#34;language-cpp++&#34; data-lang=&#34;cpp++&#34;&gt;#include &amp;lt;frozen/map.hpp&amp;gt;

static constexpr frozen::map&amp;lt;ir_command, UserCommand, 41&amp;gt; ir_command_map = {
	{0x0002000D, UserCommand::speed_0},
    ...
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;然后重新编译，代码体积略微膨胀。但是运行时的堆内存占用一下减小千余字节。
代码膨胀，是因为原来编译器会把这 41 个 KV 对，一共 82 个数字存在 .rodata 段里, 然后在 启动的时候调用构造函数构造 map。如今编译器直接在 .rodata 段里构造出一个 map 容器的二叉树。在运行时直接在这个只读的，放在 FLASH 而不是 RAM 里的 二叉树进行查找。不需要构造了。因此减少了 RAM 的使用。但是存在 .rodata 段的二叉树，比原始的82个整数要多占一些空间。&lt;/p&gt;</description>
    </item>
    <item>
      <title>调用约定和上下文切换</title>
      <link>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</link>
      <pubDate>Fri, 03 Jan 2025 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2025/01/03/calling-convertion-and-context-swap.html</guid>
      <description>&lt;p&gt;编写协程库的时候，我常常在想，上下文切换的速度，受&lt;strong&gt;调用约定&lt;/strong&gt;的影响非常大。&lt;/p&gt;
&lt;p&gt;因为用户协程的上下文切换，本质上是调用一个 函数。而这个函数需要 “切换” 非易失性寄存器。&lt;/p&gt;
&lt;p&gt;因此，在给定的调用约定下，非易失性寄存器越多，则上下文切换时需要保留和恢复的寄存器数量就越多。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;而由内核进行上下文切换(也就是线程)，所有寄存器都得保留。开销是最大的。何况还有执行特权级切换的巨大开销。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;在知乎上发表的批评 云风的 coroutine 库的文章的评论区里，有个人提到了 &lt;a href=&#34;https://photonlibos.github.io/blog/stackful-coroutine-made-fast&#34;&gt;这篇文章&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;好家伙，他们对内联汇编玩出花来了。使用内联汇编的 clobbered registers 列表来自动生成寄存器的保存和恢复代码。&lt;/p&gt;
&lt;p&gt;然后，他们给 clang 提了一个补丁，增加了一个叫 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定。&lt;/p&gt;
&lt;p&gt;所谓 &lt;code&gt;preserve_none&lt;/code&gt;，顾名思义，就是这个调用约定下，尽可能啥寄存器都不保留，全是易失性寄存器。&lt;/p&gt;
&lt;p&gt;于是，如果使用 &lt;code&gt;preserve_none&lt;/code&gt; 的调用约定实现 &lt;code&gt;zcontext_swap&lt;/code&gt;, 则代码里并不需要保留上下文。只需要切换 rsp 寄存器，然后调用下 hook 即可返回了。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-asm&#34; data-lang=&#34;asm&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;zcontext_swap_preserve_none:
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 保存frame寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;push&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 切换栈指针
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %rsp, (%r12)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; (%r13), %rsp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;//  恢复 frame 寄存器
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;pop&lt;/span&gt; %rbp
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// if(hook_function) hook_function(argument);
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;test&lt;/span&gt; %r14, %r14
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jne&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;f&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回 argument
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %rax
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;ret&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;1:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// 如果有 hook ，则调用 hook 后返回
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, &lt;span style=&#34;color:#66d9ef&#34;&gt;ARG1_REG&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;mov&lt;/span&gt; %r15, %r12 &lt;span style=&#34;color:#75715e&#34;&gt;// 同时兼容 preserve_none 调用约定 的 hook
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#a6e22e&#34;&gt;jmp&lt;/span&gt; * %r14 &lt;span style=&#34;color:#75715e&#34;&gt;// 开启尾调用优化.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在 无 hook 的情况下，只需 8 条指令即完成上下文切换。&lt;/p&gt;</description>
    </item>
    <item>
      <title>协程切换为什么需要 一个 hook_function 参数.</title>
      <link>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</link>
      <pubDate>Sat, 28 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/28/context-switch-need-a-hook.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;刚刚，我将 zcontext 的 API 进行了以下修正。&lt;/p&gt;
&lt;p&gt;从&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;改成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;zcontext_swap&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; from, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_t&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; to, &lt;span style=&#34;color:#66d9ef&#34;&gt;zcontext_swap_hook_function_t&lt;/span&gt; hook_function, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; argument);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;增加了一个 hook_function。这是为何呢？这个 hook_function 又是怎么使用的呢？在什么情况下运行呢？&lt;/p&gt;
&lt;p&gt;别着急，我一一道来。&lt;/p&gt;
&lt;h2 id=&#34;需求1自动进行栈回收&#34;&gt;需求1：自动进行栈回收&lt;/h2&gt;
&lt;p&gt;协程需要分配一个新栈。而协程执行完毕的时候，需要对分配的栈内存进行回收。
而协程自身是无法执行这个任务的。协程只有不在运行状态，他的栈才能释放。而他在运行状态下，又如何调用 free 释放自己呢？
free 本身运行也依赖栈。free 不能把自己正在使用的栈给释放了。&lt;/p&gt;
&lt;p&gt;因此，这个需求我用了一些比较绕的方法实现了。其实就是让调度器负责回收。这就限制了调度器只能跑在主线程上。
并且调度器（主事件循环）需要和协程的代码进行一定程度的耦合。&lt;/p&gt;
&lt;p&gt;但是为了解决内存泄漏，这个耦合也是不得不为之。其实应该有更好的解决方法的。&lt;/p&gt;
&lt;h2 id=&#34;需求2线程安全的协程切换&#34;&gt;需求2：线程安全的协程切换&lt;/h2&gt;
&lt;p&gt;在多线程运行调度器的情况下，可能发生协程切换的竞争。具体情况如下：&lt;/p&gt;
&lt;p&gt;假设运行2个线程执行 GetQueuedCompletionStatus。姑且称为 主线程A, 主线程B.
为了更好的性能，通常的做法是让线程A负责 accept, 而线程B负责处理客户端连接。如果处理客户端有瓶颈，还可以创建更多的线程处理。
这里先简化为2个线程。&lt;/p&gt;
&lt;p&gt;系统运行若干个 Accept 协程。并且在接受一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称是协程A吧。某个协程 A 拿到了一个新连接后，创建一个新的处理协程来处理新的连接。
姑且称这个刚刚创建的新协程为 协程C，这个新接受的连接对应 socket C。&lt;/p&gt;
&lt;p&gt;好了，协程A, 接受了一个新连接，然后创建了 协程 C。此时协程 C 和协程 A ，都是在主线程 A 上运行的。&lt;/p&gt;
&lt;p&gt;这时，我们要往socket C 上投递 WSARecv 了。此时投递是在 主线程A上进行的。由于 socket C 绑定了线程B的 IO完成端口，因此稍后
会在主线程 B 上获得完成事件。此时协程 C 是在 线程 A 上运行的。调用 WSARecv 后，紧接着就要进行“协程挂起”操作。
正常来说，线程B获得socket C 的完成事件后，就会恢复协程C。于是，协程 C 后续就在 线程 B 上运行了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>从0开始写上下文切换</title>
      <link>https://microcai.org/2024/12/26/context-switch-explained.html</link>
      <pubDate>Thu, 26 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/26/context-switch-explained.html</guid>
      <description>&lt;h1 id=&#34;有栈协程的核心是执行上下文执行上下文的核心是栈&#34;&gt;有栈协程的核心是执行上下文。执行上下文的核心是栈。&lt;/h1&gt;
&lt;p&gt;因此，切换栈就等于切换了上下文。&lt;/p&gt;
&lt;h1 id=&#34;栈在协程切换上的核心地位&#34;&gt;栈在协程切换上的核心地位&lt;/h1&gt;
&lt;p&gt;栈，存储了一个协程/线程 的“调用链”，以及依附于这条链上的“变量”。&lt;/p&gt;
&lt;p&gt;没有栈，ret 指令将无所适从。&lt;/p&gt;
&lt;p&gt;虽说栈是核心，但是栈本质是堆叠存储“历史 寄存器状态”。而当前没有入栈的寄存器状态，才是真正的当前上下文。&lt;/p&gt;
&lt;p&gt;因此，很多古代协程库的做法，是栈协程“句柄” 上，开辟一个数百字节的空间。用于存放当下的CPU寄存器的数值。
上下文切换的时候，就是把当前 cpu 寄存器拷到句柄空间，然后从新协程的句柄空间里把寄存器的值一个一个读回来。&lt;/p&gt;
&lt;p&gt;这种做法，是认可 “CPU寄存器数值的集合” 是当前上下文。栈不过是其中一个寄存器指向的一块内存区域，没什么特别的。&lt;/p&gt;
&lt;p&gt;但是，boost.fcontext 另辟蹊径。他唯一指定 栈为协程的正统核心。当前的 cpu 寄存器状态，可以通过“调用 上下文切换” 函数，变成 上一层的 “历史状态”。&lt;/p&gt;
&lt;p&gt;于是本层所要做的，就只是切换栈。在切换栈前，也只须将本层寄存器状态入栈。切换后，再将寄存器状态出栈。&lt;/p&gt;
&lt;p&gt;因此，在 boost.fcontext 眼里，代表协程正统的，不是那个存储了几百个字节的寄存器数值的句柄空间，而是 栈顶指针。&lt;/p&gt;
&lt;p&gt;而用于引用协程的那个句柄， fcontext_t 结构，不过就是存储了一个栈顶指针。
而不像 ucontext_t 那样，好家伙洋洋洒洒数百字节体积。&lt;/p&gt;
&lt;p&gt;这就是对“何谓上下文”的理解理念不同带来的设计差异。&lt;/p&gt;
&lt;p&gt;这点设计差异，造成了数据结构的不同。数据结构都不同了，自然上下文切换的代码也不尽相同了。正是所谓的，数据结构决定了算法。&lt;/p&gt;
&lt;p&gt;来个上下文切换代码看看&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/context_switch_code.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;作为对比，看下 ucontext 系是怎么做上下文切换的：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code_swapcontext.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这就是不同的设计理念带来的差异。&lt;/p&gt;
&lt;p&gt;ucontext 认为 cpu寄存器是上下文，栈只是其中一个寄存器所引用的附属上下文。
而 boost.fcontext 则认为，栈就是上下文的全部。包括了所有的寄存器历史。&lt;/p&gt;
&lt;p&gt;&lt;em&gt;所谓寄存器的历史，是说进行函数调用的时候，编译器会生成入栈指令保留寄存器的数值，以便函数返回后能恢复这些寄存器的值。于是在调用链上，每一层调用帧上面都保留了一份寄存器的“快照‘&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;既然寄存器的快照就在栈上留着，那只要把当前的状态再“压栈”一次。那么所有的上下文，不就都用一个栈顶表达了吗？&lt;/p&gt;
&lt;p&gt;显然我们会发现，将栈视为协程的核心，能极大的简化代码。&lt;/p&gt;
&lt;p&gt;这点差异，还影响了 make_context 的设计。&lt;/p&gt;
&lt;h1 id=&#34;新建协程&#34;&gt;新建协程&lt;/h1&gt;
&lt;p&gt;一个协程上下文切换库，只需要编写3个函数&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;上下文切换&lt;/li&gt;
&lt;li&gt;新上下文创建&lt;/li&gt;
&lt;li&gt;新上下文的出生点&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中，新建上下文的出生点代码，是不需要暴露给用户的内部使用代码。另外两个，是作为库接口的形式存在的。&lt;/p&gt;
&lt;p&gt;上下文的切换，在上节已经赘述过了。就是当前状态 push 入栈。然后切换栈顶，然后 pop 出栈。大功告成。&lt;/p&gt;
&lt;p&gt;傻瓜式的代码。&lt;/p&gt;</description>
    </item>
    <item>
      <title>链接到 ucrtbase.dll</title>
      <link>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</link>
      <pubDate>Mon, 23 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/23/link-to-ucrtbase-dll.html</guid>
      <description>&lt;p&gt;使用 vc6.0 以后的 VS 编译器，最恼火的一点就是生成的 exe 依赖 msvcrXXX.dll。
其中 XXX 是个版本号。而且 msvcrXXX.dll 系统是不自带的。&lt;/p&gt;
&lt;p&gt;于是每个 exe 都得带上 vcredist.exe 安装程序。&lt;/p&gt;
&lt;p&gt;过于蛋疼。&lt;/p&gt;
&lt;p&gt;正统的解决方法是改使用静态C库。&lt;/p&gt;
&lt;p&gt;但是会带来二进制体积暴涨的问题。&lt;/p&gt;
&lt;p&gt;十分的怀念 VC6.0 可以生成exe 依赖 msvcrt.dll， 不带版本号那种。而不带版本号的那个，每个 windows 都会自带。&lt;/p&gt;
&lt;p&gt;有比较多的偏门方式，可以在 vc6 以后的版本继续链接到 msvcrt.dll 。但是一来是偏方，而来在 vs2017 以后这些偏方也没用了。&lt;/p&gt;
&lt;p&gt;后来对此也不甚钻研了，直接无脑静态链接了。&lt;/p&gt;
&lt;p&gt;最近，突然又关心起 msvcrt 问题，因为用了下 LLVM MinGW。然后在 readme 里看到了 UCRT 介绍。&lt;/p&gt;
&lt;p&gt;UCRT？ UCRT 是啥？&lt;/p&gt;
&lt;p&gt;原来微软也发现大家不爽带版本号的 msvcrXXX.dll。于是用 C++ 以 extern &amp;ldquo;C&amp;rdquo; 的方式重写了它的 C 运行时。
这个重写的新C运行时就是 UCRT。每个 win 都会带上。名为 ucrtbase.dll 和 Debug 版的 ucrtbased.dll。&lt;/p&gt;
&lt;p&gt;连这个UCRT的，还有新的 vcruntimeXXX.dll。而过去 C++ 运行时是 msvcpXXX.dll 。&lt;/p&gt;</description>
    </item>
    <item>
      <title>boost.fcontext 为何快？</title>
      <link>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</link>
      <pubDate>Wed, 18 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/18/why-boost-fcontext-is-fast.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/17/dig-into-libco.html&#34;&gt;批评 libco&lt;/a&gt; 的 上下文切换代码的时候，我曾经说，协程的上下文切换代码，并不需要恢复所有的寄存器。
只需要恢复调用约定里规定的 “非易失性寄存器”。&lt;/p&gt;
&lt;p&gt;只有操作系统进行抢占式调度的时候，才需要恢复所有的寄存器。因为抢占式调度，可以在任何时间任何地方中断线程。如果不恢复所有寄存器，则在线程的角度看来就是寄存器的值可以任何时间任何地方突然“自主改变”。&lt;/p&gt;
&lt;p&gt;而由用户执行的协程调度则不然。上下文切换，一定是代码里“主动”调用某个控制权转移接口实现的。&lt;/p&gt;
&lt;p&gt;而这个控制权转移接口，在编译器看来，不过是一次再正常不过的外部函数调用。只要按照约定，准备好寄存器。。 并且在它返回的时候，自主恢复易失性寄存器。&lt;/p&gt;
&lt;p&gt;是的没错，调用它的地方，本来就假定易失性寄存器的数值会改变。&lt;/p&gt;
&lt;p&gt;因此，在协程的上下文切换函数里，根本没有任何必要恢复易失性寄存器的内容。只需要恢复非易失性寄存器即可。&lt;/p&gt;
&lt;p&gt;为了验证我的设想，我写了一个 zcontext 进行了验证。
这个 zcontext 已提交进 uasync 代码仓库，详情看 &lt;a href=&#34;https://github.com/microcai/iocp/commit/e2d6da2a7cb208a8ed1fcdda6d835ccef193b3c4&#34;&gt;commit&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;不过我这上下文切换，只恢复了8个非易失性通用寄存器。对16 个 MMX 寄存器，还有 AVX 寄存器，都没有进行恢复。
不知道会不会出问题。于是就仔细的研读了 boost.context 的汇编代码。希望研究下怎么恢复 SSE 和 AVX 寄存器。&lt;/p&gt;
&lt;p&gt;注：boost.context 里负责上下文切换的 汇编写的 api 叫 fcontext 。&lt;/p&gt;
&lt;p&gt;结果发现 fcontext 的做法和我的不能说完全一样，简直是一模一样。&lt;/p&gt;
&lt;p&gt;无非是我用了 一排 push + 一排 pop 做的切换，而它的代码使用了 mov 指令。但都是等价的。&lt;/p&gt;
&lt;p&gt;也只恢复了非易失性通用寄存器和 2个 80387状态寄存器。&lt;/p&gt;
&lt;p&gt;这下总算完全理解为啥 boost.context 称自己的性能天下无敌了。&lt;/p&gt;
&lt;p&gt;因为确实没有比这更快的上下文切换方式了。&lt;/p&gt;
&lt;p&gt;由此可见，libco 的作者还真是水货一个。他引以为傲的那段汇编代码，就是一坨羊粪。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 腾讯 的 协程库 libco</title>
      <link>https://microcai.org/2024/12/17/dig-into-libco.html</link>
      <pubDate>Tue, 17 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/17/dig-into-libco.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;libco 是 腾讯开源的一个协程库。噱头很大，动不动就是承载了微信后台亿万并发。
敢说个不马上被喷成狗头。但是我偏就是要对这些光有名头没啥技术的东西祛魅。&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://microcai.org/2024/12/16/dig-into-coroutine-lib.html&#34;&gt;上一片文章&lt;/a&gt; 里，点评了云风的 coroutine库，其中提到了 libco 犯了和云风一样的错。&lt;/p&gt;
&lt;p&gt;其实 libco 的错误要比云风还要多的多。&lt;/p&gt;
&lt;p&gt;废话不多说，接下来点评 libco&lt;/p&gt;
&lt;h1 id=&#34;libco-错在哪里&#34;&gt;libco 错在哪里&lt;/h1&gt;
&lt;p&gt;首先错误的，仓库上一篇，他和云风的错误是一样的。表述相同的部分就不特别说明了。&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该干涉程序结构&#34;&gt;1 协程库不应该干涉程序结构&lt;/h2&gt;
&lt;p&gt;但是 libco 的此进入非彼侵入。云风的侵入，是需要永久性的携带 &lt;code&gt;struct schedule *S&lt;/code&gt;,
而 libc 的侵入，则是，它根本就不让你正常的用阻塞的思维模式设计你的代码结构。&lt;/p&gt;
&lt;p&gt;我们那它源码里自带的 example_echosrv.cpp 举例&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code1.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这是它一个建议的 echo server。前面介绍 iocp4linux 的时候，我就贴过正统代码。
算了，还是直接给个对比吧。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;alt text&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/compare_libco_uasync.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;图片里两端代码，下面的是正统协程库写的 echo server 里的 accept 循环。
而上面那段则是 libco 里的例子。&lt;/p&gt;
&lt;p&gt;正如我图片里的吐槽那样，腾讯的 libco 在编写代码的时候，很容易陷入不知所谓的境地。&lt;/p&gt;
&lt;p&gt;这就是因为它库设计的缺陷，所以必须要用很绕的方式组织代码逻辑。&lt;/p&gt;
&lt;h2 id=&#34;2-协程库不应该强依赖一个调度器&#34;&gt;2 协程库不应该强依赖一个调度器&lt;/h2&gt;
&lt;p&gt;还是刚刚腾讯自己写的 example_echosrv.cpp 例子。
这次是 main 函数。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/libco_code2.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这不仅仅是依赖调度器了，这是必须，也只能使用 libco 的事件循环。&lt;/p&gt;
&lt;p&gt;如果云风的库只能算对你壁咚，那腾讯的库就是把你裤子都扒光了后入。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;当然，不可否认一些人有网红膜拜症，非要被玩一把才开心。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;当然，如果他的库已经实现的比较完善，那么使用他的事件循环，调用他封装好的 IO api，也未尝不可以接受。神神曾经说过，被强奸的时候，反抗不了，就要学会享受。&lt;/p&gt;</description>
    </item>
    <item>
      <title>点评 云风 的 C库 coroutine</title>
      <link>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</link>
      <pubDate>Mon, 16 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/16/dig-into-coroutine-lib.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在知乎上看到两篇 吹嘘 云风的 coroutine 库的文章。&lt;/p&gt;
&lt;p&gt;人啊就是这样的，出名了以后，就是垃圾也有人吹捧。&lt;/p&gt;
&lt;p&gt;今天来点评下，云风的 coroutine 到底垃圾在哪里。又或者说，一个优秀的协程，应该优秀在哪里。&lt;/p&gt;
&lt;h1 id=&#34;云风错在哪里&#34;&gt;云风错在哪里&lt;/h1&gt;
&lt;p&gt;首先一个优秀的协程库，要做到“自然”。&lt;/p&gt;
&lt;p&gt;什么是“自然”呢？就是要做到尽量不改变原来写同步阻塞IO逻辑的时候的代码。&lt;/p&gt;
&lt;p&gt;因此引出第一错：&lt;/p&gt;
&lt;h2 id=&#34;1-协程库不应该侵入-api-设计&#34;&gt;1 协程库不应该侵入 API 设计&lt;/h2&gt;
&lt;p&gt;要使用云风的协程，被调度的协程必须有如下的函数签名&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;coroutine_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;struct&lt;/span&gt; schedule &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;S, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; arg);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;注意到那个 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数了吗？要使用协程，必须带上这个参数。&lt;/p&gt;
&lt;p&gt;哪怕本层级的函数并不直接调用 IO, 也就是不会直接用到 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数，他也得带上，并将 &lt;code&gt;struct schedule *S&lt;/code&gt; 传给所有他要调用的函数。&lt;/p&gt;
&lt;p&gt;也就是整个程序所有的函数都得带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;这也是 asio 的有栈协程设计失败的地方。一旦使用了有栈协程，所有的函数都得加上 &lt;code&gt;asio::yield_context&lt;/code&gt; 参数。&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;如果只是某个会调用 IO 的函数需要带上这个 休眠器 还好。但是假设这样的调用链条&lt;/p&gt;
&lt;p&gt;A -&amp;gt; B -&amp;gt; C -&amp;gt; D, 最终在 D函数里调用了  async_read();&lt;/p&gt;
&lt;p&gt;那显然，为了让整条路径能实现逐级传递 &lt;code&gt;struct schedule *S&lt;/code&gt;, 必然会让这条调用链上的所有函数都带上 &lt;code&gt;struct schedule *S&lt;/code&gt; 参数。&lt;/p&gt;</description>
    </item>
    <item>
      <title>基于 ucontext &#43; iocp4linux 的超简协程库</title>
      <link>https://microcai.org/2024/12/15/ucontext-based-uasync.html</link>
      <pubDate>Sun, 15 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/15/ucontext-based-uasync.html</guid>
      <description>&lt;p&gt;虽然说，使用 异步最佳的实践是使用协程。&lt;/p&gt;
&lt;p&gt;然而 c++20 的协程并不总是可用的。总不能说，不能更新编译器的地方就不配写代码吧。&lt;/p&gt;
&lt;p&gt;因此，我在上一篇文章里说道，可以继续忍受回调地狱。或者使用有栈协程。&lt;/p&gt;
&lt;p&gt;当然，如果使用 asio ， 那么一切问题都不存在。asio 支持 有栈协程，无栈协程，daff‘s device 协程，还有最基础的，回调模式。
asio 简直就是个“宇宙级” 的异步库。&lt;/p&gt;
&lt;p&gt;然而，asio 也并不总是可用。&lt;/p&gt;
&lt;p&gt;于是，基于 ucontext 的一个超简协程库就应运而生。&lt;/p&gt;
&lt;p&gt;首先，这个不是一个独立的库，他其实顺手带在 uasync 里。作为  universal_fiber.h 头文件提供。&lt;/p&gt;
&lt;p&gt;就隐藏在 iocp4linux 的 example 代码里。
见 &lt;a href=&#34;https://github.com/microcai/iocp/blob/master/example/echo_server/echo_server_stackfull.c&#34;&gt;echo_server_stackfull.c&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;没错，这次是个 C 代码。尽管我非常讨厌 C。&lt;/p&gt;
&lt;p&gt;这个库，只是为了演示如何将 proactor 和有栈协程给结合起来。虽然我本人建议最好使用 c++20 的协程。但是总有人是升级不了编译器的。
因此我再三思考后，决定还是写一个小 demo 来演示 proactor 和有栈协程 如何极便捷的结合。&lt;/p&gt;
&lt;p&gt;对于这么一个简单的 echo server 例子，作为对比，同文件夹下的 echo_server_callback.cpp 就是基于回调的。可以直观感受下，基于回调和基于协程的代码可读性。&lt;/p&gt;
&lt;h1 id=&#34;先看有栈和无栈例子对比&#34;&gt;先看有栈和无栈例子对比&lt;/h1&gt;
&lt;p&gt;这个是 echo server 左边有栈协程和右边无栈协程的 accept 循环的代码对比
&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/ucontext_code4.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;不能说毫无差别，简直可以说是一模一样&lt;/p&gt;
&lt;p&gt;也就是说有栈和无栈，是只存在底层工作机制的差异&lt;/p&gt;
&lt;p&gt;没有使用上的差异。&lt;/p&gt;
&lt;p&gt;这就是 universal_fiber.h 和 universal_async.hpp 的威力。&lt;/p&gt;
&lt;p&gt;关于那个无栈协程 universal_async.hpp 的分析，参考 &lt;a href=&#34;https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html&#34;&gt;这篇文章&lt;/a&gt;&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入异步IO 第二篇： 正确使用 IOCP，正确设计 proactor</title>
      <link>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</link>
      <pubDate>Sat, 14 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/14/use-iocp-in-the-right-way.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;reactor-和-proactor&#34;&gt;Reactor 和 Proactor&lt;/h1&gt;
&lt;p&gt;ACE 作者当年提出了数个高性能网络IO的模型，其中将这些模型总结为 Reacto 和 Proactor。如果按字母意思翻译，
则称为 反应器 和前摄器。&lt;/p&gt;
&lt;p&gt;但是，我更愿意使用更精准的汉语表达：多路复用模式 和 重叠IO模式。&lt;/p&gt;
&lt;h2 id=&#34;多路复用模式&#34;&gt;多路复用模式&lt;/h2&gt;
&lt;p&gt;前一篇文章说道，要想实现单线程并发IO, 内核必须要提供的2个机制。在 多路复用模式下，要求的机制就是&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 和 &lt;strong&gt;无阻塞IO操作&lt;/strong&gt;。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;无阻塞IO操作&lt;/strong&gt; 要求内核在IO不能立即完成的情况下，不能挂起调用线程，而是返回错误。但是此时代码不应该进入无限重试，而是等待内核的通知。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可读写状态通知&lt;/strong&gt; 如果一个 IO 操作接下来可以无阻塞立即执行，则通知程序，现在可以干活而不会失败了。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;比如我写一个 server，调用 read() 读取客户端发送的数据。如果客户端还未发送数据。则内核会挂起线程直到对方发送数据。然后 read 就执行成功并返回了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解异步IO</title>
      <link>https://microcai.org/2024/12/13/in-deepth-async.html</link>
      <pubDate>Fri, 13 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/13/in-deepth-async.html</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;干了那么多年码农，遇到 IO 从来都是写异步代码。从最初直面裸 epoll 写，到后来基本上依赖 asio 写。
最近研究 io_uring 后，试着用 io_uring 把 IOCP 那套 API 实现了。&lt;/p&gt;
&lt;p&gt;以前呆在 asio 的舒适区，根本没关注过其他程序员对异步的理解。但是 windows 程序员是最多的，当我研究IOCP的时候，
以前被我忽略掉的那群写 IOCP 的程序员，突然进入了我的视线。&lt;/p&gt;
&lt;p&gt;当我研究了他们对异步的一些吐槽后，才发现了一个真相：大部程序员并不懂异步。&lt;/p&gt;
&lt;p&gt;尤其是，我由于不熟悉 IOCP，故而为了给 iocp4linux 找测试用例，而翻遍网络，寻找使用 IOCP 写成的一些网络代码示例。
能跑通它们，才算 iocp4linux 功能完成了。对吧。&lt;/p&gt;
&lt;p&gt;结果，大部分 IOCP 的例子，虽然能跑。但是我研究了他们的代码后发现，统统都是错误的。完全没有领会到异步IO的精髓。根本就
没有真正的理解异步IO。&lt;/p&gt;
&lt;p&gt;所以，我打算写数篇最深入剖析异步IO的引导文章，足够教会大家 真正的异步思维。&lt;/p&gt;
&lt;h1 id=&#34;线程的由来&#34;&gt;线程的由来&lt;/h1&gt;
&lt;p&gt;现在的程序员大部分都是新世纪后出生的。所以早就忘记了线程的设计初衷了。我看到大部分新世纪程序员都说线程是为了并发，为了压榨cpu的性能。&lt;/p&gt;
&lt;p&gt;其实多线程压榨 cpu 的性能，是最近十几年才有的。而线程的历史，和操作系统一样古老。
计算机诞生的前半个世纪，CPU都是单核的。那时候就已经有了多线程。&lt;/p&gt;
&lt;p&gt;所以，线程的最初真正作用，实际上出乎现在的程序员的意料：是为了实现异步IO。&lt;/p&gt;
&lt;h2 id=&#34;dos-下的-io&#34;&gt;DOS 下的 IO&lt;/h2&gt;
&lt;p&gt;在个人电脑的上古时代，一个打字员的日常工作，是打字，然后 按下键盘上的 Ctrl-S。接着去泡杯茶去喝。&lt;/p&gt;
&lt;p&gt;当 wps 要将文档存入软盘，意味着这段时间，整台电脑都处于“不可操作”的状态。
直到软驱磁头吭呲吭呲的干完活，当前的应用才会复活，能继续执行其他任务了。&lt;/p&gt;
&lt;p&gt;为啥会这样呢？因为 DOS 是一个单任务的操作系统，不支持多线程。这就意味着，DOS 不支持异步 IO。WPS要写磁盘，就只能等待 DOS 完成文件写入。
期间整个电脑都无法干其他工作。&lt;/p&gt;
&lt;p&gt;这个问题，直到“多任务系统”的出现才解决。当然，多任务系统，出现的比 DOS 早多了，只不过，引入 PC 领域要晚的多。一直到 windows 出现。&lt;/p&gt;</description>
    </item>
    <item>
      <title>批量提交IO提升性能</title>
      <link>https://microcai.org/2024/12/10/io_batching-boost-performance.html</link>
      <pubDate>Tue, 10 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/10/io_batching-boost-performance.html</guid>
      <description>&lt;p&gt;在基本完成 iocp4linux 后，我抽空在 &lt;a href=&#34;https://wiki.radxa.com/Rockpi4&#34;&gt;rockpi&lt;/a&gt; 上测了下性能。&lt;/p&gt;
&lt;p&gt;使用仓库里自带的例子  test/web_server/server.cpp，我测得了大约 6000req/s 的性能。&lt;/p&gt;
&lt;p&gt;还不错。但是和 PC 上超过十万的性能相比，有那么点。。。弱鸡。&lt;/p&gt;
&lt;p&gt;但是我通过 htop 注意到了一点。wrk 压测的时候， cpu1 是 cpu 100%。而且都是 红色的。说明cpu 都花在内核时间上了。
这也是 io_uring 很牛逼的原因：活都让内核干了。&lt;/p&gt;
&lt;p&gt;==。&lt;/p&gt;
&lt;p&gt;rockpi 是个6核的soc, 其中 cpu1-cpu4 （我设定 htop 的 cpu 从 1 开始数。）是个 1.4Ghz 的小核。cpu5，cpu6 才是 1.8Ghz 的大核。&lt;/p&gt;
&lt;p&gt;这 不仅仅一核有难，5核围观。这特么干活的还是个小核。&lt;/p&gt;
&lt;p&gt;于是果断找原因，发现是中断亲和性的设定问题。将中断迁移到 cpu5 后，测试发现干活的就是 1.8Ghz 的大核啦。&lt;/p&gt;
&lt;p&gt;然后性能飙到超过 9000req/s。&lt;/p&gt;
&lt;p&gt;之前测试的性能忘记记录了，这次随手截图留存了。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/iocp4linux_perf_1.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;嘿嘿，果然给力。这优化。还是免费的。&lt;/p&gt;
&lt;p&gt;就在我沾沾自喜的时候，我又随手测试了以下 老中医写的 proxy_server。它里面带了一个简单的 http server。
wrk 压测以下，我了个去的。轻轻松松 1.6万req/s。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/asio_test1_perf.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;asio 你大爷还是你大爷！&lt;/p&gt;
&lt;p&gt;于是我琢磨着进行优化。&lt;/p&gt;
&lt;p&gt;我想到了 io_uring 提交 IO 的两步曲：&lt;/p&gt;</description>
    </item>
    <item>
      <title>超轻量级 IOCP 协程库</title>
      <link>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</link>
      <pubDate>Sun, 08 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/08/super-lightweight-iocp-coroutine.html</guid>
      <description>&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/12/04/iocp-on-linux.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提出了 &lt;a href=&#34;https://github.com/microcai/iocp&#34;&gt;iocp4linux&lt;/a&gt; 。&lt;/p&gt;
&lt;p&gt;在编写 iocp4linux 的过程中，我需要写一些测试代码。&lt;/p&gt;
&lt;p&gt;一开始，我随便的找了一个基于 IOCP 的 echo test 和一个简单的 web server。
首先确保这弄来的例子能在 windows 上编译通过。&lt;/p&gt;
&lt;p&gt;然后修改 ifdef _WIN32守卫，在 linux 平台上改为使用 iocp.h 头文件。&lt;/p&gt;
&lt;p&gt;然后很轻松的就移植到 linux 上了。&lt;/p&gt;
&lt;p&gt;但是，我对于这些 C 风格的 demo 并不满意。因为我完全改不动他们的代码。&lt;/p&gt;
&lt;p&gt;于是，我想着，何不写一个超级轻量级的一个封装库？
这个库，应该做到跨平台 —— 指能同时兼容原版 windows.h和 iocp.h。然后代码尽量短小，同时又足够易用。&lt;/p&gt;
&lt;p&gt;最后。我折腾出了一个超轻量级的协程库。&lt;/p&gt;
&lt;p&gt;废话不说，先看一段 异步 accept 的代码：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/awaitable_overlapped.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在红框处，使用的是 windows 上的异步 accept 。
在 AcceptEx 调用的时候，传入了一个 ov 对象。
这个 ov 对象，类型是 awaitable_overlapped 。
awaitable_overlapped 可以隐式转换为 &lt;code&gt;WSAOVERLAPPED*&lt;/code&gt; 从而被 AcceptEx 所接受。&lt;/p&gt;
&lt;p&gt;由于是异步 IO ， 这时代码会继续向下运行。一般如果是在非协程的代码里。此时就应该返回函数。&lt;/p&gt;
&lt;p&gt;然后把 accpet 的后续逻辑，放到 调用 &lt;code&gt;GetQueuedCompletionStatus&lt;/code&gt; 的事件循环里了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>IOCP 移植到Linux上</title>
      <link>https://microcai.org/2024/12/04/iocp-on-linux.html</link>
      <pubDate>Wed, 04 Dec 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/12/04/iocp-on-linux.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;windows 高性能IO使用的是 proactor 模型，而古代 Linux 上则是 reactor 模型。&lt;/p&gt;
&lt;p&gt;因此跨平台的网络库，通常会选择实现为其中一种模型，然后在另一个平台上使用模拟。
比如 asio 使用 proactor 模型。Linux 上使用 epoll 模拟。
又比如 libevent 使用 reactor 模型， windows 上使用 iocp 模拟。&lt;/p&gt;
&lt;p&gt;而将 iocp 模拟为 epoll 的库，就是 &lt;a href=&#34;https://github.com/piscisaureus/wepoll&#34;&gt;wepoll&lt;/a&gt; 了。&lt;/p&gt;
&lt;p&gt;但是，reactor 比较是一种比较落后的模型。因此，进行跨平台封装为 proactor 实际上是更先进的做法。&lt;/p&gt;
&lt;p&gt;虽然已经有 asio 这种 proactor 库了，但是毕竟 asio 是一个比较重量级的库。一种轻量级的 proactor 库
也是非常有市场的。&lt;/p&gt;
&lt;p&gt;更何况，既然有 wepoll 这种把 Linux api 弄到 windows 上的库，那没有 Linux IOCP 就说不过去了。&lt;/p&gt;
&lt;p&gt;于是我决定，开发一个 Linux 版的 IOCP 库。这样方便使用 IOCP 开发的各种软件可以方便的迁移到 Linux 平台。而无需重写。&lt;/p&gt;
&lt;h1 id=&#34;如何实现呢&#34;&gt;如何实现呢？&lt;/h1&gt;
&lt;p&gt;如果是在很久以前，这件事其实还是比较复杂的。然而，嘿嘿。从 linux 5.1 开始，一个崭新的名为 io_uring 的系统接口诞生了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>用iouring扩展asio</title>
      <link>https://microcai.org/2024/11/21/extending-asio.html</link>
      <pubDate>Thu, 21 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/21/extending-asio.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;什么叫扩展asio？
Beast给Asio增加了 HTTP 协议，不叫扩展asio。那什么叫扩展asio？
举个例子，给 asio 的 socket 对象，基于io_uring提供的 IORING_OP_SHUTDOWN 增加 async_shutdown() 接口，就算扩展asio。因为原本asio并没有异步shutdown功能。而且这个功能并不能靠组合原有的asio接口实现。这就叫扩展asio。&lt;/p&gt;
&lt;p&gt;扩展asio, 又不能修改asio的代码。看起来有点难办。
好在，asio的设计也是有一定的扩展性的，并非完全依赖修改源码实现扩展。
但是不可避免的，需要使用 asio::detail:: 名字空间下的非公开接口。&lt;/p&gt;
&lt;p&gt;那么，就从 async_shutdown 开始，讲解如何扩展asio吧！&lt;/p&gt;
&lt;h1 id=&#34;接口形式&#34;&gt;接口形式&lt;/h1&gt;
&lt;p&gt;不修改asio代码的大前提下，要给一个对象增加一个 async_shutdown() 的成员函数那是痴人说梦。语言上就禁了此路。&lt;/p&gt;
&lt;p&gt;不过，有两种绕过的做法&lt;/p&gt;
&lt;p&gt;其一。写一个新的socket对象，自 asio::ip::tcp::socket 继承。然后增加一个成员函数。缺点是所有使用 socket 的地方都得修改一下类型。有了IDE的重构大法，实际上为了能异步关闭而进行的迁移并不算特别大的工作量。但是如果有不需要牵一发而动全身的修改，会更好。
其二。写一个全局函数，接受一个 asio::ip::tcp::socket 并将他异步关闭。&lt;/p&gt;
&lt;p&gt;第二个方法，不需要对整个项目进行大手术。只需要在需要异步关闭的地方，将原来的同步关闭 ( &lt;code&gt;socket.shutdown();&lt;/code&gt;)，替换为  &lt;code&gt;co_await async_shutdown(socket, defered);&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;从设计美学上来说，第二个方法更好。&lt;/p&gt;
&lt;h1 id=&#34;操作系统接口&#34;&gt;操作系统接口&lt;/h1&gt;
&lt;p&gt;扩展asio, 并不是使用asio现有接口去实现一个功能。比如beast利用 asio现有的socket接口就能实现在其基础上增加 HTTP 协议支持。
我们要给 asio 的 socket 增加异步关闭功能，是实打实的让asio多了原本不存在的功能。那么显然，这样的功能，首先我们得问一问，操作系统支持吗？
如果操作系统不支持一个功能，我们想破天也没法给asio扩展出这个功能。&lt;/p&gt;
&lt;p&gt;答案是，异步关闭socket只有io_uring支持了。windows 上虽然也支持异步关闭，但是需要使用 WSAEventSelect + WSAWaitForMultipleEvents + shutdown 组合使用。IOCP不支持异步关闭。没有能传 overlaped* 的 WSAShutdown 版本。&lt;/p&gt;
&lt;h1 id=&#34;asio-的接口组织结构&#34;&gt;asio 的接口组织结构&lt;/h1&gt;
&lt;p&gt;asio 暴露给用户的接口为2种对象，其一为 executor ，其二为 io_object. executor 一般而言就是 asio::io_context。而 io_object 则通常就是 socket 咯。&lt;/p&gt;</description>
    </item>
    <item>
      <title>重叠IO（proactor）是最理想的IO模型</title>
      <link>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</link>
      <pubDate>Tue, 19 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/19/proactor-is-better-than-reactor.html</guid>
      <description>&lt;p&gt;reactor 和 proactor ， 这种毫无联系的英文专用名词，很容易把人弄晕。&lt;/p&gt;
&lt;p&gt;回归正途，使用精确的汉语描述，而非翻译，则正确的说法是：&lt;/p&gt;
&lt;p&gt;多路复用IO 和 重叠 IO 模式。&lt;/p&gt;
&lt;p&gt;所谓多路复用，顾名思义，就是好几个IO复用。。。 复用了谁？复用了线程。
它对比的是最传统的UNIX网络编程： 一个连接一个线程。并发就要开多线程。连接多了，线程就多，系统压力非常大。
而多路复用，则可以让一个线程处理多个连接。这就是复用的含义。为了实现复用，首先IO是非阻塞的。因为如果阻塞了线程，其他连接上的数据不就没法处理了么。既然非阻塞，那就会出现网络数据没准备好，就一直返回 EAGAIN 错误。一直返回难道一直重试吗？显然不现实。所以就有了一个 多路复用器。这个多路复用器最早是 select() 调用。后来是 poll() 最后是 epoll().
而重叠IO,顾名思义，就是 IO 操作是重叠的。和什么重叠？当然是和你当前的线程是重叠的。
也就是，向系统提交一个 IO 操作， 系统就会在“后台”默默的干苦力，当前线程可以立即执行其他任务。不会被阻塞。他和多路复用模式的区别是，多路复用模式，如果会阻塞，内核就返回会阻塞，而不是在后台默默干活。而 重叠IO 则即不会阻塞，也不会返回“请重试”。而是在后台开始默默的进行处理。这个IO的处理，和你程序本身的逻辑，是重叠进行的。所以叫重叠IO。&lt;/p&gt;
&lt;p&gt;话又说回来了，系统是在后台干活了，你得知道他啥时候干好了吧？总不能两眼一摸黑，不知道了吧。
因此，系统需要一个通知机制。Linux 这边，曾经有一种叫 AIO 的东西，它用 “信号” 来通知 IO 完成了。而如今 Linux 使用 io_uring 的 无锁列队 来完成通知。而 windows 则使用 一个叫“完成队列”的东西来通知，当然也可以使用 窗口消息来通知结果。&lt;/p&gt;
&lt;p&gt;不管是 win 的窗口消息，还是linux的 AIO ，在实践中都被人抛弃不用了。因此不讨论这些。&lt;/p&gt;
&lt;p&gt;我们讨论 IO完成端口，和 io_uring, 他们本质上是一样的，就是提供一个异步队列，然后应用层可以使用 一个或多个线程，去读取这个队列获得完成通知。每一个IO操作，都对应一个完成通知。
因此，重叠IO模式，其实和传统的编程思路是一致的：每调用一个函数，就获得一个返回值。
无非是，这个返回不是通过 ret 指令返回，返回结果也不是通过 EAX 寄存器返回。
而是存放到了一个消息队列里。&lt;/p&gt;
&lt;p&gt;但是，操作请求和结果返回，是一一对应的。这是一种非常自然的概念。
自然而然的，在编程上，就可以设计为 IO发起 + 完成回调。
库的作用，就是封装 系统的 IO api ，然后将 IO完成消息转化为 完成回调。
有了 IO发起+完成回调。很自然的，程序就可以组织为一种 协程结构。 发起IO操作，返回一个 promise . IO完成就是让 promise 完成状态。
想同步IO结果，只要 await 这个 promise 就可以了。
非常的容易理解，而且封装起来也非常的轻松。用起来简直就是爽到high起。&lt;/p&gt;</description>
    </item>
    <item>
      <title>真正的重叠IO</title>
      <link>https://microcai.org/2024/11/18/real-overlaped-io.html</link>
      <pubDate>Mon, 18 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/18/real-overlaped-io.html</guid>
      <description>&lt;p&gt;不知有没有人想过，为何微软将windows 的异步API称为“重叠IO”而不是异步IO。&lt;/p&gt;
&lt;p&gt;在我看来，重叠IO和异步IO的区别，主要在于发起IO后的动作。&lt;/p&gt;
&lt;p&gt;重叠IO, 发起 IO 后，继续执行应用层的逻辑。应用可以选择在任何何时的地点再选择同步（阻塞等待 or 异步等待）IO的结果。
异步IO, 发起 IO 后，立即挂起当前业务逻辑（也就是立即非阻塞等待 IO 结果），回到事件循环，以便执行其他业务逻辑。&lt;/p&gt;
&lt;p&gt;放到协程的设计角度，重叠 IO 相当于这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;async&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;function&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;file&lt;/span&gt;.&lt;span style=&#34;color:#a6e22e&#34;&gt;read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干点不依赖&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_result&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;await&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;read_promise&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    ... &lt;span style=&#34;color:#a6e22e&#34;&gt;干需要&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;IO&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;操作结果的事情&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;而异步 IO, 则是这样使用&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; function &lt;span style=&#34;color:#a6e22e&#34;&gt;do_read&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; co_await file.&lt;span style=&#34;color:#a6e22e&#34;&gt;async_read&lt;/span&gt;(...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#75715e&#34;&gt;// do other logic.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以看出来，重叠 IO 在发出 IO 操作后，可以继续执行其他逻辑。只有当确实需要数据的时候，再进行等待。
而异步IO模式下，发出IO后，必须立即挂起当前协程等待IO完成。&lt;/p&gt;
&lt;p&gt;那么，这两种差异，对现实中的程序有什么影响呢？&lt;/p&gt;
&lt;p&gt;我们先考虑一个最简单的应用： 静态 web 服务器。&lt;/p&gt;
&lt;p&gt;在静态web服务器里，最核心的处理逻辑，就是找到用户要下载的文件，然后将文件发送给客户端。伪代码如下&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;awaitable&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; handle_send_file(&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; target, &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; socket)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; buffer[&lt;span style=&#34;color:#ae81ff&#34;&gt;65536&lt;/span&gt;];
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    fs&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;file f(target, flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;binary&lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt;flags&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;open);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;long&lt;/span&gt; total &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt;(;;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; read_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; f.async_read_some(buffer);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; (read_size &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;            &lt;span style=&#34;color:#66d9ef&#34;&gt;break&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        total &lt;span style=&#34;color:#f92672&#34;&gt;+=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;co_await&lt;/span&gt; socket.async_write_some(buffer, read_size);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    }
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;co_return&lt;/span&gt; total;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个代码里，主要的逻辑就是 循环读取文件，然后发送。&lt;/p&gt;</description>
    </item>
    <item>
      <title>不要 new 一个 char 数组当缓冲区</title>
      <link>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</link>
      <pubDate>Sat, 16 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/16/do-not-new-a-buffer.html</guid>
      <description>&lt;p&gt;性能调优是一个有魔力的工作。最近研究到了 &lt;code&gt;std::pmr::&lt;/code&gt;, 就想着看能否有些老代码能改进改进，提高下性能。&lt;/p&gt;
&lt;p&gt;但是，测试的时候，发现还是有一些路径的效率不理想。&lt;/p&gt;
&lt;p&gt;经过好久的排查，最终定位代码到这么一行&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_unique&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;[]&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(buffer_size);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;好家伙，原来 &lt;code&gt;make_unique&amp;lt;char[]&amp;gt;&lt;/code&gt; 这么慢的吗？&lt;/p&gt;
&lt;p&gt;原来 make_unique 不单单是 分配了 buffer_size 个字节的内存，同时还 构造了如此数量的 char 对象。
问题是我这只是个 buffer, 不需要初始化啊！&lt;/p&gt;
&lt;p&gt;继续查看生成的汇编代码，发现 make_unique 还是很聪明的，并没有在一个 for 循环里调用5百万次 char 的构造函数。
看来第一种 for 循环五百万次赋值 0 的担忧是没了。
结果看到了汇编代码里的 &lt;code&gt;call memset@plt&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;所以说，哪怕编译器自动的把初始化代码优化为了一个  memset 调用，它还是调用了 memset ， memset 对一个 5MB 的内存，还是要花点时间的。&lt;/p&gt;
&lt;p&gt;于是我随手把代码改成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; buffer_size &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;unique_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;decltype&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free)&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; buffer(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;malloc(buffer_size), &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;free);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;测试发现性能飙升了十几倍。&lt;/p&gt;
&lt;h1 id=&#34;总结&#34;&gt;总结&lt;/h1&gt;
&lt;p&gt;在不需要初始化的 buffer 分配领域，使用 malloc 是比 new 更好的选择。&lt;/p&gt;</description>
    </item>
    <item>
      <title>可变模板参数包迭代</title>
      <link>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</link>
      <pubDate>Wed, 13 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/13/range-for-on-parameter-pack.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;如果你写了一个模板函数，模板函数里使用了 可变参数。比如你写了个&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么，要如何去访问这些可变的参数呢？&lt;/p&gt;
&lt;h3 id=&#34;方法-1&#34;&gt;方法 1&lt;/h3&gt;
&lt;p&gt;使用递归法。比如定义2个 print, 一个是单参数的，另一个是 2个模板参数的。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Arg arg);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Arg1 arg1, Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print(arg1);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print(args...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在可变参的 print 里， 它首先将第一个参数调用了单参数版的 print. 接着把剩下的参数调用自身。&lt;/p&gt;
&lt;p&gt;如果剩下的参数就一个了，那么编译器也是匹配到单参数版的 print 从而结束递归。&lt;/p&gt;
&lt;h3 id=&#34;方法-2&#34;&gt;方法 2&lt;/h3&gt;
&lt;p&gt;使用 &lt;strong&gt;折叠表达式&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	(print_one(args), ...);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个方法里，&lt;code&gt;(print_one(args), ...);&lt;/code&gt;就是所谓的 &lt;strong&gt;折叠表达式&lt;/strong&gt;。 它的意思就是把 前面的 重复一下。每次重复的时候，各使用参数包里的一个参数。&lt;/p&gt;
&lt;h3 id=&#34;方法-3&#34;&gt;方法 3&lt;/h3&gt;
&lt;p&gt;打包进 std::tuple 后使用。比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;tuple&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Args...&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tuple_arg)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// ???
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt;... Args&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; print(Args... args)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	print_tuple(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;forward_as_tuple(args...));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;吼吼，那么问题来了， tuple 版本要怎么实现？&lt;/p&gt;</description>
    </item>
    <item>
      <title>把闭包变成函数指针—— trampoline 原理解析</title>
      <link>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</link>
      <pubDate>Sat, 02 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/02/lambda-to-function-pointer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一个让 C 形式的回调函数支持 闭包的小转换工具, &lt;a href=&#34;https://github.com/avplayer/avboost/blob/master/include/boost/cfunction.hpp&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;那时候，我说过，要想把 boost.function 传给 C 接口，那这个 C 接口，必须得带一个 &lt;code&gt;void* user_data&lt;/code&gt; 的参数。&lt;/p&gt;
&lt;p&gt;比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb, &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; user_data);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;可以利用这个 cfuntion，把 &lt;code&gt;boost::function&amp;lt;int(int, int)&amp;gt;&lt;/code&gt; 给当成 callback_t 使用。
而 boost::function 本身又可以接受 lambda, boost::bind ， 从而组合出非常易用的使用方式。&lt;/p&gt;
&lt;p&gt;但是，这十年来，我也偶尔会遇到一些 C 库的 api ， 他就只能接受裸指针，不能接受 &lt;code&gt;void* user_data&lt;/code&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这就很难受了。因为没有办法传递 void*, 也就无法给回调函数设置“上下文”。也就彻底失去了上下文关联能力了。不得不将所需的
数据通过“全局变量”传递给回调函数。十分丑陋不说，还导致回调函数变成了无法重入的。&lt;/p&gt;
&lt;h1 id=&#34;转机&#34;&gt;转机&lt;/h1&gt;
&lt;p&gt;其实，如果使用 GCC 编译器，GCC 也提供一个叫 “nested function” 的功能，比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c&#34; data-lang=&#34;c&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;int&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt;)(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;bool&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;callback_t&lt;/span&gt; cb);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;main&lt;/span&gt;()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; hello &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;nested_function&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#a6e22e&#34;&gt;printf&lt;/span&gt;(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;hello = %d&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;\n&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&lt;/span&gt;, hello);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#a6e22e&#34;&gt;register_callback&lt;/span&gt;(nested_function);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个 nested_function 能访问 main 里定义的对象，算的上一种“闭包”了，但是，它仍然可以转换为不需要 void* 的裸函数指针。&lt;/p&gt;</description>
    </item>
    <item>
      <title>类型萃取技术：函数签名当模板参数</title>
      <link>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/function-signature-as-template-parameter.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;在 &lt;a href=&#34;https://microcai.org/2024/11/01/type-erasuer.html&#34;&gt;上一篇&lt;/a&gt; 文章里，我提到了 std::function 的模板参数，是一个叫&lt;strong&gt;函数签名&lt;/strong&gt; 的东西。&lt;/p&gt;
&lt;p&gt;什么是函数签名？&lt;/p&gt;
&lt;p&gt;比如 main 函数，他的签名是 &lt;code&gt;int(int, char**)&lt;/code&gt;。所谓函数签名，是指函数声明去掉 函数名和变量名 后得到的一个精简描述。 这个精简描述，指导编译器如何按”调用约定“产生具体的汇编指令以调用一个函数。&lt;/p&gt;
&lt;p&gt;函数名，不过是在最后的 call 指令里，提供了具体的目标地址。&lt;/p&gt;
&lt;p&gt;但是，如果你问 decltype(&amp;amp;main) 的类型是啥，其实他的类型是&lt;code&gt;int (*)(int, char**)&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;因为 &amp;amp;main 是 main 函数的函数指针。 函数签名是形如 R(args&amp;hellip;) 的东西，而函数指针的类型，就是 R (*)(args&amp;hellip;)&lt;/p&gt;
&lt;p&gt;函数签名甚至不是一个合法的类型，你不能定义  &lt;code&gt;int(int,int) p;&lt;/code&gt; 这样的一个变量。
但是你可以用 &lt;code&gt;int (*p)(int, int)&lt;/code&gt; 定一个 函数指针 p, 其指向的函数，具有 &lt;code&gt;int(int, int)&lt;/code&gt; 这样的签名。&lt;/p&gt;
&lt;p&gt;那么，对于  std::function 来说，他的模板参数要怎么写，才能接受一个签名呢？&lt;/p&gt;
&lt;p&gt;其实很简单，就把签名当成一个类型。也就是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Signature&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;function&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;那么有人问了，这 Signature 就一个类型啊，那 function 的 括号操作符 要怎么写？&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Signature operator()(Signature)&lt;/code&gt; ?&lt;/p&gt;
&lt;p&gt;显然不对。&lt;/p&gt;
&lt;p&gt;这括号操作符，必然是要把签名里的 返回值和参数给拆开来。&lt;/p&gt;
&lt;p&gt;把一个类型里的具体组成部分拆出来？&lt;/p&gt;
&lt;p&gt;哈哈！ 这技术，听起来不可思议！&lt;/p&gt;</description>
    </item>
    <item>
      <title>重提类型擦除器</title>
      <link>https://microcai.org/2024/11/01/type-erasuer.html</link>
      <pubDate>Fri, 01 Nov 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/11/01/type-erasuer.html</guid>
      <description>&lt;h1 id=&#34;序&#34;&gt;序&lt;/h1&gt;
&lt;p&gt;十年前，我曾经写过一篇有关类型擦除器的文章, &lt;a href=&#34;https://microcai.org/2014/04/21/type-erasure.html&#34;&gt;见这&lt;/a&gt;。&lt;/p&gt;
&lt;p&gt;十年后，我打算再探讨下类型擦除器。&lt;/p&gt;
&lt;p&gt;C++ 对 多态 的支持，在核心层面，就两条： 虚继承 和 模板。&lt;/p&gt;
&lt;p&gt;假设你要设计一个 线程池。这个池你可以“投递”各种任务进去。&lt;/p&gt;
&lt;p&gt;什么叫”任务“呢？ 就是一段代码。于是，早期你想到，可以使用 函数指针。&lt;/p&gt;
&lt;p&gt;于是你的 线程池长这样&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;void&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;task_function_t)();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task_function_t&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; tasks;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task_function_t job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这样的代码，有个问题，那就是你“投递” 的任务，他干活得有数据。如果投递的任务，只能是一个函数指针。
那么这个函数，就得使用“全局变量“来传递工作内容了。&lt;/p&gt;
&lt;p&gt;所以说，这个 task ，不能是个函数指针。它得携带对象。&lt;/p&gt;
&lt;p&gt;于是，自然的，你想到了 多态，虚函数。那么很快你就改进了第二个版本&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;task&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;virtual&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; run() &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;virtual&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;~&lt;/span&gt;task(){}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;threadpool&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;list&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;task&lt;span style=&#34;color:#f92672&#34;&gt;*&amp;gt;&lt;/span&gt; tasks;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; post(task&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; job);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;显然，如果要给任务携带点状态，就可以写一个 task 对象，比如&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-cpp&#34; data-lang=&#34;cpp&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;some_task&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; task
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; work_arg1;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; work_arg2;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	some_task(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg1, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; arg2);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;run&lt;/span&gt;() &lt;span style=&#34;color:#66d9ef&#34;&gt;override&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#75715e&#34;&gt;// do some work with args.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;想要带上啥状态，一股脑的给添加到自己写的派生类里就行了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>微软不会起名</title>
      <link>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</link>
      <pubDate>Wed, 30 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/30/ms-went-wrong-on-coroutine-naming.html</guid>
      <description>&lt;p&gt;微软不会起名，而且名字还具有极大的误导性。&lt;/p&gt;
&lt;p&gt;先说类名：&lt;/p&gt;
&lt;p&gt;首先，微软的协程原作者，他总是用 &lt;code&gt;Task&amp;lt;&amp;gt;&lt;/code&gt; 来命名一个协程函数。但是这就是他犯的第一个错误。
因为只有 await 构成的一系列调用，那条调用链才是一个 “任务”。 也就是 asio 作者所说的 co_spawn. 只有被 spawn 出来的协程，才叫一个任务。而被 await 的函数，不能叫任务，而是”可异步等待返回的函数“。 因此 asio 作者使用 &lt;code&gt;asio::awaitable&amp;lt;&amp;gt;&lt;/code&gt; 来命名，而不是 &lt;code&gt;task&amp;lt;&amp;gt;&lt;/code&gt; 是十分妥帖的。&lt;/p&gt;
&lt;p&gt;接着是 promise_type ，这个微软就是纯粹的瞎搞了。不同于 Task&amp;lt;&amp;gt; 只是出现在微软的示例代码里，promise_type 可是直接进了标准。这瞎命名带来的恶劣影响要大的多。为啥说这个不能是 promise_type 呢？ 因为这个对象存储的是 协程状态。因此 asio 使用 coro_frame 来命名，显然要更正确的。它存储的就是当前协程帧的状态数据。&lt;/p&gt;
&lt;p&gt;最后是 final_suspend ，这个类名简直就是严重误导性的集大成者。他干的活和 suspend 毫无关系。实际上他干的恰恰不是 suspend 的活，而是 “恢复调用者” 。协程作为可等待函数，他的调用者调用了一个协程后，调用者才是真正的被 suspend 了。被调用者是执行中。处于 running 状态。当被调用者完成工作，他要 恢复 调用者，让调用者醒来继续干活。&lt;/p&gt;
&lt;p&gt;因此， final_suspend 其实应该叫 resume_caller .&lt;/p&gt;
&lt;p&gt;接着说 三件套函数名：&lt;/p&gt;
&lt;p&gt;await_suspend 其实不是 挂起。协程 A 调用 协程 B, 实际上是 A 被挂起。可是代码上却是 调用 B 的 await_suspend 。这简直就是极大的误导性。当 B 对象的 await_suspend 被调用的时候，实际上恰恰是 B 被 “恢复”， B 进入了 running 状态。这个地方准确的命名，应该叫 await_setup.&lt;/p&gt;</description>
    </item>
    <item>
      <title>从模板的模板论程序员的美学</title>
      <link>https://microcai.org/2024/10/19/template-template.html</link>
      <pubDate>Sat, 19 Oct 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/10/19/template-template.html</guid>
      <description>&lt;p&gt;在编写 &lt;a href=&#34;https://github.com/avplayer/ucoro&#34;&gt;µcoro&lt;/a&gt; 的时候，曾经对一个模板类的成员函数犯难了。那就是等待器三件套之一的 await_suspend 函数。&lt;/p&gt;
&lt;p&gt;我为&lt;code&gt;template&amp;lt;typename T&amp;gt; class awaitable&lt;/code&gt; 的三件套使用这样一个模板签名&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;其中，这个 PromiseType 必须得是 &lt;code&gt;awaitable&amp;lt;T&amp;gt;::promise_type&lt;/code&gt; (也就是 &lt;code&gt;awaitable_promise&amp;lt;T&amp;gt;&lt;/code&gt; ) 的其中一个实例。&lt;/p&gt;
&lt;p&gt;按前C++ 时代的做法，这个成员函数应该这么写&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;awaitable_promise&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这种写法，可以保证接收到的 h 参数，其 Promise 类型必然是 awaitable_promise 的一个参数化实例。&lt;/p&gt;
&lt;p&gt;但是，与此同时，我还希望要为 std::coroutine_handle&lt;void&gt; 这样的通用参数写一个单独的处理代码。&lt;/p&gt;
&lt;p&gt;于是，使用按前C++ 时代的做法，我需要写2个 await_suspend， 他们分别是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;awaitable_promise&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;Any&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;await_suspend&lt;/span&gt;(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;对这两个类型的 promise handle, 各自有一套不同的处理代码。&lt;/p&gt;
&lt;p&gt;但是，老王提出了不同意见。他认为，std::coroutine_handle 在标准库里，就一种表示方式，那就是&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;std&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;他批评我说，&lt;code&gt;std::coroutine_handle&amp;lt;awaitable_promise&amp;lt;Any&amp;gt;&amp;gt;&lt;/code&gt; 这样的写法不直观。而且还写了两个 await_suspend
到底哪个在干活，得多费脑细胞。&lt;/p&gt;
&lt;p&gt;后来，函数签名恢复成了&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;typename&lt;/span&gt; PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;auto&lt;/span&gt; await_suspend(std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine_handle&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;PromiseType&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; h);
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;但是，使用了 enable_if 之类的模板技巧，外加在 awaitable_promise 里添加一些辅助佐料，实现了&lt;/p&gt;</description>
    </item>
    <item>
      <title>编译期对象构造优化 .bss 为 .rodata</title>
      <link>https://microcai.org/2024/01/22/constexpr-constructor.html</link>
      <pubDate>Mon, 22 Jan 2024 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2024/01/22/constexpr-constructor.html</guid>
      <description>&lt;h1 id=&#34;问题&#34;&gt;问题&lt;/h1&gt;
&lt;p&gt;为了提高性能，我编写了一个查表法算 sin 的函数。为了适配不同 ROM 大小的 mcu, 这个表还有大有小多个版本。最大的表，里面有 1800 项，因为是保存的 0-90度的 sin 指，因此分辨率达到了 0.05度。&lt;/p&gt;
&lt;p&gt;而且，为了进一步提高性能，表里存放的，并不是 float, 而是我自己编写的定点数 float_number。&lt;/p&gt;
&lt;p&gt;问题就出在这个float_number 上。&lt;/p&gt;
&lt;p&gt;因为这个定点表我是这么写的&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;static&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; float_number sin_table[] &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; {
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; float_number(&lt;span style=&#34;color:#ae81ff&#34;&gt;0.0&lt;/span&gt;),
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.000872664515&lt;/span&gt;},float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.001745328366&lt;/span&gt;},float_number{&lt;span style=&#34;color:#ae81ff&#34;&gt;0.002617990887&lt;/span&gt;},
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt; ......
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;因为这个表，其内存放的并不是内置类型。而是我自己编写的 float_number 类。这是一个定点数类， 使用 C++ 的运算符重载机制，可以做到无缝替换 float, 实现浮点改定点。&lt;/p&gt;
&lt;p&gt;但是，正因为这个类不是内置类型，于是编译器实际上安排的是，将 &lt;code&gt;0.0, 0.000872664515&lt;/code&gt; 等数字，存于 .rodata 段，然后将 sin_table 事实上分配于 .bss 段。
并在初始化代码里将 .bss 段的 sin_table 用存于 .rodata 段的各大 double 数据进行初始化。&lt;/p&gt;
&lt;p&gt;也就是说，这个  sin 表，实际上即占用了 .rodata 也占用了 .bss 。而 .bss 段占用的是mcu里更为珍贵的RAM。
之所以最近才思考这个问题，是因为 EG6832 只有区区 8K 的 RAM。相比拥有 384K 的 ESP32 和 32K RAM 的 AT32, 这个 mcu 的内存实在过于珍贵。
以至于我很快遇到内存不足的问题。&lt;/p&gt;</description>
    </item>
    <item>
      <title>c&#43;&#43;20 协程</title>
      <link>https://microcai.org/2022/02/20/co_await.html</link>
      <pubDate>Sun, 20 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/20/co_await.html</guid>
      <description>&lt;p&gt;表面上我是想说 c++20 的协程, 其实我是想说, asio 封装后的 asio::awaitable&amp;lt;&amp;gt; , 这个威力巨大的武器将是未来异步的基石.&lt;/p&gt;
&lt;p&gt;asio::awaitable&amp;lt;&amp;gt; 的概念, 是万物皆可 await. 万物皆可 await 的概念实际上来自 nodejs.&lt;/p&gt;
&lt;p&gt;当初, nodejs 用回调地狱带火了异步. 既然回调地狱为何又火? 因为 nodejs 万物只能异步. nodejs 没有除了异步以外的 IO.
于是 nodejs 逼迫大家在异步的道路上进行探索, 终于诞生了 Promsie/await 对. Promise 是库, await 是语言关键字.
Promise 先出, await 后出. 没有 await 的 Promise 是不完整的 Promsie , 没有 Promise 的 await 是无法使用的废物.
两个天造地设的一对, 居然并不是同时出生.&lt;/p&gt;
&lt;p&gt;Promise 的概念就是, 所有的函数, 都不直接返回数据, 而是返回 Promise , 要取得真正的返回值, 就要 await 这个 Promise.
那么, 调用返回 Promise 函数的地方, 就变成了 initiator , 而 await promsie 的地方, 就是 completion handler.
也就是, Promsie/await 的概念, 正好契合了 Proactor 的异步并发模型. 自从有了 promise/await , 原先为了避免回调地狱而
设计为 on(&amp;lsquo;data&amp;rsquo;, lisener) 的 reactor 模式的库纷纷被抛弃, 大家都要选择 Promise 版的替代品.&lt;/p&gt;</description>
    </item>
    <item>
      <title>Future 和 Promise 的区别</title>
      <link>https://microcai.org/2022/02/05/future-and-promise-comparision.html</link>
      <pubDate>Sat, 05 Feb 2022 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2022/02/05/future-and-promise-comparision.html</guid>
      <description>&lt;p&gt;promise 和 yield 的区别是什么？&lt;/p&gt;
&lt;p&gt;其实区别大了去了&lt;/p&gt;
&lt;p&gt;yield 虽然写异步看起来像同步，爽了。&lt;/p&gt;
&lt;p&gt;但是强制了必须等待 io 的模型。&lt;/p&gt;
&lt;p&gt;yield async io, 必须 io 完成，你的协程才能进一步执行&lt;/p&gt;
&lt;p&gt;和原来同步模式的线程io是一样的。必须 io完成你的线程才能继续。&lt;/p&gt;
&lt;p&gt;promise 则不然。 promise 可以在需要等待io结果的地方再 yield，结果出来以前可以执行其他操作&lt;/p&gt;
&lt;p&gt;在线程时代，也有一个和 promise 的作用非常类似的东西，就是 future。&lt;/p&gt;
&lt;p&gt;future 从未流行过。&lt;/p&gt;
&lt;p&gt;promise 之于协程，如 std.future 之于线程。然而 future 不流行，因为同步 IO 的写法已经过时了。
现在是异步的天下。&lt;/p&gt;
&lt;p&gt;虽然看起来有点标题党，但是 future 确实就是线程版的Promise. Promise 是为了更好的在异步环境里重叠异步操作。
future则试图给同步的线程模型里赛点异步的东西。&lt;/p&gt;
&lt;p&gt;这种硬塞就好像你给五菱宏光mini ev 塞五连杆悬挂一样，人家根本就用不上。真用上的，还会买五菱宏光吗？&lt;/p&gt;</description>
    </item>
    <item>
      <title>多WAN平衡</title>
      <link>https://microcai.org/2019/04/04/multiWAN.html</link>
      <pubDate>Thu, 04 Apr 2019 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2019/04/04/multiWAN.html</guid>
      <description>&lt;p&gt;曾经我也搞了两条宽带，见 &lt;a href=&#34;https://microcai.org/2016/12/07/use-neighbor-CMCC.html&#34;&gt;使用邻居的CMCC网络&lt;/a&gt; 。
然后利用路由器的loadbalance就可以使用多条线路了。
但是，问题恰恰在这里。效果并不好。因为2条宽带并不是一样容量的，对同一目标的访问速度也不尽相同。所以退而求次，选择了只把某些 cmcc 访问速度更快的目标通过 邻居网络出去。&lt;/p&gt;
&lt;p&gt;虽然我换了一个城市，然后选择了CMCC，也没有破解邻居的电信宽带wifi密码。但是多年前的失败经历还是让我感觉需要某种自动的机制自动的探测目标网络使用哪条线路是最快的。&lt;/p&gt;
&lt;p&gt;这就是 &lt;a href=&#34;https://github.com/microcai/smartproxy&#34;&gt;smartproxy&lt;/a&gt; 的了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 是最好的编程语言</title>
      <link>https://microcai.org/2017/11/04/c-is-the-best-language-forever.html</link>
      <pubDate>Sat, 04 Nov 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/11/04/c-is-the-best-language-forever.html</guid>
      <description>&lt;p&gt;好的语言是怎么来的? 有人说, 是设计出来的, 有人说, 是抄出来的. newbie 说, 是实践来的.&lt;/p&gt;
&lt;p&gt;什么是实践呢? 实践, 就是摸石头过河, 吸收合适的, 抛弃不合适的. 这不就是进化吗?&lt;/p&gt;
&lt;p&gt;正如好的物种是进化来的一样, 好的语言也是进化来的.&lt;/p&gt;
&lt;p&gt;物种的进化, 首先是要适应已有的环境, 然后才是展望未来, 设法适应未来的环境. 即使某些功能器官已经不再需要, 仍然保留着进化的痕迹.
进化是不可逆的. 如果一开始因为环境因素, 进化出的生物特性在后来的环境变化中是非常有害的, 进化却不能推倒重来. 只能继续在这个不利的基础上改进.&lt;/p&gt;
&lt;p&gt;认识到这一点, 再回过头来审视 C++ 语言.  C++ 语言的许多缺陷, 来自对 C 的兼容, 或者确切的说, 是因为从 C 语言开始进化的, 对C的兼容, 就是进化的痕迹.
进化不能推倒重来, 只能在 C 这个不利的基础上改进.&lt;/p&gt;
&lt;p&gt;但是, C 的不利, 是站在今天的角度看的. 在当时, C 是最成功的语言. 兼容 C, 是最有利于发展的. 从 C 开始进化, 在当时就是最好的选择. 而进化, 就是当年最优秀的物种才得以继续发展演化.&lt;/p&gt;
&lt;p&gt;C 当年是最好最成功的语言, 那么进化就会发生在 C 的身上, 而不是其他语言的身上. 正如远古的猿类进化成了人, 同时也进化出了猴子一样, 远古的 C 语言进化出了 C++, 也会有顽固分子选择止步不前, 就有了现在的 C. 猴子当然不如人, 但是猴子也会存在. 所以 C 会继续存在. 但是真正的发展是看C++的.&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用异常实现cache</title>
      <link>https://microcai.org/2017/04/09/simple-cache-container.html</link>
      <pubDate>Sun, 09 Apr 2017 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2017/04/09/simple-cache-container.html</guid>
      <description>&lt;p&gt;异常用来做错误处理的时候，程序到处都是 try  cache ，代码十分的丑陋，我是不怎么喜欢的，我喜欢 asio 那种用 error_code  汇报错误 —— 不传 ec 的时候就抛异常，传就不抛，改为写入错误到 ec。&lt;/p&gt;
&lt;p&gt;但是，异常用来做流程控制，又特别的好用。流程控制，无非顺序、选择、分支和循环。在 c++里，又比 C 多了一个异常。在嵌套很深的地方，跳出逻辑，除了异常，就没有其他更好的办法了。&lt;/p&gt;
&lt;p&gt;在编写软件的时候，时常需要对一些数据做 cache。在使用的时候，要先检查 cache，存在则使用 cache ，不存在则按照老办法办，然后存入 cache。&lt;/p&gt;
&lt;p&gt;每次使用前都进行判断， 污染了快速路径的代码，对有简洁洁癖的程序员来说，内心是十分的纠结的。&lt;/p&gt;
&lt;p&gt;这个时候， 你就需要 异常。将 cache hit 作为正常的流程进行编写， 假定全部的数据都是在 cache 里的。这万一发生了 cache miss ， 则抛出异常，并在异常处理重新载入数据。然后重启处理。&lt;/p&gt;
&lt;p&gt;说到重启处理， 在 Windows 的 SEH 里，存在 &lt;code&gt;EXECEPT_CONTINUE_EXECUTION&lt;/code&gt; 这个异常处理的结果， windows 看到异常处理函数返回这个，就会回到发生异常的地方重新执行。然而这毕竟是一个 Windows 系统特有的 SEH ， 而且依赖底层CPU提供的机制。 编写C++是断然不能使用这套机制的。&lt;/p&gt;
&lt;p&gt;思考的最终结果，就是下面这样的结构&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
for (int =0; i &amp;lt; retry_times ; i++)
{ 
    try  
    {
            auto  v = cache_map_sometype.get_cache(key);
            // process with v ....
            ........
    }  
    catch(cache_miss&amp;amp;)
    {   
           // load v from other resources, database, filesystem, network, etc.
           ......
            cache_map_sometype.add_cache(key, v);
            contine; // NOTE about this.
    }
    break;  
}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;在正常处理流程里， 执行到最后会有个 break 退出 for 循环。所以 for 循环在 cache hit 的状态下只执行一次。在 cache miss 的时候， catch block 里最后有一行 continue 。 于是就重启处理过程了。&lt;/p&gt;</description>
    </item>
    <item>
      <title>纯真数据库下载或自动更新实现</title>
      <link>https://microcai.org/2014/05/11/qqwry_dat_download.html</link>
      <pubDate>Sun, 11 May 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/05/11/qqwry_dat_download.html</guid>
      <description>&lt;p&gt;用过珊瑚虫的童鞋都知道, 有个叫 &amp;ldquo;纯真数据库&amp;rdquo; 的东西, 可以查询 ip 地址对应的物理地址.&lt;/p&gt;
&lt;p&gt;纯真数据库是有个名为 QQWry,DAT 的二进制文件, 可以通过纯真数据库自己提供的查询程序进行更新.&lt;/p&gt;
&lt;p&gt;有关该数据库格式和解析的内容, 本帖子暂时不讲, 有机会的话, 偶会另行开个新帖子讲讲.&lt;/p&gt;
&lt;p&gt;这里讲的是, 不通过官方的查询程序, 如何获取到这个数据库. 通过对官方程序进行抓包, 得出下载此数据库, 主要需要下载&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://update.cz88.net/ip/copywrite.rar&#34;&gt;http://update.cz88.net/ip/copywrite.rar&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;和&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://update.cz88.net/ip/qqwry.rar&#34;&gt;http://update.cz88.net/ip/qqwry.rar&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;两个文件.&lt;/p&gt;
&lt;p&gt;但是很明显,这两个压根不是 rar 文件呀! 别被扩展名迷惑了.&lt;/p&gt;
&lt;p&gt;因为要下载两个文件, 所以得出一个很明显的结论, ** 第二个文件需要用到第一个文件里的信息才能正确解开, 获得 qqwry.dat 文件. **&lt;/p&gt;
&lt;p&gt;那么,  copywrite.rar 里到底有神马东西呢?&lt;/p&gt;
&lt;p&gt;我们来打开它&lt;/p&gt;
&lt;p&gt;ghex copywrite.rar&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;copywrite.png&#34; loading=&#34;lazy&#34; src=&#34;https://microcai.org/images/copywrite_rar.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;好吧,老实说, 根本看不明白嘛!&lt;/p&gt;
&lt;p&gt;那咋办？&lt;/p&gt;
&lt;p&gt;祭出　IDA !!!!!!&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;华丽的风格线，　其实网上已经有人说了，　这个　copywrite.rar 就是如下一个结构体．&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;struct&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;copywritetag&lt;/span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; sign;&lt;span style=&#34;color:#75715e&#34;&gt;// &amp;#34;CZIP&amp;#34;
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; version;&lt;span style=&#34;color:#75715e&#34;&gt;//一个和日期有关的值
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; unknown1;&lt;span style=&#34;color:#75715e&#34;&gt;// 0x01
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; size;&lt;span style=&#34;color:#75715e&#34;&gt;// qqwry.rar大小
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; unknown2;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;uint32_t&lt;/span&gt; key;&lt;span style=&#34;color:#75715e&#34;&gt;// 解密qqwry.rar前0x200字节所需密钥
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; text[&lt;span style=&#34;color:#ae81ff&#34;&gt;128&lt;/span&gt;];&lt;span style=&#34;color:#75715e&#34;&gt;//提供商
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;    &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt; link[&lt;span style=&#34;color:#ae81ff&#34;&gt;128&lt;/span&gt;];&lt;span style=&#34;color:#75715e&#34;&gt;//网址
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这里，最重要的就是　key 这个整数拉！　接下来要在解码　qqwry.rar 里用到&lt;/p&gt;</description>
    </item>
    <item>
      <title>聊聊  type  erasure</title>
      <link>https://microcai.org/2014/04/21/type-erasure.html</link>
      <pubDate>Mon, 21 Apr 2014 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2014/04/21/type-erasure.html</guid>
      <description>&lt;h1 id=&#34;什么是类型橡皮擦&#34;&gt;什么是类型橡皮擦?&lt;/h1&gt;
&lt;p&gt;type eraer是什么？ 为什么这么有用？ 到底它是如何帮助你构建灵活强大的软件的？&lt;/p&gt;
&lt;p&gt;我们知道 C＋＋ 是一个强类型的语言。 不同类型之间有天壤之别 ，不能任意转化——函数有签名，只有符合类型检查才能调用。
类型稍微有点不匹配，那带来的是一堆堆编译错误。
然后很多时候，我们会想，C＋＋的类型能不要那么强就好了！比如说设计一个回调函数 ，这回调函数非得是那个类型的才能使用，多不方便。
为了方便用户，为了能适应变化，我们将不得不使用 void*  参数，然后不停地进行强制类型转换。&lt;/p&gt;
&lt;p&gt;如果 &amp;hellip;&amp;hellip;&lt;/p&gt;
&lt;p&gt;如果能把类型变弱点就好了!&lt;/p&gt;
&lt;p&gt;type erasure 技术应运而生。
其实我们常用的 std::function / boost::function 就是一种  type erasure。
std::function 在一定程度上，抹去了函数的类型。不论来的类型是函数对象，还是函数指针，它统统接受，统统能赋值给它。要知道，函数对象可是有无穷多种类型。&lt;/p&gt;
&lt;h1 id=&#34;弱类型-和模板啥区别&#34;&gt;弱类型？ 和模板啥区别？&lt;/h1&gt;
&lt;p&gt;模板靠编译期自动生成一个类型兼容的函数来做到弱类型，而  type erasure则能实现在运行期弱类型。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;template&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Callback&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; somefunc( &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;  somearg, Callback  callback); 
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个是弱类型了吧，但是是靠编译期实现的。如果有100 个类型的回调，就会生成 100 份代码，去适应 100 个类型的回调函数。
但是如果是这样的代码&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;somefunc&lt;/span&gt;( &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; somearg, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;function&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; callback); 
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;这个也是弱类型吧，但是，不论有多少回调类型，一份代码足矣。
也就是说， type erasure 能弥补模板运行期弱类型能力不足的问题。&lt;/p&gt;
&lt;p&gt;而有时候，你不得不使用 type erasure。
比如说，你需要保持一个容器，里面全是回调函数。
那么模板就无能为力了。因为创建一个容器的时候，已经要把所有的元素的类型都固定为一个了。
这个时候你必须借助 type erasure&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;vector&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;function&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;()&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; function_container;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;有的人会说，用  void*  不也能实现么？&lt;/p&gt;</description>
    </item>
    <item>
      <title>让 C 回调支持 boost::bind</title>
      <link>https://microcai.org/2013/08/25/function-for-c-callback.html</link>
      <pubDate>Sun, 25 Aug 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/08/25/function-for-c-callback.html</guid>
      <description>&lt;p&gt;C++ 的 bind 非常方便! 但是如果你不得不处理一些 C 接口, 情况就会变得很糟糕, 你不得不处理一堆的 void* ,
不能使用 bind ! 有神码办法可以解决这个问题呢!? 答案就是 接下来介绍的模板技术 c_func_wraper !&lt;/p&gt;
&lt;p&gt;用法很简单, 看下面的例子&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;static&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;my_thread_func&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; a, &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; b,  &lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; c)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;cout &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  a &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  b &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  c &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&amp;lt;&lt;/span&gt;  std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;endl;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; NULL;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;main&lt;/span&gt;(&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;char&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;[])
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	c_func_wraper&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;) (&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;),  &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;()&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; func;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	func &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;bind(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;my_thread_func, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;3&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_t new_thread;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_create(&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;new_thread, NULL, func.c_func_ptr(), func.c_void_ptr());
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	pthread_join(new_thread, NULL);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;        &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;}
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;pthread 是一个典型的 C 接口,  需要传递给线程的参数通过 void* 传递进来.  c_func_wraper 则将 bind 和 C 接口的回调给整合起来了!&lt;/p&gt;</description>
    </item>
    <item>
      <title>GC是错误的内存管理模式</title>
      <link>https://microcai.org/2013/07/27/gc-is-wrong-way-of-doing-memory-managment.html</link>
      <pubDate>Sat, 27 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/27/gc-is-wrong-way-of-doing-memory-managment.html</guid>
      <description>&lt;p&gt;只要写程序,  就免不了要和各种资源打交道, 其中最频繁的莫过于内存了.&lt;/p&gt;
&lt;p&gt;任何一个程序都需要内存管理. 它不管是简单的还是复杂的, C 语言的还是 java 语言的. 所不一样的是, 内存管理的细节掌握在谁的手里.&lt;/p&gt;
&lt;p&gt;对于 C 语言, 毫无疑问的, 程序员掌握所有细节. 程序员获得了最大的灵活性, 作为代价, 编译器不对任何&lt;em&gt;&lt;strong&gt;内存管理上的疏忽&lt;/strong&gt;&lt;/em&gt;负责. 而人是 &lt;em&gt;最容易犯错&lt;/em&gt; 的生物. 意味着, 程序员总会犯错, 因此很难写出在内存管理上没有瑕疵的程序.&lt;/p&gt;
&lt;p&gt;毫无疑问的, 将内存管理的重担全部丢给程序员, 是编译器水平低下的时代无奈的选择. 随着编译器技术的发展, 将内存管理的任务从程序员手中接管是必然的.&lt;/p&gt;
&lt;p&gt;对于如何接管内存管理, 语言作者们分成了截然不同的两派&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;垃圾收集&lt;/li&gt;
&lt;li&gt;RAII (Resource Acquisition Is Initialization) + 智能指针&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;在带有垃圾收集的语言里, 程序员只管分配内存, 无需操心释放. 垃圾收集器间歇性的运作, 会将不再使用的内存释放掉. 至于如何标记哪些内存是不再使用的, 几十年间发展出了各种算法. 许多语言都带有多种标记算法供选择.  &amp;ldquo;没有哪一种垃圾收集策略是适合所有程序的, 所以各种语言都发展出多套垃圾收集器, 供运行时选择.&amp;rdquo;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;在许多语言里, 垃圾收集并不是编译器实现的, 而是由语言附带的运行时环境实现的, 编译器为运行时提供了附加的信息. 这就导致了语言和运行时的强耦合. 让人无法分清语言的特性和运行时的特性.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;垃圾收集不是完美的, 使用垃圾收集并不意味着就可以高枕无忧了.&lt;/strong&gt; 垃圾收集并不意味着内存泄漏成为过去式, 倒是野指针确实成为了过去式, 因为只要还有指针引用一个对象, 这个对象就绝对不会被释放. (不过, 带有垃圾收集的语言或多或少都废除了指针吧, 用引用替代了指针)&lt;/p&gt;
&lt;p&gt;有很多很多复杂的原因丢会导致垃圾收集器无法回收特定的内存, 导致这部分内存泄漏. 更严重的是, 你很难将内存泄漏和还未被清除的内存完全区别开来. 到底是&lt;strong&gt;延迟收集策略&lt;/strong&gt; 还是真的发生了&lt;strong&gt;内存泄漏&lt;/strong&gt;
?   你永远都无法正确分辨.&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 闭包 探秘</title>
      <link>https://microcai.org/2013/07/20/closure.html</link>
      <pubDate>Sat, 20 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/20/closure.html</guid>
      <description>&lt;p&gt;我经常说协程, 说协程的时候又经常会提到闭包. 还有我常说, boost::bind 是神器  &lt;strong&gt;归根结底, 神的是  &amp;ldquo;闭包&amp;rdquo;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;没有闭包, 就无法实现 asio 协程 (注意, 我说的是 ASIO的协程, 并不是通常意义上 setjmp/longjmp 或者 CreateFiber 又或者 boost.context 创建的协程)&lt;/p&gt;
&lt;p&gt;每次使用 bind , 你就创建了一个闭包.&lt;/p&gt;
&lt;h1 id=&#34;简单的来说--闭包就是带状态的函数&#34;&gt;简单的来说,  闭包就是带状态的函数&lt;/h1&gt;
&lt;p&gt;一个函数, 带上了一个状态, 就变成了闭包了.  什么叫 &amp;ldquo;带上状态&amp;rdquo; 呢? 意思是这个闭包有属于自己的变量, 这些个变量的值是创建闭包的时候设置的, 并在调用闭包的时候, 可以访问这些变量.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;函数是代码, 状态是一组变量&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;将代码和一组变量捆绑 (bind) , 就形成了闭包&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;内部包含 static 变量的函数, 不是闭包, 因为这个 static 变量不能捆绑. 你不能捆绑不同的 static 变量. 这个在编译的时候已经确定了.  &lt;strong&gt;闭包的状态捆绑, 必须发生在运行时&lt;/strong&gt;.&lt;/p&gt;
&lt;h1 id=&#34;闭包的实现&#34;&gt;闭包的实现&lt;/h1&gt;
&lt;p&gt;C++　里使用闭包有３个办法&lt;/p&gt;
&lt;h2 id=&#34;重载--operator&#34;&gt;重载  operator()&lt;/h2&gt;
&lt;p&gt;因为闭包是一个函数+一个状态, 这个状态通过 隐含的 this 指针传入.  所以 闭包必然是一个函数对象.
因为成员变量就是极好的用于保存状态的工具, 因此实现 operator() 运算符重载, 该类的对象就能作为闭包使用.
默认传入的 this 指针提供了访问成员变量的途径.&lt;/p&gt;</description>
    </item>
    <item>
      <title>我为什么喜欢用协程</title>
      <link>https://microcai.org/2013/07/19/why-I-like-stackless-coroutine.html</link>
      <pubDate>Fri, 19 Jul 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/07/19/why-I-like-stackless-coroutine.html</guid>
      <description>&lt;p&gt;查看过 avbot 代码的人都知道, avbot 到处都是协程. 用句 ACG 的话来说,  &lt;em&gt;博士是&lt;strong&gt;协程控&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;那么, 为啥我会那么喜欢使用协程呢? 答案是协程大大简化了编程, 尤其是内存管理.&lt;/p&gt;
&lt;h2 id=&#34;协程简化了内存管理&#34;&gt;协程简化了内存管理&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;写过异步程序的人都知道, 编写异步代码最容易犯的错就是内存泄露了.&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;asio的无栈协程通过 &lt;strong&gt;闭包&lt;/strong&gt; 的形式, 将异步过程所要操作的资源绑定到 &lt;strong&gt;闭包&lt;/strong&gt; 上, 并使用 shared_ptr 对这些资源执行引用计数管理. 当最后一个回调执行完毕后, shared_ptr 确保了资源的正确释放. 对于 copyable 的资源, 甚至直接作为 &lt;strong&gt;闭包&lt;/strong&gt; 的一部分, 让资源随着闭包被 ASIO 拷贝, 释放, 拷贝, 释放, 最终最后一个&lt;strong&gt;闭包&lt;/strong&gt;完成使命, 彻底撤销.&lt;/p&gt;
&lt;p&gt;下面这个是 QQ 登陆过程的一个协程代码&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-c++&#34; data-lang=&#34;c++&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#75715e&#34;&gt;// qq 登录办法-验证码登录
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;login_vc_op&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;coroutine{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;typedef&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; result_type;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	login_vc_op(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;qqimpl&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; webqq, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string _vccode, webqq&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;webqq_handler_t handler)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; m_webqq(webqq), vccode(_vccode), m_handler(handler)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string md5 &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; webqq_password_encode(m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_passwd, vccode, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_verifycode.uin);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#75715e&#34;&gt;// do login !
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string url &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;str(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;format(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;%s/login?u=%s&amp;amp;p=%s&amp;amp;verifycode=%s&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;webqq_type=%d&amp;amp;remember_uin=1&amp;amp;aid=%s&amp;amp;login2qq=1&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;u1=http%%3A%%2F%%2Fweb.qq.com%%2Floginproxy.html&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;%%3Flogin2qq%%3D1%%26webqq_type%%3D10&amp;amp;h=1&amp;amp;ptredirect=0&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;ptlang=2052&amp;amp;from_ui=1&amp;amp;pttype=1&amp;amp;dumy=&amp;amp;fp=loginerroralert&amp;amp;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;								  &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;action=2-11-7438&amp;amp;mibao_css=m_webqq&amp;amp;t=1&amp;amp;g=1&amp;#34;&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; LWQQ_URL_LOGIN_HOST
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_qqnum
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; md5
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; vccode
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_status
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;							  &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; APPID
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;						  );
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_stream &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_shared&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_stream&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;ref(m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice()));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_stream&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;request_options(
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;request_opts()
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			(avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_options&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;cookie, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_cookies.lwcookies)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			(avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;http_options&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;connection, &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;close&amp;#34;&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		m_buffer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;make_shared&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;streambuf&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		avhttp&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;async_read_body(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;m_stream, url, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;m_buffer, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// 在这里实现　QQ 的登录.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;operator&lt;/span&gt;()(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code ec, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;size_t bytes_transfered)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;istream response( m_buffer.get());
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;( ( check_login( ec, bytes_transfered ) &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt; ) &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; ( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_status &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; LWQQ_STATUS_ONLINE ) )
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_clientid &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; generate_clientid();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#75715e&#34;&gt;//change status,  this is the last step for login
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#75715e&#34;&gt;// 设定在线状态.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;change_status(LWQQ_STATUS_ONLINE, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}&lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;using&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;namespace&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;detail;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#75715e&#34;&gt;// 登录完成 后的后续操作
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;operator&lt;/span&gt;()(&lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code&lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;using&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;namespace&lt;/span&gt; boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;detail;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;(ec)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt;;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		&lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			BOOST_ASIO_CORO_REENTER(&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;//polling group list
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				BOOST_ASIO_CORO_YIELD m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;update_group_list(&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;this&lt;/span&gt;);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#75715e&#34;&gt;// 每 10 分钟修改一下在线状态.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				lwqq_update_status(m_webqq, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_cookies.ptwebqq);
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_group_msg_insending &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;!&lt;/span&gt;m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.empty();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_group_msg_insending )
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;tuple&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string, WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;send_group_message_cb&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; v &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.front();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;delayedcallms( m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice(), &lt;span style=&#34;color:#ae81ff&#34;&gt;500&lt;/span&gt;, boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;bind( &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;send_group_message_internal, m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;shared_from_this(), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ), boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;get&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt;( v ) ) );
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;					m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;m_msg_queue.pop_front();
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;				m_webqq&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;get_ioservice().post(bind_handler(m_handler, ec));
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;			}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;		}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string webqq_password_encode( &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; pwd, &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; vc, &lt;span style=&#34;color:#66d9ef&#34;&gt;const&lt;/span&gt; std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; uin)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;//              ... 代码略 ...
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	&lt;span style=&#34;color:#66d9ef&#34;&gt;int&lt;/span&gt; check_login(boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;system&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;error_code &lt;span style=&#34;color:#f92672&#34;&gt;&amp;amp;&lt;/span&gt; ec, std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;size_t bytes_transfered)
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	{
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;//              ... 代码略 ...
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;private&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;qqimpl&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;WebQQ&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; m_webqq;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	webqq&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;webqq_handler_t m_handler;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	read_streamptr m_stream;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;shared_ptr&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;boost&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;asio&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;streambuf&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; m_buffer;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;	std&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt;string vccode;
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;};
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;在这个协程里, 有的&lt;strong&gt;闭包&lt;/strong&gt;成员被 shared_ptr 管理, 有的没有.
这些资源, 统统都没有使用显式的内存管理, 而是让这些对象随着闭包的撤销被自动的析构.&lt;/p&gt;</description>
    </item>
    <item>
      <title>模板多态</title>
      <link>https://microcai.org/2013/04/05/template-as-polymiorphism.html</link>
      <pubDate>Fri, 05 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/05/template-as-polymiorphism.html</guid>
      <description>&lt;h1 id=&#34;需求&#34;&gt;需求&lt;/h1&gt;
&lt;p&gt;jack 正在实现一个 avhttp , 并且也已经相当的可用了。 他在实现http协议的时候，就对 HTTPS 和 HTTP 的实现做了一个相当重要的决定 &amp;mdash;&amp;ndash; HTTPS和HTTP必须是统一的代码。&lt;/p&gt;
&lt;p&gt;那么，要优雅的做到这一点，显然只有一个办法：多态。&lt;/p&gt;
&lt;p&gt;但是很不幸的是，SSL 需要 asio::ssl::ssl_stream , 而 TCP 则用的是 asio::ip::tcp::socket。于是 jack 想到了boost::variant。 这是一个支持 非POD成员作为一个 unin 的库解决方案。&lt;/p&gt;
&lt;p&gt;很不幸，即便如此， SSL 和 TCP 仍然有相当多的代码不能公用。然后对于代理服务器的支持， SSL 和 TCP 就更不能统一处理。&lt;/p&gt;
&lt;p&gt;依然要相当多的条件分支。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;就不能有一个更干净的办法么？
&lt;/code&gt;&lt;/pre&gt;
&lt;h1 id=&#34;分层实现&#34;&gt;分层实现&lt;/h1&gt;
&lt;p&gt;于是我提出了将 avhttp 中 HTTP 请求过程分两层实现，一个是 DNS查询、TCP 链接的发起、代理服务器握手、SSL 握手等一系列的步骤。 也就是说，在真正的发起一次 HTTP 请求之前的一系列操作将其归类到第一层。接着，是第二层，就是真正的 HTTP 协议处理了。&lt;/p&gt;
&lt;p&gt;那么第一层，无论是 HTTPS 还是 HTTP， 几乎肯定都是和 TCP 打交道，只有最后一步 HTTPS 多了一个 SSL 握手， 而 HTTP 则不需要。 这样， 第一层，不论是 HTTPS 还是 HTTP，只有唯一一处条件判断选择 SSL 握手这个分支语句。&lt;/p&gt;</description>
    </item>
    <item>
      <title>深入理解C&#43;&#43;</title>
      <link>https://microcai.org/2013/04/02/deepunderstandingcpp.html</link>
      <pubDate>Tue, 02 Apr 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/04/02/deepunderstandingcpp.html</guid>
      <description>&lt;p&gt;说一下我为何回归 C++ 了吧 : 简单: 生命有限。&lt;/p&gt;
&lt;p&gt;用 C , 固然是只有一个范式, 学起来容易, 上手简单， 可是需要操心的问题太多了: 内存泄露, 野指针, 各种断错误。
可能你会说, 内存管理，小心点就可以了。
但我觉得,如果你总是用 200% 的精力去避免内存泄露，你就没有精力开发正常的软件了。你会对软件的逻辑进行折中，因为你实在没有精力开发需要你花很多时间写逻辑的代码了。
于是, 各种因为&amp;quot;实现起来麻烦&amp;quot; 为借口进行功能精简。所以我重新拿起了高级语言。&lt;/p&gt;
&lt;p&gt;那么, 就面临者选择: 1 c++ 2 python 3 java etc&lt;/p&gt;
&lt;h1 id=&#34;那么-为啥选择了-c-呢--因为-c-的抽象能力是所有语言中最高的&#34;&gt;那么, 为啥选择了 c++ 呢? —— 因为 C++ 的抽象能力是所有语言中最高的&lt;/h1&gt;
&lt;p&gt;我为啥怎么说呢？&lt;/p&gt;
&lt;h2 id=&#34;你比如说java为啥java是个烂语言呢&#34;&gt;你比如说java,为啥java是个烂语言呢&lt;/h2&gt;
&lt;p&gt;&lt;em&gt;这个和jvm无关&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;博士说过性能问题是狗屎, 我不喜欢考虑性能问题。 java的烂和jvm无关。&lt;/p&gt;
&lt;h2 id=&#34;java-烂就烂在-gc-和面向对象&#34;&gt;java 烂就烂在 GC 和面向对象&lt;/h2&gt;
&lt;p&gt;面向对象+GC 就组合成了一个臭不可闻的烂语言。&lt;/p&gt;
&lt;h3 id=&#34;为啥-gc-和面向对象被我那么贬低呢&#34;&gt;为啥 GC 和面向对象被我那么贬低呢?&lt;/h3&gt;
&lt;p&gt;&lt;em&gt;因为 对象 的抽象能力实在是太弱了, 并且也不是正确的抽象&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;比如 人&lt;/p&gt;
&lt;p&gt;你要用 class human 抽象?&lt;/p&gt;
&lt;p&gt;那人能干啥?&lt;/p&gt;
&lt;p&gt;这都是你不得不考虑的问题&lt;/p&gt;
&lt;p&gt;还有&lt;/p&gt;
&lt;p&gt;你觉得应该搞继承&lt;/p&gt;
&lt;p&gt;然后人从 哺乳动物继承&lt;/p&gt;</description>
    </item>
    <item>
      <title>使用 boost 执行 base64 解码</title>
      <link>https://microcai.org/2013/03/28/boost-base64.html</link>
      <pubDate>Thu, 28 Mar 2013 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2013/03/28/boost-base64.html</guid>
      <description>&lt;p&gt;&lt;a href=&#34;http://en.wikipedia.org/wiki/Base64&#34;&gt;base64&lt;/a&gt; 编码最初是为了电子邮件开发的。因为电子邮件是个文本协议，不能传输二进制数据，甚至中文也无法进行传输。只能传输ascii编码的文本。这样一来就诞生了多种将二进制数据编码到ascii里的编码方案，base64是其中之一。&lt;/p&gt;
&lt;p&gt;base64是一种非常简单的编码，只要进行一次迭代即可完成解码。&lt;/p&gt;
&lt;p&gt;什么？一次迭代？？？&lt;/p&gt;
&lt;p&gt;这就让我们有机会借助 Boost 提供的迭代器非常简洁的写出base64解码器。&lt;/p&gt;
&lt;p&gt;Boost 提供了一个叫 boost::archive::iterators::binary_from_base64 的迭代器。但是直接使用它并不能完成 base64解码。&lt;/p&gt;
&lt;p&gt;还应该外面再套一层 archive::iterators::transform_width 以 6bit 为单位转换到 8bit。&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;typedef	archive::iterators::transform_width&amp;lt; 
		archive::iterators::binary_from_base64&amp;lt;const char* &amp;gt;, 8, 6, char&amp;gt;
			base64decodeIterator;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;那么这个就应该是用于解码的 base64decodeIterator&lt;/p&gt;
&lt;p&gt;但是，稍等。如果用来解码电子邮件里的东西，会经常出异常，说有不能允许的字符出现在了base64输入里。&lt;/p&gt;
&lt;p&gt;为什么呢？ 因为电子邮件以 78个字符断行了。也就是出现了base64里不允许的 CRLF。&lt;/p&gt;
&lt;p&gt;那么，怎么办？ 解码前先替换删除 CRLF ?&lt;/p&gt;
&lt;p&gt;非也非也，这么做是愚蠢的哦，因为我们要的就是一次迭代的效果。
所以，archive::iterators::binary_from_base64&amp;lt;const char* &amp;gt; 使用的是 const char * 这个迭代器，对吧，我们改一下，使用 boost::filter_iterator 这个迭代器。过滤掉非base64编码字符。&lt;/p&gt;
&lt;p&gt;boost::filter_iterator 需要使用一个模板参数，参数是一个过滤用的仿函数。&lt;/p&gt;
&lt;p&gt;于是我们写一个&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;struct is_base64_char {
bool operator()(char x) { return boost::is_any_of(&amp;quot;0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/=&amp;quot;)(x);}
};
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;然后使用     boost::filter_iterator&amp;lt;is_base64_char, const char*&amp;gt; 作为 archive::iterators::binary_from_base64 的迭代器，就形如&lt;/p&gt;</description>
    </item>
    <item>
      <title>内存管理随笔</title>
      <link>https://microcai.org/2012/10/31/mm.html</link>
      <pubDate>Wed, 31 Oct 2012 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2012/10/31/mm.html</guid>
      <description>&lt;h3 id=&#34;思考一&#34;&gt;思考一：&lt;/h3&gt;
&lt;p&gt;任何一个程序，只要不是 helloworld 那样的简单程序，必然会用到内存管理。内存管理是写程序不可避免的过程。C程序员最大的恶魔就是野指针和内存泄漏。这是每个C程序员的噩梦。C++继承了C的缺陷，基本上半斤八两。而且C++还可以自由重载new操作符，给内存管理更加重了复杂性。
我常常在想，写BASH脚本的时候，我们有管理过内存么？即便是java那样的语言，内存管理也是后台进行的，并不是可避免的，俗称GC。可是写脚本的时候，真的完全没用内存管理方面的困扰。&lt;/p&gt;
&lt;p&gt;到底是哪里出了问题呢？到底为何脚本就不用管理内存？&lt;/p&gt;
&lt;h3 id=&#34;思考二&#34;&gt;思考二：&lt;/h3&gt;
&lt;p&gt;能不能完全不依靠malloc/free new/delete 编写出一个 c/c++程序呢？&lt;/p&gt;
&lt;p&gt;结果是显然的，能！&lt;/p&gt;
&lt;p&gt;但是只有对 hello world 那样的程序才有用。最近的一项小随笔项目证实了我的想法 &lt;a href=&#34;https://github.com/microcai/hm&#34;&gt;https://github.com/microcai/hm&lt;/a&gt; 。在这个程序里，我没用使用任何 malloc/free new/delete 来管理内存。&lt;/p&gt;
&lt;p&gt;为何这个程序可以不用内存管理呢？ 于是在另一个随笔项目里，我依然使用了内存管理，虽然是智能指针自动管理的，但是毕竟使用了 new 操作 &lt;a href=&#34;https://github.com/microcai/googleproxy&#34;&gt;https://github.com/microcai/googleproxy&lt;/a&gt; 。我在想，凭啥这个程序就必须使用 new 了？&lt;/p&gt;
&lt;h3 id=&#34;思考三&#34;&gt;思考三：&lt;/h3&gt;
&lt;p&gt;程序，说到底就是一个状态机。在 hm 程序里，我采用的是“过程化”编程，外加同步多进程的IO模型。在 googleproxy 程序里，使用的是单线程异步IO的模型。&lt;/p&gt;
&lt;p&gt;hm里，状态机的状态就是进程的状态。一步一步执行下去，状态随之切换。cpu执行到哪一行，哪一行就是当前状态。&lt;/p&gt;
&lt;p&gt;googleproxy里，情况有了变化，因为使用了异步，所有的状态变化都是围绕一个中心进行的： boost::io_service::run() 。 在 run() 里，通过回调来通知状态的变化。也就是说，cpu执行到哪个回调，哪个就是当前状态。
区别是什么：&lt;/p&gt;
&lt;p&gt;在不同的状态之间，我们有数据要共享！ hm 多使用局部变量，不同的状态需要共享数据，通常也处于同一代码层级！可以直接引用需要的数据！&lt;/p&gt;
&lt;p&gt;googleproxy 里，不同的状态之间，是不同的 run() 操作的回调，需要共享数据，但是上一个状态的局部变量已经消失！上一个状态的局部变量已经消失！
要跨栈域引用共享数据，唯一的办法就是将数据创建在堆上！&lt;/p&gt;
&lt;p&gt;简单的来说，在一个程序里，所有代码的执行路径可以归纳为从 main() 开始的一个调用树。一个函数只能引用本层和上层的局部变量，无法引用子层和兄弟层和兄弟的子层的局部变量。因为这些地方的变量都是不存在的呀！&lt;/p&gt;
&lt;p&gt;所以，只能将共享数据创建在堆上。这样才能跨过调用树的生存周期！&lt;/p&gt;
&lt;p&gt;这也是唯一需要堆管理的理由。&lt;/p&gt;
&lt;p&gt;如果一个变量要进入函数的时候创建在堆上，退出的时候释放，通常的做法其实就是使用栈变量，或者是使用可变长度的stl容器。&lt;/p&gt;
&lt;p&gt;如果返回值是对象，也不要使用指针了，直接返回对象吧！别担心临时对象拷贝开销了。&lt;/p&gt;
&lt;p&gt;只有当跨栈域共享对象的时候，才考虑使用堆吧！
记住：即便如此，也不要使用裸指针。裸指针只用来进行直接内存访问（底层编程的时候），千万别用来引用对象。使用智能指针吧！放弃对象的拷贝开销的担心吧！ 那几百个周期的拷贝操作比 new/delete 的内存管理代码的开销相比，还是低太多里。何况有了 c++11 的 Move 语义，很多时候已经没用拷贝开销里。&lt;/p&gt;
&lt;p&gt;放心大胆的脚本化C++程序吧！ 实在需要跨栈共享数据的时候，使用 shared_ptr 引用吧！&lt;/p&gt;</description>
    </item>
    <item>
      <title>C&#43;&#43; 王者归来</title>
      <link>https://microcai.org/2012/10/12/cppreturn.html</link>
      <pubDate>Fri, 12 Oct 2012 00:00:00 +0800</pubDate>
      <guid>https://microcai.org/2012/10/12/cppreturn.html</guid>
      <description>&lt;p&gt;曾几何时，学会了C语言。安装了VC6这个神叉IDE。&lt;/p&gt;
&lt;p&gt;然后被迫开始CPP路程。由于C++兼容C，所以一直在以C的方式写C++。然后慢慢的开始学写C++代码。写C++代码是从MFC开始的。慢慢的，我学会了用class，感觉是个比struct好用的多的结构体。再慢慢的，我学会了继承，还有&amp;hellip; 多重继承。&lt;/p&gt;
&lt;p&gt;MFC 就是我的导师。开始不停的向MFC学习。既然用了c++的继承，就认识到了继承的陷阱。继承后，构造函数和构析函数的执行次序，等等。还有虚继承后的各种问题和陷阱。&lt;/p&gt;
&lt;p&gt;一一去了解。&lt;/p&gt;
&lt;p&gt;在程序结构方面，开始向 MFC 看齐。喜欢把任何操作都包装到class里。设计class的时候，开始过度设计。总考虑到某天我会需要继承它。说不定还需要多重继承。等等。明明已经设计好class，却喜欢继续添加功能。永远用不到的功能。只因为我“未来可能需要在别的程序里用，可能需要继承它。”&lt;/p&gt;
&lt;p&gt;任何一个程序，我都为它设计对象，全局的程序对象又有子对象，子又有子，子子孙孙无穷尽也～&lt;/p&gt;
&lt;p&gt;成员变量一多，构造函数里成员变量初始化代码就变多。然后设计构造函数重载。写更多的用不到的构造函数。
我没有意识到，我已经犯了过度设计的毛病了&lt;/p&gt;
&lt;p&gt;而c++另一个强大的功能“模板”我却一无所知。当我发现了c++还有模板功能的时候，我只是简单的尝试了一下，发现模板无法在VC下很好的被自动完成。又听说模板会导致代码膨胀，诸如此类。我只小用一下模板。就丢弃了模板。继续我过度设计的c++之路。&lt;/p&gt;
&lt;p&gt;&lt;font color=&#34;red&#34;&gt; 某一天，我开始Linux之路。  &lt;/font&gt;&lt;/p&gt;
&lt;p&gt;当我开始写出第一个GTK程序的时候，发现了C之美。C可以写出和C++一样的对象代码。而且没有了 C++的许多陷阱。&lt;/p&gt;
&lt;p&gt;也正因为C，我开始摒弃了过度设计。所设计的API皆以现阶段够用为限。未来怎么样，未来再添加好了。没有了c++的包袱，再也不设计class了。都是简单的函数。函数完成一个“过程”。而不再是操作一个“对象”。让我把精力放到了“过程”本身，而不会再去设计“漂亮的对象”。&lt;/p&gt;
&lt;p&gt;之后阅读到了Linus对C++的一篇讽刺邮件。对比自身，多多感触。c++确实是个容易写出糟糕代码的语言。&lt;/p&gt;
&lt;p&gt;从此发誓不再用c++，只以C写代码。&lt;/p&gt;
&lt;p&gt;再一次拾起C++，是因为c++11的发布，有了一些新的语法糖。我虽然不再打算写c++代码，但是没打算不再读别人的c++代码。如果别人用c++11写了新的代码，我确看不懂，不是损失是什么。我决定看一看c++11。&lt;/p&gt;
&lt;p&gt;c++11最令我着迷的新特性就是lambda。还有新的for语法。当然，boost::bind 和 boost::function 进入了 std。成为的标准的一部分。我对 std::function 的印象只限于“更好的函数指针替代”。&lt;/p&gt;
&lt;p&gt;lambda 一用，发现非常不错。好多麻烦的 static 函数都可以被匿名的 lambda取代了。我喜欢这种让名称空间更干净的感觉。&lt;/p&gt;
&lt;p&gt;我开始纠结lambda了。动摇了。如果只用c++兼容C的那部分，然后lambda，就是带lambda的C嘛！这样自欺欺人的开始用C++。&lt;/p&gt;
&lt;p&gt;参与了朋友的一个小项目。他是个重度c++粉。但是因为他的关系，我开始真正的拿起了boost。他说，没有boost他就没办法写代码。&lt;/p&gt;
&lt;p&gt;这里有个小插曲，我在Linux下一直用eclipse编程，但是也因为boost把eclipse搞崩溃了，重拾了KDevelop。结果发现KDevelop已经不再是我第一次使用的时候（Kdevelop 3.？ 的样子，好多年前的尝试。）那样使用正则匹配的自动完成了，真正的和eclipse一样是通过语法解析获得的自动完成列表。这导致KDevelop的自动完成功能异常强大，和 eclipse一样智能。所不同的是，eclipse在解析boost的代码的时候会时不时的崩溃，而且eclipse花了很久很久的假死状态解析boost头文件。毕竟是java开发的，速度还是不行啊！但是KDevelop完成boost头文件的解析只需要几秒钟。第一次打开cpp文件的时候，KDevelop在后台花了及秒钟解析了boost头文件，然后打代码的时候boost的所有功能就全部都能提示出来了。和eclipse一样的自动完成，速度快了几百倍，我马上切换到了KDevelop，并卸载了eclipse。&lt;/p&gt;
&lt;p&gt;其实之前也尝试过boost，都被假死状态的eclipse弄怕了。所以关了eclipse的index功能没了boost的语法提升瞎写过。&lt;/p&gt;
&lt;p&gt;但是换到KDevelop后那畅快淋淋的感觉，打出 boost:: 后那完善的提示，我马上开始全身心的试用boost。&lt;/p&gt;
&lt;p&gt;就是这一试用，让我重回了c++的怀抱。重回c++后，我发现了c++正确的用法：&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;class只能作为基础，构建比int/long/char要高级点的对象。绝不能用来构造程序本身。像MFC那样搞个 CMyApp 绝对是对c++的侮辱。也就是说，程序主体仍是C语言式的。

可以用class构建string，构建bigint，用重载为bigint编写大数乘法... 这才是 class 和运算符重载的意义。绝对不能肆意滥用。

必要的时候编写模板代替宏。

模板更好的用法是使用boost这样现成的模板库。

设计回调函数，使用 std::function/boost::function。这样可以使用 std::bind/boost::bind 绑定任意多的参数给回调函数用，避免C里的void*user_data设计。

虚回调函数绝对是个傻逼设计。迫使用户使用继承并进行虚成员函数重载。
&lt;/code&gt;&lt;/pre&gt;</description>
    </item>
  </channel>
</rss>
