欧美涩涩视频,欧美成人一区在线,欧美揉bbbbb揉bbbbb

试用新版本luabind

清源游民 — Wed, 06 May 2009 16:46:00 GMT

环境xp sp3 , vs2008 sp1, luabind 0.8.1,lua 5.1.4 , boost 1_36_0
先把lua, luabind �~�成静态库�Q�（下图只是debug,release�c�M��)�Q?br>

做完之后整理�Q�lua, luabind 以sdk 形式�l�织好，我是�q�样�l�织:
\luabind_build\sdk\luabind\include
\luabind_build\sdk\luabind\msvc-9.0-sp1\lib
\luabind_build\sdk\lua\include
\luabind_build\sdk\lua\msvc-9.0-sp1\lib
�q�样�Q�把sdk中的东东保存一份，方便以后使用。写一个MFC��程序测�?br>

1 //关键代码
2 //mfc class function
3 void CMFC_LuaDlg::SetEditText(const char* text)
4 {
5     Edit_1.SetWindowText(text);
6     UpdateData(FALSE);
7 }
8 //register
9 luabind::module(L)
10     [
11     luabind::class_<CMFC_LuaDlg>("mfc_dlg")
12       .def"set_text",&CMFC_LuaDlg::SetEditText)
13     ];
14 //load lua file
15 if (0==luaL_dofile(L,filepath))
16     {
17         ret=true;
18     }
19 //run lua function
20  luabind::call_function<void>(L,"update_text",dlg);
21

脚本内容:

1 function update_text(dlg)
2 dlg:set_text("你好�Q�欢�q�来到lua 脚本世界")
3 end

�q�行�l�果�Q?br>

清源游民 2009-05-07 00:46 发表评论

c++,要细心不能想当然

清源游民 — Wed, 06 May 2009 13:09:00 GMT

两段惛_��然写下的代码�Q�你看出问题了吧

1 class Data;
2 Data* FindData();
3 void GetData(Data* dataPtr)
4 {
5 dataPtr=FindData();
6 }
7 Data* data=NULL;
8 GetData(data);
9 data->somefunction();

�W�二�D�代码，更得仔细�?br>

1 class A;
2 class B;
3 A const * GetA();
4 B const * GetB();
5 template<typename T>
6 int GetSpecialValue(T* classPtr)
7 {
8    return  3721;
9 }
10
11 template<>
12 int GetSpecialValue<>(A* classPtr)
13 {
14    return  37;
15 }
16 template<>
17 int GetSpecialValue<>(B* classPtr)
18 {
19    return 21;
20 }
21 A const * classPtr=GetA();
22 int ret=GetSpecialValue(classPtr);
23 cout<<ret<<endl; //out 3721! why not 37?
24
25
26

�W�一�D늚�问题在于看到指针惛_��然认为是地址�Q�data 可以带回反回��|��其实因�ؓ�q�里是��g��递，实参data把自��q��D��l�了dataPtr,dataPtr后来��实从FindData()得到了想要的��|��但这对一点媄响也没有�Q�所以函数返回时�Q�data的值没有发生变化，也就是没有带回想要的倹{�?br>只要不想当然�Q�仔�l�一惛_��明白了，解决办法很简单：

1 void GetData(Data*& dataPtr)
2 4 {
3 5 dataPtr=FindData();
4 6 }

�W�二�D늚�问题是没有注意到那个const, T* �?T const* 是不一��L��Q�不能完全匹配，所以不会找到对A�c�d��的特化版�?解决办法可以�q�样�Q?br>

1 template<typename T>
2 int GetSpecialValue(T const* classPtr)
3 {
4    return  3721;
5 }
6
7 template<>
8 int GetSpecialValue<>(A const* classPtr)
9 {
10    return  37;
11 }
12 template<>
13 int GetSpecialValue<>(B const* classPtr)
14 {
15    return 21;
16 }

能过�q�两个小例子��可以知道，C++�l�节很多�Q�要仔细�Q�不能想当然�?br>

清源游民 2009-05-06 21:09 发表评论

清源游民 — Fri, 09 Nov 2007 14:32:00 GMT

摘要: 阅读全文

清源游民 2007-11-09 22:32 发表评论

清源游民 — Fri, 09 Nov 2007 14:21:00 GMT

摘要: 阅读全文

清源游民 2007-11-09 22:21 发表评论

清源游民 — Thu, 31 May 2007 07:11:00 GMT

Microsoft发布的DirectX 10代表了自从可�~�程Shader出现以来�?D API斚w��的最巨大的进步。通过一番脱胎换骨般的重建，DirectX 10展现��Z��p�d��非常醒目的新�Ҏ��，包括高度优化的运行时�Q�强大的Geometry Shader�Q�纹理数�l�等�{�，�q�些�Ҏ��将引领PC实时三维囑�Ş�q�入一个全新的世界�?

DirectX 发展��?/h2>
　　在过�ȝ��十年中，DirectX已经�E�x��成�ؓ了Microsoft Windows�q�_��上进行游戏开发的首选API。每一代的DirectX都带来对新的囑�Ş��g�Ҏ��的支持�Q�因此每�ơ都能帮助游戏开发者们�q�出惊�h的一步�?/p>
　　微��YDirectX API(Application Programming interface :应用�E�序界面) 最早发布于1995�q�_��其设计目标是为Windows�q�_��软�g开发�h员提供一个更��便的针对多媒体和游戏应用�~�程的标准接口�?/p>
　　在DirectX出台�Q�开发者针寚w��频、视频等的操作必��d��于硬件进行，——当�Ӟ��Z��OpenGL能够在很大程序上减轻工作量，但OpenGL获得的支持显然远�q�不够。——而显卡、声卡等的��品种�c�M��多，要编写一�ƾ能�q�行在所有��^��C��的游戏简直是一件噩梦般的工作�?/p>
　　通过提供一�p�d��的针对多媒体应用的API�Q�如囑�Ş(包括2D�?D应用)、音频或输入讑֤��{�，DirectX提供了一整套的多媒体接口�Ҏ��Q�这可以让开发者根据API�~�写相应的��Y件程序，而不必考虑具体的硬�Ӟ��g的差别性显得无��重，�~�程人员得以更有效率的开发各�U�多媒体、游戏��Y件�?/p>
　　当然�Q�DirectX的发展�ƈ不是一帆风��的�Q�最初的版本�q�谈不上�E�_��。　

版本操作�pȝ�� 发布日期

DirectX 1.0 Windows 95a 9/30/95

DirectX 2.0/2.0a Windows 95OSR2/NT4.0 6/5/96

DirectX 3.0/3.0a Windows NT 4.0 SP3 9/15/96

DirectX 4.0 未发�?/td>

DirectX 5.0 Windows NT 4.0/Beta for NT 5.0 7/16/97

DirectX 5.1 Windows 95/98/NT4.0 12/1/97

DirectX 5.2 Windows 95 5/5/98

DirectX 6.0 Windows 98/NT4.0 8/7/98

DirectX 6.1 Windows 95/98/98SE 2/3/99

DirectX 7.0 Windows 95/98/98SE/2000 9/22/99

DirectX 7.0a Windows 95/98/98SE/2000 9/99

DirectX 7.1 Windows 95/98/98SE/ME/2000 9/16/99

DirectX 8.0/8.0a Windows 95/98/98SE/ME/2000 9/30/2000

DirectX 8.1 Windows 95/98/98SE/ME/2000/XP 11/12/01

DirectX 9
Shader Model 2.0 Windows 95/98/98SE/ME/2000/XP 12/19/2002

DirectX 9
Shader Model 2.0b Windows 98/98SE/ME/2000/XP 8/13/2003

DirectX 9
Shader Model 3.0 Windows 98/98SE/ME/2000/XP 8/9/2004

DirectX 3D的发�?/h2>
　　DirectX中应用在3D囑�Ş斚w��的特定DirectX API即Direct3D�Q�这也是DirectX中最重要的部分。不�q�，DirectX 3D得到�q�泛应用是在DirectX 6.0之后�Q?/p>
　　DirectX 6.0�Q�加入了双线性过滤、三�U�性过滤等优化3D囑փ�质量的技术，加入环境影射凹凸贴图�Q��3D游戏的画面更��h��真实感�?/p>
　　DirectX 7.0�Q�最大的特色��是支持了T&L�Q�中文名�U�是“坐标转换和光�?#8221;�Q?D游戏中坐标和灯光的�{换工作从此由CPU转交�l�了GPU�Q�比DX6.1性能提升20%。这也成��׃��nVIDIA GeForce 256与ATi Radeon 256的辉煌，�?DFX��d��退出市场竞争�?/p>
　　DirectX 7.0a�Q�增��Z��力反馈游戏控制设备的性能和兼�Ҏ��?/p>
　　DirectX 7.1�Q�与Windows Millennium一同发布�?/p>
　　DirectX 8.0/8.0a�Q�支持Shader Model 1.0�?.1�Q�从此在昑֍�中引入可�~�程像素着色器(Pixel Shaders)和顶点着色器(Vertex Shaders)的概念，同时应用在Xbox游戏��Z��。同��gT&L仅仅实现的固定光��p�{换相比，VS和PS单元的灵�z�L��更大，它��GPU真正成�ؓ了可�~�程的处理器�?/p>
　　DirectX 8.1�Q?Pixel Shader升��?.2�?.3�?.4版，可以支持最高每旉��28指��o执行�Q�其�?.4版当时仅ATi Radeon 8500昑֍�支持�?/p>
　　DirectX 9.0 Shader Model 2.0�Q?SM2.0的shader性能更强�Q�支持最�?6指��o的pixel shader长度�Q�同时DirectPlay和一些音频方面也有大�q�提升�?/p>
　　DirectX 9.0 Pixel Shader 2.0b�Q?ATI Radeon X600/700/800�p�d��昑֍�首先采纳�Q�开始支持更多指�?最�?536)和更多��时寄存器(32相比之前�?2)�Q�同时还加入新的贴面寄存�?facing register)和几何实�?geometry instancing)的支持�?/p>
　　DirectX 9.0 Shader Model 3.0�Q�支持更多指令，支持指��o的流量控制和动态分支，从而��得编�E��h员可以在shaders中加入��@环操作，使得�~�程更加�Ҏ��Q�首�ơ被Geforce 6800昑֍�采用�?/p>
　　从DirectX的发展史中我们可以看刎ͼ�微��Y�?D API和硬件一同发展，新硬件带来新的DX�Ҏ��，新的DX�Ҏ��加速硬件的发展�Q�在DirectX10上面�Q�又是一�?D囑�Ş发展的新境界�?/p>

DirectX 10的架构优�?/h2>
　　DirectX之所以在�q�大的开发者中��行�Q�是得益于它的简单易用和丰富的功能特性。然而，DirectX一直被一个主要的问题所困扰�Q�那��是高CPU负蝲�?/p>
　　在图形编�E�API出现之前�Q?D应用�E�序直接向图形硬件发送命令来完成囑�Ş的绘制工作。虽然这样开发工作比较繁重，但硬件效率则能在很大�E�度上得��C��证�?/p>
　　而如DirectX和OpenGL�q�样的图形API则是通过在图形硬件和应用�E�序之间架�v了一个中间层�Q�这��P��应用�E�序可以使用�l�一的图形编�E�代码来完成对底层硬件的操作�Q�将�E�序员们从与大量的图形硬件交互的恶梦中解救出来。但是，�q�也造成了每�ơDirectX从应用程序那里接收到一条命令时�Q�就必须先对�q�条命��o�q�行分析和处理，再向囑�Ş��g发送相对应的硬件命令。由于这个分析和处理的过�E�由CPU完成�Q�造成了每一�?D�l�图命��o都会带来CPU的负载�?/p>
　　从技术角度，�q�种CPU负蝲�l?D图象带来两个负面影响�Q�首先，限制了画面中可以同时�l�制的物体数量；其次�Q�限制了可以在一个场景中使用的独立的�Ҏ��的数量。这��׃��得游戏画面中的细节数量受��C��很大的限�Ӟ��而图像具有真实感的主要要求便是丰富的�l�节�?/p>
　　DirectX 10的主要优势便是最大程度地降低了CPU负蝲�Q�主要通过三个途径来达到这个目的：�W�一�Q�修改API核心�Q��得绘制物体和切换材质�Ҏ��时的消耗降低，提高�l�图效率�Q�第二，引入新的机制�Q�降低图形运��操作对CPU的依赖性，使更多的�q�算在GPU中完成；�W�三�Q��大量的物体可以通过调用单条DirectX�l�制命��o�q�行扚w��l�制�?/p>
　　下面我们��来仔细的看一下这三种方式�Q?/p>
　　提高�l�图效率

　　在DirectX 10中，对上代DirectX版本中三�l�数据和�l�制命��o的验证过�E�进行了很大�E�度的修攏V��所谓三�l�数据和命��o的验证，是指在DirectX�l�制囑�Ş之前�Q�对传给它的囑�Ş数据和绘制命令进行格式和数据完整性的��查，以保证它们被送到囑�Ş��g时不会导致硬件出问题�Q�这是很必要的一步操作，但是不幸的是�q�会带来很大的性能开销�?/p>

　　从上表我们可以很�Ҏ��的看出，在DirectX 9中，每次�l�制一帧画面之前，都会对即��用的相关数据�q�行一�ơ验证。而DirectX 10中，仅当�q�些数据被创建后验证一�ơ。这很明显是可以大大提高游戏�q�行中的效率的�?/p> 降低囑�Ş�q�算对CPU的依�?/strong>
　　在降低图形运��对CPU的依赖方面，DirectX 10 引入的三个重要机制就是：�U�理阵列(texture arrays)、绘刉��?(predicated draw)和流式输�?stream out)。不要被�q�三个晦涩的名词吓倒，实际上它们是三个不难理解的机制�?/p>
　　�U�理阵列

