善意提醒

如果您打开本站很慢,布局排版混乱,并且看不到图片,那么可能是因为您还没有掌握用科学的方法上网的本领。
显示标签为“软件开发”的博文。显示所有博文
显示标签为“软件开发”的博文。显示所有博文

2026-04-08

当 AI 遇上忒修斯之船

在软件中需要加入一些为用户个性化定制的内容推送,因此需要一个用户标识。

正常情况下,如果用户有登录,就是一个 UserID 的事情。然而我们这次的场景是匿名使用,所以没有这个 UserID 可以用,需要自己来生成一个。

以及,产品设计上希望能做到还是能大致识别到一个「人」。同一台机器上如果有多个我们的软件,最好能得到相同的 ID。因此最后商量下来决定采用设备 ID(或设备指纹)的方式。

如果是 Web 浏览器,算是有相对成熟的方案。浏览器指纹也不是一两个人在做了,「广告」这个需求天然就需要这种东西。然而我们是 MFC 程序,需要自己想办法。

我以前做 Shareware 的时候也大致接触过一些 DeviceID 的东西,知道这种事情吃力不讨好。很难覆盖那么多种类的硬件,特别有一些可能还是服务器上才能见到的东西。万一搞不好,说不定在某些特殊硬件上还要出什么状况,所以并不是一件容易的事情。所幸我们这次的事情并不是性命攸关的「注册码」,只是一个可有可无的身份标识,即使拿不到,也可以接受,因此压力没那么大。

很自然地,我想到了让 AI 来做这个事情。说到「见多识广」,可能没有人比得上它。知识结构也是它比较新,不用担心去网上找到的开源代码只能支持老旧硬件的事情。把需求描述给了它,很快就生成了一个函数,专门用来在 Windows 上得到 DeviceID。

自测的时候,问题来了:DeviceID 有时候会变。
其实这个问题一早就埋下了,是我需求没向AI说清楚,算我的锅。

说起来,这类需求虽然都可以描述为 DeviceID,但实际上是不同的:

  1. 用于区分两台设备;
  2. 用于追踪使用者。

两者是有大区别的。前一种就最好是有点变化就换个 ID,后一种则应该只要怀疑可能还是原来那台,那 ID 就不要动。

但是,这种事情确实不太好把握。加根内存条算不算新设备?可能不应该算。那换块硬盘呢?如果 CPU 升了个级,心脏都变了,还说没变化,有点说不过去吧?以及,如果用户把操作系统从正版的 Win10 家庭版给重装成了盗版 Win11 专业版呢?

图片由 Google Gemini 3 Pro + Nano Banana Pro 生成

我们的需求肯定是希望尽可能不要因为一丁点儿变化就换一个 DeviceID。但这事是一个「忒修斯之船」悖论。变到什么程度才算一台新设备?如果太过追求某一个极端,就会落入两头的陷阱。要确保 DeviceID 的「排他性」,就需要冒「稳定性」不佳的风险。

AI一开始给出来的方案,「稳定性」是不够好的。即使硬件和 OS 都没有发生变化,它也可能会变。据说是多核 CPU 的线程绑定带来的问题。麻烦在于,如果我不从需求侧来反推,以及没有进行足够数量的测试,很可能发现不了。

解决了这个问题,还有另外一个问题:如何保证这段用于生成 DeviceID 的代码,在各种硬件上都能稳定运行?

我们的要求很低:如果不能保证生成 DeviceID,那就别生成,或者生成一个可能会重复的,都 OK。这算是允许牺牲 DeviceID 的「稳定性」,来换取更好的「鲁棒性」。这个需求我从一开始就给了 AI,它的确也在代码上作了处理,我有看到。然而,如何保证呢?作更多的测试?

我目前能想到的:在调用的时候套一个 try...catch,不知道有没有用。另一个我知道肯定有用的办法,就是把这个事情扔给一个独立的进程来做,这样应该可以保证万无一失。软件运行架构会需要一点调整。我知道这样去做,AI 呢?你如果只是把它限制在写函数这件事情上的话,它肯定没法告诉你答案。

这种事情,让 Claude Code 来做,能更好吗?如果让 OpenClaw 放开手脚不限费用地去干,它最终能搞定吗?GIGO,如果人想偷懒的话,估计就会很难。

2026-02-04

CEF 的异步 CreateBrowser 造成的问题及解决方案

图片由 Google Gemini 3 Pro + Nano Banana Pro 生成

公司有个软件,用到了 CEF 浏览器。CEFWebClient 是一个 CEFClient 的子类,作为一个子窗口放在另外一个由我们软件控制生命周期的父窗口中的。这个父窗口的创建,有时候是自动的,而且可能会短期内进行多次。因此,我们遇到了一个问题:如果父窗口太快被「干掉」,那么可能会 Crash。

父窗口的这个行为,当然可以被认为是「不正常」。但首先我的问题是「为什么」。为什么会出现这种事情?

一年前,查这个问题费了我不少时间和精力。本文主要是把相关经验给传承下去,因此接下来我就尽量长话短说了。

CEF 中创建浏览器的方法是先 new 一个 CEFWebClient,放在智能指针里面,然后交给 CefBrowserHost::CreateBrowser() 去创建窗口。这一步许多人都知道,教程和文档上都是这样写的。不太为人所知的细节是:CefBrowserHost::CreateBrowser() 可能是异步的。

这里就要介绍一些上下文了。
跟 Demo 不同,我们的软件,把 multi_threaded_message_loop 设置为 true。几乎是必须如此,因为这个程序并不单纯是个浏览器而已,没法把主线程消息循环让给 CEF。
在多线程模式下,CEF 会有自己的一些线程用来干活。包括创建浏览器窗口这种事情,也是在它的线程中,而不是调用线程或主线程。

因此,CefBrowserHost::CreateBrowser() 是在另一个线程中进行的。这一点我一开始确实没想到,建个窗口而已,谁会想到 CEF 要搞成异步的啊?官方文档也没强调这个事实。这导致调用线程在函数调用返回时,浏览器窗口还没真正创建起来,只是把这个任务给安排了下去而已。如果父窗口在浏览器窗口真正创建前被销毁了,实际创建浏览器窗口的时候就会出问题。

我们的调用线程其实就是主线程,一开始尝试了让主线程等着,但不行。不管是用信号同步,还是用个 while 循环暴力堵住,都会导致死锁。很明显,CefBrowserHost::CreateBrowser() 在子线程中先是作了一些准备工作,然后又用到了主线程,毕竟创建窗口只可能在主线程中进行。可能是一个 SendMessage 类似的操作。我们是直接用了 Spotify 预编译好的 CEF 二进制分发包,并没有从 CEF 源代码从头编译,所以没有往里面深究。总之如果不把主线程空出来,后面的事情没法继续。

简单休眠 20ms 再放行貌似就可以解决问题,似乎是因为工作线程那边的准备工作已经完成了,已经能够正确应对父窗口被销毁这种事情了。但 20ms 时间够不够?谁知道呢。肯定不能靠这种方式在生产环境上运作。最好是有个判断标志可以判断出准备工作做完了没有,但目前 CEF 对我们来说是个黑盒,也没留这个窗口,我们只能想办法去探上一探。

CefBrowserHost::CreateBrowser() 的第二个参数,是个 CefRefPtr 智能指针,具备引用计数。这个引用计数,对调试器是可见的。我盯着看了一阵子,发现只要引用计数上升到一定程度再放行,就没有问题。貌似工作线程在「准备阶段」把这个智能指针挂到了主线程够得着的地方了,以便创建窗口时访问。只要这个操作已经完成,此后即使父窗口被析构,引用计数也不会有被降为 0 的担忧,后面就能正常工作下去。

这个引用计数在cef_base.h里面,class CefRefCount的私有成员,

//
// Class that implements atomic reference counting.
///
class CefRefCount {
 public:
  CefRefCount() : ref_count_(0) {}

  ///
  // Increment the reference count.
  ///
  void AddRef() const { base::AtomicRefCountInc(&ref_count_); }

  ///
  // Decrement the reference count. Returns true if the reference count is 0.
  ///
  bool Release() const { return !base::AtomicRefCountDec(&ref_count_); }

  ///
  // Returns true if the reference count is 1.
  ///
  bool HasOneRef() const { return base::AtomicRefCountIsOne(&ref_count_); }

  ///
  // Returns true if the reference count is at least 1.
  ///
  bool HasAtLeastOneRef() const {
    return !base::AtomicRefCountIsZero(&ref_count_);
  }

 private:
  mutable base::AtomicRefCount ref_count_;
  DISALLOW_COPY_AND_ASSIGN(CefRefCount);
};

还好是在头文件里面,而且只是一个权限问题,因此连重新编译 libcef_dll_wrapper.lib 都不需要。魔改了一下,我们就这样用下去了。

