狂想的天空

alpha混合技术对熟悉游戏的人来说不会陌生，这种技术在如今的游戏特效里已经被用烂了。3D的游戏就

不说了，2D的游戏里，这种技术也是满眼皆是。
　　alpha混合听上去很神秘，实际非常简单，其作用就是要实现一种半透明效果。假设一种不透明东西

的颜色是A，另一种透明的东西的颜色是B，那么透过B去看A，看上去的颜色C就是B和A的混合颜色，可以

用这个式子来近似，设B物体的透明度为alpha(取值为0-1，0为完全透明，1为完全不透明)

R(C)=alpha*R(B)+(1-alpha)*R(A)
G(C)=alpha*G(B)+(1-alpha)*G(A)
B(C)=alpha*B(B)+(1-alpha)*B(A)

　　R(x)、G(x)、B(x)分别指颜色x的RGB分量。看起来这个东西这么简单，可是用它实现的效果绝对不简

单，应用alpha混合技术，可以实现出最眩目的火光、烟雾、阴影、动态光源等等一切你可以想象的出来

的半透明效果。

　　火光、烟雾的效果是事先做好一个火或雾的图和一个alpha通道图(用过Photoshop的人都该知道什么

是alpha通道)，画上去的时候每点每点计算，得到的就是火光掩映的效果。雾化效果在3D里还需要模糊一

下，在这里就免了，本来alpha混合就有不小的计算量了，算法再不优化再加上模糊或其它的一些什么原

因，那么你就是在看幻灯片了。(关于优化，网上见仁见智，我再找时候再讲)。

　　动态光源，听起来高深的一塌。那我先讲一下阴影，这个就简单了，以往的游戏也有阴影(象《仙剑

》)，不过我们把它升一下级，从不透明变成半透明而已。就是把一个影子图放在地表上面作alpha混合(

而且可以简化，因为影子的alpha值可以是一定的，这样就可以大幅提高计算速度)就OK了。

　　该讲动态光源了。我们把没有光源的地方想象成一张黑幕蒙在屏幕上，没光也就什么都看不到。那么

我们就加上一个光源，相当于在黑幕上挖了一个洞，这个洞的大小就是被照亮的范围，现在我们可以看到

下面的东西了。但现在这个效果说是光源，倒不如说是个窗户，要显得象光源，就要让光源的中心最亮，

逐渐向四周暗下去，最后到什么都看不见，这才象个光源。具体现就是alpha混合啦，蒙版的颜色是黑

，中心alpha值为0，完全透明，到光源的尽头alpha值为1，完全不透明，成果就是这个样子，象这么回事

吧！光源做好了，动态的光源就是实时生成一个动态的alpha蒙版，然后盖上去就行了。

　　不难吧！游戏里(其实也不只游戏，好多算法也是这样)的一些技术听起来很玄，说通了也就是那么回

事，只不过不是一下子就能想到就是了。

　　Diablo里面就大量应用了alpha混合技术(至少我看上去象)，那些眩目的魔法产生出来的半透明效果

，还有乱飞的火球照亮迷宫，每个火球也就是个小的光源，一堆光源产生出来的蒙版(就是对应的alpha相

加，超过255就截断)再蒙上去。(真正的光源应该是这样的：当alpha值超过255时，alpha=alpha-255，

alpha是一个Byte时也就是回绕，同时该点蒙版的色彩变为白色，这才是对的，不过简单起见，还是原来

那样就可以了)。

from: http://www.gameres.com/

摘要：from:CSDN　查看全文