　　传统的DirectX在多张纹理中�q�行切换的操作是�U�很�l�CPU带来很大压力的操作，因�ؓ每切换一�ơ，都要调用一�ơDirectX的API函数。而每�l�制一个��用新�U�理的物体，��p��q�行一�ơ这��L��切换操作�Q�有时�ؓ了实现特�D�的材质�Ҏ��Q�绘制一个物体时可能��p��切换好几�ơ纹理，开销很大�?/p>
　　所以，之前游戏中经�怼�出现��大量的��纹理拼合到一张大的纹理中�Q�通过�l�不同的三维物体分配�q�张大纹理的不同局部的方式�Q�以期减��纹理切换，提高游戏�q�行效率。这�U�方式实现�v来相当复杂，而且DirectX 9中对�U�理的尺寸的限制�?048×4048像素�Q�也��是��_��如果要容下更多的��纹理块�Q�可能就得加载很多张�q�样的大�U�理�?/p>
　　DirectX 10引入的新的纹理阵列机构，��允许在一个由昑֍��l�护的阵列中容纳512张单独的�U�理�Q�而且�Q�在shader�E�序中可以��用一条新的指令来获取�q�个阵列中的��L��一张纹理。而这�U�shader指��o是运行在GPU中的�Q�这��P��把原来要消耗很多CPU旉��的纹理切换工作轻村֜�转给了GPU。由于纹理一般是直接攑֜�昑֭�中的�Q�因此以�q�样的方式，��工作交与和昑֭�一同位于显卡上的GPU来完成更有效率。如今，在DirectX 10中，只要一开始设�|�好�U�理阵列中的�U�理�Q�然后每�ơ绘制一个物体时为它指定一个纹理的索引��P��q�同物体三维数据一起传递到shader中，��可以放心的让GPU来给物体选纹理了�?/p>
　　�l�制预测

　　在一般的三维场景里，很多物体都是完全被别的物体挡在后面的。这时候如果要昑֍��l�制�q�些物体��是白费力气。尽��高�U�的GPU可以通过��g��法��场景画面中被挡住的像素(注意是像�?预先剔除�Q�但是仍然会有很多不应进行的多余�q�算。例如，一个完全被挡住的复杂的角色模型�Q�它的��n上可能有几千个顶点，需要做复杂的骨骼皮肤动��d��理、顶点光照运��等�{�，然而，GPU是在处理完这些顶点之后，�q�要把这个角色模型一个像素一个像素地��d��画面中时�Q�才开始判断每个像素是否需要画�Q�而当所有的像素都被剔除了时�Q�之前做的顶点处理也��全白费了。在DirectX 10中的�l�制预测便正是针对这�U�情�늚�解决�Q�简�a�之，�l�制预测通过用一个可以代表某个复杂物体的��单物体来判断�q�个物体是否被全部挡住了�Q�例如用一个可以罩住刚才那个角色的大盒子，当绘制这个盒子时�Q�如果发现所有的像素都被屏蔽掉了�Q�也��x��说这个盒子肯定完全看不见�Q�那么，里面的角色绘制包括骨骼皮肤运��等之类的操作便完成不必�q�行。而一个盒子顶多有八个��点�Q�相比处理几千个��点�Q�开销��得多�?/p>
　　另外�Q�以前这个步骤中有些真运��也需CPU完成的，在DirectX 10中，已经完全交由GPU来做�Q�这也可以在一定程度上减轻CPU的压力�?br>数据��式输出

　　数据��式输出也是DirectX 10的重要特性，它允许GPU上的Vertex shader或Geometry shader向显存中��d��数据�Q�而这在以往的vertex shader中是不可能的�?/p>
　　在之前的DirectX版本中，vertex shader只能��d��昑֭�中已有的��点数据�Q�而DirectX 10中引入的新的Geometry shader�Q�不但能��d��昑֭�中的��点数据、几�?炏V��线�D�c��三角�Ş)数据�Q�还可以生成新的几何数据攑֛�昑֭��?/p> 扚w��l�制
　　在DirectX 9中，�Ҏ��染状态的��理一直是个十分信赖于CPU�q�算能力的操作。所谓渲染状态，是指昑֍��q�行一�ơ绘制操作时所需要设�|�的各种数据和参数。例如，要绘制一个�h物角�Ԍ��需要先讄��他的几何模型数据的数据格式、纹理过滤模式、半透明混合模式�{�等�Q�每讄��一��，都要调用一�ơDirectX API�Q�占用大量CPU旉��Q�极大的�U�束了渲染的性能�?/p>
　　��Z��使这些操作能够批量的�q�行�Q�DirectX 10中引入了两个新的�l�构——状态对�?state object)和常量缓�?constant buffers)�?/p>
　　状态对象就是将以前的零散状态按照功能归�l��ؓ几个整体�Q�这��P��当要讄��一�p�d��相关状态时�Q�无需为每一个状态来调用一�ơDirectX API,只需要调用一�ơ将�q�些状态统�l�设�|�到昑֍�中去�?/p>
　　而常量缓冲是另一个十分有意义的机制。在�l�制模型前的准备工作中，渲染状态的讄��只是一��部分。还是拿�l�制人物角色来说�Q�能照亮�q�个人的光源的颜艌Ӏ�位�|�、类型、范围等�{�，都要提前讄��昑֍��Q��ؓ了通过骨骼来带动他的皮肤做出姿势，�q�要讄��骨骼的位�|�信息等�{�，而这些东西主要都是通过GPU中的帔R��寄存�?constant registers)来传递给它的。每个常量寄存器可以存储一�?�l�的��点型向�?卛_��个��Q�Ҏ��)。常量寄存器是游戏程序向GPU输入游戏场景中数据的重要途径�?/p>
　　在DirectX 9中，�q�种帔R��寄存器的数量是十分有限的�Q�而且每次更新一个寄存器�Q�都需要调用一�ơDirectX API函数。DirectX 10通过使用帔R��~�冲(constant buffer)�q�种�l�构�Q�在每个constant buffer中都可以容纳4096个常量，而且只需调用一�ơAPI��可以更��C��大批帔R��?/p>
　　比如��_��在以前的DirectX版本中，如果�E�序惛_��场景里画很多的树木和杂草�Q�可以采用一个类��g��“克隆”的方法：先做好一��|��几棵树、草的三�l�模型，然后在画一帧画面时�Q�不停的在不同的位置、方向，用不同的大小为参敎ͼ�调用DirectX API的绘制函数来画这些模型，��可以画出很多草木来。但是每��M��，都要讄��一大堆参数后调用一�ơAPI�Q�这是很耗CPU旉��的，所以在以前的游戏中鲜有大规模且�l�节丰富的森林场景�?/p>
　　而在DirectX 10中，我们可以先把树、草的几个模型设�l�显卡，然后��所有要�ȝ��树木的位�|�、方向和大小一�ơ性的写入到constant buffer中，�q�样�Q�显卡便一下把所有的树木和草都一��L��制出来了�?/p>
　　��M��Q�DirectX 10通过提前数据验证、纹理阵列、绘刉��、流式输出、状态对象、常量缓冲等机制�Q�帮助游戏的效果和效率上升到一个新的高度。这��P��也避免了之前DirectX版本因CPU负蝲�q�大而无法对囑�Ş实施更多�l�节优化的问题�?/p>
Shader Model 4.0

　　DirectX 10另一个引人瞩目的�Ҏ��便是引入了Shader Model 4.0�Q�那么，Shader Model 4.0能够带来怎样的新�Ҏ��，特别是将它与DirectX 9.0c中Shader Model 3.0相比�Ӟ��

　　引入新Shader : Geometry shader

　　DirectX 10新引入的Geometry Shader�Q�可以简单地�~�程操纵几何囑օ��Q�同�Ӟ�� vertex、geometry、pixel shader采用了统一的Sahder架构�?/p>
　　Geometry shaders是可�~�程囑�Ş��水�U�的一大进步。它�W�一�ơ允许由GPU来动态的生成和销毁几何图元数据。通过和新的数据流输出功能配合使用�Q�许多以前无法实施的��法现在都可以在GPU中��用了�?/p>
　　�l�一的Shader架构