至于引用计数要增加到多少才算是可以放行,我们取了一个经验数据。但这个方案我们一直用得有点担心。最后还是遇到了问题。重现出来一查,就是这个经验数据不再适用了。

正确的解决方案,还是要回到 CEF 的官方机制 OnAfterCreated() 上来。
官方是这样说的:一个 CefBrowser 有没有创建成功,一定要等到 OnAfterCreated() 被调用。不管是要干什么正经事情,还是要「去死」,都得等到它调用了以后。
实际试下来,虽然 OnAfterCreated() 的调用比引用计数「到位」要迟,但的确可以保证不出事情。

所以事情其实没有那么复杂:如果 OnAfterCreated() 还没被调用到,那么就不能关闭父窗口。不能关闭怎么办?先把窗口给 SW_HIDE 了,然后向 CEFWebClient 作个标记。等到 OnAfterCreated() 被调用的时候,再向父窗口发个消息让它自己销毁,调 DestroyWindow() 就行。

经验教训是:一切还得按规矩办。自己想土办法,或许能在某些场合解决问题,但终究不是长治久安之策。
但是,虽然没有看或调试源代码,不过这次也算是刺探了一下 CEF 的一些内部运行机制,也是有好处的。

2025-11-11

你可能从未注意过的 MFC 陷阱:模态对话框禁用机制的局限性

在最近的一个软件开发案例中,遇到了不容易处理的情况。

在我们的软件中,有那种一直浮在界面上的非模态对话框,例如那种浮动的工具面板。但是,这种窗口,貌似不会在主窗口弹出模态对话框的时候被 Disable。如果模态对话框是在这个非模态对话框中弹出的,那没有问题。

用 VS2013 和升级到最新的 VS2022 各写了一个测试程序,发现这就是 MFC 的默认逻辑。
在主窗口上放了两个点击后各自会弹出非模态对话框和模态对话框的按钮。先弹出非模态对话框,然后再去弹出模态对话框。此时主窗口被 Disable,无法响应鼠标、键盘消息。但非模态对话框不受影响。

本想靠调整产品设计「容忍」过去。但问题在于,如果在保持模态对话框弹出的情况下,去把非模态对话框先关闭了,那主窗口会被 Enable。此时它跟模态对话框之间都能响应鼠标、键盘消息,效果就好像之前弹出的模态对话框变成了非模态对话框一样。这个时候就会有「后果」了,产品设计再怎么调整,也没法让软件在这种乱了套的情况下还能工作正常。


在网上 Google 了半天,不要说解决方案,连问题都没人提到。讲解模态 / 非模态对话框的文章有一些,但都是很入门的介绍。只是从「使用者」的角度去讲用法谈区别,并没有涉及我遇到的问题。很少从原理角度进行说明,更没有去分析源代码。大概 MFC 现在用的人真的不多了吧?

图片由 Google Gemini 生成

还是得自己动手,在 DoModal() 处下了一个断点,单步跟踪进到 MFC 的代码里面看了一下,就明白了。以下代码来自 VS2013,VS2022 我貌似没有安装 MFC 源代码,但从表现上看二者在这个逻辑上应该相差无几。我们一起来看看 CDialog::DoModal() 到底干了些什么事情吧:

INT_PTR CDialog::DoModal()
{
	// can be constructed with a resource template or InitModalIndirect
	ASSERT(m_lpszTemplateName != NULL || m_hDialogTemplate != NULL ||
		m_lpDialogTemplate != NULL);

	// load resource as necessary
	LPCDLGTEMPLATE lpDialogTemplate = m_lpDialogTemplate;
	HGLOBAL hDialogTemplate = m_hDialogTemplate;
	HINSTANCE hInst = AfxGetResourceHandle();
	if (m_lpszTemplateName != NULL)
	{
		hInst = AfxFindResourceHandle(m_lpszTemplateName, RT_DIALOG);
		HRSRC hResource = ::FindResource(hInst, m_lpszTemplateName, RT_DIALOG);
		hDialogTemplate = LoadResource(hInst, hResource);
	}
	if (hDialogTemplate != NULL)
		lpDialogTemplate = (LPCDLGTEMPLATE)LockResource(hDialogTemplate);

	// return -1 in case of failure to load the dialog template resource
	if (lpDialogTemplate == NULL)
		return -1;

	// disable parent (before creating dialog)
	HWND hWndParent = PreModal();
	AfxUnhookWindowCreate();
	BOOL bEnableParent = FALSE;
	CWnd* pMainWnd = NULL;
	BOOL bEnableMainWnd = FALSE;
	if (hWndParent && hWndParent != ::GetDesktopWindow() && ::IsWindowEnabled(hWndParent))
	{
		::EnableWindow(hWndParent, FALSE);
		bEnableParent = TRUE;
		pMainWnd = AfxGetMainWnd();
		if (pMainWnd && pMainWnd->IsFrameWnd() && pMainWnd->IsWindowEnabled())
		{
			//
			// We are hosted by non-MFC container
			// 
			pMainWnd->EnableWindow(FALSE);
			bEnableMainWnd = TRUE;
		}
	}

	TRY
	{
		// create modeless dialog
		AfxHookWindowCreate(this);
		if (!CreateRunDlgIndirect(lpDialogTemplate, CWnd::FromHandle(hWndParent), hInst) && !m_bClosedByEndDialog)
		{
			// If the resource handle is a resource-only DLL, the dialog may fail to launch. Use the
			// module instance handle as the fallback dialog creator instance handle if necessary.
			CreateRunDlgIndirect(lpDialogTemplate, CWnd::FromHandle(hWndParent), AfxGetInstanceHandle());
		}

		m_bClosedByEndDialog = FALSE;
	}
	CATCH_ALL(e)
	{
		TRACE(traceAppMsg, 0, "Warning: dialog creation failed.\n");
		DELETE_EXCEPTION(e);
		m_nModalResult = -1;
	}
	END_CATCH_ALL

	if (bEnableMainWnd)
		pMainWnd->EnableWindow(TRUE);
	if (bEnableParent)
		::EnableWindow(hWndParent, TRUE);
	if (hWndParent != NULL && ::GetActiveWindow() == m_hWnd)
		::SetActiveWindow(hWndParent);

	// destroy modal window
	DestroyWindow();
	PostModal();

	// unlock/free resources as necessary
	if (m_lpszTemplateName != NULL || m_hDialogTemplate != NULL)
		UnlockResource(hDialogTemplate);
	if (m_lpszTemplateName != NULL)
		FreeResource(hDialogTemplate);

	return m_nModalResult;
}

看到高亮的代码应该就能明白了。MFC 在弹出模态对话框的时候,只是把 hWndParent 给 Disable 了。然后如果发现主窗口还没被 Disable,再补上一刀。后面这个逻辑应该就是为了应对在非模态对话框中弹出模态对话框的情况。

看到了这些逻辑,就可以明白本文最开始讲到的情况是情理之中的。模态对话框只管住了大 BOSS 和父亲,对于兄弟和叔伯之类,都没有去管。如果情况复杂一点,例如非模态对话框中又弹了第二层的对话框,那么不管这个对话框是模态还是非模态,接下来都有机会整出点问题。


知道了问题的原因,接下来就要寻找靠谱的解决方案了。肯定有人解决过这类问题,因为有些软件没有这种问题。但不知道是因为觉得问题太简单了不值得说,还是想藏着掖着?

希望是前者。因为真正的解决方案确实也很简单。

之前有同事尝试解决这个问题,办法是让模态对话框去通知所有的非模态对话框(或者说需要被 Disable 的窗口)自行 Disable,用了我们软件内部与 Windows 消息相互独立的另外一套通讯机制。

但这个解决方案有一些问题:模态对话框除了自己开发的那些,还有系统提供的 MessageBox、文件打开对话框等,另外还包括第三方库中的那些,都是我们无力触达的。所以虽然它花了很多力气让对话框们去多重继承一个基类,但还是没法彻底解决这类问题。

回头想想,主窗口不是总是会被 Disable 的么?那么监听主窗口的 WM_ENABLE 消息,在事件处理函数中把那些需要额外 Disable 掉的窗口集中处理掉,不是就可以了?

实际做起来也很简单,基本上就是在主窗口的 OnEnable() 中用 EnableWindow(bEnable) 把状态传递过去。唯一需要动点脑筋的,就是让那些需要额外 Disable 掉的窗口把自己的 HWND 注册到一个主窗口拿得到的地方,也就是说待处理的窗口列表需要管理起来。

具体的实现代码我就不贴了。重要的是解决问题的思路,具体如何实现,可以有很多种办法,选择适合自己的哪一种就好。相信读到这里的,都是合格的 Win32 / MFC 程序员。

2025-01-15