字符，字节和编码 [from：http://www.regexlab.com/zh/encoding.htm] 级别：中级 摘要：本文介绍了字符与编码的发展过程，相关概念的正确理解。举例说明了一些实际应用中，编码的实现方法。然后，本文讲述了通常对字符与编码的几种误解，由于这些误解而导致乱码产生的原因，以及消除乱码的办法。本文的内容涵盖了“中文问题”，“乱码问题”。 掌握编码问题的关键是正确地理解相关概念，编码所涉及的技术其实是很简单的。因此，阅读本文时需要慢读多想，多思考。 引言 “字符与编码”是一个被经常讨论的话题。即使这样，时常出现的乱码仍然困扰着大家。虽然我们有很多的办法可以用来消除乱码，但我们并不一定理解这些办法的内在原理。而有的乱码产生的原因，实际上由于底层代码本身有问题所导致的。因此，不仅是初学者会对字符编码感到模糊，有的底层开发人员同样对字符编码缺乏准确的理解。 回页首 1. 编码问题的由来，相关概念的理解 1.1 字符与编码的发展 从计算机对多国语言的支持角度看，大致可以分为三个阶段： 　 系统内码 说明 系统 阶段一 ASCII 计算机刚开始只支持英语，其它语言不能够在计算机上存储和显示。 英文 DOS 阶段二 ANSI编码 （本地化） 为使计算机支持更多语言，通常使用 0x80~0xFF 范围的 2 个字节来表示 1 个字符。比如：汉字 '中' 在中文操作系统中，使用 [0xD6,0xD0] 这两个字节存储。 不同的国家和地区制定了不同的标准，由此产生了 GB2312, BIG5, JIS 等各自的编码标准。这些使用 2 个字节来代表一个字符的各种汉字延伸编码方式，称为 ANSI 编码。在简体中文系统下，ANSI 编码代表 GB2312 编码，在日文操作系统下，ANSI 编码代表 JIS 编码。 不同 ANSI 编码之间互不兼容，当信息在国际间交流时，无法将属于两种语言的文字，存储在同一段 ANSI 编码的文本中。 中文 DOS，中文 Windows 95/98，日文 Windows 95/98 阶段三 UNICODE （国际化） 为了使国际间信息交流更加方便，国际组织制定了 UNICODE 字符集，为各种语言中的每一个字符设定了统一并且唯一的数字编号，以满足跨语言、跨平台进行文本转换、处理的要求。 Windows NT/2000/XP，Linux，Java 字符串在内存中的存放方法： 在 ASCII 阶段，单字节字符串使用一个字节存放一个字符（SBCS）。比如，"Bob123" 在内存中为： 42 6F 62 31 32 33 00 B o b 1 2 3 \0 在使用 ANSI 编码支持多种语言阶段，每个字符使用一个字节或多个字节来表示（MBCS），因此，这种方式存放的字符也被称作多字节字符。比如，"中文123" 在中文 Windows 95 内存中为7个字节，每个汉字占2个字节，每个英文和数字字符占1个字节： D6 D0 CE C4 31 32 33 00 中 文 1 2 3 \0 在 UNICODE 被采用之后，计算机存放字符串时，改为存放每个字符在 UNICODE 字符集中的序号。目前计算机一般使用 2 个字节（16 位）来存放一个序号（DBCS），因此，这种方式存放的字符也被称作宽字节字符。比如，字符串 "中文123" 在 Windows 2000 下，内存中实际存放的是 5 个序号： 2D 4E 87 65 31 00 32 00 33 00 00 00      ← 在 x86 CPU 中，低字节在前 中 文 1 2 3 \0 　 一共占 10 个字节。 回页首 1.2 字符，字节，字符串 理解编码的关键，是要把字符的概念和字节的概念理解准确。这两个概念容易混淆，我们在此做一下区分： 　 概念描述 举例 字符 人们使用的记号，抽象意义上的一个符号。 '1', '中', 'a', '$', '￥', …… 字节 计算机中存储数据的单元，一个8位的二进制数，是一个很具体的存储空间。 0x01, 0x45, 0xFA, …… ANSI 字符串 在内存中，如果“字符”是以 ANSI 编码形式存在的，一个字符可能使用一个字节或多个字节来表示，那么我们称这种字符串为 ANSI 字符串或者多字节字符串。 "中文123" （占7字节） UNICODE 字符串 在内存中，如果“字符”是以在 UNICODE 中的序号存在的，那么我们称这种字符串为 UNICODE 字符串或者宽字节字符串。 L"中文123" （占10字节） 由于不同 ANSI 编码所规定的标准是不相同的，因此，对于一个给定的多字节字符串，我们必须知道它采用的是哪一种编码规则，才能够知道它包含了哪些“字符”。而对于 UNICODE 字符串来说，不管在什么环境下，它所代表的“字符”内容总是不变的。 回页首 1.3 字符集与编码 各个国家和地区所制定的不同 ANSI 编码标准中，都只规定了各自语言所需的“字符”。比如：汉字标准（GB2312）中没有规定韩国语字符怎样存储。这些 ANSI 编码标准所规定的内容包含两层含义： 使用哪些字符。也就是说哪些汉字，字母和符号会被收入标准中。所包含“字符”的集合就叫做“字符集”。 规定每个“字符”分别用一个字节还是多个字节存储，用哪些字节来存储，这个规定就叫做“编码”。 各个国家和地区在制定编码标准的时候，“字符的集合”和“编码”一般都是同时制定的。因此，平常我们所说的“字符集”，比如：GB2312, GBK, JIS 等，除了有“字符的集合”这层含义外，同时也包含了“编码”的含义。 “UNICODE 字符集”包含了各种语言中使用到的所有“字符”。用来给 UNICODE 字符集编码的标准有很多种，比如：UTF-8, UTF-7, UTF-16, UnicodeLittle, UnicodeBig 等。 回页首 1.4 常用的编码简介 简单介绍一下常用的编码规则，为后边的章节做一个准备。在这里，我们根据编码规则的特点，把所有的编码分成三类： 分类 编码标准 说明 单字节字符编码 ISO-8859-1 最简单的编码规则，每一个字节直接作为一个 UNICODE 字符。比如，[0xD6, 0xD0] 这两个字节，通过 iso-8859-1 转化为字符串时，将直接得到 [0x00D6, 0x00D0] 两个 UNICODE 字符，即 "ÖÐ"。 反之，将 UNICODE 字符串通过 iso-8859-1 转化为字节串时，只能正常转化 0~255 范围的字符。 ANSI 编码 GB2312, BIG5, Shift_JIS, ISO-8859-2 …… 把 UNICODE 字符串通过 ANSI 编码转化为“字节串”时，根据各自编码的规定，一个 UNICODE 字符可能转化成一个字节或多个字节。 反之，将字节串转化成字符串时，也可能多个字节转化成一个字符。比如，[0xD6, 0xD0] 这两个字节，通过 GB2312 转化为字符串时，将得到 [0x4E2D] 一个字符，即 '中' 字。 “ANSI 编码”的特点： 1. 这些“ANSI 编码标准”都只能处理各自语言范围之内的 UNICODE 字符。 2. “UNICODE 字符”与“转换出来的字节”之间的关系是人为规定的。 UNICODE 编码 UTF-8, UTF-16, UnicodeBig …… 与“ANSI 编码”类似的，把字符串通过 UNICODE 编码转化成“字节串”时，一个 UNICODE 字符可能转化成一个字节或多个字节。 与“ANSI 编码”不同的是： 1. 这些“UNICODE 编码”能够处理所有的 UNICODE 字符。 2. “UNICODE 字符”与“转换出来的字节”之间是可以通过计算得到的。 我们实际上没有必要去深究每一种编码具体把某一个字符编码成了哪几个字节，我们只需要知道“编码”的概念就是把“字符”转化成“字节”就可以了。对于“UNICODE 编码”，由于它们是可以通过计算得到的，因此，在特殊的场合，我们可以去了解某一种“UNICODE 编码”是怎样的规则。 回页首 2. 字符与编码在程序中的实现 2.1 程序中的字符与字节 在 C++ 和 Java 中，用来代表“字符”和“字节”的数据类型，以及进行编码的方法： 类型或操作 C++ Java 字符 wchar_t char 字节 char byte ANSI 字符串 char[] byte[] UNICODE 字符串 wchar_t[] String 字节串→字符串 mbstowcs(), MultiByteToWideChar() string = new String(bytes, "encoding") 字符串→字节串 wcstombs(), WideCharToMultiByte() bytes = string.getBytes("encoding") 以上需要注意几点： Java 中的 char 代表一个“UNICODE 字符（宽字节字符）”，而 C++ 中的 char 代表一个字节。 MultiByteToWideChar() 和 WideCharToMultiByte() 是 Windows API 函数。 回页首 2.2 C++ 中相关实现方法 声明一段字符串常量： // ANSI 字符串，内容长度 7 字节 char     sz[20] = "中文123"; // UNICODE 字符串，内容长度 5 个 wchar_t（10 字节） wchar_t wsz[20] = L"\x4E2D\x6587\x0031\x0032\x0033"; UNICODE 字符串的 I/O 操作，字符与字节的转换操作： // 运行时设定当前 ANSI 编码，VC 格式 setlocale(LC_ALL, ".936"); // GCC 中格式 setlocale(LC_ALL, "zh_CN.GBK"); // Visual C++ 中使用小写 %s，按照 setlocale 指定编码输出到文件 // GCC 中使用大写 %S fwprintf(fp, L"%s\n", wsz); // 把 UNICODE 字符串按照 setlocale 指定的编码转换成字节 wcstombs(sz, wsz, 20); // 把字节串按照 setlocale 指定的编码转换成 UNICODE 字符串 mbstowcs(wsz, sz, 20); 在 Visual C++ 中，UNICODE 字符串常量有更简单的表示方法。如果源程序的编码与当前默认 ANSI 编码不符，则需要使用 #pragma setlocale，告诉编译器源程序使用的编码： // 如果源程序的编码与当前默认 ANSI 编码不一致， // 则需要此行，编译时用来指明当前源程序使用的编码 #pragma setlocale(".936") // UNICODE 字符串常量，内容长度 10 字节 wchar_t wsz[20] = L"中文123"; 以上需要注意 #pragma setlocale 与 setlocale(LC_ALL, "") 的作用是不同的，#pragmasetlocale 在编译时起作用，setlocale() 在运行时起作用。 回页首 2.3 Java 中相关实现方法 字符串类 String 中的内容是 UNICODE 字符串： // Java 代码，直接写中文 String string = "中文123"; // 得到长度为 5，因为是 5 个字符 System.out.println(string.length()); 字符串 I/O 操作，字符与字节转换操作。在 Java 包 java.io.* 中，以“Stream”结尾的类一般是用来操作“字节串”的类，以“Reader”，“Writer”结尾的类一般是用来操作“字符串”的类。 // 字符串与字节串间相互转化 // 按照 GB2312 得到字节（得到多字节字符串） byte [] bytes = string.getBytes("GB2312"); // 从字节按照 GB2312 得到 UNICODE 字符串 string = new String(bytes, "GB2312"); // 要将 String 按照某种编码写入文本文件，有两种方法： // 第一种办法：用 Stream 类写入已经按照指定编码转化好的字节串 OutputStream os = new FileOutputStream("1.txt"); os.write(bytes); os.close(); // 第二种办法：构造指定编码的 Writer 来写入字符串 Writer ow = new OutputStreamWriter(new FileOutputStream("2.txt"), "GB2312"); ow.write(string); ow.close(); /* 最后得到的 1.txt 和 2.txt 都是 7 个字节 */ 如果 java 的源程序编码与当前默认 ANSI 编码不符，则在编译的时候，需要指明一下源程序的编码。比如： E:\>javac -encoding BIG5 Hello.java 以上需要注意区分源程序的编码与 I/O 操作的编码，前者是在编译时起作用，后者是在运行时起作用。 回页首 3. 几种误解，以及乱码产生的原因和解决办法 3.1 容易产生的误解 　 对编码的误解 误解一 在将“字节串”转化成“UNICODE 字符串”时，比如在读取文本文件时，或者通过网络传输文本时，容易将“字节串”简单地作为单字节字符串，采用每“一个字节”就是“一个字符”的方法进行转化。 而实际上，在非英文的环境中，应该将“字节串”作为 ANSI 字符串，采用适当的编码来得到 UNICODE 字符串，有可能“多个字节”才能得到“一个字符”。 通常，一直在英文环境下做开发的程序员们，容易有这种误解。 误解二 在 DOS，Windows 98 等非 UNICODE 环境下，字符串都是以 ANSI 编码的字节形式存在的。这种以字节形式存在的字符串，必须知道是哪种编码才能被正确地使用。这使我们形成了一个惯性思维：“字符串的编码”。 当 UNICODE 被支持后，Java 中的 String 是以字符的“序号”来存储的，不是以“某种编码的字节”来存储的，因此已经不存在“字符串的编码”这个概念了。只有在“字符串”与“字节串”转化时，或者，将一个“字节串”当成一个 ANSI 字符串时，才有编码的概念。 不少的人都有这个误解。 第一种误解，往往是导致乱码产生的原因。第二种误解，往往导致本来容易纠正的乱码问题变得更复杂。 在这里，我们可以看到，其中所讲的“误解一”，即采用每“一个字节”就是“一个字符”的转化方法，实际上也就等同于采用 iso-8859-1 进行转化。因此，我们常常使用 bytes = string.getBytes("iso-8859-1") 来进行逆向操作，得到原始的“字节串”。然后再使用正确的 ANSI 编码，比如 string = new String(bytes, "GB2312")，来得到正确的“UNICODE 字符串”。 回页首 3.2 非 UNICODE 程序在不同语言环境间移植时的乱码 非 UNICODE 程序中的字符串，都是以某种 ANSI 编码形式存在的。如果程序运行时的语言环境与开发时的语言环境不同，将会导致 ANSI 字符串的显示失败。 比如，在日文环境下开发的非 UNICODE 的日文程序界面，拿到中文环境下运行时，界面上将显示乱码。如果这个日文程序界面改为采用 UNICODE 来记录字符串，那么当在中文环境下运行时，界面上将可以显示正常的日文。 由于客观原因，有时候我们必须在中文操作系统下运行非 UNICODE 的日文软件，这时我们可以采用一些工具，比如，南极星，AppLocale 等，暂时的模拟不同的语言环境。 /table> 3.3 网页提交字符串 当页面中的表单提交字符串时，首先把字符串按照当前页面的编码，转化成字节串。然后再将每个字节转化成 "%XX" 的格式提交到 Web 服务器。比如，一个编码为 GB2312 的页面，提交 "中" 这个字符串时，提交给服务器的内容为 "%D6%D0"。 在服务器端，Web 服务器把收到的 "%D6%D0" 转化成 [0xD6, 0xD0] 两个字节，然后再根据 GB2312 编码规则得到 "中" 字。 在 Tomcat 服务器中，request.getParameter() 得到乱码时，常常是因为前面提到的“误解一”造成的。默认情况下，当提交 "%D6%D0" 给 Tomcat 服务器时，request.getParameter() 将返回 [0x00D6, 0x00D0] 两个 UNICODE 字符，而不是返回一个 "中" 字符。因此，我们需要使用 bytes = string.getBytes("iso-8859-1") 得到原始的字节串，再用 string = new String(bytes, "GB2312") 重新得到正确的字符串 "中"。 回页首 回页首 3.4 从数据库读取字符串 通过数据库客户端（比如 ODBC 或 JDBC）从数据库服务器中读取字符串时，客户端需要从服务器获知所使用的 ANSI 编码。当数据库服务器发送字节流给客户端时，客户端负责将字节流按照正确的编码转化成 UNICODE 字符串。 如果从数据库读取字符串时得到乱码，而数据库中存放的数据又是正确的，那么往往还是因为前面提到的“误解一”造成的。解决的办法还是通过 string = new String( string.getBytes("iso-8859-1"), "GB2312") 的方法，重新得到原始的字节串，再重新使用正确的编码转化成字符串。 回页首 3.5 电子邮件中的字符串 当一段 Text 或者 HTML 通过电子邮件传送时，发送的内容首先通过一种指定的字符编码转化成“字节串”，然后再把“字节串”通过一种指定的传输编码（Content-Transfer-Encoding）进行转化得到另一串“字节串”。比如，打开一封电子邮件源代码，可以看到类似的内容： Content-Type: text/plain;         charset="gb2312" Content-Transfer-Encoding: base64 sbG+qcrQuqO17cf4yee74bGjz9W7+b3wudzA7dbQ0MQNCg0KvPKzxqO6uqO17cnnsaPW0NDEDQoNCg== 最常用的 Content-Transfer-Encoding 有 Base64 和 Quoted-Printable 两种。在对二进制文件或者中文文本进行转化时，Base64 得到的“字节串”比 Quoted-Printable 更短。在对英文文本进行转化时，Quoted-Printable 得到的“字节串”比 Base64 更短。 邮件的标题，用了一种更简短的格式来标注“字符编码”和“传输编码”。比如，标题内容为 "中"，则在邮件源代码中表示为： // 正确的标题格式 Subject: =?GB2312?B?1tA=?= 其中， 第一个“=?”与“?”中间的部分指定了字符编码，在这个例子中指定的是 GB2312。 “?”与“?”中间的“B”代表 Base64。如果是“Q”则代表 Quoted-Printable。 最后“?”与“?=”之间的部分，就是经过 GB2312 转化成字节串，再经过 Base64 转化后的标题内容。 如果“传输编码”改为 Quoted-Printable，同样，如果标题内容为 "中"： // 正确的标题格式 Subject: =?GB2312?Q?=D6=D0?= 如果阅读邮件时出现乱码，一般是因为“字符编码”或“传输编码”指定有误，或者是没有指定。比如，有的发邮件组件在发送邮件时，标题 "中"： // 错误的标题格式 Subject: =?ISO-8859-1?Q?=D6=D0?= 这样的表示，实际上是明确指明了标题为 [0x00D6, 0x00D0]，即 "ÖÐ"，而不是 "中"。 回页首 4. 几种错误理解的纠正 误解：“ISO-8859-1 是国际编码？” 非也。iso-8859-1 只是单字节字符集中最简单的一种，也就是“字节编号”与“UNICODE 字符编号”一致的那种编码规则。当我们要把一个“字节串”转化成“字符串”，而又不知道它是哪一种 ANSI 编码时，先暂时地把“每一个字节”作为“一个字符”进行转化，不会造成信息丢失。然后再使用 bytes = string.getBytes("iso-8859-1") 的方法可恢复到原始的字节串。 误解：“Java 中，怎样知道某个字符串的内码？” Java 中，字符串类 java.lang.String 处理的是 UNICODE 字符串，不是 ANSI 字符串。我们只需要把字符串作为“抽象的符号的串”来看待。因此不存在字符串的内码的问题。 回页首

摘要：来源:天极开发　查看全文

摘要：from: http://blog.csdn.net/tanlingyun/archive/2007/04/25/1584097.aspx　查看全文

摘要：D3DX 是一个静态库，容易使用在发布的产品上。D3DX 也提供3D 图形应用程序公共的操作。D3DX包含下面几个方面：抽象数据类型，helper对象，triangle meshes，resource function和一些其他函数。 具体类提供了颜色，材质，向量，矩阵，面和quaternion。他们实现为C++类，并且也提供了一些操作在这些类上全局函数。helper对象实现了矩阵堆栈，text rendering,spirites和multi-pass 渲染效果，render target assistance。这些对象是以COM对象实现的。　查看全文

Smart Pointer是C++中的一个大题目，要说清楚他的所有好处很需要费点力气。我就一个功能一个功能的说。有我理解不透的地方希望大家指点。

1.copy-to-write
当生成一个C++ object的时候如果这个class很大，这个object会占用很多空间。那么每生成一个就占用一片空间，这样会占用很多系统资源。同时降低效率。一个解决方法就是对用拷贝构造函数生成的object，让他不存储数据，而只存储一个指向原来object数据的指针。这样空间就节省了很多。但问题在于这样两个object完全联结在了一起。如果修改了其中一个，另一个也跟着变了。所以这种方法不可取。这里讲的copy-to-write技术就是解决这类问题的方法。当通过引用一个已有object去拷贝构造新object时，新object只有一个指向已有object的指针。这两个object共享数据。直到其中一个需要修改数据的时候，再把这两块数据分离。这里举一个最简化的例子。假设一个class叫CLargeObject，里面存有很多数据。我们用一个inner class来把所有数据放在一起，叫CData。CData里面存有大量数据，例如一个数据库。这里用最简单的模型来表示，假设只有一个整数int m_nVal; CData里面需要包含另一个变量。叫作索引数目(reference count)。它记录了指向这个CData object的来自CLargetObject类的指针各数。也就是说，总共有多少CLargeObject的object正在引用着当前的CData object。

class CLargeObject
{
private:
    struct CData
    {
    private:
        int m_nVal;
      &nbp; int m_nReferenceCount;
    }
};

对于每个CLargeObject的object，我们用一个CData类的指针来指向其数据。
CData *m_pData;

CLargeObject至少有两个构造函数。第一个是标准的构造函数，初始化其数据。这时数据是唯一的，所以必须新生成一个CData的object来存储数据。
CLargeObject::CLargeObject(int nVal)
{
    m_pData = new Data(nVal);
}
而对于CData类的构造函数而言，初始化他的CLargeObject是第一个指向他的，这一时刻索引数目m_nReferenceCount是1。
CLargeObject::Data::Data(int nVal) : m_nVal(nVal), m_nReferenceCount(1) {}

CLargeObject的第二个构造函数是拷贝构造(copy constructor)。这样生成的object不需要有新的数据，和已有的object共享数据就可以了。这是索引数目需要加1。表示又有一个object指向当前的CData了。
CLargeObject::CLargeObject(const CLargeObject &ob) // copy constructor
{
    ob.m_pData->m_nReferenceCount++;
    m_pData = ob.m_pData;
}


这样CLargeObject就构造好了，使用了可能的最少的内存。下面看看他的析够函数(destructor)。当一个object被delete的时候，它的数据不一定无效，如果别的object还在引用着这个数据，数据需要留下来。当然，数据的索引数目无论如何都要减1。
CLargeObject::~CLargeObject()
{
    if (--m_pData->m_nReferenceCount == 0)
        delete m_pData;
}

下面看一看赋值操作。先说用已有的CLargeObject赋值给这个CLargeObject。这时当前CLargeObject里面的数据要指向已有的这个object，就搞定了。
CLargeObject& CLargeObject::operator = (const CLargeObject& ob)    // copy assignment
{
    ob.m_pData->m_nReferenceCount++;
    if (--m_pData->m_nReferenceCount == 0)
        delete m_pData;
    m_pData = ob.m_pData;

    return *this;
}

再来看看如何对CLargeObject里面的数据进行真正的修改。这样就一定需要对当前的object独立操作了，否则就影响到了其它指向同一块数据的CLargeObject。这样CData类需要一个新的函数，生成只用于当前CLargetObject的数据。如果当前的引用数目是1，那么当然这个CData就是只用于这个CLargeObject的了。否则就重新new一个CData返回。
        Data* CLargeObject::CData::get_own_copy()    // clone if necessary
        {
            if (m_nReferenceCount==1)
                return this;
            m_nReferenceCount--;
            return new Data(m_nVal);
        }
CLargeObject修改前用这个函数得到唯一的object，然后对它赋值。
void CLargeObject::SetVal(int nNewVal)
{
    m_pData = m_pData->get_own_copy();
    m_pData->m_nVal = nNewVal;
}
对于所有可能改变CData值的操作，都需要用这种方法。

下面是只读函数，简单。直接返回值，什么特殊的都不用作。
int CLargeObject::GetVal() const
{
    return m_pData->m_nVal;
}


这样copy-to-write技术就实现了。下面把完整的程序写一下：

 

class CLargeObject

{

public:

    CLargeObject(int nVal);

    CLargeObject(const CLargeObject &ob);

    ~CLargeObject();

 

    CLargeObject& operator = (const CLargeObject& ob);

    void SetVal(int nNewVal);

    int GetVal() const;

private:

    struct Data

    {

    public:

       Data(int nVal) : m_nVal(nVal), m_nReferenceCount(1) {}

    private:

       friend class CLargeObject;

       Data* get_own_copy()    // clone if necessary

       {

           if (m_nReferenceCount==1)

              return this;

           m_nReferenceCount--;

           return new Data(m_nVal);

       }

 

       // control variables.

       int m_nReferenceCount;

 

       // actual data portion

       int m_nVal;

    };

 

    Data *m_pData;

};

 

CLargeObject::CLargeObject(int nVal)

{

    m_pData = new Data(nVal);

}

 

CLargeObject::CLargeObject(const CLargeObject &ob) // copy constructor

{

    ob.m_pData->m_nReferenceCount++;

    m_pData = ob.m_pData;

}

 

CLargeObject::~CLargeObject()

{

    if (--m_pData->m_nReferenceCount == 0)

       delete m_pData;

}

 

CLargeObject& CLargeObject::operator = (const CLargeObject& ob)    // copy assignment

{

    ob.m_pData->m_nReferenceCount++;

    if (--m_pData->m_nReferenceCount == 0)

       delete m_pData;

    m_pData = ob.m_pData;

 

    return *this;

}

 

void CLargeObject::SetVal(int nNewVal)

{

    m_pData = m_pData->get_own_copy();

    m_pData->m_nVal = nNewVal;

}

 

 

 

int CLargeObject::GetVal() const

{

 

    return m_pData->m_nVal;

 

}

很多存储数据的系统class，如string，CString等都有这种设计。所以记住这个应用是很有必要的。

 转载：

from:http://www.bc-cn.net/

摘要：from:http://www.frontfree.net/　查看全文

from:http://www.gameres.com

很早以前就想写一些关于OGRE的文章了，一直没机会。 
理解一个渲染引擎，我觉得最重要的是先抓住了它的主架构，它的主线，渲染流程，不然的话，一个引擎几万行，甚至几十万行的代码，光是打开solution就能吓你一跳了，OGRE也有十几万行的代码量，我一开始看它的时候也是无从下手，感觉代码太多了，不知道从哪开始看好，这个class看看，那个class看看，由于对整个引擎没有一个清晰的认识，看过了也印象不深，所以，最后，还是决定先找出它的主线，了解它的渲染流程，这样才能有机地把各个部分联系起来。

      这篇短文也是对OGRE的主要渲染流程的一个介绍，可能对一些class不会太多地去介绍具体的实现细节。我所用的代码都是取自于OGRE的最新的CVS版本。

      读者最好对OGRE有一定的了解，至少得看懂它的example，不然可能一些东西理解起来比较困难。对D3D，OPENGL有一定了解更好。

      如果你看过D3D SDK中带的例子，你一定知道一个比较简单的3D程序要运行起来，至少都会涉及下的几部分：

      首先是数据的来源，包括顶点数据，纹理数据等，这些数据可以从文件中读取，也可以在程序运行时生成。

      接下来，我们会建立顶点缓冲区把顶点保存起来，建立texture对象来表示texture，对顶点组成的物体设置它在世界坐标系下的坐标，设置摄像机的位置，视点，设置viewport的位置和大小，然后就可以在渲染循环中开始调用渲染操作了，经过了front buffer和back buffer的交换，我们就能在屏幕上看到3D图形了，伪代码如下：

      setupVertexBuffer

      setWorldTransform

      setCamera

      setProjectionTransform

      setViewport

       beginFrame

      setTexture

      drawObject

      endFrame 

      以下就是渲染一个物体的主要步骤，在我看来，这就是3D程序的主线，同样道理，无论你多复杂的渲染引擎，都得实现上述的这些步骤，其他的一些效果如阴影，光照等，都是附着在这条主线上的，所以，如果你能在你所研究的渲染引擎上也清晰地看到这条主线，可能对你深入地研究它会大有帮助，下面，我们就一起来找到OGRE中的这条主线。

      OGRE的渲染循环都是起源于Root::renderOneFrame，这个函数在OGRE自带的example中是不会显式调用的，因为example都调用了Root::startRendering，由startRendering来调用renderOneFrame，如果你用OGRE来写真正的游戏，或者编辑器，你可能就需要在的消息主循环中调用renderOneFrame了，顾名思义，这个函数就是对整个OGRE进行一帧的更新，包括动画，渲染状态的改变，渲染api的调用等，在这个函数中，会包括了我们上述伪代码的几乎全部内容，所以是本文的重点所在。

      进入renderOneFrame，可以看到头尾两个fire函数，这种函数在OGRE中经常出现，一般都是fire…start和fire…end一起出现的，在这些函数中，可能会处理一些用户自定义的操作，如_fireFrameStarted就会对所以的frameListener进行处理，这些fire函数可以暂时不用理会，继续看_updateAllRenderTargets，在这个函数中，会委派当前所用的renderer对所有创建出来的render target进行update，render target也就是渲染的目的地，一般会有两种，一种是render texture，一种是render buffer，接着进入RenderSystem::_updateAllRenderTargets，可以看到在render system中，对创建出来的render target是用RenderTargetPriorityMap来保存的，以便按照一定的顺序来对render target进行update，因为在渲染物体到render buffer时，一般会用到之前渲染好的render texture，所以render texture形式的render target需要在render buffer之前进行更新。

      进入render target的update，可以看到，它仍然把update操作继续传递下去，调用所有挂在这个render target上的viewport的update。

      Viewport其实就是定义了render target上的一块要进行更新的区域，所以一个render target是可以挂多个viewport的，以实现多人对战时分屏，或者是画中画等效果，可以把OGRE中的viewport看成是保存camera和rendertarget这两者的组合，把viewport中所定义的camera所看到的场景内容渲染到viewport所定义的render target的区域里。

      Viewport还有一个重要信息是ZOrder，可以看到RenderTarget中的ViewportList带有一个比较函数，所以在RenderTarget::update中，ZOrder越小的，越先被渲染，所以，如果两个viewport所定义的区域互相重叠了，而且ZOrder又不一样，最终的效果就是ZOrder小的viewport的内容会被ZOrder大的viewport的内容所覆盖。

      继续进入Viewport::update，就像前面所说，它调用它所引用的camera来渲染整个场景，而在Camera::_renderScene中，是调用SceneManager::_renderScene(Camera* camera, Viewport* vp, bool includeOverlays)。SceneManager::_renderScene里就是具体的渲染流程了。从函数名称还有参数也可以看出来，这个函数的作用就是利用所指定的camera和viewport，来把场景中的内容渲染到viewport所指定的render target的某块区域中。根据camera，我们可以定出view matrix，projection matrix，还可以进行视锥剔除，只渲染看得见的物体。注意，我们这里只看标准的SceneManager的方法，不看BspSceneManager派生类的方法，而且，我们会抛开跟主线无关的内容，如对shadow的setup，骨骼动画的播放，shader参数的传递等，因为我们只注重渲染的主流程。

      在SceneManager::_renderScene中所应看的第一个重要函数是_updateSceneGraph，OGRE对场景的组织是通过节点树来组织的，一个节点，你可以看成是空间中的某些变换的组合，如位置，缩放，旋转等，这些变换，会作用到挂接在这些节点上的具体的物体的信息，也就是说，节点保存了world transform，对具体的物体，如一个人，在空间中的定位，都是通过操作节点来完成的。同时节点还保存了一个世界坐标的AABB，这个AABB能容纳所有它所挂接的物体的大小，主要是用于视锥裁减的，如果当前摄像机看不见某个节点的AABB，那么说明摄像机看不见节点所挂接的所有物体，所以在渲染时可以对这个节点视而不见。

      _updateSceneGraph的内部处理比较繁琐，我们只需知道，经过了_updateSceneGraph，场景节点树中的每个节点都经过了更新，包括位置，缩放，和方位，还有节点的包围盒。

      继续回到SceneManager::_renderScene，接下来要看的是setViewport，它会调用具体的renderer的setviewport的操作，设置viewport中所挂接的render target为当前所要渲染的目标，viewport中的区域为当前所要渲染的目标中的区域。

      接下来要碰到OGRE渲染流程中的一个重要的概念，Render Queue。这个东西实在内容比较多，还是以后有机会单独提出来说吧，你可以简单把它想成是一个容器，里面的元素就是renderable，每个renderable可以看成是每次调用drawprimitive函数所渲染的物体，可以是一个模型，也可以是模型的一部分。在RenderQueue中，它会按材质来分组这些renderable，还会对renderable进行排序。

      在每一次调用SceneManager::_renderScene时，都会调用SceneManager::prepareRenderQueue来清理RenderQueue，然后再调用SceneManager::__findVisibleObjects来把当前摄像机所能看见的物体都加入到RenderQueue中。

      SceneManager::__findVisibleObjects是一个递归的处理过程，它从场景的根节点开始，先检查摄像机是否能看见这个节点的包围盒（包围盒在_updateSceneGraph时已经计算好了），如果看不见，那么这个节点，还有它的子节点都不用管了。如果能看见，再检测挂在这个节点上的所有MovableObject，如果当前所检测的MovableObject是可见的，就会调用它的_updateRenderQueue方法，一般在这个方法里就可以把和这个MovableObject相关的renderable送入RenderQueue了。

      这里要说说MovableObject，MovableObject主要是用于表示场景中离散的物体，如Entity，顾名思义，能移动的物体，不过它的“能移动”这个能力是要通过SceneNode来实现的，所以MovableObject来能显示出来，首先得先挂接在某个场景节点上，通过场景节点来定位。你可以控制MovableObject的一些属性，如某个MovableObject是否要显示，是否要隐藏，都可以通过MovableObject::setVisible方法来实现。

      检测完该节点上的MovableObject之后，就继续调用所有子节点的_findVisibleObjects方法，一直递归下去。这样，就能把场景中所有要渲染的renderable所加入到RenderQueue中了。

      至此，我们就拥有了要渲染的物体的信息了，接下来就是对这些物体进行渲染了，你会发现跟D3D或OpenGL的代码很类似的调用：

       mDestRenderSystem->clearFrameBuffer

      mDestRenderSystem->_beginFrame    

       mDestRenderSystem->_setProjectionMatrix

       mDestRenderSystem->_setViewMatrix 

       _renderVisibleObjects();

      mDestRenderSystem->_endFrame();

      这些api的作用和D3D中的类似调用的作用都差不多，这里再说一下_renderVisibleObjects()，在这个函数中，会对RenderQueue中的每个renderable进行渲染，用的是visitor模式来遍历操作每个renderable，最终在SceneManager::renderSingleObject中取出每个renderable所保存的顶点，索引，世界矩阵等信息，来进行渲染。这其中还包括了查找离该renderable最近的光源等操作，比较复杂。

      到这里，SceneManger::_renderScene的流程基本走完了，也就是说，OGRE一帧中的渲染流程差不多也结束了，你应该也发现，这个流程跟你用D3D写一个简单程序的流程基本是一样的，在这个流程的基础上，再去看具体的实现，如怎么样设置纹理，怎么样调用你熟悉的D3D或OpenGL的API来渲染物体，应该会简单得多。

      对OGRE的渲染流程的大概介绍到这里也结束了，很多细节都没涉及，以后有机会再写吧。

注：

转载自：http://bbs.gameres.com/showthread.asp?threadid=70441

 一、C 风格（C-style）强制转型如下：

    (T) expression // cast expression to be of type T

    函数风格（Function-style）强制转型使用这样的语法：
    T(expression) // cast expression to be of type T

    这两种形式之间没有本质上的不同，它纯粹就是一个把括号放在哪的问题。
我把这两种形式称为旧风格（old-style）的强制转型。

   二、 C++的四种强制转型形式：

　　C++ 同时提供了四种新的强制转型形式（通常称为新风格的或 C++ 风格的强制转型）：
　　const_cast(expression)
　　dynamic_cast(expression)
　　reinterpret_cast(expression)
　　static_cast(expression)

　　每一种适用于特定的目的：

　　dynamic_cast

主要用于执行“安全的向下转型（safe downcasting）”，
也就是说，要确定一个对象是否是一个继承体系中的一个特定类型。
它是唯一不能用旧风格语法执行的强制转型，也是唯一可能有重大运行时代价的强制转型。
   
     static_cast

可以被用于强制隐型转换（例如，non-const 对象转型为 const 对象，int 转型为 double，等等），
它还可以用于很多这样的转换的反向转换（例如，void* 指针转型为有类型指针，基类指针转型为派生类指针），
但是它不能将一个 const 对象转型为 non-const 对象（只有 const_cast 能做到），它最接近于C-style的转换。
   

　　 const_cast

一般用于强制消除对象的常量性。它是唯一能做到这一点的 C++ 风格的强制转型。

　　 reinterpret_cast

是特意用于底层的强制转型，
导致实现依赖（implementation-dependent）（就是说，不可移植）的结果，
例如，将一个指针转型为一个整数。这样的强制转型在底层代码以外应该极为罕见。
　　

旧风格的强制转型依然合法，但是新的形式更可取。

首先，在代码中它们更容易识别（无论是人还是像 grep 这样的工具都是如此），
这样就简化了在代码中寻找类型系统被破坏的地方的过程。

第二，更精确地指定每一个强制转型的目的，使得编译器诊断使用错误成为可能。
例如，如果你试图使用一个 const_cast 以外的新风格强制转型来消除常量性，你的代码将无法编译。

 dynamic_cast .vs. static_cast

class B { ... };
class D : public B { ... };

void f(B* pb)
{
   D* pd1 = dynamic_cast<D*>(pb);
   D* pd2 = static_cast<D*>(pb);
}

If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same

value if pb == 0.

If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return

zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply

returns a pointer to that supposed D object.

即dynamic_cast可用于继承体系中的向下转型，
即将基类指针转换为派生类指针，
比static_cast更严格更安全。
dynamic_cast在执行效率上比static_cast要差一些,
但static_cast在更宽上范围内可以完成映射,
这种不加限制的映射伴随着不安全性.
static_cast覆盖的变换类型除类层次的静态导航以外,
还包括无映射变换,窄化变换(这种变换会导致对象切片,丢失信息),
用VOID*的强制变换,隐式类型变换等...

 static_cast .vs. reinterpret_cast

    reinterpret_cast是为了映射到一个完全不同类型的意思,
这个关键词在我们需要把类型映射回原有类型时用到它.
我们映射到的类型仅仅是为了故弄玄虚和其他目的,
这是所有映射中最危险的.(这句话是C++编程思想中的原话)

   
static_cast 和 reinterpret_cast 操作符修改了操作数类型. 它们不是互逆的;
 static_cast 在编译时使用类型信息执行转换, 在转换执行必要的检测(诸如指针越界计算, 类型检查).
 其操作数相对是安全的.
另一方面, reinterpret_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换,

 例子如下:

    int n=9; double d=static_cast < double > (n);

    上面的例子中, 我们将一个变量从 int 转换到 double. 这些类型的二进制表达式是不同的.
要将整数 9 转换到 双精度整数 9, static_cast 需要正确地为双精度整数 d 补足比特位.
其结果为 9.0. 而reinterpret_cast 的行为却不同:

    int n=9;
    double d=reinterpret_cast<double & > (n);

    这次, 结果有所不同.
在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析。

 from:
http://blog.bioon.com/user1/8688/archives/2006/45399.shtml

C++中的虚函数(virtual function) C++中的虚函数(virtual function) 1.简介     虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类定义的函数。假设我们有下面的类层次： class A { public:     virtual void foo() { cout << "A::foo() is called" << endl;} }; class B: public A { public:     virtual void foo() { cout << "B::foo() is called" << endl;} }; 那么，在使用的时候，我们可以： A * a = new B(); a->foo();       // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!     这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。     虚函数只能借助于指针或者引用来达到多态的效果，如果是下面这样的代码，则虽然是虚函数，但它不是多态的： class A { public:     virtual void foo(); }; class B: public A {     virtual void foo(); }; void bar() {     A a;     a.foo();   // A::foo()被调用 } 1.1 多态     在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍然针对上面的类层次，但是使用的方法变的复杂了一些： void bar(A * a) {     a->foo();  // 被调用的是A::foo() 还是B::foo()？ } 因为foo()是个虚函数，所以在bar这个函数中，只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a指向的是A类的实例，则A::foo()被调用，如果a指向的是B类的实例，则B::foo()被调用。 这种同一代码可以产生不同效果的特点，被称为“多态”。 1.2 多态有什么用？     多态这么神奇，但是能用来做什么呢？这个命题我难以用一两句话概括，一般的C++教程（或者其它面向对象语言的教程）都用一个画图的例子来展示多态的用途，我就不再重复这个例子了，如果你不知道这个例子，随便找本书应该都有介绍。我试图从一个抽象的角度描述一下，回头再结合那个画图的例子，也许你就更容易理解。     在面向对象的编程中，首先会针对数据进行抽象（确定基类）和继承（确定派生类），构成类层次。这个类层次的使用者在使用它们的时候，如果仍然在需要基类的时候写针对基类的代码，在需要派生类的时候写针对派生类的代码，就等于类层次完全暴露在使用者面前。如果这个类层次有任何的改变（增加了新类），都需要使用者“知道”（针对新类写代码）。这样就增加了类层次与其使用者之间的耦合，有人把这种情况列为程序中的“bad smell”之一。     多态可以使程序员脱离这种窘境。再回头看看1.1中的例子，bar()作为A-B这个类层次的使用者，它并不知道这个类层次中有多少个类，每个类都叫什么，但是一样可以很好的工作，当有一个C类从A类派生出来后，bar()也不需要“知道”（修改）。这完全归功于多态--编译器针对虚函数产生了可以在运行时刻确定被调用函数的代码。 1.3 如何“动态联编”     编译器是如何针对虚函数产生可以再运行时刻确定被调用函数的代码呢？也就是说，虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型[1]中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。     我所说的“标准”方式，也就是所谓的“VTABLE”机制。编译器发现一个类中有被声明为virtual的函数，就会为其搞一个虚函数表，也就是VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个vptr字段，该字段指向本类的VTABLE。通过这些手段，编译器在看到一个虚函数调用的时候，就会将这个调用改写，针对1.1中的例子： void bar(A * a) {     a->foo(); } 会被改写为： void bar(A * a) {     (a->vptr[1])(); }     因为派生类和基类的foo()函数具有相同的VTABLE索引，而他们的vptr又指向不同的VTABLE，因此通过这样的方法可以在运行时刻决定调用哪个foo()函数。     虽然实际情况远非这么简单，但是基本原理大致如此。 1.4 overload和override     虚函数总是在派生类中被改写，这种改写被称为“override”。我经常混淆“overload”和“override”这两个单词。但是随着各类C++的书越来越多，后来的程序员也许不会再犯我犯过的错误了。但是我打算澄清一下： override是指派生类重写基类的虚函数，就象我们前面B类中重写了A类中的foo()函数。重写的函数必须有一致的参数表和返回值（C++标准允许返回值不同的情况，这个我会在“语法”部分简单介绍，但是很少编译器支持这个feature）。这个单词好象一直没有什么合适的中文词汇来对应，有人译为“覆盖”，还贴切一些。 overload约定成俗的被翻译为“重载”。是指编写一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型数作为参数，也可以接受浮点数作为参数。 2. 虚函数的语法     虚函数的标志是“virtual”关键字。 2.1 使用virtual关键字     考虑下面的类层次： class A { public:     virtual void foo(); }; class B: public A { public:     void foo();    // 没有virtual关键字! }; class C: public B  // 从B继承，不是从A继承！ { public:     void foo();    // 也没有virtual关键字！ };     这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说，基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。 2.2 纯虚函数     如下声明表示一个函数为纯虚函数： class A { public:     virtual void foo()=0;   // =0标志一个虚函数为纯虚函数 };     一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。 2.3 虚析构函数     析构函数也可以是虚的，甚至是纯虚的。例如： class A { public:     virtual ~A()=0;   // 纯虚析构函数 };     当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。考虑下面的例子： class A { public:     A() { ptra_ = new char[10];}     ~A() { delete[] ptra_;}        // 非虚析构函数 private:     char * ptra_; }; class B: public A { public:     B() { ptrb_ = new char[20];}     ~B() { delete[] ptrb_;} private:     char * ptrb_; }; void foo() {     A * a = new B;     delete a; }     在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这是否有点儿可怕？     如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。     纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。 2.4 虚构造函数？     构造函数不能是虚的。 3. 虚函数使用技巧 3.1 private的虚函数     考虑下面的例子： class A { public:     void foo() { bar();} private:     virtual void bar() { ...} }; class B: public A { private:     virtual void bar() { ...} };     在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。     这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。 3.2 构造函数和析构函数中的虚函数调用     一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”。例如： class A { public:     A() { foo();}        // 在这里，无论如何都是A::foo()被调用！     ~A() { foo();}       // 同上     virtual void foo(); }; class B: public A { public:     virtual void foo(); }; void bar() {     A * a = new B;     delete a; }     如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同样，在new B的时候，A的构造函数被调用，但是在A的构造函数中，被调用的是A::foo()而不是B::foo()。 3.3 多继承中的虚函数 3.4 什么时候使用虚函数     在你设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。从设计的角度讲，出现在基类中的虚函数是接口，出现在派生类中的虚函数是接口的具体实现。通过这样的方法，就可以将对象的行为抽象化。     以设计模式[2]中Factory Method模式为例，Creator的factoryMethod()就是虚函数，派生类override这个函数后，产生不同的Product类，被产生的Product类被基类的AnOperation()函数使用。基类的AnOperation()函数针对Product类进行操作，当然Product类一定也有多态（虚函数）。     另外一个例子就是集合操作，假设你有一个以A类为基类的类层次，又用了一个std::vector<A *>来保存这个类层次中不同类的实例指针，那么你一定希望在对这个集合中的类进行操作的时候，不要把每个指针再cast回到它原来的类型（派生类），而是希望对他们进行同样的操作。那么就应该将这个“一样的操作”声明为virtual。     现实中，远不只我举的这两个例子，但是大的原则都是我前面说到的“如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的”。这句话也可以反过来说：“如果你发现基类提供了虚函数，那么你最好override它”。 转载 from:http://www.xiaozhou.net/ReadNews.asp?NewsID=946

1.引言

　　C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C语言的全局变量和函数所采用的编译和连接方式与C语言完全相同。作为一种欲与C兼容的语言，C++保留了一部分过程式语言的特点（被世人称为“不彻底地面向对象”），因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同。

2.从标准头文件说起

　　某企业曾经给出如下的一道面试题：

　　面试题
　　为什么标准头文件都有类似以下的结构？




#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*...*/
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */

　　分析
　　显然，头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。

　　那么
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
}
#endif