　　在DirectX 9中，Pixel shader��L��在各个方面落后于vertex shaders�Q�包括常量寄存器个数、可用的指��o个数、shader长度�{�。程序员需要区分对待这两种shader�?/p>
　　而在shader model 4中，无论 vertex、geometry和pixel shader�Q�均有统一的指令集、同��L��临时/帔R��寄存器个敎ͼ�它们��^�{�的�׃�nGPU中的所有可用资源。这��P��在编�E�时便不必再考虑每种shader自��n的限制了�?/p>
　　癑ր�于DirectX 9的可用资�?/em>

　　对于shader中可用的资源�Q�在Shader model 4.0中比原来有了惊�h的扩充。就像早期的�E�序员们�l�尽脑汁的省着用可怜的640k内存一��P��在��用以前的DirectX开发游戏的�q�程中，�E�序员需要小心翼��的分配珍贵的shader寄存器资源。寄存器的数量，直接影响着shader�E�序的复杂度。这和在640k内存�?机器上，怎么也不可能写出Microsoft Office�q�样的大规模软�g是同一个道理�?/p>
　　而在DirectX 10中，��时寄存器由原来的32个扩充到�?096个，��常量寄存器由原来的256个扩充到�?5536个�?/p>
　　更多的渲染目�?Render Target)

　　所谓渲染目标，��是指GPU可以把画面绘制到的目标，我们可以把它理解为GPU的画布。一般来��_��渲染目标被输出到屏幕上，�q�样我们��p��看到��d��的画面了。但是有时�ؓ了实��C��些特效，某些渲染�l�果�q�不直接��d��屏幕上，而是再返�l�GPU做进一步的�Ҏ��处理�Q�而且渲染目标中也不一定是��d��的画面的颜色信息�?/p>
　　�Ҏ��囑�Ş�Ҏ��的需要，渲染目标可能是每个物体距��d��q�的�q�近�Q�或者物体表面上每个像素的方向，或者每个物体表面的温度�{�等�Q�之��Z��实现�Ҏ��Q�可以按需要在其中�l�制��M��信息。�ؓ了提高这�U�情况下的效率，很多新的昑֍�都支持在同一遍Shader执行�l�束后，同时把不同的信息�l�制��C��同的渲染目标中。在DirectX 9中就已经支持�q�种机制了，但是它约束最多同时向四个渲染目标�l�制。而DirectX 10��这个数量提升了一倍�?/p> 更多的纹�?/em>
　　在Shader Model 4.0中提供了对纹理阵�?Texture arrays)的支持。在前文中已�l�对�U�理阵列有了比较详细的介�l�，在这里只着重介�l�一下与shader相关的部分�?/p>
　　在每个纹理阵列中�Q�最多可以保�?512张同样大��的�U�理。而且每张贴图的分辨率被扩展到�?192×8192。更大的分��L率意味着�U�理中更丰富的细节。在一个shader中能够同时访问的�U�理个数被增加到�?28个，也就是说在每�ơ执行同一个shader�Ӟ��可以使用一个纹理阵列的512个纹理中�?28个。所以说�Q�在DirectX 10中，�U�理的多��h��和�l�节�E�度��会有大�q�的提升�?/p>
　　新的HDR颜色格式

　　要说�q�些�q�来在实时图形界炒得最热的概念�Q�应该是HDR了。它通过采用��点格式的颜色格式来为纹理、光照等计算提供极大的精度和颜色范围(以前的纹理一�?都是采用整数型的颜色格式)。尽��最后显�C�到屏幕上还是每个颜色通道8位的整数格式�Q�但是以前由于在材质、光照计��中�U�理也是用每通道8位的格式来参与计��，所以在昄��到画面之前，很多�l�节��在低精度的�q�算中丢�׃��?/p>
　　而采用每颜色通道16位��Q�Ҏ��的纹理，能够保证在运��过�E�中几乎没有颜色�l�节信息的丢失。另外，采用16位��Q�Ҏ��式的颜色通道�Q�可以表现更大的颜色范围。这些就是HDR的优��性�?/p>
　　对用戯��言�Q�当游戏中的画面�|�上一层HDR效果后，立刻昑־�和真正的照片一��P��有朦胧的光晕、细致的高光和十分自然的色调�?/p>
　　然而，采用每个颜色通道16位��Q�Ҏ��的格式，比采用每通道8位的整数格式的纹理要多占据一倍的昑֭��Q�这�l�绘制的效率带来了负面的影响。所以在 DirectX 10中引入了两个新的HDR格式。第一�U�是R11G11B10�Q�表�C�红色和�l�色通道�?1位��Q�Ҏ��Q�而蓝色通道采用10位��Q�Ҏ��表示。那么，��Z��么不都用 11位呢�Q�这是�ؓ了凑32�q�个整数。学�q�计��机的�h都知道，当内存中一个数据单元的宽度�?2位时�Q�对它的操作效率最高；而且在纹理数据中一般要求每个像素的数据宽度�?的倍数�Q�如2,8,16,32,64�{�等。又因�ؓ人眼对蓝色的敏感度不如对�U�色和绿�Ԍ��所以它比其他两个通道��用了一位�?/p>
　　另外一�U�格式是采用每通道9位尾数、所有通道�׃�n5位指数的形式(众所周知�Q�在计算��Z��Q��Q�Ҏ��是采用尾数附加指数的形式来表�C�的)�Q�加��h��q�是32位�?�q�些新的格式使得�U�理能够与原来占用同样多的显存空��_��避免了大的空间和带宽消耗。同�Ӟ��Z��适合需要精��的�U�学计算的场合，DirectX 10能够支持每通道32�?4个通道加�v�?28�?�_�ֺ�的��Q�Ҏ��U�理�?/p>
　　DirectX 10中带来的�q�些扩充和提高，使得创徏前所未有的细节的实时游戏场景真正成�ؓ可能�?/p>
几何着色器与流式输�?/h2>
　　在DirectX 10发布之前�Q�图形硬件只有在GPU上操作已有数据的能力。顶点着色器(Vertex Shader)和像素着色器(Pixel Shader)都允许程序操作内存中已有的数据。这�U�开发模型非常成功，因�ؓ它在复杂�|�格蒙皮和对已有像素�q�行�_��计算斚w��都表现的很出艌Ӏ�但是，�q�种开发模型不允许在图像处理器上生成新数据。当一些物体在游戏中被动态的创徏�?比如新型武器的外�?�Q�就需要调用CPU。可惜现在大多数游戏已经很给CPU带来了很大的压力�Q�游戏进行时动态创建庞大数量新数据的机会就变得微乎其微了�?/p>
　　Shader Model 4.0中引入的几何着色器(Geometry Shader)�Q�第一�ơ允许程序在囑փ�处理器中创徏新数据。这一革命性的事�g使得GPU在系�l�中的角色由只可处理已有数据的处理器变成了可以以极快速度既可处理又可生成数据的处理器。在以前囑�Ş�pȝ��上无法实现的复杂��法现如今变成了现实�?/p>
　　几何着色器被放在顶点着色器和光栅化阶段(Rasterizer)中间。所谓光栅化�Q�就是一行一行的扫描每个三角形，把它们一个像素一个像素的�l�制到画�?上。几何着色器把经�q�顶点着色器处理�q�的��点当作输入�Q�对于每个顶点，几何着色器可以生成1024个顶点作��出。这�U�生成大量数据的能力叫做数据扩大 (Data Amplification)。同��L��Q�几何着色器也可以通过输出更少的顶�Ҏ��删除��点�Q�因此，��叫做数据羃��?Data Minimization)。这两个新特性��GPU在改变数据流斚w��变得异常强大�?/p>
　　�l�分的虚拟位�U�脓�?Displacement Mapping with Tessellation)

　　几何着色器让虚拟位�U�脓囑֏�以在GPU上生成。虚拟位�U�脓图是在离�U�渲染系�l�中非常��行的一��Ҏ��术，它可以用一个简单的模型和高度图(Height Map)渲染出非常复杂的模型。高度图是一张用来表�C�模型上各点高度的灰度图。渲染时�Q�低多边形的模型会被�l�分成多边�Ş更多的模型，再根据高度图上的信息�Q�把多边形挤出，来表现细节更丰富的模型�?/p>
　　而在DirectX 9中，GPU无法生成新的数据�Q�低多边形的模型无法被细分，所以只有小部分功能的虚拟位�U�脓囑֏�以实现出来。现在，使用DirectX 10的强大力量，��C��千计的顶点可以凭�I�创造出来，也就实现了实时渲染中真正的细分的虚拟位移贴图�?/p>
　　��Z��边缘(Adjacency)的新��法

　　几何着色器可以处理三种囑օ��Q�顶炏V��线和三角�Ş。同��L��Q�它也可以输��三种囑օ�中的��M��一�U�，虽然每个着色器只能输出一�U�。在处理�U�和三角形时�Q�几何着色器有取得边�~�信息的能力。��用线和三角�Ş边缘上的��点�Q�可以实现很多强大的��法。比如，边缘信息可以用来计算卡通渲染和真实毛发渲染的模型轮廓�?/p>
　　��式输出(Stream Output)

　　在DirectX 10之前�Q�几何体必须在写入内存之前被光栅化�ƈ送入像素着色器(pixel shader)。DirectX 10引入了一个叫做数据流式输�?Stream Output)的新�Ҏ��，它允许数据从��点着色器或几何着色器中直接被传入帧缓冲内�?Frame Buffer Memory)。这�U�输出可以被传回渲染��水�U�K��新处理。当几何着色器与数据流输出�l�合使用�Ӟ��GPU不仅可以处理新的囑�Ş��法�Q�还可以提高一般运��和物理�q�算的效率�?/p>
　　在生成、删除数据和数据��输��些技术的支持下，一个完整的�_�子�pȝ��可以独立地在GPU上运行了。粒子在几何着色器中生成，在数据扩大的�q�程中被扩大与派生。新的粒子被数据��输出到内存�Q�再被传回到��点着色器制作动画。过了一�D�|��_��它们开始逐渐消失�Q�最后在几何着色器中被销毁�?br>

高��渲染语言(HLSL 10)

　　DirectX 10 ��Z��前的DirectX 9中的“高��着色语�a�”(High Level Shading Language )带来了诸多功能强大的新元素。其中包括可以提升常量更新速度�?#8220;帔R��~�冲�?#8221;(Constant Buffers)�Q�提升渲染流�E�中操作数据的灵�z�L��的“视图”(view)�Q��ؓ更广泛的��法所准备�?#8220;整数与位指��o”(Integer and Bitwise Instructions)�Q�添加了switch语句�?/p>
　　帔R��寄存�?Constant Buffers)