这样赚钱真的太轻松了

图片来自 Stable Diffusion,纯属虚构

本文又标题党了。
可能会被以为是鸡汤文或者软文吧,但其实是篇吐槽文。

作为 Web 前端开发,可以不懂 Nginx 如何配置,对于安装更是敬若(er)神(yuan)明(zhi)。
作为 Web 后端 Java 开发,完全不懂 Redis 也就算了,甚至都不敢碰。提起需要部署个联调测试环境,就让我去「找人」来解决。仅仅是 MySQL、Redis、Nginx 这几个常见东东的安装,一开口就跟说我「需要好几天」。
就这点玩意儿,我利用下班前收拾东西那点碎时间就做掉了。
难道开发人员自己联调还得配个运维吗,然后还得配个项目经理去帮他们跟美工沟通。现在的开发人员都怎么了?

如果开发只是写代码,我也会啊。搭环境这种事情对我来说简直小菜一碟,我还会配置,会运维,会调优,甚至会魔改。项目管理让我干,产品设计也丢给我,美工给的图片不满意我自己改。SVN 让我来管,一个个 Merge 代码出了冲突都两手一摊等着我来处理。慢查询优化我不做没人做,SQL / 正则看不懂也都找到我。Python 代码我来写,PHP 代码我来写,香草 JS 我来写,还别提本职工作 C/C++。我这也会那也会,会的东西比他们多多了。他们能拿这些薪水,我岂不是可以超过他们好多倍?

说起来,老板的工资还真的挺好赚的。

2017-05-25

将 C++11 新特性用于代码优化

关于 C++11 的科普,在这里就不详细进行了,可以参考 维基百科 页面。即使是中文页面,我认为写得足够详细和系统了。

总之,C++11 对原始的 C/C++ 作出了在我看来是不算小的改动。有一些概念,放在以前的时代是绝对真理,在 C++11 推出之后,可能需要重新了解一下了。VS2013 对 C++11 的支持并不算「完美」,不过大部分「有用」的特性还是到位了。这里就以它为例,来谈谈如何把 C++11 的新特性应用到你的软件开发工作中来提升性能和开发效率。

本文提到的 C++11 的这些新特性,我大致把它们分为两类:一类是可以直接提升代码的性能表现的,我列在「性能优化」部分;另一类虽然不能直接提升代码的性能,但可以提升开发效率,便于更快地开发出可维护性更好的代码,我列在「非性能优化部分」。

另外,受作者水平所限,本文并不是对 C++11 在这些方面的完整的参考内容,仅仅作为一个引导来阅读吧。


性能优化部分

右值引用和 move 语义
C++11 引入了右值引用,支持了 move 语义。在我看来,这个变化的意义可能是 C++11 里面最大的一个。右值引用和 move 语义是什么,这里不展开。通俗一点地讲,这个特性使得程序员可以在必要的时候自行决定到底是深拷贝还是浅拷贝。对于大量的数据「搬运」操作,可以节省下不少时间。对于性能优化来说,意义重大。

其实就算没有右值引用,在 C++11 之前的时代也可以做类似的优化。C++ 程序员只要对于自己的资源管理类显式地提供深 / 浅拷贝版本的函数即可。不过这样一来代码工作量会比较大,程序会变得比较复杂,并且始终不是一个规范。现在这一切都不是问题了。

对于 STL 自己的类/容器,VS2013 已经做了足够的优化。例如,你可以通过:
string strA = std::move(strB);
来把 strB 的字符串动态内存部分直接给到 strA,速度比简单的赋值要快不少。当然,strB 就不再具有有意义的值了(这里例子中会变成空字符串)。当你 push_back 或 insert 一个 string 到容器里面的时候,如果 string 其实是一个临时变量,那么用 move 语义你也可以得到相当明显的性能提升。

如果例子里面 string 换成一个 map<string, string>,那么提升会更明显。总之,内存的分配和释放,以及 memcpy 操作统统被避免了。所以,理论上需要传递的东西越多,你得到的性能提升就会越显著。

就地部署(emplace)
C++11 对于常见的 STL 容器,都提供了一种能提升性能的数据置入方法,称之为「就地部署」。通过用就地部署取代原来的 push_back 或 insert 之类的操作,不再需要先构造再传递,而是由容器直接调用目标对象的构造函数来完成数据填充。

在某些情况下(T 提供了对应的构造函数时),这样可以避免一次拷贝构造的开销。而最差的情况(T 没有提供对应的构造函数),也最多不过就是与 push_back 和 insert 效果一模一样而已。所以我建议所有能用上就地部署的地方,都统统用上,无需太多考虑。

并且,就地部署与 move 语义相互并不冲突,而且是互有补充。move 语义解决深拷贝慢的问题,就地部署试图减少哪怕是浅拷贝的执行次数。两者配合起来效果更加完美。

散列表
在 C++11 里,不再需要通过第三方库来引入散列表(或者叫哈希表)了。STL 正式支持了四种散列表的实现,全部都冠以「unordered_」的前缀,以便与一些第三方实现相区别。

对于大多数用 map / set 实现的代码,只要简单替换容器就可以得到性能上的提升。map / set 基于红黑树(自平衡二叉树),时间复杂度至少是 log(N)。散列表版本的 map / set 提供常数级的时间复杂度,随着数据量的增大,无论是写入还是读取的性能都超过了红黑树版本的 map / set。

我个人的测试结论是:同是 set<string>,即使是小数据量,散列表版读取代价也只是红黑树版的约 60%;小数据量下,红黑树版写入略快,但在容器内数据量达到「万」级别的时候,散列表的写入速度也开始超越红黑树版(此为 Release 版测试结论,Debug 版在「百」级别即发生超越现象)。

所以我认为,只有在数据量很小,并且写入与读取的概率大致相当时,使用红黑树版 map / set 才在性能上可能有明显收益。其余情况,都建议采用散列表版本 map / set。当然,如果 T 是自定义类,并且你不愿意为它写散列函数,那就算了。


非性能优化部分

完美转发
C++11 中所谓「完美转发」的特性,其实是配合右值引用来使用的。如果为了支持右值引用,而不得不让自己的代码量变大一倍,那有些人可能就要望而却步了。完美转发其实是借用了模板技术,使得你可以只写一份代码,就可以兼顾(常量)左值引用与右值引用的情况。工作量更少,代码更简洁,出错的概率也就更低。

不过,采用模板技术的缺点就是:编译期展开。这一方面降低了编译器的效率,另一方面会导致头文件的包含关系变得不太容易整理。除此之外,还有一种我称之为「不完美转发」的替代解决方案,本质上是在性能上作出一定程度上还算可以接受牺牲,来换取代码简洁性,取得一个还算 OK 的平衡。我会另外写一篇 Blog 来介绍一下它。

类型推导
「类型推导」也就是所谓的 auto 类型。这个东西使用起来基本没有门槛。很多人可能最开始接触 C++11 就是通过它了。

这个的确是一个好东西,用来写 STL 的 iterator 类型再合适不过了。因为我们本来也不怎么关心 iterator 的具体类型。不过,仍然不建议滥用。如果到处都是 auto,阅读你代码的人会经常性地需要回顾才能知道一个变量的类型,特别是在你没有用匈牙利命名法的时候更是如此。

所以,我的建议是:当你觉得一个变量的类型写起来很麻烦,而你其实并不关心它的时候,放心地用 auto。并且,auto 变量的作用域不要太大,if / for / while 循环内的局部变量用它是最合适的。

基于范围的 for 循环
很多语言早就可以这样写了。而 C++11 现在也可以这样写了:
for (auto& stk : stocklist)
相比起:
for (auto pIter = stocklist.begin(); pIter != stocklist.end(); ++pIter)
孰优孰劣一目了然。何况后者通常还需要跟一句:
auto stk = (*pIter);
不过,如果是一个 map,你可能经常要取 pIter->first / second 之类。或者你打算在循环里面对 pIter 做 erase 操作,那还是用传统方式比较好。

空指针
用 nullptr 取代 NULL。我觉得最大的好处就是 nullptr 的颜色没有 NULL 扎眼。不过,由于 NULL 也表示 0,有的时候也表示无效句柄。我觉得对于所有指针类型的 NULL,置换成 nullptr 可能会对阅读代码有一定帮助。

角括号
C++11 的编译器现在可以识别 >> 到底是两个模板类的嵌套,还是 >> 运算符。因此写代码的时候就不特意空上一格,写多层模板类嵌套的时候就更美观一点。

不过,多层模板类嵌套,本来就不可能「美观」到哪里去。起码我是不建议太多此类的代码实践的。

初始化列表
vector 可用这样的方式来进行初始化:
vector<int> vecX = { 1, 2, 3, 4 };
的确是比以前省事了。也就是说,C-Style 数组的存在意义又少了一层。