　　的作用又是什么呢？我们将在下文一一道来。
　　

3.深层揭密extern "C"

　　extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。

　　被extern "C"限定的函数或变量是extern类型的；

　　extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：
　　extern int a;

　　仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

　　通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数。

　　与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。

　　被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

　　未加extern “C”声明时的编译方式

　　首先看看C++中对类似C的函数是怎样编译的。

　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo( int x, int y );

　　该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

　　_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。
　　同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

　　未加extern "C"声明时的连接方式

　　假设在C++中，模块A的头文件如下：
// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
int foo( int x, int y );
#endif

　　在模块B中引用该函数：
// 模块B实现文件　moduleB.cpp
#include "moduleA.h"
foo(2,3);

　　实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

　　加extern "C"声明后的编译和连接方式

　　加extern "C"声明后，模块A的头文件变为：
// 模块A头文件　moduleA.h
#ifndef MODULE_A_H
#define MODULE_A_H
extern "C" int foo( int x, int y );
#endif

　　在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

　　（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

　　（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

　　如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

　　所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：
　　实现C++与C及其它语言的混合编程。
　　明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。
　　

\4.extern "C"的惯用法

　　（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：
extern "C"
{
#include "cExample.h"
}

　　而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

　　笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：
/* c语言头文件：cExample.h */
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H
extern int add(int x,int y);
#endif
/* c语言实现文件：cExample.c */
#include "cExample.h"
int add( int x, int y )
{
return x + y;
}
// c++实现文件，调用add：cppFile.cpp
extern "C"
{
#include "cExample.h"
}
int main(int argc, char* argv[])
{
add(2,3);
return 0;
}

