可变模板参数包迭代

序 如果你写了一个模板函数,模板函数里使用了 可变参数。比如你写了个 template<typename... Args> int print(Args... args); 那么,要如何去访问这些可变的参数呢? 方法 1 使用递归法。比如定义2个 print, 一个是单参数的,另一个是 2个模板参数的。 template<typename Arg> int print(Arg arg); template<typename Arg1, typename... Args> int print(Arg1 arg1, Args... args) { print(arg1); print(args...); } 在可变参的 print 里, 它首先将第一个参数调用了单参数版的 print. 接着把剩下的参数调用自身。 如果剩下的参数就一个了,那么编译器也是匹配到单参数版的 print 从而结束递归。 方法 2 使用 折叠表达式 template<typename... Args> int print(Args... args) { (print_one(args), ...); } 在这个方法里,(print_one(args), ...);就是所谓的 折叠表达式。 它的意思就是把 前面的 重复一下。每次重复的时候,各使用参数包里的一个参数。 方法 3 打包进 std::tuple 后使用。比如 template<typename... Args> int print_tuple(std::tuple<Args...> tuple_arg) { // ??? } template<typename... Args> int print(Args... args) { print_tuple(std::forward_as_tuple(args...)); } 吼吼,那么问题来了, tuple 版本要怎么实现? ...

November 13, 2024

把闭包变成函数指针—— trampoline 原理解析

序 十年前,我曾经写过一个让 C 形式的回调函数支持 闭包的小转换工具, 见这。 那时候,我说过,要想把 boost.function 传给 C 接口,那这个 C 接口,必须得带一个 void* user_data 的参数。 比如 typedef int (*callback_t)(int arg1, int arg2, void* user_data); bool register_callback(callback_t cb, void* user_data); 可以利用这个 cfuntion,把 boost::function<int(int, int)> 给当成 callback_t 使用。 而 boost::function 本身又可以接受 lambda, boost::bind , 从而组合出非常易用的使用方式。 但是,这十年来,我也偶尔会遇到一些 C 库的 api , 他就只能接受裸指针,不能接受 void* user_data typedef int (*callback_t)(int arg1, int arg2); bool register_callback(callback_t cb); 这就很难受了。因为没有办法传递 void*, 也就无法给回调函数设置“上下文”。也就彻底失去了上下文关联能力了。不得不将所需的 数据通过“全局变量”传递给回调函数。十分丑陋不说,还导致回调函数变成了无法重入的。 转机 其实,如果使用 GCC 编译器,GCC 也提供一个叫 “nested function” 的功能,比如 typedef int (*callback_t)(int arg1, int arg2); bool register_callback(callback_t cb); int main() { int hello = 1; int nested_function(int arg1, int arg2) { printf("hello = %d\n", hello); } register_callback(nested_function); } 这个 nested_function 能访问 main 里定义的对象,算的上一种“闭包”了,但是,它仍然可以转换为不需要 void* 的裸函数指针。 ...

November 2, 2024

类型萃取技术:函数签名当模板参数

序 在 上一篇 文章里,我提到了 std::function 的模板参数,是一个叫函数签名 的东西。 什么是函数签名? 比如 main 函数,他的签名是 int(int, char**)。所谓函数签名,是指函数声明去掉 函数名和变量名 后得到的一个精简描述。 这个精简描述,指导编译器如何按”调用约定“产生具体的汇编指令以调用一个函数。 函数名,不过是在最后的 call 指令里,提供了具体的目标地址。 但是,如果你问 decltype(&main) 的类型是啥,其实他的类型是int (*)(int, char**)。 因为 &main 是 main 函数的函数指针。 函数签名是形如 R(args…) 的东西,而函数指针的类型,就是 R (*)(args…) 函数签名甚至不是一个合法的类型,你不能定义 int(int,int) p; 这样的一个变量。 但是你可以用 int (*p)(int, int) 定一个 函数指针 p, 其指向的函数,具有 int(int, int) 这样的签名。 那么,对于 std::function 来说,他的模板参数要怎么写,才能接受一个签名呢? 其实很简单,就把签名当成一个类型。也就是 template<typename Signature> class function; 那么有人问了,这 Signature 就一个类型啊,那 function 的 括号操作符 要怎么写? Signature operator()(Signature) ? 显然不对。 这括号操作符,必然是要把签名里的 返回值和参数给拆开来。 把一个类型里的具体组成部分拆出来? 哈哈! 这技术,听起来不可思议! ...

November 1, 2024

重提类型擦除器

序 十年前,我曾经写过一篇有关类型擦除器的文章, 见这。 十年后,我打算再探讨下类型擦除器。 C++ 对 多态 的支持,在核心层面,就两条: 虚继承 和 模板。 假设你要设计一个 线程池。这个池你可以“投递”各种任务进去。 什么叫”任务“呢? 就是一段代码。于是,早期你想到,可以使用 函数指针。 于是你的 线程池长这样 class threadpool { typedef void (*task_function_t)(); std::list<task_function_t> tasks; public: void post(task_function_t job); }; 这样的代码,有个问题,那就是你“投递” 的任务,他干活得有数据。如果投递的任务,只能是一个函数指针。 那么这个函数,就得使用“全局变量“来传递工作内容了。 所以说,这个 task ,不能是个函数指针。它得携带对象。 于是,自然的,你想到了 多态,虚函数。那么很快你就改进了第二个版本 class task { public: virtual void run() = 0; virtual ~task(){} }; class threadpool { std::list<task*> tasks; public: void post(task* job); }; 显然,如果要给任务携带点状态,就可以写一个 task 对象,比如 class some_task : public task { int work_arg1; int work_arg2; public: some_task(int arg1, int arg2); void run() override { // do some work with args. } }; 想要带上啥状态,一股脑的给添加到自己写的派生类里就行了。 ...

November 1, 2024

微软不会起名

微软不会起名,而且名字还具有极大的误导性。 先说类名: 首先,微软的协程原作者,他总是用 Task<> 来命名一个协程函数。但是这就是他犯的第一个错误。 因为只有 await 构成的一系列调用,那条调用链才是一个 “任务”。 也就是 asio 作者所说的 co_spawn. 只有被 spawn 出来的协程,才叫一个任务。而被 await 的函数,不能叫任务,而是”可异步等待返回的函数“。 因此 asio 作者使用 asio::awaitable<> 来命名,而不是 task<> 是十分妥帖的。 接着是 promise_type ,这个微软就是纯粹的瞎搞了。不同于 Task<> 只是出现在微软的示例代码里,promise_type 可是直接进了标准。这瞎命名带来的恶劣影响要大的多。为啥说这个不能是 promise_type 呢? 因为这个对象存储的是 协程状态。因此 asio 使用 coro_frame 来命名,显然要更正确的。它存储的就是当前协程帧的状态数据。 最后是 final_suspend ,这个类名简直就是严重误导性的集大成者。他干的活和 suspend 毫无关系。实际上他干的恰恰不是 suspend 的活,而是 “恢复调用者” 。协程作为可等待函数,他的调用者调用了一个协程后,调用者才是真正的被 suspend 了。被调用者是执行中。处于 running 状态。当被调用者完成工作,他要 恢复 调用者,让调用者醒来继续干活。 因此, final_suspend 其实应该叫 resume_caller . 接着说 三件套函数名: await_suspend 其实不是 挂起。协程 A 调用 协程 B, 实际上是 A 被挂起。可是代码上却是 调用 B 的 await_suspend 。这简直就是极大的误导性。当 B 对象的 await_suspend 被调用的时候,实际上恰恰是 B 被 “恢复”, B 进入了 running 状态。这个地方准确的命名,应该叫 await_setup. ...

October 30, 2024

从模板的模板论程序员的美学

在编写 µcoro 的时候,曾经对一个模板类的成员函数犯难了。那就是等待器三件套之一的 await_suspend 函数。 我为template<typename T> class awaitable 的三件套使用这样一个模板签名 template<typename PromiseType> auto await_suspend(std::coroutine_handle<PromiseType> h); 其中,这个 PromiseType 必须得是 awaitable<T>::promise_type (也就是 awaitable_promise<T> ) 的其中一个实例。 按前C++ 时代的做法,这个成员函数应该这么写 template<typename Any> auto await_suspend(std::coroutine_handle<awaitable_promise<Any>> h); 这种写法,可以保证接收到的 h 参数,其 Promise 类型必然是 awaitable_promise 的一个参数化实例。 但是,与此同时,我还希望要为 std::coroutine_handle 这样的通用参数写一个单独的处理代码。 于是,使用按前C++ 时代的做法,我需要写2个 await_suspend, 他们分别是 template<typename Any> auto await_suspend(std::coroutine_handle<awaitable_promise<Any>> h); auto await_suspend(std::coroutine_handle<> h); 对这两个类型的 promise handle, 各自有一套不同的处理代码。 但是,老王提出了不同意见。他认为,std::coroutine_handle 在标准库里,就一种表示方式,那就是 template<typename PromiseType> class std::coroutine_handle; 他批评我说,std::coroutine_handle<awaitable_promise<Any>> 这样的写法不直观。而且还写了两个 await_suspend 到底哪个在干活,得多费脑细胞。 后来,函数签名恢复成了 template<typename PromiseType> auto await_suspend(std::coroutine_handle<PromiseType> h); 但是,使用了 enable_if 之类的模板技巧,外加在 awaitable_promise 里添加一些辅助佐料,实现了 ...

October 19, 2024

编译期对象构造优化 .bss 为 .rodata

问题 为了提高性能,我编写了一个查表法算 sin 的函数。为了适配不同 ROM 大小的 mcu, 这个表还有大有小多个版本。最大的表,里面有 1800 项,因为是保存的 0-90度的 sin 指,因此分辨率达到了 0.05度。 而且,为了进一步提高性能,表里存放的,并不是 float, 而是我自己编写的定点数 float_number。 问题就出在这个float_number 上。 因为这个定点表我是这么写的 static const float_number sin_table[] = { float_number(0.0), float_number{0.000872664515},float_number{0.001745328366},float_number{0.002617990887}, ...... }; 因为这个表,其内存放的并不是内置类型。而是我自己编写的 float_number 类。这是一个定点数类, 使用 C++ 的运算符重载机制,可以做到无缝替换 float, 实现浮点改定点。 但是,正因为这个类不是内置类型,于是编译器实际上安排的是,将 0.0, 0.000872664515 等数字,存于 .rodata 段,然后将 sin_table 事实上分配于 .bss 段。 并在初始化代码里将 .bss 段的 sin_table 用存于 .rodata 段的各大 double 数据进行初始化。 也就是说,这个 sin 表,实际上即占用了 .rodata 也占用了 .bss 。而 .bss 段占用的是mcu里更为珍贵的RAM。 之所以最近才思考这个问题,是因为 EG6832 只有区区 8K 的 RAM。相比拥有 384K 的 ESP32 和 32K RAM 的 AT32, 这个 mcu 的内存实在过于珍贵。 以至于我很快遇到内存不足的问题。 ...

January 22, 2024

c++20 协程

表面上我是想说 c++20 的协程, 其实我是想说, asio 封装后的 asio::awaitable<> , 这个威力巨大的武器将是未来异步的基石. asio::awaitable<> 的概念, 是万物皆可 await. 万物皆可 await 的概念实际上来自 nodejs. 当初, nodejs 用回调地狱带火了异步. 既然回调地狱为何又火? 因为 nodejs 万物只能异步. nodejs 没有除了异步以外的 IO. 于是 nodejs 逼迫大家在异步的道路上进行探索, 终于诞生了 Promsie/await 对. Promise 是库, await 是语言关键字. Promise 先出, await 后出. 没有 await 的 Promise 是不完整的 Promsie , 没有 Promise 的 await 是无法使用的废物. 两个天造地设的一对, 居然并不是同时出生. Promise 的概念就是, 所有的函数, 都不直接返回数据, 而是返回 Promise , 要取得真正的返回值, 就要 await 这个 Promise. 那么, 调用返回 Promise 函数的地方, 就变成了 initiator , 而 await promsie 的地方, 就是 completion handler. 也就是, Promsie/await 的概念, 正好契合了 Proactor 的异步并发模型. 自从有了 promise/await , 原先为了避免回调地狱而 设计为 on(‘data’, lisener) 的 reactor 模式的库纷纷被抛弃, 大家都要选择 Promise 版的替代品. ...

February 20, 2022

Future 和 Promise 的区别

promise 和 yield 的区别是什么? 其实区别大了去了 yield 虽然写异步看起来像同步,爽了。 但是强制了必须等待 io 的模型。 yield async io, 必须 io 完成,你的协程才能进一步执行 和原来同步模式的线程io是一样的。必须 io完成你的线程才能继续。 promise 则不然。 promise 可以在需要等待io结果的地方再 yield,结果出来以前可以执行其他操作 在线程时代,也有一个和 promise 的作用非常类似的东西,就是 future。 future 从未流行过。 promise 之于协程,如 std.future 之于线程。然而 future 不流行,因为同步 IO 的写法已经过时了。 现在是异步的天下。 虽然看起来有点标题党,但是 future 确实就是线程版的Promise. Promise 是为了更好的在异步环境里重叠异步操作。 future则试图给同步的线程模型里赛点异步的东西。 这种硬塞就好像你给五菱宏光mini ev 塞五连杆悬挂一样,人家根本就用不上。真用上的,还会买五菱宏光吗?

February 5, 2022

多WAN平衡

曾经我也搞了两条宽带,见 使用邻居的CMCC网络 。 然后利用路由器的loadbalance就可以使用多条线路了。 但是,问题恰恰在这里。效果并不好。因为2条宽带并不是一样容量的,对同一目标的访问速度也不尽相同。所以退而求次,选择了只把某些 cmcc 访问速度更快的目标通过 邻居网络出去。 虽然我换了一个城市,然后选择了CMCC,也没有破解邻居的电信宽带wifi密码。但是多年前的失败经历还是让我感觉需要某种自动的机制自动的探测目标网络使用哪条线路是最快的。 这就是 smartproxy 的了。

April 4, 2019

C++ 是最好的编程语言

好的语言是怎么来的? 有人说, 是设计出来的, 有人说, 是抄出来的. newbie 说, 是实践来的. 什么是实践呢? 实践, 就是摸石头过河, 吸收合适的, 抛弃不合适的. 这不就是进化吗? 正如好的物种是进化来的一样, 好的语言也是进化来的. 物种的进化, 首先是要适应已有的环境, 然后才是展望未来, 设法适应未来的环境. 即使某些功能器官已经不再需要, 仍然保留着进化的痕迹. 进化是不可逆的. 如果一开始因为环境因素, 进化出的生物特性在后来的环境变化中是非常有害的, 进化却不能推倒重来. 只能继续在这个不利的基础上改进. 认识到这一点, 再回过头来审视 C++ 语言. C++ 语言的许多缺陷, 来自对 C 的兼容, 或者确切的说, 是因为从 C 语言开始进化的, 对C的兼容, 就是进化的痕迹. 进化不能推倒重来, 只能在 C 这个不利的基础上改进. 但是, C 的不利, 是站在今天的角度看的. 在当时, C 是最成功的语言. 兼容 C, 是最有利于发展的. 从 C 开始进化, 在当时就是最好的选择. 而进化, 就是当年最优秀的物种才得以继续发展演化. C 当年是最好最成功的语言, 那么进化就会发生在 C 的身上, 而不是其他语言的身上. 正如远古的猿类进化成了人, 同时也进化出了猴子一样, 远古的 C 语言进化出了 C++, 也会有顽固分子选择止步不前, 就有了现在的 C. 猴子当然不如人, 但是猴子也会存在. 所以 C 会继续存在. 但是真正的发展是看C++的. ...

November 4, 2017

使用异常实现cache

异常用来做错误处理的时候,程序到处都是 try cache ,代码十分的丑陋,我是不怎么喜欢的,我喜欢 asio 那种用 error_code 汇报错误 —— 不传 ec 的时候就抛异常,传就不抛,改为写入错误到 ec。 但是,异常用来做流程控制,又特别的好用。流程控制,无非顺序、选择、分支和循环。在 c++里,又比 C 多了一个异常。在嵌套很深的地方,跳出逻辑,除了异常,就没有其他更好的办法了。 在编写软件的时候,时常需要对一些数据做 cache。在使用的时候,要先检查 cache,存在则使用 cache ,不存在则按照老办法办,然后存入 cache。 每次使用前都进行判断, 污染了快速路径的代码,对有简洁洁癖的程序员来说,内心是十分的纠结的。 这个时候, 你就需要 异常。将 cache hit 作为正常的流程进行编写, 假定全部的数据都是在 cache 里的。这万一发生了 cache miss , 则抛出异常,并在异常处理重新载入数据。然后重启处理。 说到重启处理, 在 Windows 的 SEH 里,存在 EXECEPT_CONTINUE_EXECUTION 这个异常处理的结果, windows 看到异常处理函数返回这个,就会回到发生异常的地方重新执行。然而这毕竟是一个 Windows 系统特有的 SEH , 而且依赖底层CPU提供的机制。 编写C++是断然不能使用这套机制的。 思考的最终结果,就是下面这样的结构 for (int =0; i < retry_times ; i++) { try { auto v = cache_map_sometype.get_cache(key); // process with v .... ........ } catch(cache_miss&) { // load v from other resources, database, filesystem, network, etc. ...... cache_map_sometype.add_cache(key, v); contine; // NOTE about this. } break; } 在正常处理流程里, 执行到最后会有个 break 退出 for 循环。所以 for 循环在 cache hit 的状态下只执行一次。在 cache miss 的时候, catch block 里最后有一行 continue 。 于是就重启处理过程了。 ...

April 9, 2017

纯真数据库下载或自动更新实现

用过珊瑚虫的童鞋都知道, 有个叫 “纯真数据库” 的东西, 可以查询 ip 地址对应的物理地址. 纯真数据库是有个名为 QQWry,DAT 的二进制文件, 可以通过纯真数据库自己提供的查询程序进行更新. 有关该数据库格式和解析的内容, 本帖子暂时不讲, 有机会的话, 偶会另行开个新帖子讲讲. 这里讲的是, 不通过官方的查询程序, 如何获取到这个数据库. 通过对官方程序进行抓包, 得出下载此数据库, 主要需要下载 http://update.cz88.net/ip/copywrite.rar 和 http://update.cz88.net/ip/qqwry.rar 两个文件. 但是很明显,这两个压根不是 rar 文件呀! 别被扩展名迷惑了. 因为要下载两个文件, 所以得出一个很明显的结论, ** 第二个文件需要用到第一个文件里的信息才能正确解开, 获得 qqwry.dat 文件. ** 那么, copywrite.rar 里到底有神马东西呢? 我们来打开它 ghex copywrite.rar 好吧,老实说, 根本看不明白嘛! 那咋办? 祭出 IDA !!!!!! 华丽的风格线, 其实网上已经有人说了, 这个 copywrite.rar 就是如下一个结构体. struct copywritetag{ uint32_t sign;// "CZIP" uint32_t version;//一个和日期有关的值 uint32_t unknown1;// 0x01 uint32_t size;// qqwry.rar大小 uint32_t unknown2; uint32_t key;// 解密qqwry.rar前0x200字节所需密钥 char text[128];//提供商 char link[128];//网址 }; 这里,最重要的就是 key 这个整数拉! 接下来要在解码 qqwry.rar 里用到 ...

May 11, 2014

聊聊 type erasure

什么是类型橡皮擦? type eraer是什么? 为什么这么有用? 到底它是如何帮助你构建灵活强大的软件的? 我们知道 C++ 是一个强类型的语言。 不同类型之间有天壤之别 ,不能任意转化——函数有签名,只有符合类型检查才能调用。 类型稍微有点不匹配,那带来的是一堆堆编译错误。 然后很多时候,我们会想,C++的类型能不要那么强就好了!比如说设计一个回调函数 ,这回调函数非得是那个类型的才能使用,多不方便。 为了方便用户,为了能适应变化,我们将不得不使用 void* 参数,然后不停地进行强制类型转换。 如果 …… 如果能把类型变弱点就好了! type erasure 技术应运而生。 其实我们常用的 std::function / boost::function 就是一种 type erasure。 std::function 在一定程度上,抹去了函数的类型。不论来的类型是函数对象,还是函数指针,它统统接受,统统能赋值给它。要知道,函数对象可是有无穷多种类型。 弱类型? 和模板啥区别? 模板靠编译期自动生成一个类型兼容的函数来做到弱类型,而 type erasure则能实现在运行期弱类型。 template<class Callback> void somefunc( int somearg, Callback callback); 这个是弱类型了吧,但是是靠编译期实现的。如果有100 个类型的回调,就会生成 100 份代码,去适应 100 个类型的回调函数。 但是如果是这样的代码 void somefunc( int somearg, std::function<void> callback); 这个也是弱类型吧,但是,不论有多少回调类型,一份代码足矣。 也就是说, type erasure 能弥补模板运行期弱类型能力不足的问题。 而有时候,你不得不使用 type erasure。 比如说,你需要保持一个容器,里面全是回调函数。 那么模板就无能为力了。因为创建一个容器的时候,已经要把所有的元素的类型都固定为一个了。 这个时候你必须借助 type erasure std::vector<std::function<void()>> function_container; 有的人会说,用 void* 不也能实现么? ...

April 21, 2014

让 C 回调支持 boost::bind

C++ 的 bind 非常方便! 但是如果你不得不处理一些 C 接口, 情况就会变得很糟糕, 你不得不处理一堆的 void* , 不能使用 bind ! 有神码办法可以解决这个问题呢!? 答案就是 接下来介绍的模板技术 c_func_wraper ! 用法很简单, 看下面的例子 static void * my_thread_func(int a, int b, int c) { std::cout << a << b << c << std::endl; return NULL; } int main(int, char*[]) { c_func_wraper<void *(*) (void *), void*()> func; func = boost::bind(&my_thread_func, 1, 2, 3); pthread_t new_thread; pthread_create(&new_thread, NULL, func.c_func_ptr(), func.c_void_ptr()); pthread_join(new_thread, NULL); return 0; } pthread 是一个典型的 C 接口, 需要传递给线程的参数通过 void* 传递进来. c_func_wraper 则将 bind 和 C 接口的回调给整合起来了! ...

August 25, 2013

GC是错误的内存管理模式

只要写程序, 就免不了要和各种资源打交道, 其中最频繁的莫过于内存了. 任何一个程序都需要内存管理. 它不管是简单的还是复杂的, C 语言的还是 java 语言的. 所不一样的是, 内存管理的细节掌握在谁的手里. 对于 C 语言, 毫无疑问的, 程序员掌握所有细节. 程序员获得了最大的灵活性, 作为代价, 编译器不对任何内存管理上的疏忽负责. 而人是 最容易犯错 的生物. 意味着, 程序员总会犯错, 因此很难写出在内存管理上没有瑕疵的程序. 毫无疑问的, 将内存管理的重担全部丢给程序员, 是编译器水平低下的时代无奈的选择. 随着编译器技术的发展, 将内存管理的任务从程序员手中接管是必然的. 对于如何接管内存管理, 语言作者们分成了截然不同的两派 垃圾收集 RAII (Resource Acquisition Is Initialization) + 智能指针 在带有垃圾收集的语言里, 程序员只管分配内存, 无需操心释放. 垃圾收集器间歇性的运作, 会将不再使用的内存释放掉. 至于如何标记哪些内存是不再使用的, 几十年间发展出了各种算法. 许多语言都带有多种标记算法供选择. “没有哪一种垃圾收集策略是适合所有程序的, 所以各种语言都发展出多套垃圾收集器, 供运行时选择.” 在许多语言里, 垃圾收集并不是编译器实现的, 而是由语言附带的运行时环境实现的, 编译器为运行时提供了附加的信息. 这就导致了语言和运行时的强耦合. 让人无法分清语言的特性和运行时的特性. 垃圾收集不是完美的, 使用垃圾收集并不意味着就可以高枕无忧了. 垃圾收集并不意味着内存泄漏成为过去式, 倒是野指针确实成为了过去式, 因为只要还有指针引用一个对象, 这个对象就绝对不会被释放. (不过, 带有垃圾收集的语言或多或少都废除了指针吧, 用引用替代了指针) 有很多很多复杂的原因丢会导致垃圾收集器无法回收特定的内存, 导致这部分内存泄漏. 更严重的是, 你很难将内存泄漏和还未被清除的内存完全区别开来. 到底是延迟收集策略 还是真的发生了内存泄漏 ? 你永远都无法正确分辨. ...

July 27, 2013

C++ 闭包 探秘

我经常说协程, 说协程的时候又经常会提到闭包. 还有我常说, boost::bind 是神器 归根结底, 神的是 “闭包” 没有闭包, 就无法实现 asio 协程 (注意, 我说的是 ASIO的协程, 并不是通常意义上 setjmp/longjmp 或者 CreateFiber 又或者 boost.context 创建的协程) 每次使用 bind , 你就创建了一个闭包. 简单的来说, 闭包就是带状态的函数 一个函数, 带上了一个状态, 就变成了闭包了. 什么叫 “带上状态” 呢? 意思是这个闭包有属于自己的变量, 这些个变量的值是创建闭包的时候设置的, 并在调用闭包的时候, 可以访问这些变量. 函数是代码, 状态是一组变量 将代码和一组变量捆绑 (bind) , 就形成了闭包 内部包含 static 变量的函数, 不是闭包, 因为这个 static 变量不能捆绑. 你不能捆绑不同的 static 变量. 这个在编译的时候已经确定了. 闭包的状态捆绑, 必须发生在运行时. 闭包的实现 C++ 里使用闭包有3个办法 重载 operator() 因为闭包是一个函数+一个状态, 这个状态通过 隐含的 this 指针传入. 所以 闭包必然是一个函数对象. 因为成员变量就是极好的用于保存状态的工具, 因此实现 operator() 运算符重载, 该类的对象就能作为闭包使用. 默认传入的 this 指针提供了访问成员变量的途径. ...

July 20, 2013

我为什么喜欢用协程

查看过 avbot 代码的人都知道, avbot 到处都是协程. 用句 ACG 的话来说, 博士是协程控 那么, 为啥我会那么喜欢使用协程呢? 答案是协程大大简化了编程, 尤其是内存管理. 协程简化了内存管理 写过异步程序的人都知道, 编写异步代码最容易犯的错就是内存泄露了. asio的无栈协程通过 闭包 的形式, 将异步过程所要操作的资源绑定到 闭包 上, 并使用 shared_ptr 对这些资源执行引用计数管理. 当最后一个回调执行完毕后, shared_ptr 确保了资源的正确释放. 对于 copyable 的资源, 甚至直接作为 闭包 的一部分, 让资源随着闭包被 ASIO 拷贝, 释放, 拷贝, 释放, 最终最后一个闭包完成使命, 彻底撤销. 下面这个是 QQ 登陆过程的一个协程代码 // qq 登录办法-验证码登录 class login_vc_op : boost::asio::coroutine{ public: typedef void result_type; login_vc_op(boost::shared_ptr<qqimpl::WebQQ> webqq, std::string _vccode, webqq::webqq_handler_t handler) : m_webqq(webqq), vccode(_vccode), m_handler(handler) { std::string md5 = webqq_password_encode(m_webqq->m_passwd, vccode, m_webqq->m_verifycode.uin); // do login ! std::string url = boost::str( boost::format( "%s/login?u=%s&p=%s&verifycode=%s&" "webqq_type=%d&remember_uin=1&aid=%s&login2qq=1&" "u1=http%%3A%%2F%%2Fweb.qq.com%%2Floginproxy.html" "%%3Flogin2qq%%3D1%%26webqq_type%%3D10&h=1&ptredirect=0&" "ptlang=2052&from_ui=1&pttype=1&dumy=&fp=loginerroralert&" "action=2-11-7438&mibao_css=m_webqq&t=1&g=1") % LWQQ_URL_LOGIN_HOST % m_webqq->m_qqnum % md5 % vccode % m_webqq->m_status % APPID ); m_stream = boost::make_shared<avhttp::http_stream>(boost::ref(m_webqq->get_ioservice())); m_stream->request_options( avhttp::request_opts() (avhttp::http_options::cookie, m_webqq->m_cookies.lwcookies) (avhttp::http_options::connection, "close") ); m_buffer = boost::make_shared<boost::asio::streambuf>(); avhttp::async_read_body(*m_stream, url, *m_buffer, *this); } // 在这里实现 QQ 的登录. void operator()(boost::system::error_code ec, std::size_t bytes_transfered) { std::istream response( m_buffer.get()); if( ( check_login( ec, bytes_transfered ) == 0 ) && ( m_webqq->m_status == LWQQ_STATUS_ONLINE ) ) { m_webqq->m_clientid = generate_clientid(); //change status, this is the last step for login // 设定在线状态. m_webqq->change_status(LWQQ_STATUS_ONLINE, *this); }else { using namespace boost::asio::detail; m_webqq->get_ioservice().post(bind_handler(m_handler, ec)); } } // 登录完成 后的后续操作 void operator()(const boost::system::error_code& ec) { using namespace boost::asio::detail; if(ec) { m_webqq->get_ioservice().post(bind_handler(m_handler, ec)); return; } else { BOOST_ASIO_CORO_REENTER(this) { //polling group list BOOST_ASIO_CORO_YIELD m_webqq->update_group_list(*this); // 每 10 分钟修改一下在线状态. lwqq_update_status(m_webqq, m_webqq->m_cookies.ptwebqq); m_webqq->m_group_msg_insending = !m_webqq->m_msg_queue.empty(); if( m_webqq->m_group_msg_insending ) { boost::tuple<std::string, std::string, WebQQ::send_group_message_cb> v = m_webqq->m_msg_queue.front(); boost::delayedcallms( m_webqq->get_ioservice(), 500, boost::bind( &WebQQ::send_group_message_internal, m_webqq->shared_from_this(), boost::get<0>( v ), boost::get<1>( v ), boost::get<2>( v ) ) ); m_webqq->m_msg_queue.pop_front(); } m_webqq->get_ioservice().post(bind_handler(m_handler, ec)); } } } private: std::string webqq_password_encode( const std::string & pwd, const std::string & vc, const std::string & uin) { // ... 代码略 ... } private: int check_login(boost::system::error_code & ec, std::size_t bytes_transfered) { // ... 代码略 ... } private: boost::shared_ptr<qqimpl::WebQQ> m_webqq; webqq::webqq_handler_t m_handler; read_streamptr m_stream; boost::shared_ptr<boost::asio::streambuf> m_buffer; std::string vccode; }; 在这个协程里, 有的闭包成员被 shared_ptr 管理, 有的没有. 这些资源, 统统都没有使用显式的内存管理, 而是让这些对象随着闭包的撤销被自动的析构. ...

July 19, 2013

模板多态

需求 jack 正在实现一个 avhttp , 并且也已经相当的可用了。 他在实现http协议的时候,就对 HTTPS 和 HTTP 的实现做了一个相当重要的决定 —– HTTPS和HTTP必须是统一的代码。 那么,要优雅的做到这一点,显然只有一个办法:多态。 但是很不幸的是,SSL 需要 asio::ssl::ssl_stream , 而 TCP 则用的是 asio::ip::tcp::socket。于是 jack 想到了boost::variant。 这是一个支持 非POD成员作为一个 unin 的库解决方案。 很不幸,即便如此, SSL 和 TCP 仍然有相当多的代码不能公用。然后对于代理服务器的支持, SSL 和 TCP 就更不能统一处理。 依然要相当多的条件分支。 就不能有一个更干净的办法么? 分层实现 于是我提出了将 avhttp 中 HTTP 请求过程分两层实现,一个是 DNS查询、TCP 链接的发起、代理服务器握手、SSL 握手等一系列的步骤。 也就是说,在真正的发起一次 HTTP 请求之前的一系列操作将其归类到第一层。接着,是第二层,就是真正的 HTTP 协议处理了。 那么第一层,无论是 HTTPS 还是 HTTP, 几乎肯定都是和 TCP 打交道,只有最后一步 HTTPS 多了一个 SSL 握手, 而 HTTP 则不需要。 这样, 第一层,不论是 HTTPS 还是 HTTP,只有唯一一处条件判断选择 SSL 握手这个分支语句。 ...

April 5, 2013

深入理解C++

说一下我为何回归 C++ 了吧 : 简单: 生命有限。 用 C , 固然是只有一个范式, 学起来容易, 上手简单, 可是需要操心的问题太多了: 内存泄露, 野指针, 各种断错误。 可能你会说, 内存管理,小心点就可以了。 但我觉得,如果你总是用 200% 的精力去避免内存泄露,你就没有精力开发正常的软件了。你会对软件的逻辑进行折中,因为你实在没有精力开发需要你花很多时间写逻辑的代码了。 于是, 各种因为"实现起来麻烦" 为借口进行功能精简。所以我重新拿起了高级语言。 那么, 就面临者选择: 1 c++ 2 python 3 java etc 那么, 为啥选择了 c++ 呢? —— 因为 C++ 的抽象能力是所有语言中最高的 我为啥怎么说呢? 你比如说java,为啥java是个烂语言呢 这个和jvm无关 博士说过性能问题是狗屎, 我不喜欢考虑性能问题。 java的烂和jvm无关。 java 烂就烂在 GC 和面向对象 面向对象+GC 就组合成了一个臭不可闻的烂语言。 为啥 GC 和面向对象被我那么贬低呢? 因为 对象 的抽象能力实在是太弱了, 并且也不是正确的抽象 比如 人 你要用 class human 抽象? 那人能干啥? 这都是你不得不考虑的问题 还有 你觉得应该搞继承 然后人从 哺乳动物继承 ...

April 2, 2013