统一初始化
struct 可以被这样初始化:
struct C
{
    int a;
    int b;
    int c;
};
C c{1, 2, 3};
class 的 public 成员也可以。
在某些喜欢使用各种结构体的代码中,这个特性可以让你少写一大堆构造函数。

通用智能指针
std::shared_ptr<T>,强在可以指向任意对象,缺点也由此而生:由于引用计数保存在 shared_ptr 中,因此对智能指针的赋值操作是线程不安全的。这个问题,有一篇Blog论述,我觉得写得不错,就直接引用不细讲了。从原理和测试数据来看,我认为这篇 Blog 是靠谱的。

所以,虽然 shared_ptr 很强大,但使用场合需要注意:单线程随便用。多线程下,赋值过程要注意。单对单没啥问题,最好不要出现左值右值交叉的情况(一个线程在 A = B,另一个线程在 B = C)。若因业务需求无法避免的话,要考虑当作临界资源加锁保护。实在不行,就写一个专用智能指针,把引用计数放在 T 里面,加锁保护,就不会有问题了。

正则表达式
与散列表类似,不再需要第三方实现,现在 C++11 也直接支持正则表达式了。我以前要找一个 Unicode 支持得好的 Regex 库真的是苦水一堆,现在有了官方支持真的是太好了。

2017-05-21

正确地获取 Windows 的版本号

以前,想要获取 Windows 的版本号很简单,有个 Win32 API 函数名字叫做 GetVersion,望文生义,接下来要做的事情就是去 MSDN 上查下用法就可以了。

现在,GetVersion 会被报告成「过期函数」了。也许还能用,但(据 MSDN 说)起码在 Win10 上是别指望得到预期的结果了。道理也很简单,Win10 都搞滚动升级了,版本号规则肯定也和之前不一样了,你还指望这么老的函数能兼容么?

别痴心妄想了,GetVersionEx 也一样过期。那么,眼下有什么好办法吗?

一般来说,拿 Windows 版本号可能有两种用途:

  • 我想看看你 Windows 版本达到我要求没。
  • 我就是想知道你 Windows 版本号是多少。

对于前者,微软现在在 MSDN 上是这样推荐的:它做了一组 Version Helper functions,你如果想知道当前 Windows 的版本是不是某个特定的发行版,调这组函数就可以。我们来看看这组函数中三个典型:

  • IsWindowsXPOrGreater
  • IsWindowsXPSP3OrGreater
  • IsWindowsServer

不需要更多说明,我们从名字中就可以看出,这组函数可以用于判断 Windows 的大版本,Service Pack 的版本(结合大版本),以及能知道是不是服务器版操作系统。通常情况下,这些函数大概是够了。

但是,有的时候我们并不关心版本号高低,我们只是想要一个版本号(例如记录日志时)而已。微软对此的建议是:用 GetFileVersionInfo 去获取一个系统 DLL(例如 Kernel32.dll)的文件版本号(原文看 这里)。

相关的代码虽然能找到,MSDN 上也有官方例子(有点小 Bug),但比起一行 GetVersion 来代码量实在是不能算很少。由此可见,处理「过期函数」真的没有想象中那么容易。最后我还是提供一下我从项目代码中挖出来的一个实现吧。别照抄,如果你不想引入 STL 的话:

#include <windows.h>
#include <Strsafe.h>

#pragma comment(lib, "Version.lib")

// 获取文件版本
std::wstring GetFileVersionString(const std::wstring& strFilePath, bool bStrVer = false) {
    DWORD dwVerInfoSize = GetFileVersionInfoSize(strFilePath.c_str(), nullptr);
    if (dwVerInfoSize) {
        std::vector<BYTE> vecVerData(dwVerInfoSize);
        if (GetFileVersionInfo(strFilePath.c_str(), NULL, dwVerInfoSize, &vecVerData[0])) {
            LPCVOID pBlock = &vecVerData[0];

            UINT cbTranslate;
            TCHAR SubBlock[MAX_PATH];
            struct LANGANDCODEPAGE {
                WORD wLanguage;
                WORD wCodePage;
            } *lpTranslate;

            // 阅读语言和代码页列表
            VerQueryValue(pBlock,
                L"\\VarFileInfo\\Translation",
                (LPVOID*)&lpTranslate,
                &cbTranslate);

            if (bStrVer && lpTranslate) {
                // 读取第一种语言和代码页的文件版本
                for (size_t i = 0; i < (cbTranslate / sizeof(struct LANGANDCODEPAGE)); ++i) {
                    StringCchPrintf(SubBlock, sizeof(SubBlock) / sizeof(TCHAR),
                        L"\\StringFileInfo\\%04x%04x\\ProductVersion",
                        lpTranslate[i].wLanguage,
                        lpTranslate[i].wCodePage);

                    LPVOID lpBuffer = nullptr;
                    UINT dwBytes;
                    if (VerQueryValue(pBlock, SubBlock, &lpBuffer, &dwBytes) && lpBuffer && dwBytes > 0) {
                        std::wstring strVersion(reinterpret_cast<TCHAR*>(lpBuffer));
                        return strVersion;
                    }
                }
            }

            // 未找到任何字符串版本
            VS_FIXEDFILEINFO* lpffi = nullptr;
            UINT uLen = 0;
            // 注意:这里的第二个参数 "\" 是固定写法,表示查询根块
            if (VerQueryValue(pBlock, L"\\", (LPVOID*)&lpffi, &uLen) && lpffi && uLen >= sizeof(VS_FIXEDFILEINFO)) {
                std::wstringstream wos;
                wos << HIWORD(lpffi->dwFileVersionMS) << L"." << LOWORD(lpffi->dwFileVersionMS) << L"."
                    << HIWORD(lpffi->dwFileVersionLS) << L"." << LOWORD(lpffi->dwFileVersionLS);
                return wos.str();
            }
        }
    }
    return L"";
}

// 获取 OS 版本信息
std::wstring GetOSVersion(const std::wstring& strWinSysDir, bool bStrVer) {
    std::wstring strWinSysFilePath = strWinSysDir;
    if (!strWinSysFilePath.empty() && strWinSysFilePath.back() != L'\\') {
        strWinSysFilePath += L'\\';
    }
    return GetFileVersionString(strWinSysFilePath + L"Kernel32.dll", bStrVer);
}

2017-05-20

SDL 检查不报错事件调查报告

Visual Studio 2013 VC 项目默认是启用 SDL 检查的。通常而言,这会使得一些「过期」函数在编译时被报告 Error。比如 strcpy 和 inet_addr 之类都会遇到这个问题。

理论上讲,这些过期函数的确不安全,或者说容易被不安全地调用。微软也很「贴心」地在编译器的报错信息中给出了解决方案,比如用 strcpy_s 和 InetPton 来替换,都不用你去搜解决办法了。所以按照我的习惯,一般是就地解决掉这些问题再往下走。

不过呢,可能有的人性子比较急,也有的时候是从旧项目移植,想快点编译完先跑一下看看效果。改代码毕竟要时间,从 strcpy 改成 strcpy_s 可能还好,而从 inet_addr 改到 InetPton 就真的没有想象中那么轻松。所以编译器也给出了另一种建议,你可以设上几个 Macro,SDL 也是可以被忽略的。

到此为止都还比较和谐,大家都是有商有量地做事情。然而当我腾出时间准备把过期函数扫扫干净,把同事临时加的 Macro 去掉之后一编译,问题来了——SDL 这次怎么不报错了?

再三确认过 vcxproj 中已经没有了相关的 Macro,并且 SDL 的确是打开了。但这次编译就是不会报错,似乎对我面前的 strcpy 视而不见。为什么呢?

Google 上搜了一大圈也没有方向。最后还是被我排除法硬试出来的——平台工具集如果选了 v120_xp,那么 SDL 即使打开,有些过期函数也不会报错。是不是 SDL 就此失效,我不清楚,因为我没法去覆盖所有的过期函数。我估计,微软是这样想的:你既然打算让这个程序跑在过期的 OS 上,那函数过期不过期已经不重要了。

其实还有一个更重要的原因:strcpy_s 还好,但要是把 inet_addr 真的换成了 InetPton,你就会发现在 WinXP 下你的程序根本就跑不起来。实际上,WinXP 就不支持 InetPton。MSDN 上的信息表明,最低也要 Vista 才可以。

我们的程序暂时还不能抛弃 WinXP 用户,但若要完全不知道用了哪些过期函数我又心有不甘,于是我打算做一个 #if……#else……#endif 来解决这个过期 OS 兼容的问题。搜了一下,正确的姿势应该是:
#if (_WIN32_WINNT >= 0x602)
#else
#endif
最后我是在 Debug 版本上用了平台工具集 v120,在 Release 时还是用了 v120_xp。过期函数只会局限在以上 Macro 范围内,有限度地使用。