　　如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

　　（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。
　　笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：
//C++头文件 cppExample.h
#ifndef CPP_EXAMPLE_H
#define CPP_EXAMPLE_H
extern "C" int add( int x, int y );
#endif
//C++实现文件 cppExample.cpp
#include "cppExample.h"
int add( int x, int y )
{
return x + y;
}
/* C实现文件 cFile.c
/* 这样会编译出错：#include "cExample.h" */
extern int add( int x, int y );
int main( int argc, char* argv[] )
{
add( 2, 3 );
return 0;
}

　　如果深入理解了第3节中所阐述的extern "C"在编译和连接阶段发挥的作用，就能真正理解本节所阐述的从C++引用C函数和C引用C++函数的惯用法。对第4节给出的示例代码，需要特别留意各个细节。
PConline

摘要：Create new XML documents; parse and modify existing XML documents. All from the methods of one simple class utilizing MFC or STL strings. With CMarkup you can run the example right out of the zip file, look through its source code if you like, and compile XML capability into your own application in minutes.　查看全文

摘要：from:慧聪网　查看全文

摘要：AAF与MXF和GXF面向不同的应用。AAF不能直接用于文件交换，它支持高性能的编辑应用，包括非线性编辑和多层画面合成、特技效果和丰富的元数据，可接受外部基准...　查看全文

