免费亚洲一区二区,黄色影院成人,裸体歌舞表演一区二区

溪流 — Sat, 05 Nov 2022 18:05:00 GMT

背景

事情的�v因是�Q�想找个�?Windows �?Mac 的构建方案。第一考虑自然�?CMake�Q�毕竟基本上是事实标准了�?/p>

但是研究了一�?Modern CMake�Q�也��是�?target 为核心的理念。但发现看了好几天文档，也折腑և�了可用的东西�Q�但仍然是没梳理清楚什么理��c��原理。然�?CMake 本��n语法��很复杂�Q�再加上�?target 一套概念，要给 target 讄��各种属性之�cȝ��Q�有点强�?OOP 的感觉……但其实我们只是需要一�?include_dir �?lib_dir 而已�Q�其他都是��Q云~

但如果退回到传统模式�Q�不�?Modern 概念呢，好像可以��就�Q�但�W�一不去用一个工��L��最新模式，好像有点不上�q�的感觉�Q�python 2 除外�Q�；�W�二�Q�CMake 的两大痛点——语法特立独行、文档晦涩难懂——还是让人有点不爽�?/p>

那蟩出来看别的选择呢？目前相对成熟的也只有 Google �?gn+ninja �Ҏ��了。gn �q�套东西�?Chromium 里是完全配置好的�Q�用��h��q�算��手�Q�但要是独立拿出来呢�Q�就没那么便宜了。关键是它的 toolchain 是要自己定义的�?/p>