另外,WinXP 也不支持条件变量 CONDITION_VARIABLE,所以这个服役期超长的操作系统是真的应该淘汰了。我不得不说一句:WannaCry,干得好!

2017-03-29

对 VS2013 下 C++11 的精准转发与通用引用的一点研究

在 C++11 中,允许用以下方式编写模板函数:
#include <iostream>
#include <string>
class A
{
public:
    template <typename T>
    void foo(T&& t)
    {
        T _t = std::forward<T>(t);
    }
};
int main()
{
    std::string s1 = "test";
    A a;
    a.foo(s1);
    std::cout << "1:" << s1 << std::endl;
    a.foo(std::move(s1));
    std::cout << "2:" << s1 << std::endl;
    a.foo("ok");
}
以上代码在 Visual Studio 2013 上测试通过。输出是:
1:test
2:
可以看到,模板函数 A.foo 只有一个声明和实现,但既可以接受左值,也可以接受右值。并且当 S1 被当作右值引用传入的时候,其值是确确实实被「丢弃」了。这就是所谓的精准转发(把 T 的类型准确地传递到使用者),以及通用引用(用一个 T&& 就可以表示所有的情况)。对于要写库的程序员来说,可谓是一个福音了。
然而,对于模板类,下面的写法看上去很好,但是编译会报错的:
template <typename T>
class A
{
    T _t;
    public:
    void foo(T&& t)
    {
        _t = std::forward<T>(t);
    }
};
int main()
{
    std::string s1 = "test";
    A<std::string> a;
    a.foo(s1);
    std::cout << "1:" << s1 << std::endl;
    a.foo(std::move(s1));
    std::cout << "2:" << s1 << std::endl;
    a.foo("ok");
}
编译后报错:
error C2664: “void A<std::string>::foo(T&&)”: 无法将参数 1 从“std::string”转换为“std::string&&”
with
[
    T=std::string
]
无法将左值绑定到右值引用
这大概是因为,T 的类型在 A<std::string> 的时候就确定了,因此编译器无法进行更多的类型推导。
那么怎么办呢?其实也不难,foo  函数像下面这样写就可以了:
template <typename T>
class A
{
    T _t;
    public:
    template <typename X>
    void foo(X&& t)
    {
        _t = std::forward<X>(t);
    }
};
在函数模板中用一个新类型就可以了。如果 T 跟 X 不一致,那么编译器反正会检查出来的。不用担心。
还有一个问题:有的时候我们会把 foo 的实现写在 class 的外面。那这个时候怎么办呢?
我本来想抛题目给大家去做。不过都到最后了卖关子也没什么意思,还是直说吧:
template <typename T>
class A
{
    T _t;
    public:
    template <typename X>
    void foo(X&& t);
};
template <typename T>
template <typename X>
void A<T>::foo(X&& t)
{
    _t = std::forward<X>(t);
}
标红的两行,只能是这个顺序。类的模板定义在上面,函数的模板定义在下面。颠倒过来,报错。要写在一行也可以,先左后右就行。但是要想把尖括号打开强行并成一句,报错。

2017-02-03

折腾 boost::python 的一些收获

最近从事了一些通过 boost 在 C++ 中调用 Python 脚本的工作。折腾下来有一些收获,记录一下,也许也可以帮到有些人。

一、关于万能变量类型


对于习惯了 Python 的 C++ 程序员而言,boost::python::object 这个东西是一个巨大的诱惑。它让你几乎可以像在 Python 里面那样使用弱类型的变量,同时还支持数组和字典之类的复杂变量类型,并且还支持嵌套。这简直就是一个万能变量类型,有了它,常见的需求几乎都可以满足了。

而且它还快,还容易用。它其实是 PyObject* 的一个封装,也就是说 PyObject* 其实功能也一样,但是没它容易使用。JsonCPP 里面的 Json::Value 也可以「万能」,但性能与 boost::python::object 相差颇多。这真的是一个巨大的诱惑。

但是在这里,我要给大多数 C++ 程序员泼一盆冷水。在单线程下,这个梦想可能真的是事实:但是在多线程下,boost::python::object 就是一个

boost::python::object 为什么快?因为它基于 PyObject*,具有引用计数,所以赋值才飞快,浅拷贝嘛。但是引用计数的问题就是线程不安全。

当然,光是引用计数本身不会导致线程安全性问题,导致问题的是引用计数带来的临界区对象引用问题,而归根结底,是 Python C API 的「并发问题不归我管」的思路。boost::python 的封装机制使得对象引用不好控制,也不太可见。想法是好的:使用者不需要关心这些。但现实就很无奈了。

所以,尽管很不甘心,关于万能变量类型的实现,我还是老老实实地用回了 Json::Value。

二、类型转换与判断


要从 boost::python::object 转换成 C/C++ 原生变量类型,一般用 boost::python::extract<T>。转出来的对象调 check() 就可以确定是不是正确的类型。转 boost::python::list 或 boost::python::dict 也是一样。

有一点需要特别注意的是:用 boost::python::extract<bool> 的时候,很可能得不到你预想的结果。你会发现,int 也被转成 bool 了(check() 返回 true),反过来也一样。这个不是 Bug,是 boost::python 故意这样搞的。BOOST_PYTHON_BOOL_INT_STRICT 宏可以解决这个问题(必须改动 boost::python 源代码并重新编译,因为相关代码在 cpp 里面不在头文件里面),它使得 int 和 bool 将被严格区分。

但是 boost::python 之所以把 int 和 bool 混起来用也不是没有道理的。这样使得 MFC 里面的那些 BOOL(不是 bool)类型的函数形参(和返回值)可以直通 Python,封装起控件来尤其方便。如果你设了 BOOST_PYTHON_BOOL_INT_STRICT,就不能这样干了,必须显式转换。左是一刀,右也是一刀。你们自己掂量吧。

反正我是没有去加 BOOST_PYTHON_BOOL_INT_STRICT,而是自己通过 _stricmp(value.ptr()->ob_type->tp_name, "bool") 搞定的。

三、清空 boost::python::list


用惯 STL 刚开始用 boost::python 的人可能会头大——怎么 dict 有 clear() 但 list 没有?
答案很简单,因为 Python C API 没提供,所以 boost::python 就没有。

说到底,boost::python 就是对 Python C API 的一个封装而已。你如果去看 boost::python 的源代码,甚至会发现里面不少的「成员函数」其实是跑去执行了一句 Python 脚本。不了解细节的 C++ 程序员很容易在这种地方栽跟头,所以我觉得 boost::python 绝对不会是一个终极形态。

要想清空数组,并不是完全没有办法。我找到的一个办法是 boost::python::delitem(list, boost::python::slice())。并发调用时记得用本文最后一节的办法加锁。但是我是真的不建议在多线程环境下用 boost::python,太多坑了。如果实在要用,在完成了 Python 脚本调用,把数据转换好之后,就赶紧离开 boost::python 区域吧。

四、boost::python::object 深拷贝


boost::python::object 默认的赋值操作都是作浅拷贝,极快。然而,有的时候需要深拷贝怎么办呢?

简单数据类型直接 extract 出来就是深拷贝(传值)了。会有问题的仅仅是复杂数据结构,具体地说,list 和 dict。

dict 又是有提供 copy(),理由还是——Python 里面的 dict 有 copy(),而 list 就没有。我尝试过最简单的办法,就是把一个 list 放到一个 dict 里面去 copy() 完再拿出来用。这样肯定可以达到目的。至于有没有更好的办法呢?我反正是自那之后就弃坑了,你们去研究吧。

五、多线程并发加锁


C++ 调 Python 的时候的加锁是一个不小的话题。不过这方面中文资料也算不少,有兴趣可以去搜来研究。我这里就简单地说一下跟 boost::python 相关的部分。

加锁是用 PyGILState_STATE,像这样:
PyGILState_STATE gstate;
gstate = PyGILState_Ensure();
……    // 调用Python脚本
PyGILState_Release(gstate);
这种例子网上很多,就不细说了。
关键在于,我前面也提到了,boost::python 里面很多看起来是 object 的成员函数的东西,其实都是对 Python 脚本的调用,所以都得加锁。

事实上,只要你用到了 boost::python 的地方,都得加锁。不管是 module 和 call 这种看起来就跟「调用」二字相关的,还是在对 boost::python::object 作数据处理,看起来人畜无害的,都得加锁,无论读 / 写,否则你就等着 Crash 吧,特别是服务端程序。

这也就是我一再警告避免在多线程下使用 boost::python 的原因。当然,我这边是不得不用,只能小心翼翼,如履薄冰,然后尽量控制不要让菜鸟程序员去写这种代码。由此可见,隐藏了实现细节并非全是好事,也并非全是对新手有益。