摘要：过去十年来，CPU的处理速度几乎是几何级数的跃升，内存（memory）的存取速度亦大幅增加，而数据储存装置 主要是磁盘（hard disk） 的存取速度相较之下，较为缓慢。　查看全文

.........................

Clearing the Entire Vector Array

The clear() member function of the vector array can be used to clear all of the elements from the array. Be aware, if the array contained points to memory that was created dynamically, i.e. the new operator was used, the memory will not be freed, therefore causing a memory leak. So, you would need to make sure that you called the delete operator for each element within the array before calling the clear() function. Here is an example:

// same as before

class CMyClass
{
public:
  CMyClass() {}
  CMyClass(int def_x, int def_y) : x(def_x), y(def_y) {}
  virtual ~CMyClass() {}

  // this classes member functions
  // ...

  // some data (i.e. x and y)...
  int x, y;
};

void main()
{
  // create an array of CMyClass object pointers
  vector<CMyClass*> arMyClass;

  // dynamically add some elements (use new operator)
  arMyClass.push_back(new CMyClass(2, 40));
  arMyClass.push_back(new CMyClass(4, 60));
  arMyClass.push_back(new CMyClass(6, 80));
  arMyClass.push_back(new CMyClass(8, 100));

  // remove the second element from the array
  vector<CMyClass*>::iterator itSecond = arMyClass.begin() + 1;
  delete *itSecond;             // free the memory
  arMyClass.erase(itSecond);    // remove from
                                // the array

  // retrieve the value stored within the first x and y variables
  vector<CMyClass*>::iterator itFirst = arMyClass.begin()/* + 0 */;
  printf("First Coordinate: (%d, %d)\n", (*itFirst)->x,
                                         (*itFirst)->y);

  // start from the beginning of the array
  vector<CMyClass*>::iterator itPos = arMyClass.begin();
  // clear all elements from the array
  for(; itPos < arMyClass.end(); itPos++)
    delete *itPos;    // free the element from memory
   // finally, clear all elements from the array
  arMyClass.clear();
}