之前�q�在公司搞客��L��的时候，大家��׃�� Chromium 里面�?build、build_overrides �{�等东西全部拷出来，好家伙，几百 MB 甚至�?G。但是公叔R��嘛，没�h��干不干净�Q�怎么快怎么来。后来又看到 Google 自家�?Crashpad 里面也用了这套构建，但工具链被简化了一下，�?mini_chromium。这个比 Chromium 里的��多了，是可以拿�q�来直接用的�Q�缺��一些配�|�可以自己加。但是呢�Q�像我们�q�种�z�癖�Q�仍然是受不鸟的。所以呢�Q�我们要�q�干净净的徏立一套工具链�?/p>

构徏�pȝ��安装

首先�Q�我们明��定位。gn �?ninja 都是开发机上需要预装的�Q�不是��Y件提供的。Chromium 的搞法是自己提供�Q�gn 的文档也说让开发者提供工兗��但�q�套思�\跟传�l�的理念是冲�H�的。同�Ӟ��自己安装工具成本是比较低的：

linux
- ninja 在主��包��理�pȝ��里已�l�有了，包名可能�?ninja �?ninja-build�Q�直接安装就可以
- gn 在部分包��理�pȝ��有，��试包名 gn �?gn-build �{�，没有的话可以下蝲二进制版�?/a>�Q�或者从源代码自行编�?/li>

mac
- gn �?brew 里没有，可以下蝲二进制版�?/a>�Q�在 MacPorts 里叫 gn-devel

win
- ninja 可以�?GitHub 下蝲二进制版本，gn 可以�?gn 官网下蝲二进制版�?/a>

自己下蝲的设�|�到 PATH�Q�测�?gn --version 以及 ninja --version�Q�能�q�行卛_��

目标

希望做到提供一�?git repo�Q��用�?clone 到自己项目的 build 目录�Q�然后��用者只要在 .gn 文�g里配�|?/p>

buildconfig = "//build/BUILDCONFIG.gn"

��可以��用我们提供的工具链，�?PC 三端�q�行构徏�?/p>

使用者的唯一负担��是�~�写自己�?BUILD.gn

工具链搭�?/h2>
首先我们�?gn 的文档，以及它的例程 simple_build 里的工具��N��|�：

https://gn.googlesource.com/gn/+/HEAD/examples/simple_build/build/toolchain/BUILD.gn

�q�个是可以直接用的，只不�q�只�?linux 端（当然 mac 也能用）。我们再�l�合 chrome 里的工具��N��|�，�q�行一些完善�?/p>

基础概念

首先我们了解 gn 体系需要的最��配�|�是什么�?/p>

�W�一�Q�它需要在根目录写一�?.gn 文�g�Q�在里面定义 buildconfig�Q�指到另一个文�Ӟ��一般是

buildconfig = "//build/BUILDCONFIG.gn"

�W�二、BUILDCONFIG.gn 里面需要设�|�默认工具链�Q�也��是写一�?/p>

set_default_toolchain("//build/toolchain:gcc")

�W�三、定义工具链�Q�如上例�?//build/toolchain:gcc�?/p>

需要在 build/toolchain 下徏�?BUILD.gn 文�g�Q�内�Ҏ��

toolchain("gcc") {
	# ...
}

最后在 toolchain 里定义各�U?tool�?/p>

工具链中的工�?/h3>

�q�部分文档在�q�里�Q�https://gn.googlesource.com/gn/+/main/docs/reference.md#func_tool

��单复�q�C��下，可被定义的工��h��Q?/p>

�~�译工具:
"cc": C �~�译�?br /> "cxx": C++ �~�译�?br /> "cxx_module": 支持 module �?C++ �~�译�?br /> "objc": Objective C �~�译�?br /> "objcxx": Objective C++ �~�译�?br /> "rc": Windows 资源脚本�~�译�?br /> "asm": 汇编�?br /> "swift": Swift �~�译�?/li>
链接工具:
"alink": 静态库链接�?br /> "solink": 动态库链接�?br /> "link": 可执行文仉��接器

�Q�其他的��先不看了）

我们来看一�?https://gn.googlesource.com/gn/+/HEAD/examples/simple_build/build/toolchain/BUILD.gn 的一些关键配�|�：

toolchain("gcc") {
  tool("cc") {
    command = "gcc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
    outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
    # ...
  }
  tool("cxx") {
    command = "g++ -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
    outputs = [ "{{source_out_dir}}/{{target_output_name}}.{{source_name_part}}.o" ]
    # ...
  }
  tool("alink") {
    command = "rm -f {{output}} && ar rcs {{output}} {{inputs}}"
    outputs = [ "{{target_out_dir}}/{{target_output_name}}{{output_extension}}" ]
    # ...
  }
  tool("solink") {
    command = "g++ -shared {{ldflags}} -o $sofile $os_specific_option @$rspfile"
    outputs = [ sofile ]
    # ...
  }
  tool("link") {
    command = "g++ {{ldflags}} -o $outfile -Wl,--start-group @$rspfile {{solibs}} -Wl,--end-group {{libs}}"
    outputs = [ outfile ]
    # ...
  }
  tool("stamp") {
    command = "touch {{output}}"
  }
  tool("copy") {
    command = "cp -af {{source}} {{output}}"
  }
}

可以看到�Q�cc �?cxx 执行 command 后，生成 .o 文�g�Q�然后这�?.o 文�g可以作�ؓ alink、solink、link �?inputs�Q�被它们 command �l�箋使用�Q�最后输出静态库、动态库以及可执行文件�?/p>

其余属性可以查文档了解含义�?/p>

�Ҏ�� Chromium 中的配置

Linux

主要配置在这里：https://source.chromium.org/chromium/chromium/src/+/main:build/toolchain/gcc_toolchain.gni

也是 gcc 的，�?simple_build 里的大同��异�Q�没有特别的�?/p>

Mac

主要配置在这里：https://source.chromium.org/chromium/chromium/src/+/main:build/toolchain/apple/toolchain.gni

区别有：

�?clang �p�d��~�译工具�Q�而不�?gcc
alink 不是�?ar�Q�而��?libtool
solink 的默认扩展名�Ҏ��?dylib
用了一�?linker_driver.py 来支持生�?dSYM�Q�在里面调用�?dsymutil �?strip

Win

�~�译�?cl�Q�静态库链接�?lib�Q�动态库和可执行文�g的链接用 link
lib_switch = ""�Q�lib_dir_switch = "/LIBPATH:"�Q�前两�?lib_switch = "-l"�Q�lib_dir_switch = "-L"

建立我们的工具链

基本上是�Ҏ��上面分析的要炚w��|�，最�l�结果在此：https://github.com/Streamlet/gn_toolchain

新增的一些差异有�Q?/p>

增加全局参数 is_debug�Q�可以在 gn gen out --args="is_debug=true"传入。默�?is_debug �?false�Q�开启所有优化�?/p>
mac 下生�?dSYM 不��?python 脚本�Q�直接是 $ld ... && dsymutil ... && strip
mac 下加了一�?template�Q�app_bundle�Q�用来生�?xxx.app�Q�主要配�|�来自于 create_bundle 文档里的例子
win 下增加了一些配�|�集
- 动�?静态链�?CRT�Q?/build/config/win:console_subsystem�?/build/config/win:static_runtime
- 控制台程序、Win32 �E�序�Q?/build/config/win:console_subsystem�?/build/config/win:windows_subsystem
  
  �q�个其实一般情况下用不着�Q�只要入口函数是 main/WinMain�Q�link 默认��是控制台程�?Win32 �E�序
- XP 支持�Q?/build/config/win:console_subsystem_xp�?/build/config/win:windows_subsystem_xp
  
  具体实现是链接参数加 /SUBSYSTEM:CONSOLE,5.01 �?/SUBSYSTEM:WINDOWS,5.01。关键是后面的版本号 5.01�Q��ؓ了加版本号则必须指定子系�l�名�U�ͼ�所以分�?console_subsystem_xp �?windows_subsystem_xp。又�Q�xp �q�里提供了两�?subsystem 的配�|�集�Q�非 xp 也提供两个�?/p>
  但是我们没有�?_WIN32_WINNT=0x0501、WINVER=0x0501、_USING_V110_SDK71_�Q�也没有指定必须使用 7.0 版本�?SDK�Q�这些都是非必须的，只要不用�?XP 以后��d��?API 卛_��。��用者可以在自己�?target 里面定义�q�些宏�?/p>

使用案例

提供一个��用案例：https://github.com/Streamlet/gn_toolchain_sample

因�ؓ它以 git submodule 形式引用�?https://github.com/Streamlet/gn_toolchain�Q�所�?git clone 以后�Q�需�?git submodule update --init一下�?/p>

然后在根目录执行�Q�（��保 gn �?ninja 已经�?PATH 中）

gn gen out
ninja -C out

卛_��?/p>

Mac 下会额外生成一�?objc ��目 objc_console_application 以及一�?app_bundle�Q�ns_application.app�?/p>

Win 会额外生成一�?Win32 ��目 win32_application�?/p>

Win 下需要先执行一�?Visual Studio 带的命��o行环境，�?VS 2022 Community �?“x64 Native Tools Command Prompt for VS 2022”，cl �{�工��h��会可用�?/p>

如果要测�?XP�Q?2位）�Q�用“x86 Native Tools Command Prompt for VS 2022”进入，CD 到项目目录，执行�Q?/p>

gn gen out --args="target_cpu=\"x86\""
ninja -C out

�ȝ��

我们只用几十 KB 的大��完成了跨端支持�Q�是很轻量的一个配�|�。如果您觉得实用�q�认可这�U�方式，�Ƣ迎一��h��l�护、完善�?/p>

溪流 2022-11-06 02:05 发表评论

微��Y拼音长句模式恢复工具支持Win10 1803

溪流 — Sun, 20 Sep 2020 05:53:00 GMT

4月䆾��有人留�a�旧微软拼��x��复工具不支持Win10 1803了，我自�׃��遇到了，但因为没旉��搞，勉�ؓ光��使用了词�l�模式的微��Y拼音几个月，�l�于在八月䆾抽个�I�研�I�了下，解决了�?/p>

�q�次是因为傻逼大微��Y改了 System32\IME\shared 里的东西�Q�导致旧�pȝ��拯��来的文�g�?System32\IME\shared 的东西不兼容了。解��x��式很暴力�Q�从以前的版本复�?System32\IME\shared �q�来�?/p>

下蝲�Q?a >https://www.streamlet.org/software/mspyforever/

�Q�原发于 GitHub Pages�Q?018-10-13 13:36:04�Q?/p>

溪流 2020-09-20 13:53 发表评论

溪流 — Tue, 25 Mar 2014 17:10:00 GMT

�Q�cnBeta�Q?a title="http://www.cnbeta.com/articles/277936.htm" target="_blank">http://www.cnbeta.com/articles/277936.htm�Q?/p>

首先贴个图，大家来一起念台词~

念完了木有？很激情澎湃义愤填膺有木有�Q?/p>

�q�事情最早追溯到前年 8 月的一��文章�?a href="http://www.shnenglu.com/Streamlet/archive/2014/02/17/188249.html" target="_blank">十个步骤扑֛� Win8 中的微��Y拼音��C��验模�?/a>》，其实��是手工注册一个COM完事�Q�只是傻逼大微��Y��L��弄了注册表权限来屏蔽�Q�操作�v来略微繁琐。到目前为止�Q�Win8重装�pȝ��已经不下十次了，每次都是�q�样手工操作�Q�我已经厌倦了�?/p>

另外�q�有Win8.1上的问题�Q�由于傻逼大微��Y已经完全删除了文�Ӟ��没法这么搞了，��q��从Win8拯��文�g来，也无法简单注册��用。加上我�?.1非常非常不感冒，一直没�ȝ��I�。前些天看到之前的那��文章里 Charles Leigh 回复了两��文章（ePig 那篇是原创吧貌似�Q�感谢）�Q�提供了解决�Ҏ��。于是上个周末到现在��捣鼓个一键恢复工��P��方便自己以后重装用，也方便广大微拼党�?/p>

微拼党（包括我）孜孜不倦的�q�求微拼长句模式的情怀�Q�让我非常感动。希望傻逼大微��Y看到我们的心声。别搞什么破词组输入法了�Q�你搞不�q�本土这么多厂家的，你的下限也没有本土厂家低�Q�唯一的优势可能就是没�q�告没弹�H�了吧。至于输入算法什么的�Q�在词组模式里面�Ҏ��不��以体现得太多�Q�长句模式才是考验啊。回头吧�Q?/p>

下蝲��面�Q?a title="http://www.streamlet.org/Software/MSPYForever/" target="_blank">http://www.streamlet.org/Software/MSPYForever/

CodePlex ��目��面�Q?a title="https://mspyforever.codeplex.com/" target="_blank">https://mspyforever.codeplex.com/

请微拼党们多传播。有 Bug 及时反馈�?/p>

溪流 2014-03-26 01:10 发表评论

溪流 — Mon, 24 Jun 2013 16:18:00 GMT

摘要: Timer�q�玩意儿很常用，却又很烦人。烦��Z��处有四： 1. 如果��其讑ֈ�HWND上，�?a) 必须手工�l�护Timer的ID�Q�小心翼��地保证�q�些ID不重复，可能有�h�Q�比如我�Q�就不怎么喜欢手工�l�护��编码的ID�?... 阅读全文

溪流 2013-06-25 00:18 发表评论

裸写一个进�E�外 COM �l��g

溪流 — Sun, 02 Dec 2012 11:56:00 GMT

摘要: 引言前面九月份的八篇关于COM的文章，说的都是�q�程内COM。那�Ӟ��我们从一个含内嵌IE控�g的窗口说��P��Ҏ��COM协议手工书写了进�E�内COM�l��g�Q��ƈ由此�U�篏了一些类似ATL的框架性代码�? 今天开始，我们把脚步迈向进�E�外�l��g。同��h��从最基础的开始，本篇我们��根据进�E�外COM�l��g的加载规范手工编写一个EXE�Q�然后用标准的COM调用�Ҏ��来��用它。之前积累的框架性代码不属于�W�三方库�Q�所以这�?.. 阅读全文

溪流 2012-12-02 19:56 发表评论

溪流 — Thu, 20 Sep 2012 16:34:00 GMT

摘要: 引言在上一��《在 DLL 中加入第二个 COM �c�R��的“单用户注册”一节中�Q�我们曾提到��q��注册表依赖一事，现在我们来把�q�事儿给办了�? 注册我们在之前支持了“regsvr32 /n /i:user COMProvider.dll”这一注册命��o。这一注册命��o�l�了我们一定的扩展余地。从ATL默认的代码来看，对于DllInstall�Q�目前已定义的命令行参数��g��只有user�Q�于是我们可以定... 阅读全文

溪流 2012-09-21 00:34 发表评论

溪流 — Tue, 11 Sep 2012 16:23:00 GMT

摘要: 引言在前面几��文章里�Q�我们已�l�成功脱��ATL写了一个COM�l��g�Q��ƈ且实��C��自动化。今天，我们来加入第二个�c�，�q�且为加入第二个�c�d��一些整理工作�? 为DLL建立一个Module�c?在前面，我们��Z��使得DllCanUnloadNow能正��工作而放了一个全局变量LONG g_nModuleCount�Q��ƈ且在SampleClass的构造函数和析构函数里对它进行自增和自减。另外还有个IType... 阅读全文

溪流 2012-09-12 00:23 发表评论

让COM�l��g可被跨语�a�调用

溪流 — Sun, 09 Sep 2012 04:43:00 GMT

摘要: 错误修正首先修正一下上��（《裸写一个进�E�内 COM �l��g》）中的例子的一个小问题。类厂的CreateInstance里面�Q�上�ơ是�q�么写的�Q? STDMETHODIMP ClassFactory::CreateInstance(_In_opt_ IUnknown *pUnkOuter, &nbs... 阅读全文

溪流 2012-09-09 12:43 发表评论

裸写一个进�E�内 COM �l��g

溪流 — Thu, 06 Sep 2012 16:23:00 GMT

摘要: 引言前几天山寨了ATL的COM_INTERFACE�Q�了解了一个COM�cȝ��如何�q�行通用的组�l�。今天再来学习下COM协议�Q�看看如何实��C��个COM�l��g——当�Ӟ��也是不能用ATL的，不然��学不到什么了�? COM DLL说简单简单，说复杂也很复杂。说��单呢�Q�其实貌似只要导��Z��面这五个函数��可以了�Q?DllCanUnloadNow DllGetClassObject DllRegisterSe... 阅读全文

溪流 2012-09-07 00:23 发表评论

溪流 — Tue, 04 Sep 2012 14:16:00 GMT

摘要: 在上一��中�Q�我们实��C��COM_INTERFACE宏，�q�且重新写了一个含有WebBrowser的窗口。在那里我们留了中间层OleContainer。�ؓ了验证OleContainer的可用性，现在来写一个含有Windows Media Player�Q�下文简�U�“WMP”）控�g的窗口�? WMP控�g的容器类除了IOleClientSite、IOleInPlaceSite、IOleInPlace... 阅读全文

溪流 2012-09-04 22:16 发表评论

山寨一�?ATL �?COM_INTERFACE

溪流 — Mon, 03 Sep 2012 15:17:00 GMT

摘要: 上一��我们简单学习了下ATL 的��扉K��处理。可是，如果要裸写一个含内嵌IE控�g的窗口，�q�是要写一个很长的QueryInterface�Q�以及AddRef和Release�Q�确保引用计数的正确性。于是我们不得不参考ATL的COM_TNTERFACE的处理技巧，来达��C��定程度上的易用性�? 首先�Q�除了IUnknown以外�Q�其余所有涉及到的接口，均按上一��的形式�Q�弄成相应的IXXX... 阅读全文

溪流 2012-09-03 23:17 发表评论

学习�?ATL 的��扉K��处理

溪流 — Sun, 02 Sep 2012 05:56:00 GMT

摘要: 我们先来看一�l�接口定义： struct IX { virtual void MethodX() = 0; }; struct IXA : public IX { virtual void MethodXA() = 0; }; struct IXB : public IX {... 阅读全文

溪流 2012-09-02 13:56 发表评论

初步性能��试

溪流 — Wed, 13 Jun 2012 15:00:00 GMT

因�ؓ接下去要做优化工作，在此之前�Q�先做下��单的性能��试�?/p>

比较的对象是std::regex�Q�暂时只比较两项�Q?/p>

1、解析正则表辑ּ�的速度

2、��用解析好的正则表辑ּ��d��配字�W�串的速度�?/p>

��试代码如下�Q?span lang="EN-US">

SECTION_BEGIN(StdRegExParse100000);

PERFORMANCE_TEST_BEGIN(StdRegExParse100000);

for (int i = 0; i < 100000; ++i)

{

wregex r;

r.assign(L"http://([a-zA-Z0-9\\-]+.)+[a-zA-Z]+/");

}

PERFORMANCE_TEST_END(StdRegExParse100000);

SECTION_END();

SECTION_BEGIN(xlRegExpParse100000);

PERFORMANCE_TEST_BEGIN(xlRegExpParse100000);

for (int i = 0; i < 100000; ++i)

{

RegExp r;

r.Parse(L"http://([a-zA-Z0-9\\-]+.)+[a-zA-Z]+/");

}

PERFORMANCE_TEST_END(xlRegExpParse100000);

SECTION_END();

SECTION_BEGIN(StdRegExMatch100000);

{

wregex r;

r.assign(L"http://([a-zA-Z0-9\\-]+.)+[a-zA-Z]+/");

PERFORMANCE_TEST_BEGIN(StdRegExMatch100000);

for (int i = 0; i < 100000; ++i)

{

regex_match(L"http://w-1.w-2.w-3.streamlet.org/", r);

}

PERFORMANCE_TEST_END(StdRegExMatch100000);

}

SECTION_END();

SECTION_BEGIN(xlRegExpMatch100000);

{

RegExp r;

r.Parse(L"http://([a-zA-Z0-9\\-]+.)+[a-zA-Z]+/");

PERFORMANCE_TEST_BEGIN(xlRegExpMatch100000);

for (int i = 0; i < 100000; ++i)

{

r.Match(L"http://w-1.w-2.w-3.streamlet.org/");

}

PERFORMANCE_TEST_END(xlRegExpMatch100000);

}

SECTION_END();

前两则是分别使用std::wregex和xl::RegExp解析"http://([a-zA-Z0-9\\-]+.)+[a-zA-Z]+/"十万�ơ，后两则是拿来匚w��http://w-1.w-2.w-3.streamlet.org/十万�ơ�?/p>

�l�果如下�Q?/p>

匚w��速度差很多，解析速度差不多�?/p>

考虑到在解析�?”�?”�?”的时候，引入了很多ε边�Q�于是对那部分做点优化，去除不必要的ε边和节点构造，然后再测试：

可以看到有所提高�Q�但是解析速度�q�是跟std:wregex的差很多�Q�匹配速度有明��N��先。目前只解析到ε边�?NFA�Q�如果再做状态机转化�Q�虽然会提高匚w��速度�Q�可是解析速度会进一步下降。因此，一开始就要考虑使用一�U�更高效的状态机存储�Ҏ��?/p>

�q�两天着凉生病了�Q�好隑֏�啊…�?/p>

溪流 2012-06-13 23:00 发表评论

解析正则表达式（三）重复

溪流 — Fri, 08 Jun 2012 15:35:00 GMT

摘要: 引言 �Ҏ��预告�Q�这��我们对�?”�?”�?”进行处理，实现寚w��复的支持。“x?”匹�?个或1个“x”，“x+”匹�?��C�Q意个“x”，“x*”匹�?��C�Q意个“x”�? 有了重复�Q�就有贪婪模式和非贪婪模式。在贪婪模式下，“x+”匹配“xxxyyy”中的“xxx”；在非贪婪模式下，“x+”匹配“xxxyyy”中的第一个“x”。�ؓ了区别两�U�模式，按照通常的语法，我们在重复控制符号后面加一个�?... 阅读全文

溪流 2012-06-08 23:35 发表评论

解析正则表达式（二）字符集合

溪流 — Mon, 04 Jun 2012 14:19:00 GMT

摘要: 引言 �q�篇我们要实现的是中括号表达式�? 一个中括号里写上�Q意数目的字符�Q�表�C�匹配这些字�W�中的�Q何一个。比如“[abc]”匹配a或b或c。中括号里除了单个字�W�，也可以写字符区间�Q�比如“[a-c]”就表示从a到c的所有字�W�，�q�里“a到c”是指内码连�l�的一�p�d��字符�Q�包含首��a和c。综合�v来说�Q�中括号里面可以放�Q意个字符或者字�W�区��_��匚w��所填字�W�或字符区间内的��L��一个字�W�。比如“[acd-... 阅读全文

溪流 2012-06-04 22:19 发表评论

溪流 — Sun, 03 Jun 2012 07:16:00 GMT

摘要: 引言 ��x��正则表达式解析器好久了。前面由于一些基��设施没准备好�Q�没法开始动手。现�?xlLib 里头准备的差不多了，可以着手实施了�? 在做�q��g事之前，��M��好几�?@vczh 的文章《构造可配置词法分析器》《构造正则表辑ּ�引擎》（http://www.shnenglu.com/vczh/archive/2008/05/22/50763.html�Q�，�l�了很大的帮助和启发�Q�在�q�里表示感谢。（... 阅读全文

溪流 2012-06-03 15:16 发表评论

溪流 — Sun, 03 Jun 2012 07:16:00 GMT

溪流 2012-06-03 15:16 发表评论

溪流 — Sun, 03 Jun 2012 07:16:00 GMT

溪流 2012-06-03 15:16 发表评论

利用已有�?bind 构�?ScopeExit

溪流 — Sun, 20 May 2012 15:07:00 GMT

摘要: 对于 ScopeExit�Q�以前有提到�q�（见《这�U�代码结构如何组�l�？goto or do…while(0)�Q�》）。��用场景再��单提一下： bool GenFile() { HANDLE hFile = CreateFile(_T("Test.txt"), GENERIC_WRITE, 0, NUL, CREATE_ALWAYS, 0, NULL); ... 阅读全文

溪流 2012-05-20 23:07 发表评论

调用�U�定�ȝ��

溪流 — Fri, 11 May 2012 17:36:00 GMT

以前�?Function 的时候恰好取巧避免掉了，�q�些天在�?Bind�Q�不得已要把每个调用�U�定�|�列一遍。顺手把�q�些东西复习一下，�ȝ��如下—�?/p>

�Q�所有内定w��?VC �~�译�q�_��Q?/p>

一、x86

名称	传参方式	栈清�?/td>	C 语言函数重命名（例：int func(int, double)�Q?/td>
__cdecl	从右臛_��压栈	主调函数	前面加“_”（_func�Q?/td>
__stdcall	从右臛_��压栈	被调函数	前面加“_”，后面加“@”再加参数十�q�制字节敎ͼ�_func@12�Q?/td>
__fastcall	前两个不大于DWORD长度的参��C��左至叛_��别存�?ECX、EDX�Q�其余从双��左压�?/td>	被调函数	前面加“@”，后面加“@”再加参数十�q�制字节敎ͼ�@func@12�Q?/td>
__thiscall	ECX �?this�Q�其余从双��左压�?/td>	被调函数	仅用�?C++

二、x64

名称	传参方式	栈清�?/td>
__fastcall	前四个整�?��点数放�?RCX/XMM0、RDX/XMM1、R8/XMM2、R9/XMM3�Q�其余压栈�?br>如果�?4 个参数分别�ؓ int、float、long、double�Q�它们将分别被存�?RCX、XMM1、R8、XMM3	被调函数

64位编译环境下�Q�可以指�?__cdecl、__stdcall、__fastcall�Q�但是编译器会忽略它们。两个显�C�指定了不同调用�U�定的函��C��构成重蝲�Q�而构成重定义错误�?/p>

溪流 2012-05-12 01:36 发表评论

溪流 — Fri, 23 Mar 2012 01:53:00 GMT

�|�上的文章但凡有提到 static_cast、const_cast、reinterpret_cast、dynamic_cast 的，都会语重心长的说�Q�他们克服了 C 风格的类型�{换的�~�点�Q�应当��用它们�?/p>

可是�Q�C 风格的到底有什么坏处？C++的这�?cast 又有什么好处呢�Q?/p>

昨天以前�Q�我�q�这�?cast 是什么都不知道（很惭愧）。昨天因为同事们提到�q��g事，于是��小研究了一下。一些实验代码如下：

1、无�l�承的类型�{�?/p>

class A

{

};

class B

{

public:

operator A()

{

return A();

}

};

int main()

{

B b;

A a = (A)b; // 执行 operator A()

A a2 = static_cast(b); // 执行 operator A()

A a3 = dynamic_cast(b); // 不允�?/font>

A a4 = reinterpret_cast(b); // 不允�?/font>

A a5 = const_cast(b); // 不允�?/font>

return 0;

}

2、const_cast

struct A

{

int m;

A(int m = 0) : m(m)

{

}

};

int main()

{

const A a;

A a2 = (A)a; // 允许�Q?/font>(A) 有没有都一��P��a2 是个新变�?/font>

a2.m = 1; // a2 的改变不影响 a

A &a3 = (A &)a; // 允许

a3.m = 2; // 影响 a

// A &a4 = a; // 不允许，const 限定起作用了

A *pa5 = (A *)&a; // 允许

pa5->m = 3; // 影响 a

// A *pa6 = &a; // 不允许，const 限定起作用了

// A aa2 = const_cast(a); // 不允�?/font>

A &aa3 = const_cast(a); // 允许

aa3.m = 2; // 影响 a

A *paa5 = const_cast(&a); // 允许

paa5->m = 3; // 影响 a

const int i = 0;

const int &i2 = i;

const int *pi3 = &i;

// int j = const_cast(i); // 不允�?/font>

int &j2 = const_cast<int &>(i2); // 允许

int *pj3 = const_cast<int *>(pi3); // 允许

return 0;

}

从第1点的试验�Q�加上外界资料的说明�Q�看上去const_case 只允许具有不同cv限定�W�的同类型之间的转换�?

值得注意的是�Q�如果类型A不是指针或引用，不能使用const_cast�Q��用了也无意义�Q�见 A a2 = (A)a �q�一行）

�?const_cast 可以使用的情形，(T)value 形式都可以��用，(T)value 在功能上完全覆盖 const_cast�?

2、reinterpret_cast

class A

{

public:

operator int *()

{

return nullptr;

}

};

int main()

{

int i = 0;

double d = 1.0;

int *p = nullptr;

// int di = reinterpret_cast(d); // 不允�?/font>

int pi = reinterpret_cast<int>(p); // 允许

// int pi2 = static_cast(p); // 不允�?/font>

// double id = reinterpret_cast(i);// 不允�?/font>

// double pd = reinterpret_cast(p);// 不允�?/font>

int *ip = reinterpret_cast<int *>(i); // 允许

// int *ip2 = static_cast(i); // 不允�?/font>

// int *dp = reinterpret_cast(d); // 不允�?/font>

A a;

int *pa = (int *)a; // 允许

int *pa2 = static_cast<int *>(a); // 允许

// int *p2 = reinterpret_cast(a); // 不允�?/font>

return 0;

}

看上去，reinterpret_cast 可以理解为在指针和数��g��间�{换的一�U�方式，无关��M��q�算�W�重载，仅仅把指针�{为字面��|��或者把数字转�ؓ指针�Q��{换的�q�程中值没有�Q何改变，只是告诉�~�译器不要报�c�d��不匹配而已�?

另外�Q�在reinterpret_cast可以使用的情形，static_cast 是不可以使用的，除非定义了相应的�c�d��转换�q�算�W��?

�?reinterpret_cast 可以使用的情形，(T)value 的方式同样可以完全胜任，(T)value 在功能上完全覆盖 reinterpret_cast�?

dynamic_cast 我自认�ؓ�q�是理解的，��׃��试了�?

�l�g��Q�我的理解如下：

1�?/b>static_cast + const_cast + reinterpret_cast = (T)value

C++ 把原�?/b>C风格的的�q�三�?/b>cast拆分成了三个�Q�三者相互正交。大多数情况下，应该�?/b> static_cast 在取代着 (T)value�Q�只是在去除 cv 限定�W�的时候，换用 const_cast�Q�在取指针字面值的时候，换用 reinterpret_cast。类型�{换运��符 operator T() �?static_cast 负责执行�?/b>

2�?/b>dynamic_cast �?C++ 新增的，用于多态的情�Ş�Q�且只允许�{换具有多态关�pȝ��l�承树上的类型的指针和引用，不允许�{换类型本�w�。它不是针对 (T)value而出现的�Q�两者没有�Q何竞争关�p�，只是取决于不同的需求�?/b>

�Q�不知这��L��解是否正��，��h��评指正~�Q?

至于�|�上推崇用新写法�Q�是不是��Z��更细化而容易理解？有没有什么是 (T)value 做不到�?*_cast 能做到的�Q�或者反�q�来�Q?

溪流 2012-03-23 09:53 发表评论

��译一�?C++03 标准文档�Q?.10 左值和叛_��|��Q�请批评指正~

溪流 — Wed, 29 Feb 2012 14:50:00 GMT

3.10 Lvalues and rvalues [basic.lval]

左值和叛_�?/font>

1 Every expression is either an lvalue or an rvalue.

表达式不是左值就是右倹{�?/font>

2 An lvalue refers to an object or function. Some rvalue expressions—those of class or cv-qualified class type—also refer to objects. 47)

左值是指一个对象或者函数。某些右��|��那些带或不带cv限定�W�的�cȝ��型）也是对象�?/font>

3 [Note:
some built-in operators and function calls yield lvalues. [Example: if E is an expression of pointer type, then *E is an lvalue expression referring to the object or function to which E points. As another example, the function
int& f();
yields an lvalue, so the call f() is an lvalue expression. ] ]

[注意�Q�某些内�|�运��符以及一些函数调用会�q�回左倹{��[�?�Q�如�?E 是一个指针类型的表达式，那么 *E 是一个左��D��辑ּ��Q�指�C�指�?E 所指向的那个对象或者函数。例2�Q�函�?br>int& f();
�q�回左��|��所以函数调�?f() 是一个左��D��辑ּ�。] ]

4 [Note: some built-in operators expect lvalue operands. [Example: built-in assignment operators all expect their left hand operands to be lvalues. ] Other built-in operators yield rvalues, and some expect them. [Example: the unary and binary + operators expect rvalue arguments and yield rvalue results. ] The discussion of each built-in operator in clause 5 indicates whether it expects lvalue operands and whether it yields an lvalue. ]

[注意�Q�某些内�|�运��符需要左值操作数。[例：所有内�|�的赋��D��符的左操作数都必须是左倹{��] 有些内置�q�算�W�会�q�回叛_��结果，有些会需要右值操作数。[例：一元运��符�?”和二元�q�算�W��?”都需要右值操作数�Q��ƈ且返回右值结果。] 我们在条��?5 中会�Ҏ��有内�|�运��符�q�行讨论�Q�指出它们的操作数和�q�回�l�果是左��D��是右倹{��]

5 The result of calling a function that does not return a reference is an rvalue. User defined operators are functions, and whether such operators expect or yield lvalues is determined by their parameter and return
types.

调用�q�回��gؓ非引用类型的函数�Q�结果是叛_��{��用戯��定义的运��符也是函数�Q�这些运��符的操作数以及�l�果是左��D��是右��|��取决于（�q�算�W�重载）函数的参数和�q�回值类型�?/font>

6 An expression which holds a temporary object resulting from a cast to a nonreference type is an rvalue (this includes the explicit creation of an object using functional notation (5.2.3)).

寚w��引用�c�d��的�{换表辑ּ��Q�包括��用函数式的记可��行显�C�创建）是右��|��它将�q�回一个��时对象�?/font>

__________________
47) Expressions such as invocations of constructors and of functions that return a class type refer to objects, and the implementation can invoke a member function upon such objects, but the expressions are not lvalues.

有些表达式，比如调用构造函数的表达式，以及调用�q�回�cȝ��型的函数的表辑ּ��Q�它们也是对象，且可以对它们调用成员函数�Q�但�q�种表达式不是左倹{�?/font>

____________________________________华丽的分��늬�____________________________________

7 Whenever an lvalue appears in a context where an rvalue is expected, the lvalue is converted to an rvalue; see 4.1, 4.2, and 4.3.

如果在一个需要右值的场合出现了左��|��q�个左值将被�{换成叛_��{�?br>�?4.1�?.2�?.3�?/font>

8 The discussion of reference initialization in 8.5.3 and of temporaries in 12.2 indicates the behavior of lvalues and rvalues in other significant contexts.

12.2 中关于引用的初始化和关于临时对象的讨论，也指��Z��左右值在其他重要场合的行为�?/font>

9 Class rvalues can have cv-qualified types; non-class rvalues always have cv-unqualified types. Rvalues shall always have complete types or the void type; in addition to these types, lvalues can also have incomplete types.

�cȝ��型的叛_��可以具�?cv 限定�W�；非类�c�d��的右��g��能被 cv 限定�W�修饰。右值通常是完整类型或�?void �c�d��Q�而对于左值来��_��除了完整�c�d��?void �c�d��外，�q�可以是不完整类型�?/font>

10 An lvalue for an object is necessary in order to modify the object except that an rvalue of class type can also be used to modify its referent under certain circumstances. [Example: a member function called for an object (9.3) can modify the object. ]

通常情况下，如果要修改一个对象，它必��L��左倹{��但在某些特定的场合�Q�右值�Ş式的�c�d��象也可以被修攏V��[例：调用一个对象的成员函数�Q?.3�Q�，可以修改对象本��n。]

11 Functions cannot be modified, but pointers to functions can be modifiable.

函数�Q�对象）不能�Q�在�q�行�Ӟ��被修改，但是函数指针可以�?/font>

12 A pointer to an incomplete type can be modifiable. At some point in the program when the pointed to type is complete, the object at which the pointer points can also be modified.

指向一个不完整�c�d��的指针可能是可修改的。当�q�个被指向的�c�d��某时某刻成�ؓ完整�c�d��后，�q�个指针所指向的那个对象也是可修改的�?/font>

13 The referent of a const-qualified expression shall not be modified (through that expression), except that if it is of class type and has a mutable component, that component can be modified (7.1.5.1).

�?const 限定的表辑ּ�所对应的对象不能（通过该表辑ּ��Q�被修改�Q�除非这个对象是�cȝ��型�ƈ且含�?mutable 成员�Q�此时该 mutable 成员可以被修攏V�?/font>

14 If an expression can be used to modify the object to which it refers, the expression is called modifiable. A program that attempts to modify an object through a nonmodifiable lvalue or rvalue expression is illformed.

如果一个表辑ּ�可以被用来修�Ҏ��表达式对应的对象�Q�那么这个表辑ּ�被称为可修改的。企��N��过一个不可修改的左��D��右��D��辑ּ��M��改一个对象，是非法的�?/font>

15 If a program attempts to access the stored value of an object through an lvalue of other than one of the following types the behavior is undefined 48):
�?the dynamic type of the object,
�?a cv-qualified version of the dynamic type of the object,
�?a type that is the signed or unsigned type corresponding to the dynamic type of the object,
�?a type that is the signed or unsigned type corresponding to a cv-qualified version of the dynamic type of
the object,
�?an aggregate or union type that includes one of the aforementioned types among its members (including,
recursively, a member of a subaggregate or contained union),
�?a type that is a (possibly cv-qualified) base class type of the dynamic type of the object,
�?a char or unsigned char type.

如果�E�序通过下列�c�d��之外�c�d��的左��D��问一个对象的��|��其行为是未定义的�Q?/font>

——对象的动态类型；
——CV 限定的对象动态类型；
——对象的动态类型对应的有符��h��无符��L��型；
——CV 限定的对象动态类型有�W�号或无�W�号�c�d��Q?br>——一个成员中含有聚合或者联合类型的聚合或者联合类型（包括递归形式的定义以及成员中有子聚合�c�d��或者包含一个联合）
——对象的动态类型的基类�c�d��Q�可以被 cv 限定�W�修饎ͼ�
——char �?unsigned char �c�d��

__________________
48) The intent of this list is to specify those circumstances in which an object may or may not be aliased.
�l�出�q�䆾列表的目的是指明一些特定情形，在这些情形下对象可能被重叠，但也有可能不是，我们无法预知�?/font>

____________________________________华丽的分隔符____________________________________

以上�Q�求指正�Q�包括理解误区和语言�l�织不合理的�Q�欢�q�指出~ ^_^

溪流 2012-02-29 22:50 发表评论

溪流 — Tue, 12 Jul 2011 14:22:00 GMT

如题�Q�大致看了下�|�上能找到的一些规范，觉得大体有这么三个方面吧�Q�一个是排版斚w��的，一个是命名斚w��的，一个是书写逻辑斚w��的�?/p>
排版斚w��的大概有�Q�如何羃�q�，如何使用�I�格、换行，�{�等。命名方面的包括变量、函数、类、文件的取名�{�等。书写逻辑斚w��的就比较多了�Q�可能包括：
是否全面使用异常、出错处理资源清理如何组�l�、如何利用编译提�C�防止常见错误…�?/p>
一旉��列不全。网上常见的文档我会参考的。除此之外，想从大家�q�里征求下，以上几个大方面之外，�q�有没有比较重要的方面？大家日常工作中有没有遇到一些特别希望别��Z��使用和自�׃��L��方式做的事？以及�Q�哪些规定比较容易被推动�Q�哪些规定不�Ҏ��被推动？如果有一个规则强加在你头上，你会有怎样的心理？�{�等…�?/p>
如果您有��x��Q�请回复下，我们讨论讨论^_^

----------

��Z��再问个问题，Windows 上的开发，大家喜欢动态链�?CRT�Q?MD�?MDd�Q?�q�是静态链�?CRT�Q?MT�?MTd�Q�？��Z��么？个�h們֐�于哪�U�？在公叔R��又是怎样做的�Q?/p>

溪流 2011-07-12 22:22 发表评论

如何�?执行耗时��d��的、可随时立即退出的函数呢？

溪流 — Wed, 25 May 2011 16:36:00 GMT

如题�?/p>
�E�微解释下，因�ؓ有可能有��Z��误会�Q�放新线�E�里面去不就可以了？�q�没有解决问题。如此的话，你那个线�E�函数怎么写？或者线�E�函数里调用的某个�Q务函数怎么写？��M��Q�多�U�程虽然��L��出现在这些问题的解决�Ҏ��中，但不是多�U�程解决了这个问题。嗯……不知道说清楚了没？

目前我心里的�{�案只有�q�一�U�模式：

bool DoTask(HANDLE hQuitSignal)
{
    while (!QuitCondition)
    {
        if (WaitForSingleObject(hQuitSignal, 0) == WAIT_OBJECT_0)
        {
            return false;
        }

        // Do something
    }

    return true;
}

其中�Q��?/ Do something”部分要�l�化到瞬间执行完成的�l�度�?/p>
但是我很困惑的是�Q�如果这些�Q务很�J�重�Q�难道我必须每进行一些操作就 if (WaitForSingleObject(hQuitSignal, 0) == WAIT_OBJECT_0) ��查下吗？�q�样岂不是这�U�检��代码充斥在��d��中了�Q?/p>
不知各位有何�l�验和体会，求教~

溪流 2011-05-26 00:36 发表评论

一个简单的 Tuple 实现

溪流 — Thu, 28 Apr 2011 14:05:00 GMT

标题中说�?Tuple 是指�c�M�� boost::tuple �q�样的设施�?/p>
很多时候我们需要返�?传入一堆参敎ͼ�所以不得不每次定义一些�ؓ了数据传输的�l�构。Tuple ��是用来解决�q�一问题的，它提供即时构造一个这��L��l�构体的功能。而所付出的代��h��Q��失各个成员的明确含义�Q�只留下成员的序受��?/p>
两个元素�?Tuple ��是 Pair�Q�如 std::pair。下面我们来建立针对有限个元素的 Tuple。对于一个元素、两个元素、三个元素，我们可以分别如下实现�Q?/p>
template
struct Tuple
{
    T0 _0;
};

template
struct Tuple
{
    T0 _1;
    T1 _1;
};

template
struct Tuple
{
    T0 _1;
    T1 _1;
    T2 _2;
};

但是�q�三个写在一��P��׃��出错。�ؓ此，我们可以先定义一个含��_��多模版参数的 Tuple�Q�然后上面三个分别作为偏特化版本�Q?/p>
template
struct Tuple;

template
struct Tuple
{
    T0 _0;
};

template
struct Tuple
{
    T0 _1;
    T1 _1;
};

template
struct Tuple
{
    T0 _1;
    T1 _1;
    T2 _2;
};

如果手写的话�Q�这也可以。如果不手写�Q�我们可以��l�用之前�?a href="http://www.shnenglu.com/Streamlet/archive/2011/01/17/138693.html" target="_blank">C++ �?Function 对象的实玎ͼ�下）》中的宏循环�Ҏ��。此�Ҏ��的一个正式版本见 xlMacros.h�?/p>
定义带默认�?NullType 的模版参数声明序列如下：

#define XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN(n)     typename T##n = NullType
#define XL_TUPLE_TYPENAME_DECLARE_NT(n)             XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_NT_PATTERN, n, XL_COMMA)

它将被展开为： typename T0 = NullType, typename T1 = NullType, typename T2 = NullType, �? typename Tn = NullType

定义不带默认值的模版参数声明序列如下�Q?/p>
#define XL_TUPLE_TYPENAME_DECLARE_PATTERN(n)        typename T##n
#define XL_TUPLE_TYPENAME_DECLARE(n)                XL_REPZ(XL_TUPLE_TYPENAME_DECLARE_PATTERN, n, XL_COMMA)

它将被展开为：typename T0, typename T1, typename T2, �? typename Tn

定义模版参数使用序列如下�Q?/p>
#define XL_TUPLE_TYPENAME_LIST_PATTERN(n)           T##n
#define XL_TUPLE_TYPENAME_LIST(n)                   XL_REPZ(XL_TUPLE_TYPENAME_LIST_PATTERN, n, XL_COMMA)

它将被展开�?T0, T1, T2, �? Tn

定义成员变量声明序列如下�Q?/p>
#define XL_TUPLE_MEMBER_DECLARE_PATTERN(n)          T##n _##n;
#define XL_TUPLE_MEMBER_DECLARE(n)                  XL_REPZ(XL_TUPLE_MEMBER_DECLARE_PATTERN, n, XL_NIL)

它将被展开为：T0 _0; T1 _1; T2 _2; �?Tn _n;

现在我们开始组装：

#ifndef XL_TUPLE_DEFINE_MAX
#define XL_TUPLE_DEFINE_MAX 20
#endif

template
struct Tuple;

template
struct Tuple
{
    XL_TUPLE_MEMBER_DECLARE(n)
};

其中后一个还带有宏参�?n。我们将�q�整一个定义成宏，然后�q�行宏��@环：

#define XL_TUPLE_IMPLEMENT_PATTERN(n)   \
                                        \
template \
struct Tuple \
{                                       \
    XL_TUPLE_MEMBER_DECLARE(n)          \
};                                      \

#define XL_TUPLE_IMPLEMENT(n)    XL_REPY(XL_TUPLE_IMPLEMENT_PATTERN, n, XL_NIL)

之后再��用这个宏�Q?/p>
XL_TUPLE_IMPLEMENT(XL_TUPLE_DEFINE_MAX)

到此为止�Q�上文一开始提出的 Tuple 已经实现�Q��ƈ支持到最大约 20 个元素左叟�?/p>
然后我们可以考虑增加各种方便使用的功能�?/p>

默认构造函数�?br>

带有 n 个参数的构造函数。相兛_��定义�Q?br>#define XL_TUPLE_INITIALIZE_LIST_PATTERN(n)         _##n(_##n)
#define XL_TUPLE_INITIALIZE_LIST(n)                 XL_REPZ(XL_TUPLE_INITIALIZE_LIST_PATTERN, n, XL_COMMA)

拯��构造函数。相兛_��定义�Q?br>#define XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN(n)    _##n(that._##n)
#define XL_TUPLE_INITIALIZE_LIST_COPY(n)            XL_REPZ(XL_TUPLE_INITIALIZE_LIST_COPY_PATTERN, n, XL_COMMA)

赋值函敎ͼ�
#define XL_TUPLE_ASSIGN_PATTERN(n)                  this->_##n = that._##n;
#define XL_TUPLE_ASSIGN(n)                          XL_REPZ(XL_TUPLE_ASSIGN_PATTERN, n, XL_NIL)

各种比较函数。请注意对各元素的相应比较运��符的依赖。这里定义成�Q�Tuple �?< 只依赖于各元素的 <�Q�Tuple �?!= 也只依赖于各元素�?!=�Q�如此类推�?br>
#define XL_TUPLE_EQUAL_PATTERN(n)                   this->_##n == that._##n
#define XL_TUPLE_EQUAL(n)                           XL_REPZ(XL_TUPLE_EQUAL_PATTERN, n, &&)

#define XL_TUPLE_NOT_EQUAL_PATTERN(n)               this->_##n != that._##n
#define XL_TUPLE_NOT_EQUAL(n)                       XL_REPZ(XL_TUPLE_NOT_EQUAL_PATTERN, n, ||)

#define XL_TUPLE_LITTER_PATTERN(n)                  if (this->_##n < that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n < this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_LITTER(n)                          XL_REPZ(XL_TUPLE_LITTER_PATTERN, n, XL_NIL)

#define XL_TUPLE_GREATER_PATTERN(n)                 if (this->_##n > that._##n)         \
                                                    {                                   \
                                                        return true;                    \
                                                    }                                   \
                                                    else if (that._##n > this->_##n)    \
                                                    {                                   \
                                                        return false;                   \
                                                    }
#define XL_TUPLE_GREATER(n)                         XL_REPZ(XL_TUPLE_GREATER_PATTERN, n, XL_NIL)

同时 Tuple 中也增加相应的函敎ͼ�卛_��?/p>
最�l�代码见 xlTuple.h�Q�这里不贴了�?/p>
请多多指正�?/p>

溪流 2011-04-28 22:05 发表评论

溪流 — Tue, 29 Mar 2011 13:27:00 GMT

有个需求，能否做到实现一个类��D��L��函数�Q?/p>
template
XXX Min(T1 t1, T2 t2)
{
    return (t1 < t2 ? t1 : t2);
}
其中 XXX 是我们要推导出的�c�d��?
以下是一个失败的��试�?
我记�?Loki 里有关于如何判断某个�c�d��能否隐式转换为另一个类型的东西�Q�大意如下：
template
class Conversion
{
private:
    typedef char Small;
    class Big { char XXX[2]; };
    static Small Test(U);
    static Big Test(...);
    static T MakeT();
public:
    enum
    {
        Exists = (sizeof(Test(MakeT())) == sizeof(Small)),
    };
};
如此�Q�Conversion::Exists ��p��判断 T �?U 的�{换是否存在了�?
然后再搞个选择�Q?
template
struct Select
{
    typedef TypeIfFalse Type;
};
template
struct Select
{
    typedef TypeIfTrue Type;
};
最后，再来个：
struct NullType;
template
struct CommonType
{
    typedef typename Select::exists,
                                        U,
                                        typename Select::exists,
                                                                T,
                                                                NullType>::Type
                                       >::Type Type;
};
那么 CommonType ��是 T1 �?T2 之间哪个是他们的共有�c�d��了�?
��试�Q?
int main()
{
    CommonType::Type m = 0;
    return 0;
}
调试�Q�确�?m �?double 的。但是反�q�来�?CommonType::Type m = 0;�Q�m 却是 int 的�?
�q�说明这套机制一开始就有问题，Test(U) �?Test(�? 两个重蝲函数中，Test(�? 不会在需�?double �?int 时胜出。这是第一个问题�?
�W�二个问题，当写下如下代码的时候：
template
CommonType::Type Min(T1 t1, T2 t2)
{
    return (t1 < t2 ? t1 : t2);
}
�~�译无法通过�?u>原因是返回类型中�?CommonType 中的模板参数 T、U 无法接受此时�q�不能确定的 T1、T2�?/u>

(更正�Q�不是这个原因，�q�回�c�d��前加 typename 卛_��。现在问题还是第一个问题�?

��h��各位�Q�有没有什么方法做刎ͼ��Ƣ迎指教~

C++ 0x 中就能很方便做到了：

template
auto Min(T1 t1, T2 t2) -> decltype(t1 + t2)
{
    return (t1 < t2 ? t1 : t2);
}
int main()
{
    int a = 2;
    double b = 1.0;
    auto m = Min(a, b);
    return 0;
}

溪流 2011-03-29 21:27 发表评论

觉得 Loki::ScopeGuard ��g��不该在它自己里面 try … catch …

溪流 — Wed, 23 Mar 2011 01:39:00 GMT

ScopeGuard 只是帮我们调用一个函数而已�Q�至于这个函数是否有异常出来�Q�它不该悄悄地把它吞了，而应该还我们本来面目�Q�不知道是不是？可是��Z��么几乎所有介�l?ScopeGuard 的文章都说这 try �?catch �?用得好呢�Q?/p>

溪流 2011-03-23 09:39 发表评论

一个好玩的玩意儿：VS �?autoexp.txt

溪流 — Sun, 27 Feb 2011 09:10:00 GMT

嗯，写篇文章的目的是��Z��把我最斎ͼ�现在是次斎ͼ�的那��文章给刷下厠Z��—我不想每次看见它了�?/p>
不知大家有没有发玎ͼ�当��?VS 来调试代码的时候，那些 STL 容器的信息会以比较看得懂的方式显�C�出来：

而我们自己写的，它只能按照数据成员来昄��Q�如果数据结构稍微复杂点�Q�看�q�些直接昄��的内容得到的有用信息��׃��很少了：

那么�Q�是否有办法能让 IDE 按照我们设想的方式来昄��数据呢？�{�案是肯定的。这个配�|�就位于 autoexp.txt 中（具体路径�?X:\Program Files\Microsoft Visual Studio 10.0\Common7\Packages\Debugger\autoexp.dat�Q�如果是 VS 不同版本�Q�“Microsoft Visual Studio 10.0”中的版本号换成其他的即可，VS 2005 以上版本都支持）�?/p>
在里面搜�?vector�Q�可以找��C��用于 vector 的调试信息显�C�方式的语句�Q?/p>

std::vector<*>{
    preview (
        #(
            "[",
            $e._Mylast - $e._Myfirst,
            "](",
            #array(
                expr: $e._Myfirst[$i],
                size: $e._Mylast - $e._Myfirst
            ),
            ")"
        )
    )

    children (
        #(
            #([size] : $e._Mylast - $e._Myfirst),
            #([capacity] : $e._Myend - $e._Myfirst),
            #array(
                expr: $e._Myfirst[$i],
                size: $e._Mylast - $e._Myfirst
            )
        )
    )
}

�q�个语法的详�l�官方说明好像没有，不过大体上可以猜出来�?/p>
�W�一�?std::vector<*> 是类型，说明下面的内定w��?std::vector�Q��ƈ且适用于�Q意模版参数。紧接着是一个大括号括�v来的�D�落�?/p>
preview 开始的那一�D�表�C�当该变量单行显�C�的时候该如何昄��Q�也��是下图�W�二列的样子�Q?br>

IDE 会依�ơ显�C?preview(#( �?)) 括号内的以逗号分隔的内容，加引��L��会原��h��C�，变量�?$e 引用�Q�将 $e 视�ؓ该类型的一个变量）�?/p>
除了直接引号�Q�变量的�q�算�l�果外，�q�里�q�可以写一些高�U�点的玩意儿�Q�如 #array�Q?list�Q?tree�?/p>
#array 的格式�ؓ�Q?br>#array(
    expr: �?,
    size: �?br>)
其中 expr 里可以��?$i�Q?i 为元�?index�Q�size 表示元素个数。最�l�的�l�果为：
$i=0时的expr, $i=1时的expr, �? $i=size时的expr�?/p>
假设有一个结构：
struct Vector
{
    int *pData;
    int nCount;
};
其中 p 是指向一�?count �?int 的内存。如果要依次昄��q?count 个数字，preview 中应该写�Q?br>preview (
    #(
        #array(
            expr: $e.pData[$i],
            size: $e.nCount
        )
    )
)

#list 的格式�ؓ�Q?br>#list(
    head: �?,
    size: �?,
    next: �?br>) : �?br>其中 head 是指向第一�?Node 的指针，size 表示元素个数�Q�next 表示 Node 中指向下一�?Node 的分量名�Q�最后冒号后面还要写一�?Node 中的值分量，也就是要昄��的那个变量�?/p>
假设有结构：
struct ListNode
{
    int nData;
    ListNode *pNext;
};
struct List
{
    ListNode *pHead�Q?br>    int nCount;
};
preview 的写法�ؓ�Q?br>preview (
    #(
        #list(
            head: $e.pHead,
            size: $e.nCount,
            next: pNext
        ) : $e.nData    // 注意�Q�这里的 $e 代表 ListNode�Q�上面两�?$e 都代�?List
    )
)

#tree的格式�ؓ
#tree(
    head: �?
    left: �?
    right: �?
    size: �?br>) : �?br>其中 head 是指向根节点的指针，left �?right 分别是指向左叛_��树的分量名，size 表示元素个数�Q�最后冒号后面写节点中的值分量。IDE会对整棵树做中序遍历�?/p>
假设有结构：
struct TreeNode
{
    int nData;
    TreeNode *pLeft;
    TreeNode *pRight;
};
struct Tree
{
    TreeNode *pRoot;
    int nCount;
};
preview 的写法�ؓ�Q?br>preview (
    #(
    #tree(
        head: $e.pRoot,
        left: pLeft,
        right: Right,
        size: $e.nCount
        ) : $e.nData // 注意�Q�这里的 $e 代表 TreeNode�Q�上面两�?$e 都代�?Tree
    )
)

preview 的格式就到此。接下来�?children�Q�它用于描述点击变量左边的加号后�Q�展开的内�Ҏ��么昄��Q�如图：

IDE 会依�ơ显�C?children(#( �?)) 括号内的以逗号分隔的内容，每个昄��Z��行。刚才的 #array, #list, #tree 都可以用�Q�会昄��成第一列烦引第二列值的样子�?br>另外可以�?#(first, second) 的格式，first 会原��h��C�在�W�一列，second 会求值显�C�在�W�二列�?/p>

了解以上�q�些内容�Q�我们已�l�可以针�?STL 的那些数据结构做自定义显�C�Z��Q�对一些别的数据结构作��单的自定义显�C�Z��不难�?/p>

最后给个效果图�Q�定义了我自��q��那些容器的显�C�方式。怎么��P��看上��M��定比开头给出的那个冷冰冰的样子好很多吧�Q?/p>

溪流 2011-02-27 17:10 发表评论

C++ �?Function 对象的实玎ͼ�下）

溪流 — Mon, 17 Jan 2011 13:59:00 GMT

目录�Q?/p>
C++ �?Function 对象的实玎ͼ�上）
C++ �?Function 对象的实玎ͼ�下）

上篇中，我们实现了一个支�?R () 型函数的 Function。补充说明一下，在我们对成员函数的支持中�Q�我们是�q�样定义的：

template
class MemberFunction0 : public FunctionBase0
{

private:
    R (T::*m_pMemFun)();
    T *m_pObj;
};

Loki �Ҏ��在著作中提醒我们�Q�这里的 T 最好不要是函数�c�d��Q�改为函数指针类型，如此该类的支持范围将扩大。如下：

template
class MemberFunction0 : public FunctionBase0
{
public:
    R Invoke()
    {
        return (m_pObj->*m_pMemFun)();
    }

public:
    MemberFunction0(P pObj, R (T::*pMemFun)())
        : m_pObj(pObj), m_pMemFun(pMemFun)
    {

    }

private:
    R (T::*m_pMemFun)();
    P m_pObj;
};

于是�Q�P �?T 的关�p�M��那么紧密了，P 不一定非�?T* 不可�Q�也可以是诸�?SmartPtr 之类的玩意儿。原本只支持传入一个对象和该对象的成员函数的，现在变成传入一个具有指针概�늚�东东和一个成员函敎ͼ�只要�q�个“指针”��用运��符 �?gt; 去调用那个成员函数合乎语法即可�?/p>
接下来，我们来扩展这�?Function�Q�以支持拥有数目在给定上限内的�Q意参数的函数�?/p>
我们先来手工写一下，看看如何支持带一个参数的函数。首先定义一个虚基类�Q?/p>
template
class FunctionBase1
{
public:
    virtual R Invoke(T0) = 0;
    virtual ~FunctionBase1() {}
};

实现两个版本�Q�分别支持非成员函数和成员函敎ͼ�

template
class Function1 : public FunctionBase1
{
public:
    R Invoke(T0 v0)
    {
        return m_Fun(v0);
    }

public:
    Function1(const T &fun)
        : m_Fun(fun)
    {

    }

private:
    T m_Fun;
};

template
class MemberFunction1 : public FunctionBase1
{
public:
    R Invoke(T0 v0)
    {
        return (m_pObj->*m_pMemFun)(v0);
    }

public:
    MemberFunction1(P pObj, R (T::*pMemFun)(T0))
        : m_pObj(pObj), m_pMemFun(pMemFun)
    {

    }

private:
    R (T::*m_pMemFun)(T0);
    P m_pObj;
};

增加一个函数引用萃取的偏特化版本：

template
struct FunctionTraits
{
    typedef RetType (&ParamType)(T0);
};

增加一�?Function �cȝ��偏特化版本：

template
class Function
{
public:
    template
    Function(const T &fun)
        : m_pFunBase(new Function1::ParamType>(fun))
    {

    }

    template
    Function(P pObj, R (T::*pMemFun)(T0))
        : m_pFunBase(new MemberFunction1(pObj, pMemFun))
    {

    }

    ~Function()
    {
        delete m_pFunBase;
    }

    R operator ()(T0 v0)
    {
        return m_pFunBase->Invoke(v0);
    }

private:
    FunctionBase1 *m_pFunBase;
};

现在�Q�我们可以跑一下测试代码了�Q?/p>
Function f1(&intfun1);
Function f1_(intfun1);
Function f2(intfunctor1);
Function f3(&test, &Test::intmem1);

f1(1);
f1_(1);
f2(2);
f3(3);

当然�Q�void 函数也是支持的�?/p>
观察上面的这些代码，和我们在上一��中的代码高度一��_��不同的是那些模版参数、偏特化参数、函数调用参数等地方�?/p>
假如有这么一�l�宏�Q?br>TYPENAME_DECLARE(n) 被定义�ؓ typename T0, typename T1, �? typename Tn
TYPENAME_LIST(n) 被定义�ؓ T0, T1, �? Tn
TYPENAME_VARIABLE(n) 被定义�ؓ T0 v0, T1 v1, �? Tn vn
VARIABLE_LIST(n) 被定义�ؓ v0, v1, �? vn

那么我们可以使用一�?n ��写出支持所有具有参数的函数�?Function 了。我们抛弃掉上面�?1 �p�d��的所有类�Q�仅保持上篇留下来的代码�Q�然后利用上�?4 个宏��所有数字尾巴去掉，于是代码变成�Q?/p>
template
class FunctionBase_##n
{
public:
    virtual R Invoke(TYPENAME_LIST(n)) = 0;
    virtual ~FunctionBase_##n() {}
};

template
class Function_##n : public FunctionBase_##n
{
public:
    R Invoke(TYPENAME_VARIABLE(n))
    {
        return m_Fun(VARIABLE_LIST(n));
    }

public:
    Function_##n(const T &fun)
        : m_Fun(fun)
    {

    }

private:
    T m_Fun;
};

template
class MemberFunction_##n : public FunctionBase_##n
{
public:
    R Invoke(TYPENAME_VARIABLE(n))
    {
        return (m_pObj->*m_pMemFun)(VARIABLE_LIST(n));
    }

public:
    MemberFunction_##n(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
        : m_pObj(pObj), m_pMemFun(pMemFun)
    {

    }

private:
    R (T::*m_pMemFun)(TYPENAME_LIST(n));
    P m_pObj;
};

template
struct FunctionTraits
{
    typedef RetType (&ParamType)(TYPENAME_LIST(n));
};

template
class Function
{
public:
    template
    Function(const T &fun)
        : m_pFunBase(new Function_##n::ParamType>(fun))
    {

    }

    template
    Function(P pObj, R (T::*pMemFun)(TYPENAME_LIST(n)))
        : m_pFunBase(new MemberFunction_##n(pObj, pMemFun))
    {

    }

    ~Function()
    {
        delete m_pFunBase;
    }

    R operator ()(TYPENAME_VARIABLE(n))
    {
        return m_pFunBase->Invoke(VARIABLE_LIST(n));
    }

private:
    FunctionBase_##n *m_pFunBase;
};

当然上面�q�样子的代码是没法跑的咯。如果我们将整段代码定义��Z��个宏 BODY(n)�Q�然后用�c�M��刚才四个宏的方式定义�?FUNCTION_IMPLEMENT(n)�Q��得它的含义�ؓ BODY(0), BODY(1), �? BODY(n)�Q�所有工作就都完成了。最后只需要丢下一�?FUNCTION_IMPLEMENT(20)�Q�就可以支持 0 �?21 个参��C��?/p>
最后归�l��ؓ�Q�如何��用宏搞出“T0, T1, �? Tn�?的�Ş式�?/p>
暴力点，我们可以�q�样�Q?/p>
#define T_0 T0
#define T_1 T_0, T1
#define T_2 T_1, T2
#define T_3 T_2, T3
#define T_4 T_3, T4
#define T_5 T_4, T5
#define T_6 T_5, T6
#define T_7 T_6, T7
#define T_8 T_7, T8
#define T_9 T_8, T9

#define T(n) T_##n

�q�样子，对于上面四个宏可以，但是对于最后的 X(n)�Q��h工代码量�q�是太大了。嗯�Q�X(n)�Q�对�Q�这�?X�Q�必��d�� _1、_2、_3 �p�d��宏里面占据一个参数地位，�q�样才有那么一点点扩展性。考虑换成�q�样�Q?/p>
#define REP_0(macro, n) macro(0)
#define REP_1(macro, n) REP_0(macro, n), macro(1)
#define REP_2(macro, n) REP_1(macro, n), macro(2)
#define REP_3(macro, n) REP_2(macro, n), macro(3)
#define REP_4(macro, n) REP_3(macro, n), macro(4)
#define REP_5(macro, n) REP_4(macro, n), macro(5)
#define REP_6(macro, n) REP_5(macro, n), macro(6)
#define REP_7(macro, n) REP_6(macro, n), macro(7)
#define REP_8(macro, n) REP_7(macro, n), macro(8)
#define REP_9(macro, n) REP_8(macro, n), macro(9)

#define REP(macro, n)   REP_##n(macro, n)

然后�Q?/p>
#define TYPENAME_LIST_PATTERN(n)    T##n
#define TYPENAME_LIST(n)            REP(TYPENAME_LIST_PATTERN, n)

�q�个 TYPENAME_LIST ��是�W�合上文要求的宏。接下来如法炮制其余三个�Q?/p>
#define TYPENAME_DECLARE_PATTERN(n)     typename T##n
#define TYPENAME_DECLARE(n)             REP(TYPENAME_DECLARE_PATTERN, n)

#define TYPENAME_VARIABLE_PATTERN(n)    T##n v##n
#define TYPENAME_VARIABLE(n)            REP(TYPENAME_VARIABLE_PATTERN, n)

#define VARIABLE_LIST_PATTERN(n)        v##n
#define VARIABLE_LIST(n)                REP(VARIABLE_LIST_PATTERN, n)

最后，我们�?#define FUNCTION_IMPLEMENT(n) REP(BODY, n) 中还存在一点点问题。因�?BODY 中会含有 TYPENAME_DECLARE 之类的宏的��用，�?TYPENAME_DECLARE 正是使用 REP 定义的。这涉及到宏的递归展开�Q�C++预处理器的规则是�Q�遇到这��L��情况��停止展开。比如，我们定义 BODY(n) �?TYPENAME_DECLARE(n)�Q�于�?FUNCTION_IMPLEMENT(2) 会被展成�Q?/p>
REP(TYPENAME_DECLARE_PATTERN, 0), REP(TYPENAME_DECLARE_PATTERN, 1), REP(TYPENAME_DECLARE_PATTERN, 2)

上面�?REP 不会被��l�展开了�?/p>
为此�Q�一个不太聪明的办法��是�Q�再定义一�l?REP2。嗯�Q�是个办法，��p��么办吧。另外我们刚才的 REP �p�d��没有��分隔符作�ؓ参数�Q�默认��用逗号�Q�而最后一不的 FUNCTION_IMPLEMENT 的重复中是不能用逗号的。考虑提取出来作�ؓ参数。最后我们的所需要的宏系�l�是�Q?/p>
#define NIL
#define COMMA ,

#define REP_0(macro, splitter, n) macro(0)
#define REP_1(macro, splitter, n) REP_0(macro, splitter, n) splitter macro(1)
#define REP_2(macro, splitter, n) REP_1(macro, splitter, n) splitter macro(2)
#define REP_3(macro, splitter, n) REP_2(macro, splitter, n) splitter macro(3)
#define REP_4(macro, splitter, n) REP_3(macro, splitter, n) splitter macro(4)
#define REP_5(macro, splitter, n) REP_4(macro, splitter, n) splitter macro(5)
#define REP_6(macro, splitter, n) REP_5(macro, splitter, n) splitter macro(6)
#define REP_7(macro, splitter, n) REP_6(macro, splitter, n) splitter macro(7)
#define REP_8(macro, splitter, n) REP_7(macro, splitter, n) splitter macro(8)
#define REP_9(macro, splitter, n) REP_8(macro, splitter, n) splitter macro(9)

#define REP(macro, splitter, n)   REP_##n(macro, splitter, n)

#define REP2_0(macro, splitter, n) macro(0)
#define REP2_1(macro, splitter, n) REP2_0(macro, splitter, n) splitter macro(1)
#define REP2_2(macro, splitter, n) REP2_1(macro, splitter, n) splitter macro(2)
#define REP2_3(macro, splitter, n) REP2_2(macro, splitter, n) splitter macro(3)
#define REP2_4(macro, splitter, n) REP2_3(macro, splitter, n) splitter macro(4)
#define REP2_5(macro, splitter, n) REP2_4(macro, splitter, n) splitter macro(5)
#define REP2_6(macro, splitter, n) REP2_5(macro, splitter, n) splitter macro(6)
#define REP2_7(macro, splitter, n) REP2_6(macro, splitter, n) splitter macro(7)
#define REP2_8(macro, splitter, n) REP2_7(macro, splitter, n) splitter macro(8)
#define REP2_9(macro, splitter, n) REP2_8(macro, splitter, n) splitter macro(9)

#define REP2(macro, splitter, n)   REP2_##n(macro, splitter, n)

#define TYPENAME_DECLARE_PATTERN(n)     typename T##n
#define TYPENAME_DECLARE(n)             REP(TYPENAME_DECLARE_PATTERN, COMMA, n)

#define TYPENAME_LIST_PATTERN(n)        T##n
#define TYPENAME_LIST(n)                REP(TYPENAME_LIST_PATTERN, COMMA, n)

#define TYPENAME_VARIABLE_PATTERN(n)    T##n v##n
#define TYPENAME_VARIABLE(n)            REP(TYPENAME_VARIABLE_PATTERN, COMMA, n)

#define VARIABLE_LIST_PATTERN(n)        v##n
#define VARIABLE_LIST(n)                REP(VARIABLE_LIST_PATTERN, COMMA, n)

#define FUNCTION_IMPLEMENT(n) REP2(BODY, NIL, n)

最后，定义一�?FUNCTION_IMPLEMENT(5)�Q�就可以支持�?6 个参��C��。�ؓ了支持更多参敎ͼ�把上面的 REP 以及 REP2 �p�d��多定义一点，比如�?50�Q�那�?FUNCTION_IMPLEMENT 的括号中��可以填 50 以内的�Q意数了。考虑到宏展开对编译速度的媄响，以及实际应用中函数参数的个数�Q�定�?20 左右比较合适�?/p>
到这里，我们的Function已经实现了预期目标。接下来我本来想说说 TypeList 的。可是现在发现没�?TypeList�Q�Function 跑的通；有了 TypeList�Q�Function 也不能写的漂亮多��，虽说那些重复部分有一定的减少。Loki �?Functor 的参数类型是一个返回值类型加上一�?TypeList�Q�是��q��L��接传�?TypeList 的，不用由散的类型组合出一个TypeList�Q�但�q�是要从TypeList中萃取各个参数类型）�Q�因此用在他那里看上�ȝ��妙一点点。当�Ӟ��Loki 也在 Functor 外头包了一�?Function�Q�以支持函数�{�֐�作�ؓ模版参数的��用方式。有一点不��改观的改观是，用了 TypeList 以后�Q�就不会再有 FunctionBase_1, FunctionBase_2 �q�样的玩意儿了，取而代之的是一个统一�?FunctionBase 外加许多偏特化版本，Function* �?MemberFunction* 可以分别�l�一��Z��个，但是每一个里头都需要实�?N �?Invoke。加上篇�q�关�p�，我想�q�里��׃��说这�?TypeList 了�?/p>
代码清单太长了，��׃��贴了�Q�有意者自然能凑�v来。我目前�?xlLib 中的最�l�实现见 xlFunction.h�?/p>
关于宏，我不知道可以怎样改进。BOOST_PP_REPEAT 貌似可以调用自��n�Q�不知道如何实现的，求指教。另�?a href="http://www.shnenglu.com/vczh" target="_blank">@vczh貌似说“实��C��一门可以自己递归自己和内�|�列表处理的另一个宏”，求分享呀求分享�?/p>
2010-01-18 补充�Q�将最外层 Function 的构造函��C��?const T & 直接改�ؓ T�Q��ƈ且抛�?FunctionTraits�Q�函数实体类型将在传递过�E�中直接退化�ؓ函数指针�Q�这样就能特化出正确�?FunctionHandler。同时带来另一点媄响：如果传入 Functor�Q�字面上��多一�ơ拷贝动作。抛开�q�一点微��的性能来讲�Q�这比刚才的 FunctionTraints 要好得多了�?/strong>

溪流 2011-01-17 21:59 发表评论

C++ �?Function 对象的实玎ͼ�上）

溪流 — Sun, 16 Jan 2011 14:17:00 GMT

目录�Q?/p>
C++ �?Function 对象的实玎ͼ�上）
C++ �?Function 对象的实玎ͼ�下）

起因�?a href="http://www.shnenglu.com/Streamlet/archive/2011/01/16/138609.html" target="_blank">上一��?/a>已经说过了。现在让我们直接�q�入主题。本文的目标是，让以下代码能��利跑�v来：

int intfun0()
{
    return 1;
}

struct _intfunctor0
{
    int operator()()
    {
        return 2;
    }

} intfunctor0;

struct Test
{
    int intmem0()
    {
        return 3;
    }

} test;

int main()
{
    Function f1(&intfun0);
    Function f1_(intfun0);
    Function f2(intfunctor0);
    Function f3(&test, &Test::intmem0);

    f1();
    f1_();
    f2();
    f3();

    return 0;
}

除了上述例子中显�C�的�Q�还要支持有�q�回值的函数和没�q�回值的函数�Q�以及有0个�?个�?个、……、MAX 个参数的函数�Q�参数类型无限制。最后实现的 Function 对象仅仅可以执行��好。（至于是否可拷贝、是否可判断相等 �{�问题，都是��事�Q�本文暂不考虑。）最后，Bind 概念也不在本文讨��围之内�?/p>
对于�q�个问题�Q�我们一开始考虑的可能是怎样�l�一三种不同形式。有两个选择�Q�第一�Q��?C++ 的多态机�Ӟ��最后统一到基�c�L��针的�c�d��Q�第二，允许�c�d��部有冗余变量以及必要�?Flag�Q�用于判断是哪种形式的函敎ͼ�要如何执行。这��L��h��Q�第一�U�方案比�W�二�U�爽一炏V��于是，最初想到的实现有可能是�q�样的：

先定义一个虚基类�Q?/p>
template
class FunctionBase0
{
public:
    virtual R Invoke() = 0;
    virtual ~FunctionBase0() {}
};

然后实现一个普通函�?仿函数的版本�Q?/p>
template
class Function0 : public FunctionBase0
{
public:
    R Invoke()
    {
        return m_Fun();
    }

public:
    Function0(const T &fun)
        : m_Fun(fun)
    {

    }

private:
    T m_Fun;
};

�q�里需要说明的是，如果是普通函敎ͼ�T会被特化�?R() 或�?R (&)() 或�?R(*)()�Q�取决于使用的时候传�?fun �q�是传入 &fun。所以不必另外实现针�?R(*)() 的版本。Loki �Q�姑且就以作品名�U�C�� Loki 的作者吧�Q�他那个真名实在是太长）在他的书中称之�ؓ�?font face="Consolas">做一个，送一�?/font>”。不�q�对于他书中所说的�Q�我有一个疑惑。Loki 说传�?fun�Q�模版参�?T 会被特化�?R (&)()�Q�于是一切顺利。可是我在操作过�E�中发现 T 一直被特化�?R ()�Q�于是上�q?class 中的 m_Fun 被认为是成员函数而不是成员变量。不知道是�ؓ什么，有知道者请不吝指教哈。因��Z��上原因，本文中我一直用 &fun 的�Ş式对待普通函数�?/p>
再实��C��个成员函数的版本�Q?/p>
template
class MemberFunction0 : public FunctionBase0
{
public:
    R Invoke()
    {
        return (m_pObj->*m_pMemFun)();
    }

public:
    MemberFunction0(T *pObj, R (T::*pMemFun)())
        : m_pObj(pObj), m_pMemFun(pMemFun)
    {

    }

private:
    R (T::*m_pMemFun)();
    T *m_pObj;
};

最后是一个包装类。如果你可以接受 Function 表示 int()�Q?Function 表示 int (int)�Q�…，那么�q�里没有多少技巧可�a�。boost 的那�?function 使用的是函数�{�֐�作�ؓ模版参数�Q�即 Function�Q�Function �{��Ş式。如果不太研�I�语法，可能会像我一��P��一开始会对尖括号里的 int (int) 之类的玩意儿不太熟悉�Q�觉得很牛逹{��可是了解了以后�Q�不�q�是个函数类型而已�Q�没什么大不了的。Loki �?Functor 的��用方式是 Functor�Q�Functor。其中第一个模版参数始�l�是�q�回��|��W�二个模版参数是参数�c�d��列表�Q�Loki 使用了他创造的玩意�?TypeList 使得所有函数参数只占一个坑�Q�这在等下的支持多参数的扩展中能够带来一些美观。我比较喜欢 boost 的��用方式，让��用者直接以语言规定的�Ş式填入函数签名，而不是一些额外的�U�定�Q�“第一个模版参数表�C��回值”，“第二个到最后的模版参数表示参数”，“第二个模版参数�?TypeList 形式表示函数参数”等�Q��?/p>
��Z��辑ֈ��q�个目标�Q�我们要玩一些偏特化技巧。关于偏特化�Q�我一直以来的肤浅认识都是错误的。我原以为，对于模版�c�：

template
class Foo;

我如果特化其中一个参�?T1�Q?/p>template
class Foo
{

}
我以为只有这��h��叫偏特化�Q�以为偏特化的过�E��L��减少模版参数的。而实际上�Q�只要用某个/些类型占据原始模版参数的位置�Q�就可以了。比如，对于上述 Foo�Q�我可以特化一�?class>�Q�消��M��?T1�Q�而新�?U0、U1�Q?/p>template
class Foo>
{

}
原来 T1 的位�|�被 std::map 占据了，�q�也是偏特化。当然最后的模版参数数量也可以不变，如：
template
class Foo>
{

}
以及
template
class Foo
{

}
其中后者是实现�c�d��萃取的主要方式。只要特化以后，�q�个�c�M��然带有至��一个模版参敎ͼ��是偏特化。如果最后��生了 template<> 的�Ş式，那就是完全特化�?/p>
回到我们刚才的主题，我们要提供给用户的是�q�样一个类�Q?/p>
template
class Function;

其中参数 Signature 会被实际的函数类型所特化。但是我们只知道整体的一�?Signature �q�没有用�Q�我们必��ȝ��道被分解开来的�q�回值类型、参数类型。于是，引入一个偏特化版本�Q?/p>
template
class Function

�q�里使用 R () 特化原始�?Signature�Q�引入一个新的参�?R。于是返回值类�?R ��p��萃取出来了。实现如下：

template
class Function
{
public:
    template
    Function(const T &fun)
        : m_pFunBase(new Function0(fun))
    {

    }

    template
    Function(T *pObj, R (T::*pMemFun)())
        : m_pFunBase(new MemberFunction0(pObj, pMemFun))
    {

    }

    ~Function()
    {
        delete m_pFunBase;
    }

    R operator ()()
    {
        return m_pFunBase->Invoke();
    }

private:
    FunctionBase0 *m_pFunBase;
};

如果对上面说的“普通函数的使用方式必须是函数指针而不是函数本�w�”耿耿于怀�Q�可以再引入一个的构造函敎ͼ�

typedef R (FunctionType)();

Function(const FunctionType &fun)
    : m_pFunBase(new Function0(fun))
{

}

�q�里 FunctionType �?R(&)() �c�d��Q�强制��用它来特�?Function0 中的 T。该构造函数在重蝲册��中会取得优先权从而��普通函数本�w�的传入成�ؓ可能。不�q�，以函数本�w��Ş式传入的普通函��C��丧失一些特性，比如 Function 只能接受 int() �c�d��的普通函数而不能接�?char () 型的普通函敎ͼ�因�ؓ�q�种情况下不会走我们刚才新定义的构造函数�?/p>
�q�有一�U�做法，��是针对全局函数�Q�强制特化出模版参数为其引用�c�d��的类。定义如下元函数�Q?/p>
template
struct FunctionTraits
{
    typedef Signature ParamType;
};

template
struct FunctionTraits
{
    typedef RetType (&ParamType)();
};

然后构造函数改为：
    template
    Function(const T &fun)
        : m_pFunBase(new Function0::ParamType>(fun))
    {

    }
用以上方法，所有的�Ҏ��都不会丢失�?/p>
到这儿，我们�?Function 已经可以��试牛刀了：

Function f1(&intfun0);
Function f1_(intfun0);
Function f2(intfunctor0);
Function f3(&test, &Test::intmem0);
f1();
f1_();
f2();
f3();

上面�q�段代码已经能够正常�q�行了�?/p>
来，�l�箋做一个，送一�?/strong>。下面的代码居然也能跑（voidfun0、voidfunctor0、Test::voidmem0�c�M��int版本定义�Q�：
Function f4(&voidfun0);
Function f4_(voidfun0);
Function f5(voidfunctor0);
Function f6(&test, &Test::voidmem0);
f4();
f4_();
f5();
f6();

�q�说明了�Q�在�c�里面写一个返回��gؓ该类型的函数�Q��ƈ在里面写�?return XXX; 然后�?void 为模版参��C��入该模版�c�，是符合语法的。验证一下：

template
class Foo
{
public:
    T Bar()
    {
        printf("%s invoked\n", __FUNCTION__);
        return T();
    }
};

int main()
{
    Foo f1;
    f1.Bar();

    Foo f2;
    int i = f2.Bar();

    return 0;
}

�q�行�l�果�Q?/p>
Foo::Bar invoked
Foo::Bar invoked

到此为止�Q�我们已�l�实��C�� 0 个参数的函数支持�Q�也�?R () �c�d��的所有函数的支持。接下来�q�要实现对具�?1 个�? 个�? 个直至�Q意有限个参数的函数支持。也许您也发��C��Q�接下来的工作可以是体力�z�，我们可以照葫芦画瓢，搞出一�?FunctionBaseN、FunctionN、MemberFunctionN�Q��ƈ在最后的 Function 中再实现 N 个偏特化版本。是�Q�不错，大致上原理就是这栗��限于篇�q�，我想暂时写到�q�里�Q�下��将�l�箋谈谈宏、TypeList�Q�以及怎样��花点力气实现其�?N 个版本。最�l�达到的效果是，只要改一个宏定义�Q�就可以提高参数上限�?/p>
在本文所涉及的内容中�Q�我比较�U�结的是�Q�可否在不用多态机制的情况下达到比较优雅的形式�l�一�Q?/p>
�Ƣ迎讨论�?/p>

溪流 2011-01-16 22:17 发表评论

免费亚洲一区二区,黄色影院成人,裸体歌舞表演一区二区

背景

构徏�pȝ��安装

目标

基础概念

�Ҏ�� Chromium 中的配置

Linux

Mac

Win

建立我们的工具链

使用案例

�ȝ��

微��Y拼音长句模式恢复工具支持Win10 1803

裸写一个进�E�外 COM �l��g

让COM�l��g可被跨语�a�调用

裸写一个进�E�内 COM �l��g

山寨一�?ATL �?COM_INTERFACE

学习�?ATL 的��扉K��处理

初步性能���试

解析正则表达式（三）重复

解析正则表达式（二）字符集合

利用已有�?bind 构�?ScopeExit

调用�U�定�ȝ��

���译一�?C++03 标准文档�Q?.10 左值和叛_��|���Q�请批评指正~

如何�?执行耗时��d��的、可随时立即退出的函数 呢？

一个简单的 Tuple 实现

觉得 Loki::ScopeGuard ��g��不该在它自己里面 try … catch …

一个好玩的玩意儿：VS �?autoexp.txt

C++ �?Function 对象的实玎ͼ�下）

C++ �?Function 对象的实玎ͼ�上）

初步性能��试

��译一�?C++03 标准文档�Q?.10 左值和叛_��|��Q�请批评指正~

如何�?执行耗时��d��的、可随时立即退出的函数呢？