2014-10-31

SingleThread 下遇到的并发问题

手下某个小弟,有一天报告我说他写的某个 Win32 Application 有一个奇怪的 Bug,搞了半天搞不定,向我寻求支援。Bug 现象是:下载文件,完毕弹框提示,点掉之后报错,Crash。

通常而言,这种问题,往往是因为在释放、删除什么东西的时候,该做的事情没做对,比如对着一个对象的指针进行了重复 delete 之类。但看了下代码,没觉得这方面有什么问题。因为这是个 SingleThread 的程序,于是尝试用单步跟踪跟了一下,发现有一段代码似乎在所属对象析构之后还在跑。这就有点奇怪了:SingleThread 的 Application,不应该有这种属于 MultiThread 的毛病才对。Socket 模型用的是 AsyncSelect,也就是说「异步」是用 Windows 消息做出来的,并不是真的「并发」。那么到底是哪里不对劲呢?

再接下来分析发现,虽然是 SingleThread,但最后出错前弹的那个提示框,是在 OnReceive 的时候通过 SendMessage 去弹的。这样就有眉目了:ModalDialog 并不阻塞 ParentWindow 的消息循环,所以在弹框等待用户确认的时候,消息循环收到了 OnClose,于是 Socket 对象在用户点击确认按钮之前,其实已经被 Destroy 了。之前还没跑完的 OnReceive,接着再跑的话,当然只能 Crash 了。

分析到这里,问题就已经很明白了:这就跟 MultiThread 下临界区没加锁一样嘛。你以为 SingleThread 下每个函数就都是原子操作,不会被乱入的东西打搅?呵呵,你一 DoModal 就会给你再嵌个消息循环进去的。可怜很多小弟连 DoModel 的原理都没搞懂就开始写程序了。我上次还听几个小弟在争论相关问题呢。不是说写程序必须啥都弄明白才能开始,但若是只拎半壶水就开跑,将来就难免会碰上这种「奇怪」的问题。

要修正这个问题,也很简单,改成用 PostMessage 让 MainWindow 自己去处理弹框的事情就可以了。不过有点奇怪的是,在 XP 下好像不会看到错误现象。Win7 下直接运行 EXE 也不报错。只有通过两层以上的 CreateProcess 去调用,才会看到现象。难怪没什么用户报告这个问题。是不是 OS 觉得这个 EXE 反正会很快地 Over 掉,有些错误就不报算了?看来微软在私底下还是有一些没告诉大家的小动作的哈哈。

总结一下,这个案例教育我们:
  1. 不要以为只要是 SingleThread 就一定不会遇到并发问题。
  2. 前/后台逻辑应该要区分清晰,是后台代码就别抢前台的活儿。
  3. 还有,SendMessage / PostMessage 不要不经大脑就乱用。

2014-05-07

BCB5 在 Win7 x64 上启动时报错「1 transfer item(s) contain syntax errors」

由于 WinXP 已经被微软官方宣告服务终止,最近把工作环境升级到了 Win7,并且安装的是 x64 版本。装了之后发现,BCB5 启动的时候会弹出一个报错对话框,里面的信息很奇怪:
1 transfer item(s) contain syntax errors
点「确定」关闭对话框之后,BCB5 使用起来也没有什么问题。但每次启动都会弹框,很讨厌。那么,这是什么情况呢?

一般来讲,Win7 与 WinXP 之间,出现类似兼容性问题的原因大致有:
  • 管理员权限问题
  • 注册表键值问题
  • 系统目录问题
  • DEP 问题
在 x64 系统上,目录问题尤其突出。Program Files 现在还有个 Program Files (x86)。System32 那边也有个 SysWOW64。后者一般跟应用软件关系还不太大,但前者常常会导致很多问题。我就见过有的软件安装包都会运行出现问题。

这次的情况其实也类似。照例,先上国外网站的链接。
http://codeverge.com/embarcadero.cppbuilder.install/at-start-up-1-transfer-item-s/1096695
最后那个回复,把操作步骤写得很详尽。做 C/C++ 开发的,英语阅读一般还是不会有问题,我就不翻译了。

总之呢,这个问题就是因为 Program Files (x86) 直接引起的。另一个回复里面说把 BCB5 卸载后重新安装在 Program Files 下也能解决。当然,有问题的地方其实只有一处,所以完全没必要如此大动干戈。

2014-03-20

为什么不用动态内存分配?

在写这篇 Blog 的时候,我考虑了几分钟,在想要不要把标题写成《为什么有的程序员喜欢用动态内存分配?》。最后我还是把那些修饰词和定语给删了。虽然那个标题更准确一点,但是本文基本上是一篇吐槽文,我还是比较喜欢这种反问句的感觉。

事情是这样开始的:
在工作中,遇到了别的同事以前写的一段代码。作用是显示从某些网上下载的文件的内容。文件下载完后,也在本地保存了一份副本,这样如果下次发现本地有副本,就直接显示不用下载了。
这基本上是一个类似浏览器缓存的功能,实现起来也不难。不过这次我碰到一个 Bug,有个文件的副本,在解析的时候报错了。
因为第一次下载的时候并没有报错,所以焦点就集中到这个缓存机制上。这里面有个值得关注的地方在于,大概是出于节省本地硬盘空间的考虑,本地的副本在保存时是压缩过的。于是问题可能出在两个地方:

  • 压缩算法有问题,压缩保存的时候,把文件给弄坏了。
  • 解压缩算法有问题,无法正确还原这个文件。

这套压缩 / 解压缩的算法,是开源的(zlib)。所以我认为问题不应该出在算法本身,更可能是用法没用对。调用代码大概是这个样子的:
#define chunk 16384
void compress_file(const char* source_file , const char* dest_file)
{
    unsigned char datein[chunk];
    unsigned char dateout[chunk];
    unsigned long datelong = chunk;
    unsigned long sourcelong;
    FILE* source;
    FILE* dest;
    source = fopen(source_file , "r");
    dest = fopen(dest_file, "w+b");
    while (!feof(source))
    {
        sourcelong = fread(datein, 1, chunk, source);
        compress(dateout, &datelong, datein, sourcelong, 1);
        fwrite(dateout, datelong, 1, dest);
    }
    fclose(source);
    fclose(dest);
}
void un_compress_file(const char* source_file , const char* dest_file)
{
    unsigned char datein[chunk];
    unsigned char dateout[chunk];
    unsigned long datelong = chunk;
    unsigned long sourcelong;
    FILE* source;
    FILE* dest;
    source = fopen(source_file , "r+b");
    dest = fopen(dest_file , "w");
    while (!feof(source))
    {
        sourcelong = fread(datein, 1, chun, source);
        datelong = chunk;
        if (uncompress(dateout, &datelong, datein, sourcelong))
        {
            fwrite(dateout, datelong, 1, dest );
        }
    }
    fclose(source);
    fclose(dest);
}
这段代码我也不打算在这里分析太多,问题很明显:代码编写的初衷,是想把文件分块处理。但每块数据压缩之后的大小并没有记录在压缩文件中,也没有采取一些诸如分隔符或区块补齐之类的定位措施,所以解压缩的时候实际上是无法忠实地按压缩时的分块来还原数据的。而出问题的那个文件,大小的确是超过了 16384,于是就被弄坏了。

这里就引出了一个问题:为什么要分块?
事实上,如果这段代码没有采用固定长度的 C-style 数组,而是用动态内存分配的解决方案,压根都不会需要分块,也就不会出现这个 Bug。当然,这只是解决这个 Bug 的方案之一。对分块压缩算法的理解有问题,也是造成这个 Bug 的原因之一。从这方面着手进行改进也是可以的,各有利弊而已。
但这不是我要表达的重点。在这个案例里,下载的文件并不会很大,几十 KB 就顶天了。我真正疑惑的地方在于:为什么不用动态内存分配?
可能的解释有:
  • 担心内存碎片问题
  • 担心忘记释放
  • 嫌动态分配内存麻烦
  • 习惯了这种固定长度缓冲区的写法
  • ……
也许还有别的原因,一时半会儿我是想不到了。

那么换个问题:什么时候该用动态内存分配?
这个答案会比较明确一点:
  • 空间大小不确定(运行期确定)
  • 栈上空间不够
  • 方便与线程外部传递 / 分享数据

在本文的这个例子中,文件的长度是不确定的,每块数据压缩后的长度也是不确定的。很明显,这就是属于应该用上动态内存分配的时候。
该用的时候不用,带来的恶果就是程序的可读性和可维护性就会变得差,出 Bug 的机会更高。毕竟固定长度的内存区域就一定要处理溢出问题。而且用固定长度去处理变长内容,要分块 / 分次,要做循环,要留意退出条件,测试时要覆盖 1 和 N……,这些都带来了不必要的开销。
还不如直接分配一块内存出来,只要到时候记得回收就 OK。性能方面值得担心的话,也可以自己优化内存管理,这是可以集中处理掉的事情。而那种用固定长度的栈缓冲区来解决此类问题的办法,好听一点叫做「质朴」,难听一点叫「土」。总不能每个需要动态内存分配的地方,都用这种土办法来应对吧。