It can be argued that it is much more efficient to create all elements dynamically (with the new operator) because when iterating through the vector array, the computer will only be iterating through the size of a pointer (usually between 2 and 4 bits of memory) as opposed to iterating through very large objects. This is only really essential for software that needs to run very fast, i.e. games or real-time software. Remember that you will not need to free the memory (i.e. use the delete operator) if you have not dynamically allocated the memory (i.e. used the new operator). If you are simply storing a vector array of pointers to memory that is either static or cleaned up at a later stage, dynamically freeing the memory will not be an issue for you.

If you need to perfor large tasks with a vector array, it might be a good idea if you create a class that holds the vector array, but handles the processes that you might wish to perform on the array.

More information on this article,see the following:

http://www.codeguru.com/cpp/cpp/cpp_mfc/arrays/article.php/c4071/

以下未经说明，listctrl默认view 风格为report

1. CListCtrl 风格

      LVS_ICON: 为每个item显示大图标
      LVS_SMALLICON: 为每个item显示小图标
      LVS_LIST: 显示一列带有小图标的item
      LVS_REPORT: 显示item详细资料

      直观的理解：windows资源管理器，“查看”标签下的“大图标，小图标，列表，详细资料”

2. 设置listctrl 风格及扩展风格

      LONG lStyle;
      lStyle = GetWindowLong(m_list.m_hWnd, GWL_STYLE);//获取当前窗口style
      lStyle &= ~LVS_TYPEMASK; //清除显示方式位
      lStyle |= LVS_REPORT; //设置style
      SetWindowLong(m_list.m_hWnd, GWL_STYLE, lStyle);//设置style
 
      DWORD dwStyle = m_list.GetExtendedStyle();
      dwStyle |= LVS_EX_FULLROWSELECT;//选中某行使整行高亮（只适用与report风格的listctrl）
      dwStyle |= LVS_EX_GRIDLINES;//网格线（只适用与report风格的listctrl）
      dwStyle |= LVS_EX_CHECKBOXES;//item前生成checkbox控件
      m_list.SetExtendedStyle(dwStyle); //设置扩展风格
 
      注：listview的style请查阅msdn
      http://msdn.microsoft.com/library/default.asp?url=/library/en-us/wceshellui5/html/wce50lrflistviewstyles.asp

 

3. 插入数据

      m_list.InsertColumn( 0, "ID", LVCFMT_LEFT, 40 );//插入列
      m_list.InsertColumn( 1, "NAME", LVCFMT_LEFT, 50 );
      int nRow = m_list.InsertItem(0, “11”);//插入行
      m_list.SetItemText(nRow, 1, “jacky”);//设置数据

 