　　着色程序同普通的�E�序一样需要��用常量来定义各种参数�Q�例如光源的位置和颜�Ԍ��摄像机的位置和投��q��阵以及一些材质的参数(例如反光�?。在整个渲染的过�E�中�Q�这些常量往往需要频�J�的更新�Q�而数以百计的帔R��的��用以及更新无疑会�l�CPU带来极大的负载。DirectX 10中新加入的常量缓冲器可以�Ҏ��他们的��用频率将�q�些帔R��分配到指定的�~�冲器中�q�协调的对其�q�行更新�?/p>
　　在一个着色程序中DirectX 10支持最�?6个常量缓冲器�Q�每一个缓冲器可以存放4096个常量。与其相比DirectX 9实在是少得可怜，因�ؓ它在每个着色程序中同时最多只能支�?56个常量�?/p>

　　相比DirectX 9�Q�DirectX 10不仅提供了更多的帔R��Q�最主要的是它大�q�的提升了常量更新的速度。对那些被分配到同一个缓冲器中的帔R��Q�我们只需�q�行一�ơ操作就可以��它们全部更新完毕，而非单个单个的去更新�?/p>
　　�׃��不同的常量更新的旉��间隔各异�Q�所以跟据��用的频率来对他们�q�行�l�织��可以获得更高的效率。�D例来��_��摄像机的视矩阵只在每一帧之间发生改变，而类��D��图信息这��L��材质参数却会在图元切换时发生改变。于是这些常量缓冲器被分成了两个部分�Q�那些每帧更新的帔R��~�冲器专门存��N��些需要在两��间更新的常数�q�在两��间一�ơ把他们全部更新�Q�另外的囑օ�切换更新的常量缓冲器也同理。这样就会将更新帔R��q�程中的一些不必要的工作消除，以便让整个着色器脚本比在 DirectX 9中运行的更加��畅�?/p> 视图(Views)
　　在DirectX 9中，着色器(shader)中的数据的类型是被严格划分开的。例如，��点着色器用到的顶点缓冲器中的数据不能当作贴图的数据来让像素着色器使用。这样就��特定的资源�c�d��同其相对应的渲染��程中的特定步骤紧密地结合了��h��Q�同旉��制了资源资源在整个渲染流�E�中可以使用的范围�?/p>
　　DirectX 10舍弃�?#8220;严格区分的数据类�?#8221;�q�一概念。当一�D�|��据被创徏�Q�那么DirectX 10所做的仅仅是将其简单的当作内存中的一�D�区�?bit field)来对待。如果要想��用这一�D�|��有定义类型的数据��必��通过使用一�?#8220;view”�?使用“view”�Q�相同的一�D�|��据就可以有各�U�各��L��Ҏ��来读取。DirectX 10支持对同一�D�资源在同时使用两个“view”�?/p>
　　通过�q�种多重“view”的手�D�，��可以在整个渲染��程的不同部分以不同目的使用同一�D�|��据。例如：我们可以通过像素着色器��一�D�几何数据渲染到一张纹�?上，之后��点着色器通过一�?#8220;view”��这张纹理视��Z��个顶点缓冲器�q�将其中的数据作为几何数据渲染�?#8220;view”通过在整个渲染流�E�中的不同步骤重�?使用同一�D�|��据�ؓ“数据处理”带来了更大的灉|��性，帮助开发者实现更多更有创意更�_�ֽ�的特效�?/p>
　　整数与位�q�算指��o(Integer and Bitwise Instructions)

　　在新的高�U�着色器语言中添加了“整数与位指��o”�Q�这��h��“整数与位�q�算指��o”的操作加入其基础�q�算函数的好处在于帮助一些算法在GPU上的实现。开发者终于可以直接��用整数而非从��Q点中��{来计��出准确的答案。数�l�的索引��L��在可以轻杄��计算出来。GPU无整数运��的时代�l�于被终�l�了。这��ؓshader �E�序的开发带来很大的便利�?/p>
　　Switch 语句(Switch Statement)

　　在DirectX 10中， HLSL可以支持switch语句�Q�这��大�q�简化那些有着大量判断(分支)的着色器脚本的编码。一�U�用法就是徏立一�?#8220;航母�U�的着色器(shader) �E�序”——包含了大量的小型着色器�E�序�q�且自��n体�Ş巨大的着色器�E�序。在�q�个“航母�U�的着色器�E�序”�Q�我们可以通过讑֮�一个材质ID在switch语句�?判断来轻杄��在渲染同一个图元时切换不同的特效。也��是��_��现在一个军队中的每个士兵��n上都可以拥有各自不同的特效了�?/p>
DirectX 10的其他改�q?/h2>
　　alpha to coverage

　　在游戏中�Q�经�怋�用带有半透明信息�U�理的多边�Ş模型来模拟复杂的物体�Q�例如，草、树叶、铁丝网�{�。如果��用真正的模型�Q�一颗边�~�参差不齐的��草可能��p��消耗掉几百个多边�Ş�Q�然而采用透明�U�理�Q�可以只�?�?个多边�Ş��p��决了�?/p>

透明�U�理�C�意

　　然而，当��用这�U�有半透明信息的纹理时候，它的不透明和透明部分的边界线上，常常会出现难看的锯��。采用半透明混合技术可以解册��个问题，但是它需要把场景中所有这�cȝ��体按照由�q�到�q�的��序来绘�Ӟ��才能保证它们的遮挡关�p�L��正确的，�q�会�l�CPU带来很大的压力，�q�不可取。在以前版本的DirectX中，alpha��试和�؜合简直就是图形程序员的噩梦�?/p>
　　在DirectX 10中，使用了一�U�新的技术叫做Alpha to coverage。��用这�U�技术，在透明和不透明交界处的�U�理像素会被�q�行多极取样(Multi-sample)�Q�达到抗锯��的效果。这��在不引入大的性能开销的情况下��单�ƈ有效地解决了�q�个问题。室外场景的游戏��大大受益于�q�种技术，树叶、铁丝网、草的边�~�将会更加柔和、圆滑�?/p>

Alpha to coverage效果

　　shadow map filtering

　　阴媄�?Shadow map)技术已�l�逐渐成�ؓ了渲染真实感阴媄的流行技术。在包括《战争机器》、《分裂细胞：双重特工》、《Ghost Recon》、《刺客信条》等的各大次世代游戏中都能看到它的��n影。然而，�׃��shadow map的尺寔R��Ӟ��用它实现的阴��p��~�往往有明昄��锯��。在DirectX 10中，提供了对shadow map�q�行�q��o的功能的正式支持。经�q�过滤后�Q�阴��q��边缘��会变得更加柔和�?/p>

清源游民 2007-05-31 15:11 发表评论

清源游民 — Mon, 14 May 2007 07:56:00 GMT

const 引用是指向const 对象的引�?/span>

const int ival=1024;
const int &refVal=ival; //ok,both reference and object are const
int &ref2=ival;        //error! non const reference to a const object
可以��d��但不能修改refVal,因此�Q��Q何对refVal的赋值都是不合法的。这个限制有其意义：不能直接对ival同��|��因此不能通过使用refVal来修改ival�?br>同理�Q�用ival初始化ref2也是不合法的�Q�ref2是普通的非const引用�Q�因此可以用来修改ref2 指向的对象的倹{��能�q�ref2对ival赋��g��D��修改const对象的倹{��ؓ��L��q�样的修改，需�?span style="COLOR: #ff00ff">规定��普通的引用�l�定到const对象是不合法的�?/span>

const 引用可以初始化�ؓ不同�c�d��的对象或者初始化为右�?/span>�Q�如字面值常量：
int i=42;
// legal for const reference ONLY!
const int &r=42;
const int &r2=r+i;

double dval=3.14;
const int &r3=dval;
�~�译器展开�Q?br>int temp=dval;
const int &ri=temp;

非const引用只能�l�定��C��该引用同�c�d��的对象�?br>const引用则可以绑定到不同但相关的�c�d��的对象或�l�定到右倹{�?/span>

在C++中真正的临时对象是看不见的，它们不出现在你的源代码中。徏立一个没有命名的非堆�Q�non-heap�Q�对象会产生临时对象。这�U�未命名的对象通常在两�U�条件下产生�Q?span style="COLOR: #ff00ff">��Z��使函数成功调用而进行隐式类型�{换和函数�q�回对象时�?/span>理解如何和�ؓ什么徏立这些��时对象是很重要的�Q�因为构造和释放它们的开销对于�E�序的性能来说有着不可忽视的媄响�?br>首先考虑��Z��函数成功调用而徏立��时对象这�U�情��c��当传送给函数的对象类型与参数�c�d��不匹配时会��生这�U�情��c�?/p>
在字�W�计数的例子里，能够成功传递char数组到countChar中，但是在这里试囄��char数组调用upeercasify函数�Q�则不会成功�Q�。考虑一下这个函敎ͼ�
void uppercasify(string& str);
char subtleBookPlug[] = "Effective C++";
uppercasify(subtleBookPlug); // 错误!
没有��Z��调用成功而徏立��时对象，��Z��么呢�Q?br>假设建立一个��时对象，那么临时对象��被传递到upeercasify中，其会修改�q�个临时对象�Q�把它的字符�Ҏ��大写。但是对subtleBookPlug函数调用的真正参数没有�Q何媄响；仅仅改变了��时从subtleBookPlug生成的string对象。无疑这不是�E�序员所希望的。程序员传递subtleBookPlug参数到uppercasify函数中，期望修改subtleBookPlug的倹{��当�E�序员期望修攚w��临时对象�Ӟ��寚w��帔R��引用�Q�references-to-non-const�Q�进行的隐式�c�d��转换却修改��时对象�?span style="COLOR: #ff00ff">�q�就是�ؓ什么C++语言��止为非帔R��引用�Q�reference-to-non-const�Q��生��时对象�?/span>�q�样非常量引用（reference-to-non-const�Q�参数就不会遇到�q�种问题�?br>
把一个const对象的地址赋给一个普通的�Q�非const对象的指针也会导致编译时错误�Q?br>const double pi=3.14;
double *ptr=π   //error:ptr is a plain pointer
const double *cptr=π //ok:cptr is a pointer to const

不能使用void*指针保存const 对象的地址�Q�而必��ȝ��const void*�c�d��的指针保存�?/span>
const int universe=42;
const void *cpv=&universe; //ok;
void *pv=&universe;      //error:universe is const

允许把非const 对象的地址赋给指向const 对象的指�?/span>�Q?br>double dval=3.14;
cptr=&dval;
typedef string *pstring;
const pstring cstr;
//cstr is a const pointer to string
string *const cstr ; // equivalent to const pstring cstr;

Sales_item成员函数形参表后面的const后面所��L��作用:const 改变了隐含的this 形参的类�?/span>。在调用
total.same_isbn(trans)�Ӟ��隐含的this形参��是一个指向total对象的const Sales_item *�c�d��的指针�?br>�׃��this 是指向const对象的指针，const 成员函数不能修改调用该函数的对象�?br>const 对象�Q�指向const对象的指针或引用只能用于调用其const成员函数�Q�如果尝试用它们调用�?br>const 成员函数�Q�则是错误的�?

清源游民 2007-05-14 15:56 发表评论

用C++实现的一�U�插件体�pȝ��?----概述

清源游民 — Tue, 17 Apr 2007 07:54:00 GMT
     摘要:   阅读全文

清源游民 2007-04-17 15:54 发表评论

��类成员函数用做C回调函数

清源游民 — Fri, 30 Mar 2007 08:10:00 GMT

提出问题�Q?/font>
回调函数是基于C�~�程的Windows SDK的技术，不是针对C++的，�E�序员可以将一个C函数直接作�ؓ回调函数�Q�但是如果试囄��接��用C++的成员函��C��为回调函数将发生错误�Q�甚至编译就不能通过�?br />分析原因�Q?/font>
普通的C++成员函数都隐含了一个传递函��C��为参敎ͼ�亦即“this”指针，C++通过传递一个指向自�w�的指针�l�其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解�ؓ什么C++�cȝ��多个实例可以�׃�n成员函数但是��有不同的数据成员。由于this指针的作用，使得��一个CALLBACK型的成员函数作�ؓ回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配，从而导致回调函数安装失�?br />解决�Ҏ��Q?/font>
一,不��用成员函敎ͼ�直接使用普通C函数�Q��ؓ了实现在C函数中可以访问类的成员变量，可以使用友元操作�W?friend)�Q�在C++中将该C函数说明�?font color="#ff1493">�cȝ��友元卛_��。这�U�处理机制与普通的C�~�程中��用回调函��C��栗��?br />�?使用静态成员函�?/font>�Q�静态成员函��C��使用this指针作�ؓ隐含参数�Q�这样就可以作�ؓ回调函数了。静态成员函数具有两大特点：其一�Q�可以在没有�c�d��例的情况下��用；其二�Q�只能访问静态成员变量和静态成员函敎ͼ�不能讉K��非静态成员变量和非静态成员函数。由于在C++中��用类成员函数作�ؓ回调函数的目的就是�ؓ了访问所有的成员变量和成员函敎ͼ�如果作不到这一点将不具有实际意义。我们通过使用静态成员函数对非静态成员函�?font color="#ff1493">包装的办法来解决问题。类实例可以通过附加参数�?font color="#ff1493">全局变量的方式的方式传递到静态成员函��C��。分别�D例如下：
1�Q�参��C��递的方式
   #include
   class TClassA
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(void* pt2Object, char* text);
      // more....
   };

   // 静态包装函敎ͼ�能够调用成员函数Display(),本��n做�ؓ回调函数来��?/font>
   void TClassA::Wrapper_To_Call_Display(void* pt2Object, char* string)
   {
       // 昑ּ��c�d��转换
       TClassA* mySelf = (TClassA*) pt2Object;

       // 调用普通成员函�?br />       mySelf->Display(string);
   }

   // 回调函数的宿�?在这里回调用函数被��?br />   void DoItA(void* pt2Object, void (*pt2Function)(void* pt2Object, char* text))
   {
      // 使用回调函数
      pt2Function(pt2Object, "hi, i'm calling back using a argument ;-)");
   }

   // 执行�C�Z��
   void Callback_Using_Argument()
   {
      TClassA objA;
      DoItA((void*) &objA, TClassA::Wrapper_To_Call_Display);
   }

2�Q�全局变量的方�?br />   #include
   void* pt2Object;        // 全局变量,可以指向��L��对象
   class TClassB
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(char* text);

   };

   // 静态的包装函数
   void TClassB::Wrapper_To_Call_Display(char* string)
   {
       //需要保证全局变量值的正确�?br />       TClassB* mySelf = (TClassB*) pt2Object;
       mySelf->Display(string);
   }

   // 回调用函数的宿主,在这里回调用函数被��?br />   void DoItB(void (*pt2Function)(char* text))
   {

      pt2Function("hi, i'm calling back using a global ;-)");   // make callback
   }

   // 执行�C�Z��
   void Callback_Using_Global()
   {
      TClassB objB;
      pt2Object = (void*) &objB;
      DoItB(TClassB::Wrapper_To_Call_Display);
   }

注意�Q�通过上面两种�Ҏ��的比较可以看出，�W?�U�方法中静态包装函数可以和普通成员函��C��持签名一��_��当回调函数的宿主接口不能改变�Ӟ��q�种�Ҏ��特别有用。但因�ؓ使用了全局变量�Q�也不是一个好的设计�?/p>

清源游民 2007-03-30 16:10 发表评论

game c++

清源游民 — Wed, 27 Dec 2006 07:35:00 GMT
一般而言�Q�比起C�E�序来说�Q�C++游戏�E�序是可重用和可�l�护的。可�q�真的有价值吗�Q�复杂的C++可以在速度上与传统的C�E�序相提�q�论吗？
　　如果有一个好的编译器�Q�再加上对语�a�的了解，真的有可能用C++写出一些有效率的游戏程序来。本文描�q�C��典型的几�U�你可以用来加速游戏的技术。它假设你已�l�非常肯定��用C++的好处，�q�且你也对优化的基本概念相当熟悉�?br />　　�W�一个经常让��益的基本概念昄��是剖析（profiling�Q�的重要性。缺乏剖析的话，�E�序员将犯两�U�错误，其一是优化了错误的代码：如果一个程序的主要指标不是效率�Q�那么一切花在��其更高效上的旉��都是��费。靠直觉来判断哪�D�代码的主要指标是效率是不可信的�Q�只有直接去��量。第二个概念是程序员�l�常 "优化"到降低了代码的速度。这在C++是一个典型问题，一个简单的指��o行可能会产生巨大数量的机器代码，你应当经常检查你的编译器的输出，�q�且剖析之�?br />1、对象的构造与析构
　　对象的构造与析构是C++的核心概念之一�Q�也是编译器背着你��生代码的一个主要地斏V��未�l�认真设计的�E�序�l�常��p��不少旉��在调用构造函敎ͼ�拯��对象以及初始化��时对象等�{�。幸�q�的是，一般的感觉和几条简单的规则可以让沉重的对象代码跑得和C只有毫厘之差�?br />　　除非需要否则不构造�?br />　　最快的代码是根本不�q�行的代码。�ؓ什么要创徏一个你�Ҏ��不去使用的对象呢�Q�在后面的代码中�Q?br />
　　voide Function(int arg)
　　{
　　　　Object boj;
　　　　If(arg==0)
　　　　　　Return;
　　　　...
　　}

　　即便arg�?�Q�我们也付出了调用Object的构造函数的代�h。特别是如果arg�l�常�?�Q��ƈ且Object本��n�q�分配内存，�q�种��费会更加严重。显然的�Q�解��x��案就是把obj的定义移到判断之后�?br />　　��心在��@环中定义复杂变量�Q�如果在循环中按照除非需要否则不构造的原则构造了复杂的对象，那么你在每一�ơ��@环的时候都要付��Z��ơ构造的代�h。最好在循环外构造之以只构造一�ơ。如果一个函数在内��@环中被调用，而该函数在栈内构造了一个对象，你可以在外部构造�ƈ传递一个应用给它�?br />
　　1.1 采用初始化列�?br />　　考虑下面的类�Q?br />
　　class Vehicle
　　{
　　public
　　　　Vehicle(const std::string &name)
　　　　{
　　　　　　mName=name
　　　　}
　　private:
　　　　std::string mName;
　　}

　　因�ؓ成员变量会在构造函数本体执行前构造，�q�段代码调用了string mName的构造函敎ͼ�然后调用了一�?操作�W�，来拷贝其倹{��这个例子中的一个典型的不好之处在于string的缺省构造函��C��分配内存�Q�但实际上都会分配大大超�q�实际需要的�I�间。接下来的代码会好些�Q��ƈ且阻止了�?操作�W�的调用�Q�进一步的来说�Q�因为给��Z��更多的信息，非缺省构造函��C��更有效，�q�且�~�译器可以在构造函数函��C��为空的情况下��其优化掉�?br />
　　class Vehicle
　　{
　　public
　　　　Vehicle(const std::string &name):mName(name)
　　　　{ }
　　private:
　　　　std::string mName;
　　}

　　1.2 要前自增不要后自增（卌��++I不要I++�Q?br />　　当写x=y++时��生的问题是自增功能将需要制造一个保持y的原值的拯��Q�然后y自增�Q��ƈ把原始的��D��回。后自增包括了一个��时对象的构造，而前自增则不要。对于整敎ͼ��q�没有额外的负担�Q�但对于用户自定义类型，�q�就是浪费，你应该在有可能的情况下运用前自增�Q�在循环变量中，你会帔R��到这�U�情形�?br />　　不��用有�q�回值的操作�W?在C++中经常看到这样写��点的加法：

　　Vector operator+(const Vector &v1,const Vector &v2)

　　�q�个操作��引赯��回一个新的Vector对象�Q�它�q�必��被以值的形式�q�回。虽然这样可以写v=v1+v2�q�样的表辑ּ��Q�但象构造��时对象和对象的拷贝这��L��负担�Q�对于象��点加法�q�样常被调用的事情来说太大了一炏V��有时候是可以好好规划代码以�ɾ~�译器可以把临时对象优化掉（�q�一点就是所谓的�q�回��g��化）。但是更普遍的情形下�Q�你最好放下架子，写一炚w��看但更快速的代码�Q?br />
　　void Vector::Add(const Vector &v1,const Vector &v2)

　　注意+=操作�W��ƈ没有同样的问题，它只是修改第一个参敎ͼ��q�不需要返回一个��时对象，所以，可能的情况下�Q�你也可以用+=代替+�?br />
　　1.3 使用轻量�U�的构造函�?br />　　在上一个例子中Vector的构造函数是否需要初始化它的元素�?�Q�这个问题可能在你的代码中会有好几处出现。如果是的话�Q�它使得无论是否必要�Q�所有的调用都要付初始化的代仗��典型的来说�Q��旉��点以及成员变量就会要无辜的承受这些额外的开销�?br />　　一个好的编译器可以很好的移除一些这�U�多余的代码�Q�但是�ؓ什么要冒这个险呢？作�ؓ一般的规则�Q�你希望构造函数初始化所有的成员变量�Q�因为未初始化的数据��生错误。但是，在频�J�实例化的小�c�M��Q�特别是一些��时对象，你应该准备向效率规则妥协。首选的情况��是在许多游戏中有的vector和Matrix �c�，�q�些�c�L��然应当提供一些方法置0和识别，但它的缺省构造函数却应当是空的�?br />　　�q�个概念的推论就是你应当��U�类提供另一个构造函数。如果我们的�W�二个例子中的Vebicle�c�L��q�样写的话：

　　class Vehicle
　　{
　　public:
　　　　vehicle()
　　　　{
　　　　}
　　　　void SetName(const std::string &name)
　　　　{
　　　　　　mName=name;
　　　　}
　　private:
　　　　std::string mName
　　};

　　我们省去了构造mName的开销�Q�而在�E�后用SetName�Ҏ��讄��了其倹{��相似的�Q��用拷贝构造函数将比构造一个对象然后用=操作�W�要好一些。宁愿这��h��构造：Vebicle V1(V2)也不要这��h��构造：

　　Vehicle v1;v1=v2;

　　如果你需要阻止编译器帮你拯��对象�Q�把拯��构造函数和操作�W?声明为私有的�Q�但不要实现其中��M��一个。这��P��M��企图对该对象的拷贝都��生一个编译时错误。最好也��L��定义单参数构造函数的习惯�Q�除非你是要做类型�{换。这样可以防止编译器在做�c�d��转换时��生的隐藏的��时对象�?br />
　　1.4 预分配和Cache对象
　　一个游戏一般会有一些类会频�J�的分配和释放，比如武器什么的。在C�E�序中，你会分配一个大数组然后在需要的时候��用。在C++中，�l�过��小的规划以后，你也可以�q�样�q�Ӏ�这个方法是不要一直构造和析构对象而是��h��一个新而把旧的�q�回�l�Cache。Cache可以实现成一个模板，它就可以为所有的有一个缺省构造函数的�c�d��作。Cache模板的Sample可以在附带的CD中找到�?br />　　你也可以在需要时分配一些对象来填充Cache�Q�或者预先分配好。如果你�q�要对这些对象维护一个堆栈的话（表示在你删除对象X之前�Q�你先要删除所有在X后面分配的对象）�Q�你可以把Cache分配在一个连�l�的内存块中�?br />
2、内存管�?br />　　C++应用�E�序一般要比C�E�序更深入到内存��理的细节。在C中，所有的分配都简单的通过malloc和free来进行，而C++则还可以通过构造��时对象和成员变量来隐式的分配内存。很多C++游戏�E�序需要自��q��内存��理�E�序。由于C++游戏�E�序要执行很多的分配�Q�所以要特别��心堆的��片。一个方法是选择一条复杂的路：要么在游戏开始后�Ҏ��不分配�Q何内存，要么�l�护一个巨大的�q�箋内存块，�q�按期释放（比如在关卡之��_��。在��C��机器上，如果你想对你的内存��用很警惕的话�Q�很严格的规则是没必要的�?br />　　�W�一步是重蝲new�?Delete操作�W�，使用自己实现的操作符来把游戏最�l�常的内存分配从malloc定向到预先分配好的内存块去，例如�Q�你发现你�Q何时候最多有10000 �?字节的内存分配，你可以先分配�?0000字节�Q�然后在需要时引用出来。�ؓ了跟�t�哪些块是空的，可以�l�护一个由每一个空的块指向下一个空的块的列�?free list。在分配的时候，把前面的block�U�L��Q�在释放的时候，把这个空块再攑ֈ�前面厅R��图1描述了这个free list如何在一个连�l�的内存块中�Q�与一�p�d��的分配和释放协作的情形�?br />

�? A linked free list
[img]http://mays.soage.com/develop/optimize/200112/image/Other/OptFORCGame.gif[/img]

　　你可以很�Ҏ��的发��C��个游戏是有着许多��小的生命短暂的内存分配�Q�你也许希望为很多小块保留空间。�ؓ那些现在没有使用到的东西保留大内存块会浪费很多内存。在一定的��寸上，你应当把内存分配交给一支不同的大内存分配函数或是直接交�l�malloc()�?br />
3、虚函数
　　C++游戏�E�序的批评者��L��把矛头对准虚函数�Q�认为它是一个降低效率的��秘�Ҏ��。概忉|��的��_��虚函数的机制很简单。�ؓ了完成一个对象的虚函数调用，�~�译器访问对象的虚函数表�Q�获得一个成员函数的指针�Q�设�|�调用环境，然后跌��{到该成员函数的地址上。相对于C�E�序的函数调用，C�E�序则是讄��调用环境�Q�然后蟩转到一个既定的地址上。一个虚函数调用的额外负担是虚函数表的间接指向；�׃��事先�q�不知道��要跌��{的地址�Q�所以也有可能造成处理器不能命中Cache�?br />　　所有真正的C++�E�序都对虚函数有大量的��用，所以主要的手段是防止在那些极其重视效率的地方的虚函数调用。这里有一个典型的例子�Q?br />
　　Class BaseClass
　　{
　　public:
　　　　virtual char *GetPointer()=0;
　　};

　　Class Class1: public BaseClass
　　{
　　　　virtual char *GetPointer();
　　};

　　Class Class2:public BaseClass
　　{
　　　　virtual char *GetPointer();
　　};

　　void Function(BaseClass *pObj)
　　{
　　　　char *ptr=pObj->GetPointer();
　　}

　　如果Function()极其重视效率�Q�我们应当把GetPointer从一个虚函数�Ҏ��内联函数。一�U�方式是�l�BaseClass增加一个新的保护的数据成员�Q�在每一个类中设�|�该成员的��|��在GetPointer�q�个内联函数中返回该成员�l�调用者：

　　Class BaseClass
　　{
　　public:
　　　　inline char GetPointerFast()
　　　　{
　　　　　　return mpPointer;
　　　　}
　　protected:
　　　　inline void SetPointer(char *pData)
　　　　{
　　　　　　mpData = pData;
　　　　}
　　private:
　　　　char *mpData;
　　};

　　void Function(BaseClass *pObj)
　　{
　　　　char *ptr= pObj->GetPointerFast();
　　}

　　一个更�Ȁ�q�的�Ҏ��是重新规划你的类�l�承树，如果Class1和Class2只有一点点不同�Q�那么可以把它们捆绑到同一个类中去�Q�而用一个Flag来表明它��象Class1�q�是象Class2一样工作，同时在BaseClass中把�U�虚函数��L��。这��L��话，也可以象前面的例子一��h��GetPointer写成内联。这�U�变通看��h��不是很高雅，但是在缺��Cache的机器上跑内循环�Ӟ��你可能会很愿意�ؓ了去掉虚函数调用而把事情做得更加隄��?br />　　虽然每一个新的虚函数都只�l�每个类的虚表增加了一个指针的��寸�Q�通常是可以忽略的代�h�Q�，�W�一个虚函数�q�是在每一个对象上要求了一个指向虚表的指针。这��是说你在很��的、频�J��用的�c�M��使用��M��虚函数而造成了额外的负担�Q�这些都是不能接受的。由于��承一般都要用��C��个或几个虚函敎ͼ�臛_��有一个虚的析构函敎ͼ��Q�所以你没必要在��而频�J��用的对象上��用�Q何��ѝ�?br />
4、代码尺�?br />　　�~�译器因为C++产生冗长的代码而臭名昭著。由于内存有限，而小的东西往往是快的，所以��你的可执行文件尽可能的小是非帔R��要的。首先可以做的事情是拿一个编译器来研�I�。如果你的编译器会在可执行文件中保存 Debug信息的话�Q�那么把它们�U�除掉。（注意MS VC会把Debug信息攑֜�可执行文件外部，所以没关系�Q�异常处理会产生额外的代码，��可能的去除异常处理代码。确保连接器配置为去除无用的函数和类。开启编译器的最高优化��别，�q�尝试设�|��ؓ��寸最��化而不是速度最大化 �?有时候，�׃��Cache命中的提高，会��生更好的�q�行效果。（注意在��用这��设�|�时��查instrinsic功能是否也处于打开状态）��L��所有Debug 输出状态下的浪费空间的字符�Ԍ��使编译器把多个相同的字符串捆�l�成一个实例�?br />　　内联通常是造成大函数的首犯。编译器可以自由的选择注意或忽略你写的inline关键字，而且它们�q�会背着你制造一些内联。这是另一个要你保持轻量��的构造函数的原因�Q�这样堆栈中的对象就不会因�ؓ有大量的内联代码而膨胀。同时也要小心重载运��符�Q�即使是最��短的表达式如m1=m2*m3如果m2和m3是矩�늚�话，也可能��生大量的内联代码。一定要深入了解你的�~�译器对于内联的讄��?br />　　启用�q�行时类型信息（RTTI�Q�需要编译器为每一个类产生一些静态信息。RTTI一般来说是�~�省启用的，�q�样我们的代码可以调用dynamic_cast以及��一个对象的�c�d��Q�考虑完全��止使用RTTI和dynamic_cast以节省空��_��q�一步的��_��有时�?dynamic_cast在某些实��C��需要付出很高的代�h�Q�另一斚w��Q�当你真的需要有��Z��c�d��的不同行为的时候，增加一个不同行为的虚函数。这是更好的面向对象设计�Q�注意static_cast与这不同�Q�它的效率和C语言的类型�{换一��P��?br />
5、标准类库（STL�Q?br />　　标准�c�d��是一套实��C��常见的结构和��法的模板，例如dynamic arrays�Q�称为vector�Q�，set�Q�map�{�等。��用STL可以节省你很多时间来写和调试那些容器。和之前谈到的一��P��如果希望�pȝ��的效率最大化�Q�你必须要注意你的STL的具体实现的�l�节�?br />　　��Z��能够对应于最大范围的应用�Q�STL标准在内存分配这个领域保持了沉默。在STL容器中的每一个操作都有一定的效率保证�Q�例如，�l�一个set�q�行插入操作只要O(log n)的时��_��但是�Q�对一个容器的内存使用没有��M��保证�?br />　　让我们来仔细了解游戏开发中的一个非常普遍的问题�Q�你希望保存一�l�对象，�Q�我们会�U�其为对象列表，虽然不一定要保存在STL的列表中�Q�通常你会要求每个对象在这个表有且仅有一个，�q�样你就不用担心一个偶然��生的在容器中插入一个已存在单元的操作了。STL的set忽略副本�Q�所有的插入、删除和查询的速度都是O(log n)�Q�这是不是就是很好的选择呢？
　　虽然在set上的大多数操作的速度都是O(log n)�Q�但是这里面依然存在着潜在的危机。虽然容器的内存使用依赖于实玎ͼ�但很多实现还是在�U�黑树的基础上实现的。在�U�黑树上�Q�树的每一个节炚w��是容器的一个元素。常见的实现�Ҏ��是在每一个元素被加入到树�Ӟ��分配一个节点，而当每个元素被移出树�Ӟ��释放一个节炏V��根据你插入和删除的频繁�E�度�Q�在内存��理器上所��p��的时间将或多或少的媄响你通过使用set而获得的好处�?br />　　另外一个解��x��案是使用vector来存储元素，vector保证在容器的末端��d��元素有很高的效率。这表示实际上vector只在很偶然的情况下才重新分配内存�Q�也��是��_��当满的时候扩容一倍。当使用vector来保存一个不同元素列表的时候，你首先要��查元素是否已�l�存在，如果没有�Q�那么加入。而对整个vector��查一遍需要花费O(n)的时��_��但是但实际牵涉到的部分应该比较少�Q�这是因为vector的每个元素都在内存中�q�箋存放�Q�所以检查整个vector实际上是一个易于cache的操作。检查整个set��造成cache 不命中，�q�是因�ؓ在红黑树上分别存攄��元素可能散布在内存的各个角落。同�Ӟ��我们也注意到set必须额外�l�护一�l�标��C��讄��整个树。如果你要保存的是对象的指针�Q�set可能要花费vector所要花费的内存�?�?倍�?br />　　Set的删除操作消耗时间O(log n)�Q�看��h��是很快，如果你不考虑可能对free()的调用的话。Vector的删除操作消耗O(n)�Q�这是因��Z��被删除的那个元素开始到�l�尾处的元素�Q�每一个元素都要被拯��到前一个位�|�上。如果元素都只是指针的话�Q�那么这个拷贝将可以依靠一个简单的memcpy()来完成，而这个函数是相当快的。（�q�也是�ؓ什么通常都把对象的指针储存在STL的容器中的一个原因，而不是储存对象本�w�。如果你直接保存了对象本�w�，��会在很多操作中造成许多额外的构造函数的调用�Q�例如删除等�Q��?br />　　set和map通常来说�ȝ��大于有用�Q�如果你�q�没有意识到�q�一点的话，考虑遍历一个容器的代�h�Q�例如：

　　for(Collection::iterator it = Collection.begin(); it != Collection.end(); ++it)

　　如果Collection是vector�Q�那�?+it��是一个指针自增。但是当Collection是一个set或者是一个map的话�Q?+it包括了访问红黑树上的下一个节炏V��这个操作相当复杂而且很容易造成cache不命中，因�ؓ树的节点几乎遍布内存的各处�?br />　　当然�Q�如果你要在容器中保存大量的元素�Q��ƈ且进行许多的成员��h��Q�那么set的O(log n)的效率完全可以抵消那些内存方面的消耗。近似的�Q�如果你偶尔才��用容器，那么�q�里的效率差别就非常的小。你应该做一些效率评��C��了解多大的n会�� set变得更快。也�怽�会惊奇的发现在游戏的大多数典型应用下vector的所有效率都比set要高�?br />　　�q�还不是STL内存使用的全部。一定要了解当你使用clear�Ҏ��Ӟ��容器是否真的释放掉了它的内存。如果没有，��可能��生内存碎片。比如，如果你开始游戏的时候徏立了一个空的vector�Q�在游戏�q�程中增加元素，然后在游戏restart时调用clear�Q�这时vector未必释放它的全部内存。这个空的vector�Q�可能依然占据了堆中的内存，�q��其变成碎片。如果你真的需要这��h��实现游戏的话�Q�对�q�个问题有两�U�解法。一是你可以在创建vector时调用reserve()�Q��ؓ你可能需要的最大数量的元素保留��_��的空间。如果这不可行的话，你可以强�q�vector完全释放内存�Q?br />
　　Vector V;
　　// ... elements are inserted into V here
　　Vector().swap(v);　　// causes v to free its memory

　　Set、list以及map都没有这个问题，�q�是因�ؓ他们为每个元素分别分配和释放内存�?br />
6、高�U�特�?br />　　�~�程语言的某些特性你可能没必要用到。看上去��单的�Ҏ��可能会��D��低下的效率。而看��h��复杂的特性没准执行得很好。C++的这些黑暗角落异�怾�赖于�~�译器。当你要使用它们�Ӟ��必须了解它们的代仗��?br />　　C++的string��是一个看��h��不错的例子，但是在效率极光��要的场合应该避免使用�Q�考虑下面的代码�?br />
　　Void Function(const std::string &str)
　　{
　　}
　　Function("hello");

　　对Function()的调用包括了对给定const char*参数的构造函数的调用。在普遍的实��C��Q�这个构造函数执行了一个malloc()�Q�一个strlen()�Q�以及一个memcpy()�Q�而析构函数立��M��来做了一些无意义的事情。（�׃��该例子中的string没有被更多的应用�Q�然后又跟了一个free()。这里的内存分配完全是浪费，因�ؓ字符�?"hello"早就在程序的数据�D�中了。我们早��有它在内存中的副本了。如果Function定义了一个const char*的参敎ͼ�那么完全没有了上面所说的那些额外的调用。这��是��Z��使用方便的string而付出的高昂代�h�?br />　　模板是效率的对立面的一个例子，�Ҏ��语言标准�Q�编译器在模板实例化��Z��个具体的�c�d��时��生代码。理��Z��Q�看上去是声明了一个模板，但却实际产生了大量的�怼�的代码。如果你有了 class1的指针的vector�Q�也有class2的指针的vector�Q�你��在你的可执行文件中做了两䆾的vector的拷贝�?br />　　事实上，大多数的�~�译器做得更好，首先�Q�只有实际被使用到的模板成员函数被��生代码。其�ơ，如果事先了解了正��的行�ؓ�Q�编译器可以只��生一份代码的拯��。你可以从vector的例子发现这一点，��实只��生了一份代码（一般是vector�Q�。有了好的编译器�Q�模板还是可以在保持高效的同时提供你一般编�E�的好处�?br />　　C++的一些特性，比如初始化列表以及前自增�Q�一般来说可以提高效率。而象其它的一些特性比如运��符重蝲以及RTTI则看��h��g��是清白的�Q�但却有时带来严重的效率问题。STL的容器则描述了盲目相信函数的��法�q�行旉��可以如何让你误入歧途。避免��用潜在的低效率的语言或类库特性，同时�׃��旉��来了解你的编译器的各�U�选项。你会很快的学会设计高效的代码，�q�且解决掉你的游戏中的效率问题�?br />

清源游民 2006-12-27 15:35 发表评论

(转）剖析C++标准库智能指�?std::auto_ptr)

清源游民 — Fri, 15 Dec 2006 09:35:00 GMT
     摘要: 1.Do you Smart Pointer?       Smart Pointer,中文名：��指针, 舶来�?      不可否认,资源泄露(resource leak)曄��是C++�E�序的一大噩�?垃圾回收      机制(Garbage Collection)一旉��受注�?然而垃圾自动回收机制�ƈ不能      满��内存��理的即时性和可视�?往往佉K��傲的�E�序设计者感��C��自在.     ...  阅读全文

清源游民 2006-12-15 17:35 发表评论

如何��float转换为string

清源游民 — Fri, 15 Dec 2006 03:18:00 GMT

     可能有好多�h�Q�包括C语言老手都不知道如何��float数据转换为string�Q�我��是�q�样�Q�今天查了一下MSDN�Q�才知道C提供了_gcvt函数实现�q�个功能�Q�收��L��实不��，��Z��方便自己查询�Q�也��Z��那些像我�q�样的网友能够了解该函数的具体用法，我把MSDN的原文原��不动抄录如下：

_gcvt

Converts a floating-point value to a string, which it stores in a buffer.

char *_gcvt( double value , int digits , char * buffer );

Routine Required Header Compatibility

_gcvt Win 95, Win NT

For additional compatibility information, see Compatibility in the Introduction.

Libraries

LIBC.LIB Single thread static library, retail version

LIBCMT.LIB Multithread static library, retail version

MSVCRT.LIB Import library for MSVCRT.DLL, retail version

Return Value

_gcvt returns a pointer to the string of digits. There is no error return.

Parameters

value

Value to be converted

digits

Number of significant digits stored

buffer

Storage location for result

Remarks

The _gcvt function converts a floating-point value to a character string (which includes a decimal point and a possible sign byte) and stores the string in buffer. The buffer should be large enough to accommodate the converted value plus a terminating null character, which is appended automatically. If a buffer size of digits + 1 is used, the function overwrites the end of the buffer. This is because the converted string includes a decimal point and can contain sign and exponent information. There is no provision for overflow. _gcvt attempts to produce digits digits in decimal format. If it cannot, it produces digits digits in exponential format. Trailing zeros may be suppressed in the conversion.

Example

/* _GCVT.C: This program converts -3.1415e5 * to its string representation. */#include #include void main( void ){ char buffer[50]; double source = -3.1415e5; _gcvt( source, 7, buffer ); printf( "source: %f buffer: '%s'\n", source, buffer ); _gcvt( source, 7, buffer ); printf( "source: %e buffer: '%s'\n", source, buffer );}

Output

source: -314150.000000 buffer: '-314150.'source: -3.141500e+005 buffer: '-314150.'

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=708935

[收藏到我的网�?/a>]   skyman_2001发表�?2006�q?5�?5�?11:28:00

#  lanno 发表�?006-05-05 18:26:00  IP: 222.35.68.*

长见识了�Q�俺��L��q�样转化的：
char str[260];
float f = -3.1415926;
float f1 = 263e-5;
sprintf(str,"%f",f);
printf("%s\n",str);
sprintf(str,"%f",f1);
printf("%s\n",str);

#  Skyman 发表�?006-05-05 21:35:00  IP: 202.202.10.*

你这样做也行
但没有这��L��z?
是吧�Q?/div>

#  zhnde 发表�?006-05-11 20:15:00  IP: 129.69.212.*

灉|��吗？能具体解释一下吗�Q?/div>

#  Skyman 发表�?006-05-11 22:03:00  IP: 202.202.10.*

臛_��可以方便的控制有效数字的位数啊�?/div>

#  ztwaker 发表�?006-07-28 12:40:00  IP: 61.144.207.*

/*C++ impl*/
string cvt(const float fval)
{
stringstream ss;
ss << fval;
return ss.str();
}

......///

#  ztwaker 发表�?006-07-28 12:46:00  IP: 61.144.207.*

加上有效数字位数控制

string cvt(const float f, const int prec)
{
stringstream ss;
ss.precision(prec);
ss << f;
return ss.str();
}

清源游民 2006-12-15 11:18 发表评论

清源游民 — Thu, 14 Dec 2006 10:16:00 GMT

C++中基��c�M��相引用带来的问题

在一些大的工�E�中�Q�可能会包含几十个基��c�，免不了之间会互相引用 ( 不满��承关�p�，而是�l�合关系 ) 。也��是需要互相声明。好了，�q�时候会带来一些�؜乱。如果处理得不好�Q�会搞得一团糟�Q�根据我的经验，��单谈谈自已的处理办法�Q?/font>

�~�码�Ӟ��我们一般会��量避免 include 头文�Ӟ��而是采用声明 class XXX �?/font> 但有时候还是必��ȝ�� Include 头文�Ӟ��那么�Q�两者的划分在于什么呢�Q?/font>

应该是很明确的，但书上好像都��有提及�?/font>

首先�Q?/font>
我们要明白�ؓ什么要用声明取代头文�g包含�Q�对了，是�ؓ了避免无必要的重�~�译 ( 在头文�g发生变更�?/font> ) �?/font> 工程较大�Q�低速机�Q�或基础�cȝ��常变�?/font> ( 不合理的设计�?/font> ) �Q�编译速度�q�是会在意的�Q?/font> 另外�Q�更为重要的是，采用声明可降低代�?/font> (class) 之间的藕合度�Q�这也是面向对象设计的一大原则�?/font>

二：一般原则：
a. 头文件中��量��?/font> include, 如果可以��单申�? class clsOld; 解决�Q�那最好。减��没有必要的 include�Q?br />b. 实现文�g中也要尽量少 include, 不要 include 没有用到的头文�g�?

三：那什么时候可以只是简单声�?/font> class clsOld 呢？
��单的��_��不需要知�?/font> clsOld 的内存布局的用法都可以 ( 静态成员除�?/font> ) �Q�也��是讲如果是指针或引用方式的都行�?/font>
比如�Q?/font>
   clsOld * m_pOld;    // 指针�?/font> 4 个字节长
   clsOld & test(clsOld * pOld) {return *pOld};
一�?/font> OK �?/font>

四：什么时候不能简单声�?/font> class clsOld �Q�必��?/font> include 呢？
不满��三的情况下�Q?/font>
比如�Q?/font>
         clsOld m_Objold; // 不知道占据大��，必须要通过它的具体声明来计��?/font>
原因很简单，��x��你要计算 sizeof(classNew) �Q�但�q?/font> clsOld �?/font> size 都不知道�Q�编译器昄��会无能�ؓ力�?/font>

�Ҏ��情况�Q?/font>
          int test() { return clsOld::m_sInt;}
     静态成员调用，��x��应该是不需要知道内存布局的，但因为需要知�?/font> m_sInt 是属�?/font> clsOld 命名�I�间的，如果只声�?/font> class xxx 昄��是不��以说明的，所以必��d��含头文�g�?/font>

�l�g��所�q�ͼ�我有以下几点��Q?/font>
1 �Q�如果有共同相关依赖 ( 必须 include) 的类�Q�比�? A,B 都依�?/font> D 可以攑֜�一��P��然后直接 Include "d" �cȝ��使用者只需兛_��与本�c�L��露出的相关类型，内部用到的类型不用去��?/font> ( 不用自已�?/font> include d) 。这�?/font> �l�出�?/font> class �Q�调用者才更好�?/font> ( 不用�ȝ��代码查找�Q�是不是�q�需要包含其它头文�g ) �?/font>

2 �Q�如�?/font> A �c�M��?/font> D B �c�M��依赖 D �Q�可以把它们分开两个头文件。各�?/font> Include 。这样可避免�?/font> D 发生变化�Ӟ�� 避免不必要重�~�译�?/font>

3 �Q�类中尽量采用指针或引用方式调用其它�c�，�q�样��可以只声明 class xxx 了。�ƈ且这也符合资源最�?/font> 利用�Q�更利于使用多态�?br />
/--------------------------------------------------/////////////////////////////////////////////////////////////////////////////

对于VC++中的头文件包含值得注意的一�?/font>

　　 今天�?span lang="EN-US">VC++�~�译我这昨天写的代码时发现��L��通不�q�，看到大部分的错误都是与一个类的定义有兟�?span lang="EN-US">

　　明明我已�l�在�q�个�c�M��定义了一个成员变量，可编译器偏要说那个变量不是这个类的成员。没办法�Q�找了半天原因还是没有头�l�。再三地��认不是�?span lang="EN-US">C++的语法错误之后。我开始怀疑是不是头文件的问题。因为当我把一�?strong>#include "..."搬到#pragma once之前或者之后，错误报告��׃��发生变化。有时就只是说我的一个类重复定义了�?span lang="EN-US">

以前�?span lang="EN-US">C写头文�g的时候都是用宏定义来避免重复包含头文�?/strong>�?span lang="EN-US">C++里虽然也�q�可用这个方法，�?span lang="EN-US">VC++��是不用�Q�它用的�?strong>#pragma once。这一变化�Ҏ��来说真是有点�怸�着头脑了，我不清楚#pragma once的工作方式是如何的。而我现在遇到的问题又与这个有兟뀂找扄��上的内容看吧。上google搜了半天�Q�那些论坛里的回�{�基本上都是“防止重复包�?strong>头文�?/strong>的，你不用管他。”这��L��。可是不��他真的行吗�Q�我刚学�?span lang="EN-US">VC++�Q�我看的书上是没有讲�q�这个内容的。怎么在网上也搜不到呢�Q�经�q�我不懈的努力，�l�于让我扑ֈ�了一��?span lang="EN-US">http://www.yesky.com/127/1736627_3.shtml�?span lang="EN-US">

作�?span lang="EN-US">Adding的这�D�话�Ҏ��的帮助最大：�?/span> 既然使用了包含文�Ӟ��Z��么还要在class CMainFrame前添�?span lang="EN-US">"class CViewerView;"�{�代码？如果用包含文件代替它�Q�行不行�Q�　　很多Visual C++书籍对这些问题避而不谈，但实际上�q�是一个重要的问题。如果不能理解上�q�C��码，我们很可能�ؓ无法通过�~�译而大伤脑�{�。这些问题的出现是基于这��L��一些事实：在我们用标准C/C++设计�E�序�Ӟ��有一个原则即两个代码文�g不能�怺�包含�Q�而且多次包含�q�会造成重复定义的错误。�ؓ了解册��个难题， Visual C++使用#pragma once来通知�~�译器在生成时只包含(打开)一�ơ，也就是说�Q�在�W�一��?span lang="EN-US">#include之后�Q�编译器重新生成时不会再对这些包含文件进行包�?span lang="EN-US">(打开)和读取，因此我们看到在用向导创徏的所有类的头文�g中有#pragma once语句��׃��会觉得奇怪了。然�?span style="COLOR: red">正是�׃��q�个语句而造成了在�W�二��?span lang="EN-US">#include后编译器无法正确识别所引用的类。因此，我们在相互包含时�q�需要加入类�?span lang="EN-US">class CViewerView�q�样的语句来通知�~�译器这个类是一个实际的调用�?/span> �?span lang="EN-US">

看来��是�q�个问题了。把我的代码一加上那些�cȝ��声明以后果然通过了编译。我感觉�q�个问题�?span lang="EN-US">VC++里面来说应该是值得注意的。可能是�׃��我刚�?span lang="EN-US">VC++�Q�见识太��的原故吧。无论如何先��C��来，说不定也有�h在�ؓ�q�个#pragma once伤脑�{�呢�?span lang="EN-US">

清源游民 2006-12-14 18:16 发表评论

清源游民 — Thu, 14 Dec 2006 06:22:00 GMT

�Ҏ��x��据类型�{换的整理

int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="�E�佩�?;
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;

一、其它数据类型�{换�ؓ字符�?/b>

短整�?int)
itoa(i,temp,10);///��i转换为字�W�串攑օ�temp�?最后一个数字表�C�十�q�制
itoa(i,temp,2); ///按二�q�制方式转换

长整�?long)
ltoa(l,temp,10);

��点�?float,double)
用fcvt可以完成转换,�q�是MSDN中的例子:
int decimal, sign;
char *buffer;
double source = 3.1415926535;
buffer = _fcvt( source, 7, &decimal, &sign );
�q�行�l�果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
decimal表示��数点的位置,sign表示�W�号:0为正敎ͼ�1��?

CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;

BSTR变量
BSTR bstrValue = ::SysAllocString(L"�E�序�?);
char * buf = _com_util::ConvertBSTRToString(bstrValue);
SysFreeString(bstrValue);
AfxMessageBox(buf);
delete(buf);

CComBSTR变量
CComBSTR bstrVar("test");
char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str);
AfxMessageBox(buf);
delete(buf);

_bstr_t变量
_bstr_t�c�d��是对BSTR的封装，因�ؓ已经重蝲�?操作�W�，所以很�Ҏ��使用
_bstr_t bstrVar("test");
const char *buf = bstrVar;///不要修改buf中的内容
AfxMessageBox(buf);

通用�Ҏ��(针对非COM数据�c�d��)
用sprintf完成转换
char buffer[200]; char c = '1'; int i = 35; long j = 1000; float f = 1.7320534f; sprintf( buffer, "%c",c); sprintf( buffer, "%d",i); sprintf( buffer, "%d",j); sprintf( buffer, "%f",f);

二、字�W�串转换为其它数据类�?/font>
strcpy(temp,"123");

短整�?int)
i = atoi(temp);

长整�?long)
l = atol(temp);

��点(double)
d = atof(temp);

CString变量
CString name = temp;

BSTR变量
BSTR bstrValue = ::SysAllocString(L"�E�序�?);
...///完成对bstrValue的��?br />SysFreeString(bstrValue);

CComBSTR变量
CComBSTR�c�d��变量可以直接赋�?br />CComBSTR bstrVar1("test");
CComBSTR bstrVar2(temp);

_bstr_t变量
_bstr_t�c�d��的变量可以直接赋�?br />_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp);

三、其它数据类型�{换到CString
使用CString的成员函数Format来�{�?例如:

整数(int)
str.Format("%d",i);

��点�?float)
str.Format("%f",i);

字符串指�?char *)�{�已�l�被CString构造函数支持的数据�c�d��可以直接赋�?br />str = username;

对于Format所不支持的数据�c�d��Q�可以通过上面所说的关于其它数据�c�d��转化到char *的方法先转到char *�Q�然后赋值给CString变量�?br />

四、BSTR、_bstr_t与CComBSTR

CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封�?BSTR�?2位指�?但�ƈ不直接指向字串的�~�冲区�?br />char *转换到BSTR可以�q�样:
BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.lib
SysFreeString(bstrValue);
反之可以使用
char *p=_com_util::ConvertBSTRToString(b);
delete p;
具体可以参考一�Q�二�D�落里的具体说明�?br />
CComBSTR与_bstr_t对大量的操作�W�进行了重蝲�Q�可以直接进�?,!=,==�{�操作，所以��用非常方�ѝ�?br />特别是_bstr_t,��大家使用它�?br />

五、VARIANT 、_variant_t �?COleVariant

VARIANT的结构可以参考头文�gVC98\Include\OAIDL.H中关于结构体tagVARIANT的定义�?br />对于VARIANT变量的赋��|��首先�l�vt成员赋��|��指明数据�c�d��Q�再对联合结构中相同数据�c�d��的变量赋��|��举个例子�Q?br />VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋�?

_variant_t是VARIANT的封装类�Q�其赋值可以��用强制类型�{换，其构造函��C��自动处理�q�些数据�c�d��?br />使用旉��加上#include
例如�Q?br />long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;

COleVariant的��用与_variant_t的方法基本一��P��请参考如下例子：
COleVariant v3 = "字符�?, v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

本主题演�C�如何将各种 C++ 字符串类型�{换�ؓ其他字符丌Ӏ�可以�{换的字符串类型包�?char *�?strong>wchar_t*�?a onclick="javascript:TrackThisClick('ctl00_LibFrame_ctl02','ctl00_LibFrame_ctl03',this);" >_bstr_t�?a onclick="javascript:TrackThisClick('ctl00_LibFrame_ctl02','ctl00_LibFrame_ctl04',this);" >CComBSTR�?a onclick="javascript:TrackThisClick('ctl00_LibFrame_ctl02','ctl00_LibFrame_ctl05',this);" >CString�?a onclick="javascript:TrackThisClick('ctl00_LibFrame_ctl02','ctl00_LibFrame_ctl06',this);" >basic_string �?System.String。在所有情况下�Q�在��字�W�串转换为新�c�d��Ӟ��都会创徏字符串的副本。对新字�W�串�q�行的�Q何更攚w��不会影响原始字符�Ԍ��反之亦然�?/p>
�?char * 转换

�C�Z��

说明

此示例演�C�如何从 char * 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_char.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" using namespace std; using namespace System; int main() { char *orig = "Hello, World!"; cout << orig << " (char *)" << endl; // Convert to a wchar_t* size_t origsize = strlen(orig) + 1; const size_t newsize = 100; size_t convertedChars = 0; wchar_t wcstring[newsize]; mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a _bstr_t _bstr_t bstrt(orig); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CComBSTR CComBSTR ccombstr(orig); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a CString CString cstring(orig); cstring += " (CString)"; cout << cstring << endl; // Convert to a basic_string string basicstring(orig); basicstring += " (basic_string)"; cout << basicstring << endl; // Convert to a System::String String ^systemstring = gcnew String(orig); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (_bstr_t) Hello, World! (CComBSTR) Hello, World! (CString) Hello, World! (basic_string) Hello, World! (System::String)

�?wchar_t * 转换

�C�Z��

说明

此示例演�C�如何从 wchar_t * 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_wchar_t.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" using namespace std; using namespace System; int main() { wchar_t *orig = L"Hello, World!"; wcout << orig << L" (wchar_t *)" << endl; // Convert to a char* size_t origsize = wcslen(orig) + 1; const size_t newsize = 100; size_t convertedChars = 0; char nstring[newsize]; wcstombs_s(&convertedChars, nstring, origsize, orig, _TRUNCATE); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a _bstr_t _bstr_t bstrt(orig); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CComBSTR CComBSTR ccombstr(orig); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a CString CString cstring(orig); cstring += " (CString)"; cout << cstring << endl; // Convert to a basic_string wstring basicstring(orig); basicstring += L" (basic_string)"; wcout << basicstring << endl; // Convert to a System::String String ^systemstring = gcnew String(orig); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (wchar_t *) Hello, World! (char *) Hello, World! (_bstr_t) Hello, World! (CComBSTR) Hello, World! (CString) Hello, World! (basic_string) Hello, World! (System::String)

�?_bstr_t 转换

�C�Z��

说明

此示例演�C�如何从 _bstr_t 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_bstr_t.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" using namespace std; using namespace System; int main() { _bstr_t orig("Hello, World!"); wcout << orig << " (_bstr_t)" << endl; // Convert to a char* const size_t newsize = 100; char nstring[newsize]; strcpy_s(nstring, (char *)orig); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a wchar_t* wchar_t wcstring[newsize]; wcscpy_s(wcstring, (wchar_t *)orig); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a CComBSTR CComBSTR ccombstr((char *)orig); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a CString CString cstring((char *)orig); cstring += " (CString)"; cout << cstring << endl; // Convert to a basic_string string basicstring((char *)orig); basicstring += " (basic_string)"; cout << basicstring << endl; // Convert to a System::String String ^systemstring = gcnew String((char *)orig); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (_bstr_t) Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (CComBSTR) Hello, World! (CString) Hello, World! (basic_string) Hello, World! (System::String)

�?CComBSTR 转换

�C�Z��

说明

此示例演�C�如何从 CComBSTR 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_ccombstr.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" #include "vcclr.h" using namespace std; using namespace System; using namespace System::Runtime::InteropServices; int main() { CComBSTR orig("Hello, World!"); CW2A printstr(orig); cout << printstr << " (CComBSTR)" << endl; // Convert to a char* const size_t newsize = 100; char nstring[newsize]; CW2A tmpstr1(orig); strcpy_s(nstring, tmpstr1); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a wchar_t* wchar_t wcstring[newsize]; wcscpy_s(wcstring, orig); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a _bstr_t _bstr_t bstrt(orig); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CString CString cstring(orig); cstring += " (CString)"; cout << cstring << endl; // Convert to a basic_string wstring basicstring(orig); basicstring += L" (basic_string)"; wcout << basicstring << endl; // Convert to a System::String String ^systemstring = gcnew String(orig); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (CComBSTR) Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (_bstr_t) Hello, World! (CString) Hello, World! (basic_string) Hello, World! (System::String)

�?CString 转换

�C�Z��

说明

此示例演�C�如何从 CString 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_cstring.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" using namespace std; using namespace System; int main() { CString orig("Hello, World!"); wcout << orig << " (CString)" << endl; // Convert to a char* const size_t newsize = 100; char nstring[newsize]; strcpy_s(nstring, orig); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a wchar_t* // You must first convert to a char * for this to work. size_t origsize = strlen(orig) + 1; size_t convertedChars = 0; wchar_t wcstring[newsize]; mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a _bstr_t _bstr_t bstrt(orig); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CComBSTR CComBSTR ccombstr(orig); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a basic_string string basicstring(orig); basicstring += " (basic_string)"; cout << basicstring << endl; // Convert to a System::String String ^systemstring = gcnew String(orig); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (CString) Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (_bstr_t) Hello, World! (CComBSTR) Hello, World! (basic_string) Hello, World! (System::String)

�?basic_string 转换

�C�Z��

说明

此示例演�C�如何从 basic_string 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_basic_string.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" using namespace std; using namespace System; int main() { string orig("Hello, World!"); cout << orig << " (basic_string)" << endl; // Convert to a char* const size_t newsize = 100; char nstring[newsize]; strcpy_s(nstring, orig.c_str()); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a wchar_t* // You must first convert to a char * for this to work. size_t origsize = strlen(orig.c_str()) + 1; size_t convertedChars = 0; wchar_t wcstring[newsize]; mbstowcs_s(&convertedChars, wcstring, origsize, orig.c_str(), _TRUNCATE); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a _bstr_t _bstr_t bstrt(orig.c_str()); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CComBSTR CComBSTR ccombstr(orig.c_str()); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a CString CString cstring(orig.c_str()); cstring += " (CString)"; cout << cstring << endl; // Convert to a System::String String ^systemstring = gcnew String(orig.c_str()); systemstring += " (System::String)"; Console::WriteLine("{0}", systemstring); delete systemstring; }

输出

Hello, World! (basic_string) Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (_bstr_t) Hello, World! (CComBSTR) Hello, World! (CString) Hello, World! (System::String)

�?System::String 转换

�C�Z��

说明

此示例演�C�如何从 System.String 转换��Z��面列出的其他字符串类型�?/p>

// convert_from_system_string.cpp // compile with /clr /link comsuppw.lib #include #include #include #include "atlbase.h" #include "atlstr.h" #include "comutil.h" #include "vcclr.h" using namespace std; using namespace System; using namespace System::Runtime::InteropServices; int main() { String ^orig = gcnew String("Hello, World!"); Console::WriteLine("{0} (System::String)", orig); pin_ptr wch = PtrToStringChars(orig); // Convert to a char* size_t origsize = wcslen(wch) + 1; const size_t newsize = 100; size_t convertedChars = 0; char nstring[newsize]; wcstombs_s(&convertedChars, nstring, origsize, wch, _TRUNCATE); strcat_s(nstring, " (char *)"); cout << nstring << endl; // Convert to a wchar_t* wchar_t wcstring[newsize]; wcscpy_s(wcstring, wch); wcscat_s(wcstring, L" (wchar_t *)"); wcout << wcstring << endl; // Convert to a _bstr_t _bstr_t bstrt(wch); bstrt += " (_bstr_t)"; cout << bstrt << endl; // Convert to a CComBSTR CComBSTR ccombstr(wch); if (ccombstr.Append(L" (CComBSTR)") == S_OK) { CW2A printstr(ccombstr); cout << printstr << endl; } // Convert to a CString CString cstring(wch); cstring += " (CString)"; cout << cstring << endl; // Convert to a basic_string wstring basicstring(wch); basicstring += L" (basic_string)"; wcout << basicstring << endl; delete orig; }

输出

Hello, World! (System::String) Hello, World! (char *) Hello, World! (wchar_t *) Hello, World! (_bstr_t) Hello, World! (CComBSTR) Hello, World! (CString) Hello, World! (basic_string)

清源游民 2006-12-14 14:22 发表评论

清源游民 — Thu, 14 Dec 2006 06:11:00 GMT

CString->std::string 例子�Q?br />
CString strMfc=“test�?

std::string strStl;

strStl=strMfc.GetBuffer(0);

std::string->CString  例子�Q?br />
CString strMfc�Q?br />
std::string strStl=“test�?

strMfc=strStl.c_str();

清源游民 2006-12-14 14:11 发表评论

版本	操作�pȝ��	发布日期
DirectX 1.0	Windows 95a	9/30/95
DirectX 2.0/2.0a	Windows 95OSR2/NT4.0	6/5/96
DirectX 3.0/3.0a	Windows NT 4.0 SP3	9/15/96
DirectX 4.0		未发�?/td>
DirectX 5.0	Windows NT 4.0/Beta for NT 5.0	7/16/97
DirectX 5.1	Windows 95/98/NT4.0	12/1/97
DirectX 5.2	Windows 95	5/5/98
DirectX 6.0	Windows 98/NT4.0	8/7/98
DirectX 6.1	Windows 95/98/98SE	2/3/99
DirectX 7.0	Windows 95/98/98SE/2000	9/22/99
DirectX 7.0a	Windows 95/98/98SE/2000	9/99
DirectX 7.1	Windows 95/98/98SE/ME/2000	9/16/99
DirectX 8.0/8.0a	Windows 95/98/98SE/ME/2000	9/30/2000
DirectX 8.1	Windows 95/98/98SE/ME/2000/XP	11/12/01
DirectX 9 Shader Model 2.0	Windows 95/98/98SE/ME/2000/XP	12/19/2002
DirectX 9 Shader Model 2.0b	Windows 98/98SE/ME/2000/XP	8/13/2003
DirectX 9 Shader Model 3.0	Windows 98/98SE/ME/2000/XP	8/9/2004

Routine	Required Header	Compatibility
_gcvt		Win 95, Win NT

LIBC.LIB	Single thread static library, retail version
LIBCMT.LIB	Multithread static library, retail version
MSVCRT.LIB	Import library for MSVCRT.DLL, retail version

欧美涩涩视频,欧美成人一区在线,欧美揉bbbbb揉bbbbb

试用新版本luabind

c++,要细心不能想当然

Shader Model 4.0

高��渲染语言(HLSL 10)

用C++实现的一�U�插件体�pȝ���?----概述

���类成员函数用做C回调函数

game c++

(转）剖析C++标准库智能指�?std::auto_ptr)

如何���float转换为string

_gcvt

�Ҏ����x��据类型�{换的整理

�?char * 转换

�C�Z��

说明

输出

�?wchar_t * 转换

�C�Z��

说明

输出

�?_bstr_t 转换

�C�Z��

说明

输出

�?CComBSTR 转换

�C�Z��

说明

输出

�?CString 转换

�C�Z��

说明

输出

�?basic_string 转换

�C�Z��

说明

输出

�?System::String 转换

�C�Z��

说明

输出

用C++实现的一�U�插件体�pȝ��?----概述

��类成员函数用做C回调函数

如何��float转换为string

�Ҏ��x��据类型�{换的整理