我其实是觉得,有些程序员,会有意识(或下意识)地避免用动态内存分配。从写代码的时候就开始重视性能,是好事情,但写程序不能只看功能和性能。你写的程序,好不好懂,容不容易出问题,有没有定时炸弹,好不好改,方不方便扩展,这些也都是很重要的。性能不佳可以优化,这种代码级的性能问题(相比架构级而言)优化起来尤其容易。但其它的方面,要改善起来绝非一日之功。
往开了说,作为程序员,应该避免陷入「某个东西就是不好」的思维方式中。思维开始变得狭隘,是自身没法继续再提高(达到上限了)的标志之一。

2013-04-10

修改 GoAgent 客户端以支持 Mega

为了能用来访问 Mega,对 GoAgent 客户端代码做了略微的修改。不过首先要说明一下为什么会有这个修改。

Mega 是个总部位于 New Zealand 的网盘服务。服务器当然全世界都有,但至少在我这边 ping 值不好。严重的时候 600ms 以上,并且丢包。这样的话,不管本地有多少带宽,实际上也是不可用的。总不可能花上一整天的工夫来传一个 ISO 吧。
开着 VPN 会快,但流量和费用都是问题。于是很自然地想到了是否可以通过 GoAgent 之类的 GAE 代理来访问。Google 服务器与 Mega 之间的带宽应该是不成问题的,而 Google 服务器与我之间的速度也是我可以在一定程度上控制的。不过测试下来发现 GoAgent 不支持 OPTIONS 这种 HTTP Method,而且这个局限性是 GAE 导致的。GAE 只支持GET / POST / HEAD / POST / DELETE 这五种 HTTP Method。偏偏 Mega 在登录和上传下载的时候都会发 OPTIONS 请求,于是这个方案一度被搁置了。
后来 Mega 的速度进一步下降,有时候一整天都传不完一个 100M 的文件。于是这个方案又被我拿出来考虑。这次我准备绕开服务端的限制,直接从客户端下手。OPTIONS 请求涉及的数据量是很小的,文件传输用到的 CONNECT 之类才是主要的带宽压力。因此可以让客户端在遇到 GAE 服务器无法处理的 HTTP 请求时,直接将其发到目标服务器。由于 Mega 目前还没有被 GFW 给 IP 黑洞,因此应该可以在一种「混合模式」下被通过 GoAgent 访问到。

下面介绍一下修改方法,以 GoAgent 2.1.15 版(2.1.17 还需要服务端改动才行)为例:

首先在 local/proxy.py 中找到这两行:
"""rules match algorithm, need_forward= True or False"""
need_forward = False
第一行是注释。而下面这个 need_forward,就是用来控制是否把一个请求直接送出(FWD),而不是送去 GAE 服务器进行中转。

在后面的 if 语句前,加入这样的内容:
if self.method != 'GET' and self.method != 'POST' and self.method != 'HEAD' and self.method != 'PUT' and self.method != 'DELETE':
    if host not in http.dns:
        http.dns[host] = list(set(http.dns_resolve(host)))
    need_forward = True
非 Python 程序员也应该很容易读懂这段代码,不过要提醒一下:Python 中缩进是很关键的,改代码时一定要用空格正确地缩进。
最后,别忘了把下面那个原来的 if 改成 elif。

这样改过之后的 GoAgent 客户端,在遇到 GAE 服务端不能处理的那些 HTTP 请求类型时,就会把它们直接发到目标服务器上。
从理论上讲,这个小修改不会对 GoAgent 的翻墙能力有任何的增加,但可以让它具有更大的适用范围。一些原来不能用 GoAgent 访问的站点(比如上面提到的 Mega),现在可以用它来访问了。GAE 的流量按天计算(VPN 一般按月,VPS 也是)。并且因为可以使用多个 GAE 账号,因此流量基本上是免费且无限的。Mega 那 50GB 的大空间,终于具有一定的可用性了。

2013-03-21

如此错误检查,还不如不要

今天在查一个 Bug。表面现象很奇怪,至少让测试组觉得很奇怪。故障现象是这样的:
有一个列表框,如果里面只有两条记录,那么没事。如果有三条以上的记录,那么在删除记录时会「随机」出现程序无响应的情况。

上面这段错误描述中,「随机」二字之所以打引号,是因为其实不是随机的。只是测试组的同事没有找到规律而已。只要按从下到上的顺序进行逐个删除,就很容易遇到故障。

这种现象,有经验的程序员一看就知道跟序号、数组之类的东西有关。
果不其然,在代码中我找到了这样的一段:
pItem = ListView->Selected;
for (; pItem != NULL;)
{
    int iWhich = (int*)pItem->data;
    if (iWhich >=0 && iWhich < ItemArray.GetSize())
    {
        ItemArray.RemoveAt(iWhich);
        ListView->Delete(pItem->Index);
    }
    pItem = ListView->Selected;
}

这里解释一下,ListView->Selected 能拿到列表内当前选中的第一行,而 ItemArray 是一个项目组自己实现的数组对象。这两个东西都没啥毛病。

坑爹的代码就是这一句:
if (iWhich >=0 && iWhich < ItemArray.GetSize())
我能理解,写的人是想把iWhich的取值限定在某个区间。因为这个 iWhich 接下来会被用作数组下标。如果越界,后果不堪设想。有这个意识,是好的。
但是,仅仅意识到这个问题,还不够。接下来还有问题了:iWhich 会越界吗?什么情况下会?

我相信,如果写这段代码的人当时有问过自己这个问题,那么就不会有这个 Bug 了。
这个 iWhich 来自一个 pItem->Data,这是一个 ListView 行对象附带的 DWORD 类型的数据,其值是由使用者(程序员)赋值的。
也就是说:如果你给它正确赋值,那么就不会有不正确的值出现。如果它有问题,那么是你前面的程序造成的。

也许还是有程序员会担心,这个 pItem->Data 会不会什么时候被改掉。也可能赋值的地方是另一个程序员写的。而写这段代码的程序员出于防御性编码的目的,写下了这样的判断。那么 OK,没有关系,判断就判断吧。可是判断为 FALSE 的时候怎么办呢?
他什么都没有做。

其实,判断为 FALSE 之后,从 ListView 中删掉这一行,应该是安全的。从上面的代码中可以看出,删除行的时候,只用到了 pItem->Index。这是由操作系统自行维护的值,不会存在 Data 那种「可能没有正确赋值」的情况。
又或者,实在不放心,那么直接把整个函数 return 掉,甚至报个错,也是可以的。
现在的处理方式就直接导致了死循环。这是很糟糕的情况,单核机器的用户甚至可能会几乎没有机会来做什么处理。

好了,上面这些就是我这篇博文想说的:有防御性编码的意识,很好!但是处理方式也要正确有效。你不应该在避免一个错误的同时,引入另一个错误。

那么,最后还有个遗留问题:iWhich 为什么会越界呢?
我想,对于合格的程序员,这个问题不应该成为问题。所以我就不说了。

2006-12-17

日记2006.12.17

Chapter One

两点多才起来,真不知咋这么能睡……

Chapter Two

继续昨天的工作。

加上了胜负判断,过关 / 难度升级,必要信息显示以及横向合并,在最后加上炸弹功能之后,现在的游戏功能和手机上那个已经一致了。积分排行榜还没有做。要做也很简单,不过因为这个需要保存信息在硬盘上,所以打算和游戏进度存取的功能一并实现。

没有动画,所以游戏效果并不让我满意。GDI 要做动画也不是不可能,但是实现机理和 DirectX 版的有所不同,而且因为没有离屏缓冲,闪烁是很难避免的,我还不如直接做 DirectX 版本了。

因为许可证还没有决定,也因为动画这个原因,所以就暂时不发布了。

Chapter Three

下午大舅来访,因此「钻石飞扬(GDI)版」简单包装了一下就算了结了。等我复习一下 DirectX 再继续下个版本吧……

大舅感冒了,在我家里鼻子轰轰作响,后来又发起了烧,外婆担心得要死。不过还好刚刚打电话来说已经平安到家了。

在此也提醒各位,特别是漂流在外的各位,没有家人在身旁,更要格外注意身体哟!

日记2006.12.16

Chapter One

11 点半起来看球,为打了两个加时而激动不已,不过还是输了,挺扫兴的。正如我在姚明论坛上所说:大周末的,咋就不让人舒心一回呢?