4. 一直选中item

    选中style中的Show selection always，或者在上面第2点中设置LVS_SHOWSELALWAYS

5. 选中和取消选中一行

    int nIndex = 0;
    //选中
    m_list.SetItemState(nIndex, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED);
    //取消选中
    m_list.SetItemState(nIndex, 0, LVIS_SELECTED|LVIS_FOCUSED);
 

6. 得到listctrl中所有行的checkbox的状态

      m_list.SetExtendedStyle(LVS_EX_CHECKBOXES);
      CString str;
      for(int i=0; i      {
           if( m_list.GetItemState(i, LVIS_SELECTED) == LVIS_SELECTED || m_list.GetCheck(i))
           {
                str.Format(_T("第%d行的checkbox为选中状态"), i);
                AfxMessageBox(str);
           }
      }

7. 得到listctrl中所有选中行的序号

      方法一：
      CString str;
      for(int i=0; i      {
           if( m_list.GetItemState(i, LVIS_SELECTED) == LVIS_SELECTED )
           {
                str.Format(_T("选中了第%d行"), i);
                AfxMessageBox(str);
           }
      }

      方法二：
      POSITION pos = m_list.GetFirstSelectedItemPosition();
      if (pos == NULL)
           TRACE0("No items were selected!\n");
      else
      {
           while (pos)
           {
                int nItem = m_list.GetNextSelectedItem(pos);
                TRACE1("Item %d was selected!\n", nItem);
                // you could do your own processing on nItem here
           }
      }

8. 得到item的信息

      TCHAR szBuf[1024];
      LVITEM lvi;
      lvi.iItem = nItemIndex;
&nbp;     lvi.iSubItem = 0;
      lvi.mask = LVIF_TEXT;
      lvi.pszText = szBuf;
      lvi.cchTextMax = 1024;
      m_list.GetItem(&lvi);

      关于得到设置item的状态，还可以参考msdn文章
      Q173242: Use Masks to Set/Get Item States in CListCtrl
               http://support.microsoft.com/kb/173242/en-us

9. 得到listctrl的所有列的header字符串内容

      LVCOLUMN lvcol;
      char  str[256];
      int   nColNum;
      CString  strColumnName[4];//假如有4列

      nColNum = 0;
      lvcol.mask = LVCF_TEXT;
      lvcol.pszText = str;
      lvcol.cchTextMax = 256;
      while(m_list.GetColumn(nColNum, &lvcol))
      {
           strColumnName[nColNum] = lvcol.pszText;
           nColNum++;
      }

10. 使listctrl中一项可见，即滚动滚动条

    m_list.EnsureVisible(i, FALSE);

11. 得到listctrl列数

    int nHeadNum = m_list.GetHeaderCtrl()->GetItemCount();

12. 删除所有列

      方法一：
         while ( m_list.DeleteColumn (0))
       因为你删除了第一列后，后面的列会依次向上移动。

      方法二：
      int nColumns = 4;
      for (int i=nColumns-1; i>=0; i--)
          m_list.DeleteColumn (i);

13. 得到单击的listctrl的行列号

      添加listctrl控件的NM_CLICK消息相应函数
      void CTest6Dlg::OnClickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           // 方法一：
           /*
           DWORD dwPos = GetMessagePos();
           CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
  
           m_list.ScreenToClient(&point);
  
           LVHITTESTINFO lvinfo;
           lvinfo.pt = point;
           lvinfo.flags = LVHT_ABOVE;
    
           int nItem = m_list.SubItemHitTest(&lvinfo);
           if(nItem != -1)
           {
                CString strtemp;
                strtemp.Format("单击的是第%d行第%d列", lvinfo.iItem, lvinfo.iSubItem);
                AfxMessageBox(strtemp);
           }
          */
  
          // 方法二:
          /*
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           if(pNMListView->iItem != -1)
           {
                CString strtemp;
                strtemp.Format("单击的是第%d行第%d列",
                                pNMListView->iItem, pNMListView->iSubItem);
                AfxMessageBox(strtemp);
           }
          */
           *pResult = 0;
      }

 

14. 判断是否点击在listctrl的checkbox上

      添加listctrl控件的NM_CLICK消息相应函数
      void CTest6Dlg::OnClickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           DWORD dwPos = GetMessagePos();
           CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
  
           m_list.ScreenToClient(&point);
  
           LVHITTESTINFO lvinfo;
           lvinfo.pt = point;
           lvinfo.flags = LVHT_ABOVE;
    
           UINT nFlag;
           int nItem = m_list.HitTest(point, &nFlag);
           //判断是否点在checkbox上
           if(nFlag == LVHT_ONITEMSTATEICON)
           {
                AfxMessageBox("点在listctrl的checkbox上");
           }
           *pResult = 0;
      }

15. 右键点击listctrl的item弹出菜单

      添加listctrl控件的NM_RCLICK消息相应函数
      void CTest6Dlg::OnRclickList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           if(pNMListView->iItem != -1)
           {
                DWORD dwPos = GetMessagePos();
     nbsp;          CPoint point( LOWORD(dwPos), HIWORD(dwPos) );
   
                CMenu menu;
                VERIFY( menu.LoadMenu( IDR_MENU1 ) );
                CMenu* popup = menu.GetSubMenu(0);
                ASSERT( popup != NULL );
                popup->TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this );
           }
           *pResult = 0;
  }

 

16. item切换焦点时(包括用键盘和鼠标切换item时)，状态的一些变化顺序

      添加listctrl控件的LVN_ITEMCHANGED消息相应函数
      void CTest6Dlg::OnItemchangedList1(NMHDR* pNMHDR, LRESULT* pResult)
      {
           NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
           // TODO: Add your control notification handler code here
   
           CString sTemp;
 
           if((pNMListView->uOldState & LVIS_FOCUSED) == LVIS_FOCUSED &&
            (pNMListView->uNewState & LVIS_FOCUSED) == 0)
           {
                sTemp.Format("%d losted focus",pNMListView->iItem);
           }
           else if((pNMListView->uOldState & LVIS_FOCUSED) == 0 &&
               (pNMListView->uNewState & LVIS_FOCUSED) == LVIS_FOCUSED)
           {
                sTemp.Format("%d got focus",pNMListView->iItem);
           }
 
           if((pNMListView->uOldState & LVIS_SELECTED) == LVIS_SELECTED &&
            (pNMListView->uNewState & LVIS_SELECTED) == 0)
           {
                sTemp.Format("%d losted selected",pNMListView->iItem);
           }
           else if((pNMListView->uOldState & LVIS_SELECTED) == 0 &&
            (pNMListView->uNewState & LVIS_SELECTED) == LVIS_SELECTED)
           {
                sTemp.Format("%d got selected",pNMListView->iItem);
           }
   
           *pResult = 0;
      }

17. 得到另一个进程里的listctrl控件的item内容

http://www.codeproject.com/threads/int64_memsteal.asp

18. 选中listview中的item

Q131284: How To Select a Listview Item Programmatically
http://support.microsoft.com/kb/131284/en-us

19. 如何在CListView中使用CListCtrl的派生类

http://www.codeguru.com/cpp/controls/listview/introduction/article.php/c919/

20. listctrl的subitem添加图标

      m_list.SetExtendedStyle(LVS_EX_SUBITEMIMAGES);
      m_list.SetItem(..); //具体参数请参考msdn

 

21. 在CListCtrl显示文件，并根据文件类型来显示图标

      网上找到的代码，share
      BOOL CTest6Dlg::OnInitDialog()
      {
           CDialog::OnInitDialog();
  
           HIMAGELIST himlSmall;
           HIMAGELIST himlLarge;
           SHFILEINFO sfi;
           char  cSysDir[MAX_PATH];
           CString  strBuf;
 
           memset(cSysDir, 0, MAX_PATH);
  
           GetWindowsDirectory(cSysDir, MAX_PATH);
           strBuf = cSysDir;
           sprintf(cSysDir, "%s", strBuf.Left(strBuf.Find("\\")+1));
 
           himlSmall = (HIMAGELIST)SHGetFileInfo ((LPCSTR)cSysDir, 
                      0, 
                      &sfi,
                      sizeof(SHFILEINFO), 
                      SHGFI_SYSICONINDEX | SHGFI_SMALLICON );
  
           himlLarge = (HIMAGELIST)SHGetFileInfo((LPCSTR)cSysDir, 
                      0, 
                      &sfi, 
                      sizeof(SHFILEINFO), 
                      SHGFI_YSICONINDEX | SHGFI_LARGEICON);
  
           if (himlSmall && himlLarge)
           {
                ::SendMessage(m_list.m_hWnd, LVM_SETIMAGELIST,
                             (WPARAM)LVSIL_SMALL, (LPARAM)himlSmall);
                ::SendMessage(m_list.m_hWnd, LVM_SETIMAGELIST,
                             (WPARAM)LVSIL_NORMAL, (LPARAM)himlLarge);
           }
           return TRUE;  // return TRUE  unless you set the focus to a control
      }
 
      void CTest6Dlg::AddFiles(LPCTSTR lpszFileName, BOOL bAddToDocument)
      {
           int nIcon = GetIconIndex(lpszFileName, FALSE, FALSE);
           CString strSize;
           CFileFind filefind;
 
           //  get file size
           if (filefind.FindFile(lpszFileName))
           {
                filefind.FindNextFile();
                strSize.Format("%d", filefind.GetLength());
           }
           else
                strSize = "0";
  
           // split path and filename
           CString strFileName = lpszFileName;
           CString strPath;
 
           int nPos = strFileName.ReverseFind('\\');
           if (nPos != -1)
           {
                strPath = strFileName.Left(nPos);
                strFileName = strFileName.Mid(nPos + 1);
           }
  
           // insert to list
           int nItem = m_list.GetItemCount();
           m_list.InsertItem(nItem, strFileName, nIcon);
           m_list.SetItemText(nItem, 1, strSize);
           m_list.SetItemText(nItem, 2, strFileName.Right(3));
           m_list.SetItemText(nItem, 3, strPath);
      }
 
      int CTest6Dlg::GetIconIndex(LPCTSTR lpszPath, BOOL bIsDir, BOOL bSelected)
      {
           SHFILEINFO sfi;
           memset(&sfi, 0, sizeof(sfi));
  
           if (bIsDir)
           {
            SHGetFileInfo(lpszPath, 
                         FILE_ATTRIBUTE_DIRECTORY, 
                         &sfi, 
                         sizeof(sfi), 
                         SHGFI_SMALLICON | SHGFI_SYSICONINDEX |
                         SHGFI_USEFILEATTRIBUTES |(bSelected ? SHGFI_OPENICON : 0)); 
            return  sfi.iIcon;
           }
           else
           {
            SHGetFileInfo (lpszPath, 
                         FILE_ATTRIBUTE_NORMAL, 
                         &sfi, 
                         sizeof(sfi), 
                         SHGFI_SMALLICON | SHGFI_SYSICONINDEX | 
                         SHGFI_USEFILEATTRIBUTES | (bSelected ? SHGFI_OPENICON : 0));
            return   sfi.iIcon;
           }
           return  -1;
      }