Chapter Two

本来是打算出去逛逛的,但看完球已经快下午三点了。趁今天阳光不错,洗了个澡。最近洗澡真是越来越像过节了。

Chapter Three

五点多,已经没办法再出去了,索性做正事。

N-Gage QD 上有个小游戏叫「钻石飞扬」。表姐去年春节时玩过之后,一直念念不忘。不过PC上一直找不到类似的游戏,有一次找到一个 Flash 的,但做得很初级也很简陋。看到它,我说,还是自己做一个吧,可能都要好看一点点。

今天就开始做了。有段时间没有用 VC 了,居然在预编译头的问题上卡了一下。不过确实也是以前没有遇到过的,明天抽空说一下。

小游戏,想先看看算法的效果,偷懒用 MFC 的向导生成了一个 SDI 的框架。拿 GDI 在客户区简单画了一个界面,然后就开始搭建数据结构。考虑过一段时间了,但是并没有认真写下来,只是想想,因此还是不太满意。OO 的程度还不够充分,打算下次套 DirectX 的时候顺便把 CDiamond 再丰满一些起来。算法倒也顺利,一个深度优先的递归寻路,一个 O(n) 的下坠算法,都还挺简单也挺满意。横向合并和炸弹明天再做了,现在框架已成,加上输赢判断和记分规则就可以玩了。

还没想好用什么许可证发布,做好再说吧。

2006-11-19

日记2006.11.19

Chapter One

又是一个梦。前所未有的清晰,估计是因为快醒时的缘故。
都说梦是反的,那我岂不是该郁闷了?

Chapter Two

家里洗衣机也不正常。早期的全自动,十多年的机龄了。照我的意见,统统都要换掉。
没法,内衣、小件自己手洗,大件就丢给老妈拿洗衣机洗了。

Chapter Three

升级了财智理财到最新的 5.20 版,然后去买了正版。又一个绑定机器码的 ShareWare,等我要离开重庆时又得找对方更换注册信息了。

新版还不错,虽然仍旧比较杂乱。金融的东西那么多,能化繁为简确实是一件比较困难的事情。比较关注的亮点,都得到了比较不错的改进。曾经问题很大的物品(固定资产)管理,现在可以比较清楚了。于是马上对自己的物品进行了整理和清算,帐面上资产量下降了不少。基金管理也总算走上正轨了。虽然仍旧没有输入货币型基金的资料,但是结合允许为 0 的费率以及基金的分红再投资功能,自己录入代码的货币基金也运行得相当良好。

对这半个月来的帐目进行了核对,居然只有 ¥3.50 没有主,超出了我的预期。

Chapter Four

准备把以前写了一大半的那个游戏修改器给予彻底的完成。程序代码已经不打算改动了,自从 Windows 2000 下窗口移位的bug被修正了之后,就没有什么需要改动的地方。但是武器库的图片和介绍都只完成了一小半,因此这次的任务就是要把它们补齐。

两个原因。一是受了前两天下载的 Diable II 1.10 修改器的刺激。一个 180KB 的修改器,居然做得好像游戏一样,像模像样的。二是看过了几个军事题材的电子期刊之后,对战争机器们又有了点兴趣。

只增加图片、文字资料,似乎不是什么大问题。因此打算把图片拿 JPEG 压缩了之后再放在资源 DLL 中。至于 JPEG 算法,不打算采用现成的 DLL 或控件,而打算从 IJG Library——Independent JPEG Group's Library,即 Linux 下 libjpeg 的源代码下手。看过 IJG 的说明,提到有给 VC 用的 Makefile,因此把说明书打印了出来,装订好,准备这段时间研究一下。

2006-09-05

CVS 还是 VSS?

上个月安排一个手下去研究 CVS,研究完后给大家做培训。培训时间就在今天上午,因此今天上午早早地就去了。

听过之后,感觉 CVS 对于我们现在的情况可能并不是一个很合适的解决方案。它的特点是对源代码的管理能力比较强,支持代码冲突合并,而锁定机制被弱化。它假定代码冲突一定会存在,并把处理的责任扔给开发人员。

我想,对于一些 CVS 应用得比较好,或者说比较合适的场合,多是 Commit 和 Update 的角色分工比较明确。简单地说,适合用于分发、共享代码,而不是协调一个小组的内部成员的工作。一个小组的内部成员,工作角色很可能是平等的。大家都有修改代码和获取新代码的需求,也就是说都在自由地,而且很可能是频繁地 Commit 和 Update。那么代码冲突发生的机会太大了,这样做成本可能会很高。可能需要每个人花不少时间去核对自己的代码和别人代码的不同之处,甚至可能需要一个「仲裁者」。虽然可以通过人为规定来减少冲突的发生,不过那样就和我上版本控制系统的初衷相悖了。

于是决定还是使用 VSS 来完成版本控制的功能。这样起码只要规定每个人要获取代码只能从 VSS 来 CheckOut 就可以了。

2006-08-22

作为管理者的感慨

今天分派了三个任务给手下完成。编写任务说明书就花了一个上午外加二十六分钟,足以可见,沟通和管理的成本也是不便宜的。

我的管理,应该还算因人而异了。如果是能够独当一面的人才,我就把一件囫囵任务交给他,让他自己去做,自己去分析,自己去安排开发计划,让我过目一下就可以。如果是有潜力的新人,我会逐步放手,先给他做切分得很 Clear 的任务,然后慢慢减少自己干预的程度。如果是已经被证明了只能完成那种交待得很清楚的任务的手下,那么我会把工作安排成一系列简单明了的指令,明确他要做什么,像个 Sergeant。

低于这最后一个档次的手下,我认为就是不合格的了。下午的时候,老板的司机让我和门口一个「小孩」谈谈,说看看他水平如何,能不能在这里跟着干。坐下,问他软件开发方面的能力怎么样,直接回答说:「能力很糟糕。」小吓了我一跳,我想,他不是极度不自信,就是心态叛逆。再问下去,原来只会 VB、DELPHI 一类的快速开发工具,而且并没有什么实际的作品。电大刚毕业,这种专业水平也属正常。但我看他自信实在是缺缺,而且沟通方面也问题多多,——几次误解我的意思,口齿也不甚清楚。看来的确不是一个合格的人才。

想想真是可惜,这两年来我带过六个手下,先后走了三个。其中两个是花了比较大力气培养起来的 Lotus 工程师,这也导致了如今我手中这一部分工作无人接手。但我今后并不打算培养这方面的人才。毕竟时过境迁,这种过时的东西就让它过去吧,不想再误人子弟了。只是,其中有一个人天赋真的不错,却因为得不到合理的待遇而不辞而别。而别的部门因为这样的原因毅然走掉的人也不在少数。按照上头的说法:「铁打的营盘流水的兵」。黎叔的「二十一世纪什么最贵?人才!」似乎也只是一句台词。我能做到的,只是尽量让自己的手下能多学东西,每天过得充实、有兴趣,工作安排上「喂饱」他们,让他们有足够的成就感。不过,终于,这些快要与我无关了。

新找的工作,估计一开始是不会让我带人的,只可能别人带我,我想这方面我也得去适应。当然更可能是让我自生自灭,这个我倒是有相当的把握。不过,有人可以指挥时,效率明显会不同。即使手下们能力都不如我,但一个好汉三个帮,众人拾柴火焰高。今年的两个毕业生到位之后,一些堆积了很久都没法去处理的问题立刻得到了解决。这从某个方面也说明了「多线程并发」的重要性。

无所谓,我对于能不能担任管理岗位也没有什么要求。既然过去的经历已经证明我至少是个合格的管理者,相比起来,我更喜欢作一个纯技术人员,因为这样可以少长几根白头发。

2006-06-29

《C Traps & Pit Falls》读后偶感

内容有点旧,不过看过之后还是有一些收获。

其中有一段很有趣的回忆:

……我还记得自己在开发某个系统时,曾经与一个用户有过这样一场对话:

「这部分记录中可能出现的代码有哪些?」 「可能的代码是 X、Y 和 Z。」
「如果与 X、Y 和 Z 不同的代码在这里出现,该怎么办呢?」
「这不可能发生。」
「嗯,但如果这种情况确实发生时,程序需要做些适当的处理。你认为程序应该做些什么呢?」
「这个我可不关心。」 「你真的不关心?」 「对。」
「那么,如果程序在检测到不同于 X、Y 和 Z 的代码出现时删除整个数据库,你也不会介意吗?」
「太荒唐了。你绝对不能删除整个数据库!」
「那就是说,你还是介意程序在这种情况下的行为。那么,你希望程序做些什么呢?」

……

看到这里,忍不住直想发笑。昨天我还遇到类似的对话来着。美国人就是会搞笑,我当时怎么没有想到这样幽他们一默呢?