22. listctrl内容进行大数据量更新时，避免闪烁

      m_list.SetRedraw(FALSE);
      //更新内容
      m_list.SetRedraw(TRUE);
      m_list.Invalidate();
      m_list.UpdateWindow();
 
或者参考

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_mfc_cwnd.3a3a.setredraw.asp

23. listctrl排序

Q250614：How To Sort Items in a CListCtrl in Report View
http://support.microsoft.com/kb/250614/en-us

24. 在listctrl中选中某个item动态改变其icon或bitmap

Q141834: How to change the icon or the bitmap of a CListCtrl item in Visual C++
http://support.microsoft.com/kb/141834/en-us

25. 在添加item后，再InsertColumn()后导致整列数据移动的问题

Q151897: CListCtrl::InsertColumn() Causes Column Data to Shift
http://support.microsoft.com/kb/151897/en-us

26. 关于listctrl第一列始终居左的问题

解决办法：把第一列当一个虚列，从第二列开始插入列及数据，最后删除第一列。
     
具体解释参阅   http://msdn.microsoft.com/library/default.asp?url=/library/en-us/shellcc/platform/commctls/listview/structures/lvcolumn.asp

 

27. 锁定column header的拖动

http://msdn.microsoft.com/msdnmag/issues/03/06/CQA/

28. 如何隐藏clistctrl的列

    把需隐藏的列的宽度设为0,然后检测当该列为隐藏列时，用上面第27点的锁定column 的拖动来实现

29. listctrl进行大数据量操作时，使用virtual list   

http://www.codeguru.com/cpp/controls/listview/advanced/article.php/c4151/
http://www.codeproject.com/listctrl/virtuallist.asp

30. 关于item只能显示259个字符的问题

解决办法：需要在item上放一个edit。

31. 响应在listctrl的column header上的鼠标右键单击

Q125694: How To Find Out Which Listview Column Was Right-Clicked
http://support.microsoft.com/kb/125694/en-us

32. 类似于windows资源管理器的listview

Q234310: How to implement a ListView control that is similar to Windows Explorer by using DirLV.exe
http://support.microsoft.com/kb/234310/en-us

 

33. 在ListCtrl中OnTimer只响应两次的问题

Q200054：
PRB: OnTimer() Is Not Called Repeatedly for a List Control
http://support.microsoft.com/kb/200054/en-us

34. 以下为一些为实现各种自定义功能的listctrl派生类

          (1)    拖放       
                   http://www.codeproject.com/listctrl/dragtest.asp

                   在CListCtrl和CTreeCtrl间拖放
                   http://support.microsoft.com/kb/148738/en-us
 
          (2)    多功能listctrl
                   支持subitem可编辑，图标，radiobutton，checkbox，字符串改变颜色的类
                   http://www.codeproject.com/listctrl/quicklist.asp
 
                   支持排序，subitem可编辑，subitem图标，subitem改变颜色的类
                   http://www.codeproject.com/listctrl/ReportControl.asp

          (3)    subitem中显示超链接
                   http://www.codeproject.com/listctrl/CListCtrlLink.asp

          (4)    subitem的tooltip提示
                   http://www.codeproject.com/listctrl/ctooltiplistctrl.asp

          (5)    subitem中显示进度条   
                   http://www.codeproject.com/listctrl/ProgressListControl.asp
                   http://www.codeproject.com/listctrl/napster.asp
                   http://www.codeguru.com/Cpp/controls/listview/article.php/c4187/

          (6)    动态改变subitem的颜色和背景色
                    http://www.codeproject.com/listctrl/highlightlistctrl.asp
                    http://www.codeguru.com/Cpp/controls/listbox/colorlistboxes/article.php/c4757/
 
          (7)    类vb属性对话框
                    http://www.codeproject.com/listctrl/propertylistctrl.asp
                    http://www.codeguru.com/Cpp/controls/listview/propertylists/article.php/c995/
                    http://www.codeguru.com/Cpp/controls/listview/propertylists/article.php/c1041/
&nsp;
          (8)    选中subitem(只高亮选中的item)
                    http://www.codeproject.com/listctrl/SubItemSel.asp
                    http://www.codeproject.com/listctrl/ListSubItSel.asp
 
          (9)    改变行高
                    http://www.codeproject.com/listctrl/changerowheight.asp
 
          (10)   改变行颜色
                    http://www.codeproject.com/listctrl/coloredlistctrl.asp
 
          (11)   可编辑subitem的listctrl
                    http://www.codeproject.com/listctrl/nirs2000.asp
                    http://www.codeproject.com/listctrl/editing_subitems_in_listcontrol.asp
 
          (12)   subitem可编辑，插入combobox，改变行颜色，subitem的tooltip提示
                    http://www.codeproject.com/listctrl/reusablelistcontrol.asp
 
          (13)   header 中允许多行字符串
                    http://www.codeproject.com/listctrl/headerctrlex.asp
 
          (14)   插入combobox
                    http://www.codeguru.com/Cpp/controls/listview/editingitemsandsubitem/article.php/c979/
 
          (15)   添加背景图片
                    http://www.codeguru.com/Cpp/controls/listview/backgroundcolorandimage/article.php/c4173/
                    http://www.codeguru.com/Cpp/controls/listview/backgroundcolorandimage/article.php/c983/
                    http://www.vchelp.net/vchelp/archive.asp?type_id=9&class_id=1&cata_id=1&article_id=1088&search_term=
   
          (16)  自适应宽度的listctrl
                    http://www.codeproject.com/useritems/AutosizeListCtrl.asp

          (17)  改变ListCtrl高亮时的颜色(默认为蓝色)
                   处理 NM_CUSTOMDRAW
           http://www.codeproject.com/listctrl/lvcustomdraw.asp


摘要：先来了解几个基本概念:　查看全文

摘要：常见的电视信号制式是PAL和NTSC，另外还有SECAM等。 NTSC即正交平衡调幅制。PAL为逐行倒像正交平衡调幅制。　查看全文

在数字系统中，各种数据要转换为二进制代码才能进行处理，而人们习惯于使用十进制数，所以在数字系统的输入输出中仍采用十进制数，这样就产生了用四位二进制数表示一位十进制数的方法，这种用于表示十进制数的二进制代码称为二－十进制代码（Binary Coded Decimal)，简称为BCD码。它具有二进制数的形式以满足数字系统的要求，又具有十进制的特点（只有十种有效状态）。在某些情况下，计算机也可以对这种形式的数直接进行运算。常见的BCD码表示有以下几种。

8421BCD编码

　　这是一种使用最广的BCD码，是一种有权码，其各位的权分别是（从最有效高位开始到最低有效位）8,4,2,1。
　　例　写出十进数563.97D对应的8421BCD码。
　　　　563.97D=0101 0110 0011 . 1001 01118421BCD
　　例　写出8421BCD码1101001.010118421BCD对应的十进制数。
　　　　1101001.010118421BCD＝0110 1001 . 0101 10008421BCD=69.58D
　　在使用8421BCD码时一定要注意其有效的编码仅十个，即：0000～1001。四位二进制数的其余六个编码1010,1011,1100,1101,1110,1111不是有效编码。

2421BCD编码

　　2421BCD码也是一种有权码，其从高位到低位的权分别为2,4,2,1，其也可以用四位二进制数来表示一位十进制数。其编码规则如下表。

余3码

　　余3码也是一种BCD码，但它是无权码，但由于每一个码对应的8421BCD码之间相差3,故称为余3码，其一般使用较少，故正须作一般性了解

，具体的编码如下表。

常见BCD编码表

十进制数 8421BCD码 2421BCD码 余3码
0        0000      0000      0011
1        0001      0001      0100
2        0010      0010      0101
3        0011      0011      0110
4        0100      0100      0111
5        0101      1011      1000
6        0110      1100      1001
7        0111      1101      1010
8        1000      1110      1011
9        1001      1111      1100
10     0001,0000 0001,0000 0100,0011

关于BCD码
BCD又分为两种，非紧密式和紧密式两种。
前面这种81秒存成 “08,01” 是非紧密式，而紧密式会存成 “81h”
(直接以十六进制储存)。

摘要：这篇文章是关于C++语言的一个新的扩展——标准模板库的（Standard Template Library），也叫STL　查看全文

摘要：unsigned long strtoul( const char *nptr, char **endptr, int base　查看全文