最近有一些朋友常问我一些乱码的问题，和他们交流过程中，发现这个编码的相关知识还真是杂乱不堪，不少人对一些

知识理解似乎也有些偏差，网上百度,google的内容，也有不少以讹传讹，根本就是错误的（例如说 unicode编码是两

个字节），各种软件让你选择编码的时候，常常是很长的一个选单，让用户不知道该如何选。基于这样的问题，我就写

下我的理解吧，一方面帮助一些需要帮助的人纠正认识，一方面作为自己以后备查的资料。

1.ASCII(American Standard Code for Information Interchange)
  美国信息交换标准代码，这是计算机上最早使用的通用的编码方案。那个时候计算机还只是拉丁文字的专利，根本没

有想到现在计算机的发展势头，如果想到了，可能一开始就会使用unicode了。当时绝大部分专家都认为，要用计算机

，必须熟练掌握英文。这种编码占用7个Bit，在计算机中占用一个字节，8位，最高位没用，通讯的时候有时用作奇偶

校验位。因此ASCII编码的取值范围实际上是：0x00-0x7f,只能表示128个字符。后来发现128个不太够用，做了扩展，

叫做ASCII扩展编码，用足八位，取值范围变成：0x00-0xff,能表示256个字符。其实这种扩展意义不大，因为256个字

符表示一些非拉丁文字远远不够，但是表示拉丁文字，又用不完。所以扩展的意义还是为了下面的ANSI编码服务。

2.ANSI（American National Standard Institite ）
  美国国家标准协会，也就是说，每个国家（非拉丁语系国家）自己制定自己的文字的编码规则，并得到了ANSI认可，

符合ANSI的标准，全世界在表示对应国家文字的时候都通用这种编码就叫ANSI编码。换句话说，中国的ANSI编码和在日

本的ANSI的意思是不一样的，因为都代表自己国家的文字编码标准。比如中国的ANSI对应就是GB2312标准，日本就是

JIT标准，香港，台湾对应的是BIG5标准等等。当然这个问题也比较复杂，微软从95开始，用就是自己搞的一个标准GBK

。GB2312里面只有6763个汉字，682个符号，所以确实有时候不是很够用。GBK一直能和GB2312相互混淆并且相安无事的
一个重要原因是GBK全面兼容GB2312，所以没有出现任何冲突，你用GB2312编码的文件通过GBK去解释一定能获得相同的

显示效果，换句话说：GBK对GB2312就是，你有的，我也有，你没得的，我还有！

好了，ANSI的标准是什么呢，首先是ASCII的代码你不能用！也就是说ASCII码在任何ANSI中应该都是相同的。其他的，

你们自己扩展。所以呢，中国人就把ASCII码变成8位，0x7f之前我不动你的，我从0xa0开始编，0xa0到0xff才95个码位

，对于中国字那简直是杯水车薪，因此，就用两个字节吧，因此编码范围就从0xA1A1 - 0xFEFE，这个范围可以表示

23901个汉字。基本够用了吧，GB2312才7000多个呢！GBK更猛，编码范围是从0x8140 - 0xFEFE,可以表示3万多个汉字

。可以看出，这两种方案，都能保证汉字头一个字节在0x7f以上，从而和ASCII不会发生冲突。能够实现英文和汉字同

时显示。
BIG5，香港和台湾用的比较多，繁体，范围： 0xA140 - 0xF9FE, 0xA1A1 - 0xF9FE，每个字由两个字节组成，其第一

字节编码范围为0xA1~0xF9，第二字节编码范围为0x40-0x7E与0xA1-0xFE，总计收入13868个字 (包括5401个常用字、

7652 个次常用字、7个扩充字、以及808个各式符号)。

那么到底ANSI是多少位呢？这个不一定！比如在GB2312和GBK，BIG5中，是两位！但是其他标准或者其他语言如果不够

用，就完全可能不止两位！

例如：GB18030:
GB18030-2000(GBK2K)在GBK的基础上进一步扩展了汉字，增加了藏、蒙等少数民族的字形。GBK2K从根本上解决了字位

不够，字形不足的问题。它有几个特点：它并没有确定所有的字形，只是规定了编码范围，留待以后扩充。
编码是变长的，其二字节部分与GBK兼容；四字节部分是扩充的字形、字位，其编码范围是首字节0x81-0xfe、二字节

0x30-0x39、三字节0x81-0xfe、四字节0x30-0x39。它的推广是分阶段的，首先要求实现的是能够完全映射到

Unicode3.0标准的所有字形。它是国家标准，是强制性的。

搞懂了ANSI的含义，我们发现ANSI有个致命的缺陷，就是每个标准是各自为阵的，不保证能兼容。换句话说，要同时显

示中文和日本文或者阿拉伯文，就完全可能会出现一个编码两个字符集里面都有对应，不知道该显示哪一个的问题，也

就是编码重叠的问题。显然这样的方案不好，所以Unicode才会出现！

3.MBCS（Multi-Byte Chactacter System（Set)）
  多字节字符系统或者字符集，基于ANSI编码的原理上，对一个字符的表示实际上无法确定他需要占用几个字节的，只

能从编码本身来区分和解释。因此计算机在存储的时候，就是采用多字节存储的形式。也就是你需要几个字节我给你放

几个字节，比如A我给你放一个字节，比如"中“，我就给你放两个字节，这样的字符表示形式就是MBCS。
在基于GBK的windows中，不会超过2个字节，所以windows这种表示形式有叫做DBCS（Double-Byte Chactacter System

），其实算是MBCS的一个特例。
C语言默认存放字符串就是用的MBCS格式。从原理上来说，这样是非常经济的一种方式。
4.CodePage
  
代码页，最早来自IBM，后来被微软，oracle ,SAP等广泛采用。因为ANSI编码每个国家都不统一，不兼容，可能导致冲

突，所以一个系统在处理文字的时候，必须要告诉计算机你的ANSI是哪个国家和地区的标准，这种国家和标准的代号（

其实就是字符编码格式的代号），微软称为Codepage代码页，其实这个代码页和字符集编码的意思是一样的。告诉你代

码页，本质就是告诉了你编码格式。
但是不同厂家的代码页可能是完全不同，哪怕是同样的编码，比如， UTF-8字符编码 在IBM对应的代码页是1208，在微

软对应的是65001,在德国的SAP公司对应的是 4110 。所以啊，其实本来就是一个东西，大家各自为政，搞那么多新名

词，实在没必要！所以标准还是很重要的！！！
比如GBK的在微软的代码页是936，告诉你代码页是936其实和告诉你我编码格式是GBK效果完全相同。那么处理文本的时

候就不会有问题，不会去考虑某个代码是显示的韩文还是中文，同样，日文和韩文的代码页就和中文不同，这样就可以

避免编码冲突导致计算机不知如何处理的问题。当然用这个也可以很容易的切换语言版本。
但是这都是治标不治本的方法，还是无法解决同时显示多种语言的问题，所以最后还是都用unicode吧，永远不会有冲

突了。
5.Unicode(Universal Code)
  这是一个编码方案，说白了就是一张包含全世界所有文字的一个编码表，不管你用的上，用不上，不管是现在用的，

还是以前用过的，只要这个世界上存在的文字符号，统统给你一个唯一的编码，这样就不可能有任何冲突了。不管你要

同时显示任何文字，都没有问题。
  因此在这样的方案下，Unicode出现了。Unicode编码范围是：0-0x10FFFF，可以容纳1114112个字符，100多万啊。全

世界的字符根本用不完了，Unicode 5.0版本中，才用了238605个码位。所以足够了。
因此从码位范围看，严格的unicode需要3个字节来存储。但是考虑到理解性和计算机处理的方便性，理论上还是用4个

字节来描述。
   Unicode采用的汉字相关编码用的是《CJK统一汉字编码字符集》— 国家标准 GB13000.1 是完全等同于国际标准《

通用多八位编码字符集 (UCS)》 ISO 10646.1。《GB13000.1》中最重要的也经常被采用的是其双字节形式的基本多文

种平面。在这65536个码位的空间中，定义了几乎所有国家或地区的语言文字和符号。其中从0x4E00到 0x9FA5 的连续

区域包含了 20902 个来自中国（包括台湾）、日本、韩国的汉字，称为 CJK (Chinese Japanese Korean) 汉字。CJK

是《GB2312-80》、《BIG5》等字符集的超集。
  CJK包含了中国，日本，韩国，越南，香港，也就是CJKVH。这个在UNICODE的Charset chart中可以明显看到。
  unicode的相关标准可以从unicode.org上面获得，目前已经进行到了6.0版本。

下面这段描述来自百度百科：
   Unicode字符集可以简写为UCS（Unicode Character Set）。早期的  unicodeUnicode标准有UCS-2、UCS-4的说法。

UCS-2用两个字节编码，UCS-4用4个字节编码。UCS-4根据最高位为0的最高字节分成2^7=128个group。每个group再根据

次高字节分为256个平面（plane）。每个平面根据第3个字节分为256行 （row），每行有256个码位（cell）。group 0

的平面0被称作BMP（Basic Multilingual Plane）。将UCS-4的BMP去掉前面的两个零字节就得到了UCS-2。 　　每个平

面有2^16=65536个码位。Unicode计划使用了17个平面，一共有17*65536=1114112个码位。在Unicode 5.0.0版本中，已

定义的码位只有238605个，分布在平面0、平面1、平面2、平面14、平面15、平面16。其中平面15和平面16上只是定义

了两个各占65534个码位的专用区（Private Use Area），分别是0xF0000-0xFFFFD和0x100000-0x10FFFD。所谓专用区

，就是保留给大家放自定义字符的区域，可以简写为PUA。 　　平面0也有一个专用区：0xE000-0xF8FF，有6400个码位

。平面0的0xD800-0xDFFF，共2048个码位，是一个被称作代理区（Surrogate）的特殊区域。代理区的目的用两个UTF-

16字符表示BMP以外的字符。在介绍UTF-16编码时会介绍。 　　如前所述在Unicode 5.0.0版本中，238605-65534*2-

6400-2408=99089。余下的99089个已定义码位分布在平面0、平面1、平面2和平面14上，它们对应着Unicode目前定义的

99089个字符，其中包括71226个汉字。平面0、平面1、平面2和平面14上分别定义了52080、3419、43253和337个字符。

平面2的43253个字符都是汉字。平面0上定义了27973个汉字。
 

6.Unicode的实现方案
   Unicode其实只是一张巨大的编码表。要在计算机里面实现，也出现了几种不同的方案。也就是说如何表示unicode

编码的问题。
（1）UTF-8（UCS Transformation Format 8bit)
    这个方案的意思以8位为单位来标识文字，注意并不是说一个文字用8位标识。他其实是一种MBCS方案，可变字节的

。到底需要几个字节表示一个符号，这个要根据这个符号的unicode编码来决定，最多4个字节。
编码规则如下：
   Unicode编码(16进制)　║　UTF-8 字节流(二进制) 　
　000000 - 00007F　║　0xxxxxxx 　　
000080 - 0007FF　║　110xxxxx 10xxxxxx 　　
000800 - 00FFFF　║　1110xxxx 10xxxxxx 10xxxxxx 　　
010000 - 10FFFF　║　11110xxx 10xxxxxx 10xxxxxx 10xxxxxx 　　
UTF-8的特点是对不同范围的字符使用不同长度的编码。对于0x00-0x7F之间的字符，UTF-8编码与ASCII编码完全相同。

UTF-8编码的最大长度是4个字节。从上表可以看出，4字节模板有21个x，即可以容纳21位二进制数字。Unicode的最大

码位0x10FFFF也只有21位。 　　
例1：“汉”字的Unicode编码是0x6C49。0x6C49在0x0800-0xFFFF之间，使用用3字节模板了：1110xxxx 10xxxxxx

10xxxxxx。将0x6C49写成二进制是：0110 1100 0100 1001， 用这个比特流依次代替模板中的x，得到：11100110

10110001 10001001，即E6 B1 89。 　　
例2：Unicode编码0x20C30在0x010000-0x10FFFF之间，使用用4字节模板了：11110xxx 10xxxxxx 10xxxxxx 10xxxxxx。

将0x20C30写成21位二进制数字（不足21位就在前面补0）：0 0010 0000 1100 0011 0000，用这个比特流依次代替模板

中的x，得到：11110000 10100000 10110000 10110000，即F0 A0 B0 B0。

（2）UTF-16
 UTF-16编码以16位无符号整数为单位。注意是16位为一个单位，不表示一个字符就只有16位。现在机器上的unicode编

码一般指的就是UTF-16。绝大部分2个字节就够了，但是不能绝对的说所有字符都是2个字节。这个要看字符的unicode

编码处于什么范围而定，有可能是2个字节，也可能是4个字节。这点请注意！
下面算法解释来自百度百科。

我们把Unicode  unicode编码记作U。编码规则如下： 
　　如果U<0x10000，U的UTF-16编码就是U对应的16位无符号整数（为书写简便，下文将16位无符号整数记作WORD）。

　　如果U≥0x10000，我们先计算U'=U-0x10000，然后将U'写成二进制形式：yyyy yyyy yyxx xxxx xxxx，U的UTF-16

编码（二进制）就是：110110yyyyyyyyyy 110111xxxxxxxxxx。为什么U'可以被写成20个二进制位？Unicode的最大码位

是0x10ffff，减去0x10000后，U'的最大值是0xfffff，所以肯定可以用20个二进制位表示。
    例如：Unicode编码0x20C30，减去0x10000后，得到0x10C30，写成二进制是：0001 0000 1100 0011 0000。用前10

位依次替代模板中的y，用后10位依次替代模板中的x，就得到：1101100001000011 1101110000110000，即0xD843

0xDC30。 　　
    按照上述规则，Unicode编码0x10000-0x10FFFF的UTF-16编码有两个WORD，第一个WORD的高6位是110110，第二个

WORD的高6位是110111。可见，第一个WORD的取值范围（二进制）是11011000 00000000到11011011 11111111，即

0xD800-0xDBFF。第二个WORD的取值范围（二进制）是11011100 00000000到11011111 11111111，即0xDC00-0xDFFF。

　　为了将一个WORD的UTF-16编码与两个WORD的UTF-16编码区分开来，Unicode编码的设计者将0xD800-0xDFFF保留下来

，并称为代理区（Surrogate）： 　　
D800－DB7F　║　High Surrogates　║　高位替代 　　
DB80－DBFF　║　High Private Use Surrogates　║　高位专用替代 　　
DC00－DFFF　║　Low Surrogates　║　低位替代 　　
   高位替代就是指这个范围的码位是两个WORD的UTF-16编码的第一个WORD。低位替代就是指这个范围的码位是两个

WORD的UTF-16编码的第二个WORD。那么，高位专用替代是什么意思？我们来解答这个问题，顺便看看怎么由UTF-16编码

推导Unicode编码。 　　
  如果一个字符的UTF-16编码的第一个WORD在0xDB80到0xDBFF之间，那么它的Unicode编码在什么范围内？我们知道第

二个WORD的取值范围是0xDC00-0xDFFF，所以这个字符的UTF-16编码范围应该是0xDB80 0xDC00到0xDBFF 0xDFFF。我们

将这个范围写成二进制： 　　1101101110000000 11011100 00000000 - 1101101111111111 1101111111111111 　　按

照编码的相反步骤，取出高低WORD的后10位，并拼在一起，得到 　　1110 0000 0000 0000 0000 - 1111 1111 1111

1111 1111  
即0xe0000-0xfffff，按照编码的相反步骤再加上0x10000，得到0xf0000-0x10ffff。这就是UTF-16编码的第一个WORD在

0xdb80到0xdbff之间的Unicode编码范围，即平面15和平面16。因为Unicode标准将平面15和平面16都作为专用区，所以

0xDB80到0xDBFF之间的保留码位被称作高位专用替代。

（3）UTF-32
 这个就简单了，和Unicode码表基本一一对应，固定四个字节。
 为什么不采用UTF-32呢，因为unicode定义的范围太大了，其实99%的人使用的字符编码不会超过2个字节，所以如同统

一用4个字节，简单倒是简单了，但是数据冗余确实太大了，不好，所以16位是最好的。就算遇到超过16位能表示的字

符，我们也可以通过上面讲到的代理技术，采用32位标识，这样的方案是最好的。所以现在绝大部分机器实现unicode

还是采用的utf-16的方案。当然也有UTF-8的方案。比如windows用的就是UTF16方案，不少linux用的就是utf8方案。

7. 编码存储差异

这里就要引出两个名词：
LE（little endian):小字节字节序，意思就是一个单元在计算机中的存放时按照低位在前（低地址），高位在后（高

地址）的模式存放。

BE（big endian):大字节字节序，和LE相反，是高位在前，低位在后。

比如一个unicode编码为：0x006C49，如果是LE，那么在文件中的存放顺序应该是：49 6c 00
如果是BE ,那么顺序应该是：00 6c 49

8.编码格式的检测

到底采用什么编码，如果能检测就好了。专家们也是这么想的，所以专家给每种格式和字节序规定了一些特殊的编码，

这些编码在unicode 中是没有使用的，所以不用担心会冲突。

这个叫做BOM（Byte Order Mark）头。意思是字节序标志头。通过它基本能确定编码格式和字节序。
UTF编码　║　Byte Order Mark 　　
UTF-8　  ║　EF BB BF 　　
UTF-16LE ║　FF FE 　　
UTF-16BE ║　FE FF 　　
UTF-32LE ║　FF FE 00 00 　　
UTF-32BE ║　00 00 FE FF
所以通过检测文件前面的BOM头，基本能确定编码格式和字节序。
但是这个BOM头只是建议添加，不是强制的，所以不少软件和系统没有添加这个BOM头（所以有些软件格式中有带BOM头

和NoBOM头的选择），这个时候要检测什么格式，就比较麻烦了
当然可以检测，但是不能保证100%准确，只能通过编码范围从概率上来检查，虽然准确度还是比较高，但是不能保证

100%。所以，时常看到检测错误的软件，也不奇怪了。

总结：
   终于写完了，其实这些问题都是不统一导致的，属于历史问题，所以才会有这些困惑，这里也呼吁所有的软件 开发

人员自觉的采用Unicode标准进行文字处理，我相信在不久的将来，这些困扰都不会存在了，因为所有软件都是unicode

d ,只要有字库，任何文字都能同时显示，也可以到任何语言的平台上的去运行，不再有乱码的困惑！
  其实现在绝大部分软件已经是这么做的了！
   另外也不要被很多名词属于所迷惑，其实这些只是标准的问题，根本没有什么新的东西，更没有什么复杂的东西。

之前一直尝试配置Ubuntu下的环境的，我的Ubuntu12.04是VirtualBox虚拟机下的，整了半天，其他都好了，就是Eclipse下面安装ADT的时候，发现Eclipse连不上网络，查过代理等都没问题，于是本地安装ADT，结果又是和网络上的一样的一堆错误。 时间关系没有整到底，于是还是使用大家通行的Cygwin来吧。 

巴拉巴拉的介绍就不说了，直接记录步骤吧。 



1. Android NDK下载 
  下载Windows系统下的版本，至于32位还是64位由你机器而定，我的是Win7 32位，下载的是：android-ndk-r8e-windows-x86.zip 
  电梯直达：http://developer.android.com/tools/sdk/ndk/index.html#Installing 
  

2. Cygwin下载 
  下载Setup.exe 
  电梯直达：http://cygwin.com/install.html 

3. 安装 Android NDK 
   解压缩到某个目录即可，例如我的： E:\DevelopEnviroment\Android\ 
   解压缩后的文件夹名字如下：android-ndk-r8e 

4. 安装Cygwin 
   运行Setup.exe,如下图片是转载自别人的（请见参考Link） 

Shell代码  

1. ANDK=/cygdrive/e/DevelopEnviroment/Android/android-ndk-r8e  
2. export ANDK  

7. 测试NDK环境 
   输入 cd $ANDK, 进入/cygdrive/e/DevelopEnviroment/Android/android-ndk-r8e 

   进入/samples/hello-jni项目下，运行$ANDK/ndk-build 
   输出效果如下： 

Output代码  
1. $ $ANDK/ndk-build  
2. Gdbserver      : [arm-linux-androideabi-4.6] libs/armeabi/gdbserver  
3. Gdbsetup       : libs/armeabi/gdb.setup  
4. Install        : libhello-jni.so => libs/armeabi/libhello-jni.so  


   以上即表明安装完毕。 

  

参考Link： http://cache.baiducontent.com/c?m=9f65cb4a8c8507ed4fece7631046893b4c4380146d96864968d4e414c42246121b30a8e16071405f8f90613441e9120db4a72b24604573ecc589954fdbb0922d288f33712d5cd04e418f4fef961d73d620e106bff60ee7cbe74290b9a5d1c82253dd24756d8081c3045b44&p=c2769a4786cc42a858b1d22454078b&newp=927f861a85cc43ff57ee937e4e55a5231610db2151d4db15&user=baidu&fm=sc&query=Android+NDK+%B1%E0%D2%EB+zlib&qid=&p1=7

http://wenku.baidu.com/view/63039e8071fe910ef12df86b.html

int a=88;
int b=a;
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。

#include <iostream>
using namespace std;

class CExample {
private:
　int a;
public:
　CExample(int b)
　{ a=b;}
　void Show ()
　{
cout<<a<<endl;
}
};

int main()
{
　CExample A(100);
　CExample B=A;
　B.Show ();
　return 0;
}

运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。

#include <iostream>
using namespace std;

class CExample {
private:
int a;
public:
CExample(int b)
{ a=b;}

CExample(const CExample& C)
{
a=C.a;
}
void Show ()
{
cout<<a<<endl;
}
};

int main()
{
CExample A(100);
CExample B=A;
B.Show ();
return 0;
}

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。

当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化。

如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。

自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。

浅拷贝和深拷贝

　　在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

要防止因为异常产生的内存泄漏，可以使用智能指针，也可以用
__try
{
}
__finally
{
}
《Windows核心编程》一书第23~25章是很好的参考资料。

----------------------------------------------------

try,catch,throw:

try包含你要防护的代码,称为防护块. 防护块如果出现异常,会自动生成异常对象并抛出.

catch捕捉特定的异常,并在其中进行适当处理.

throw可以直接抛出/产生异常,导致控制流程转到catch块.

重要观点: C++中异常是用对象来表示的,称为异常对象.

基本格式:

try { your code; }

catch(T1 t1) //T1可以是任意类型,int,char, CException...

{ /*T1指定了你要捕捉的异常的类型,t1指定了异常 对象的名称,当有异常抛出,异常对象将被复制到t1 中,这样你就可以在本处理块中使用该对象,获取相关 信息,进行适当处理. 处理代码;*/}

catch(T2* pt1)

//上面的catch是值传递,这里使用指针传递.

{ 处理代码; }

catch(...)

//...是捕捉任意类型的异常.

{ 处理代码; }

//其他代码;

/*某个catch执行完,就跳转到这里继续执行. 在没有使用C++异常处理的情况下,如果在 此之前出现异常,则//这里的其他代码不会被执行 从而造成问题.请考虑在这里放置: delete pobj1; 如果不使用用try,catch机制,内存泄漏是必然的, 因为出现问题后,执行流程无法跳转到这里. */

/*说明: try{}之后可以跟任意个catch块. 发生异常后,会生成临时的异常对象,进行一些自动处理之后,程序流程跳转到后面的catch(),逐个检查这些catch(),如果与catch() 中指定的类型一致,则将对象拷贝给catch参数中的对象, 接着执行该catch块中的代码,然后跳过其他所有剩下的catch, 继续执行后续的代码.
上面所说的自动处理指的是堆栈回退,说白了就是为函数中的局部对象调用析构函数,保证这些局部对象行为良好. */

catch()的顺序通常按照:从特殊到一般的顺序: catch(Tsub o){} catch(Tbase o){} catch(...){} 如果第一个catch为catch(Tbase){},则它将捕捉其所有派生类的 异常对象. 如果第一个catch为catch(...){},则其后的所有catch永远不可能 被执行.
重新抛出异常: 从上面的处理机制可以看到,只有一个catch可能被执行, 如果一个catch被执行,其他后续的catch就会被跳过了. 有时候一个catch中可能无法完成异常的全部处理,需要将 异常提交给更高的层,以期望得到处理.重新抛出异常实现 了这种可能性. 语法: throw ; 空的throw语句,只能在catch中使用. 它重新抛出异常对象,其外层的catch可能可以捕捉这个重新抛出的异常并做适当处理.

---------------------------------------------------------------------------------------------------------

1、基础介绍
try
{
//程序中抛出异常
throw value;
}
catch(valuetype v)
{
//例外处理程序段
}
语法小结：throw抛出值，catch接受，当然，throw必须在“try语句块”中才有效。

2、深入throw：
(i)、程序接受到throw语句后就会自动调用析构器，把该域（try后的括号内）对象clean up，然后再进
入catch语句（如果在循环体中就退出循环）。

这种机制会引起一些致命的错误，比如，当“类”有指针成员变量时（又是指针！），在 “类的构建器
”中的throw语句引起的退出，会导致这个指针所指向的对象没有被析构。这里很基础，就不深入了，提
示一下，把指针改为类就行了，比如模板类来代替指针，在模板类的内部设置一个析构函数。

(ii)、语句“throw;”抛出一个无法被捕获的异常，即使是catch(...)也不能捕捉到，这时进入终止函数
，见下catch。

3、深入catch：
一般的catch出现的形式是：
try{}
catch(except1&){}
catch(except2&){}
catch(...){} //接受所有异常
一般都写成引用（except1&），原因很简单，效率。

问题a：抛出异常，但是catch不到异常怎么办？（注意没有java类似的finally语句）
在catch没有捕获到匹配的异常的时候，会调用默认的终止函数。可以调用set_terminate()来设置终止函数，参数是一个函数指针，类型是：void (*terminate)()。

到这里，可以题个问题：“没有try-catch,直接在程序中"throw;"，会怎么样？”


其他一些技巧：
4、try一个函数体，形式如下
void fun(type1,type2) try－－－－try放在函数体后
{
函数定义
}
catch(typeX){}
这个用法的效果就相当于:
void fun()
{
try{函数定义}
}


5、throw一个函数体，形式如下：
void fun (); // 能抛出任何类型的异常
void fun () throw(except1,except2,except3)
// 后面括号里面是一个异常参数表，本例中只能抛出这3中异常
void fun () throw() // 参数表为空，不能抛出异常

问题b：假设fun()中抛出了一个不在“异常参数表”中的异常，会怎么样？

答：调用set_terminate()中设定的终止函数。然而，这只是表面现象，实际上是调用默认的unexpected()函数，然而这个默认的 unexpected()调用了set_terminate()中设定的终止函数。可以用set_unexpected()来设置unexpected, 就像set_terminate()一样的用法，但是在设定了新的“unexpected()”之后，就不会再调用set_terminater中设定的 终止函数了。

这个语法是很有用的，因为在用别人的代码时，不知道哪个地方会调用什么函数又会抛出什么异常，用一个异常参数表在申明时限制一下，很实用。
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

try{} catch(…){}

以前都是用try{} catch(…){}来捕获C++中一些意想不到的异常，今天看了Winhack的帖子才知道，这种方法在VC中其实是靠不住的。例如下面的代码：

这段代码在debug下没有问题，异常会被捕获，会弹出”catched”的消息框。但在Release方式下如果选择了编译器代码优化选项，则VC编译器会去搜索try块中的代码， 如果没有找到throw代码，他就会认为try catch结构是多余的， 给优化掉。这样造成在Release模式下，上述代码中的异常不能被捕获，从而迫使程序弹出错误提示框退出。

那么能否在release代码优化状态下捕获这个异常呢， 答案是有的。 就是__try, __except结构，上述代码如果改成如下代码异常即可捕获。

但是用__try, __except块还有问题， 就是这个不是C++标准， 而是Windows平台特有的扩展。而且如果在使用过程中涉及局部对象析构函数的调用，则会出现C2712的编译错误。 那么还有没有别的办法呢？

当然有， 就是仍然使用C++标准的try{}catch(..){}， 但在编译命令行中加入 /EHa的参数。这样VC编译器不会把try catch模块给优化掉了。

一篇比较好的英文文章谈这个问题： http://members.cox.net/doug_web/eh.htm

C++左值与右值之间共同与不同点解析

2010-02-03 17:32 佚名 博客园 我要评论(1) 字号：T | T

{   
int temp = a;   
aa=a+1;   
return temp; //返回右值   
}  

{   
aa=a+1;   
return &a; //返回左值   
}  

打开properties属性页，找到Build Events选项，选择Post-build event选项，

它的command line选项置成空

/////////

工程中command line

内容为

mkdir ..\..\..\..\发布组件\服务器组件\Release

copy /y ..\..\..\..\运行\Release\$(TargetFileName) ..\..\..\..\发布组件\服务器组件\Release\$(TargetFileName)

using namespace boost::posix_time;
using namespace boost::gregorian;
//using boost::gregorian::date;

#include <boost/date_time/posix_time/posix_time.hpp>
#define BOOST_DATE_TIME_SOURCE

原来出处：http://blog.csdn.net/beyondhaven/article/details/4204345

[转载] C++模板：函数模板和模板函数

1.函数模板的声明和模板函数的生成

1.1函数模板的声明

函数模板可以用来创建一个通用的函数，以支持多种不同的形参，避免重载函数的函数体重复设计。它的最大特点是把函数使用的数据类型作为参数。

函数模板的声明形式为：

template<typename 数据类型参数标识符>

<返回类型><函数名>(参数表)

{

    函数体

}

其中，template是定义模板函数的关键字；template后面的尖括号不能省略；typename（或class)是声明数据类型参数标识符的关键字，用以说明它后面的标识符是数据类型标识符。这样，在以后定义的这个函数中，凡希望根据实参数据类型来确定数据类型的变量，都可以用数据类型参数标识符来说明，从而使这个变量可以适应不同的数据类型。例如：

template<typename T>

T fuc(T x, int y)

{

    T x;

    //……

}

如果主调函数中有以下语句：

double d;

int a;

fuc(d,a);

则系统将用实参d的数据类型double去代替函数模板中的T生成函数：

double fuc(double x,int y)

{

    double x;

    //……

}

函数模板只是声明了一个函数的描述即模板，不是一个可以直接执行的函数，只有根据实际情况用实参的数据类型代替类型参数标识符之后，才能产生真正的函数。

关键字typename也可以使用关键字class，这时数据类型参数标识符就可以使用所有的C++数据类型。

1.2.模板函数的生成

函数模板的数据类型参数标识符实际上是一个类型形参，在使用函数模板时，要将这个形参实例化为确定的数据类型。将类型形参实例化的参数称为模板实参，用模板实参实例化的函数称为模板函数。模板函数的生成就是将函数模板的类型形参实例化的过程。例如：

使用中应注意的几个问题：

⑴ 函数模板允许使用多个类型参数，但在template定义部分的每个形参前必须有关键字typename或class，即：

template<class 数据类型参数标识符1，…，class 数据类型参数标识符n>

<返回类型><函数名>(参数表)

{

     函数体

}

⑵ 在template语句与函数模板定义语句<返回类型>之间不允许有别的语句。如下面的声明是错误的：

template<class T>

int I;

T min(T x,T y)

{

   函数体

}

⑶ 模板函数类似于重载函数，但两者有很大区别：函数重载时，每个函数体内可以执行不同的动作，但同一个函数模板实例化后的模板函数都必须执行相同的动作。

2 函数模板的异常处理

函数模板中的模板形参可实例化为各种类型，但当实例化模板形参的各模板实参之间不完全一致时，就可能发生错误，如：

template<typename T>       

void min(T &x, T &y)

{  return (x<y)?x:y;  }

void func(int i, char j)

{

   min(i, i);

   min(j, j);

   min(i, j);

   min(j, i);

}

例子中的后两个调用是错误的，出现错误的原因是，在调用时，编译器按最先遇到的实参的类型隐含地生成一个模板函数，并用它对所有模板函数进行一致性检查，例如对语句

min(i, j)；

先遇到的实参i是整型的，编译器就将模板形参解释为整型，此后出现的模板实参j不能解释为整型而产生错误，此时没有隐含的类型转换功能。解决此种异常的方法有两种：

⑴采用强制类型转换，如将语句min(i, j);改写为min(i,int( j));

⑵用非模板函数重载函数模板

方法有两种：

① 借用函数模板的函数体

此时只声明非模板函数的原型，它的函数体借用函数模板的函数体。如改写上面的例子如下：

template<typename T>       

void min(T &x, T &y)

{  return (x<y)?x:y;  }

int min(int,int);

void func(int i, char j)

{

   min(i, i);

   min(j, j);

   min(i, j);

   min(j, i);

}

执行该程序就不会出错了，因为重载函数支持数据间的隐式类型转换。

② 重新定义函数体

就像一般的重载函数一样，重新定义一个完整的非模板函数，它所带的参数可以随意。C++中，函数模板与同名的非模板函数重载时，应遵循下列调用原则：

• 寻找一个参数完全匹配的函数，若找到就调用它。若参数完全匹配的函数多于一个，则这个调用是一个错误的调用。

• 寻找一个函数模板，若找到就将其实例化生成一个匹配的模板函数并调用它。

• 若上面两条都失败，则使用函数重载的方法，通过类型转换产生参数匹配，若找到就调用它。

•若上面三条都失败，还没有找都匹配的函数，则这个调用是一个错误的调用。

此为转载文章，文章出处没有了。请大家见谅。

一、矩阵
  在 3D 游戏中，可以使用矩阵来表示一个物体的旋转。
  1) 优点：
    个人认为，理解起来最为直观。
    像现成的DXSDK库中也提供了十分完善的相关接口
    一个矩阵即可表示多种变换的组合
  2) 缺点：
    每次计算都会产生误差，因此，需要经常规范化。
    耗的内存较多些。
    
二、欧拉角
  欧拉角指的是：以世界坐标系为参考坐标系(一定记住是世界坐标系)，使用x,y,z三个值来分别表示绕(世界的)x轴、y轴、z轴旋转的角度量值。其取值是在[0, 360]间。一般用roll, pitch, yaw来表示这些分量的旋转值。因为是以世界坐标系为参考坐标系，因此每一次的旋转都不会影响到后续的旋转转轴。即：它无法表示任意轴的旋转。
  1) 优点：
    理解起来很直观。
  2) 缺点：
    会有万向锁问题。
    
三、轴-角对
  其实轴-角对与欧拉角(个人认为)是有一定的关系的。因为欧拉角说的是分别(注意：是分别)绕(以世界坐标系为参考坐标系的)三个轴旋转一定的角度。其实这三次的旋转可以最终转换到一次变换。即：最终可表示为：绕某一旋转轴旋转一定角度的变换。(意思就是说：那三次变换我们最终可以计算出旋转轴以及绕该旋转轴旋转的角度量)。
  1) 缺点：
    轴-角对表示法：插值不平滑，可能会有跳跃。(文档上说，欧拉角同样存在这个问题)
  2) 优点：
    可解决欧拉角的万向锁问题。
    
四、四元数
  四元数定义：q = w + xi + yj + zk
  
  注意：
    1) 四元数可以归一化，并且只有归一化的四元数才用来描述旋转
    2) 四元数与轴-角对很像。因为四元数描述的也是一个旋转轴与一个绕着该旋转轴旋转的量值(即：角度或弧度)。但四元数与轴-角对不等价。它们的关系如下：
      假如：轴-角对的值如下：
      轴为：n
      角为：theta
      则，对应的四元数中的w、x、y、z的值分别为：
      w = cos(theta / 2)
      x = nx * sin(theta / 2)  // nx 是轴 n 的 x 分量
      y = ny * sin(theta / 2)  // ny 是轴 n 的 y 分量
      z = nz * sin(theta / 2)  // nz 是轴 n 的 z 分量

    3) 四元数的乘法意义：
    Q = Q1 * Q2表示的是：Q先做Q2的旋转，再做Q1的旋转的结果，而且多个四元数的旋转也是要以合并的。
    4) 四元数做一次乘法需要16次乘法和加法，而3x3矩阵需要27次。所以有多次旋转操作时，使用四元数计算效率更高些。
    5) 四元数的插值过度平滑。最常用的是线性插值。

(提示：原文有图片。)

三维变换

在使用三维图形的应用程序中，可以用变换做以下事情：

• 描述一个物体相对于另一个物体的位置。
• 旋转并改变物体的大小。
• 改变观察的位置、方向和视角。

可以用一个4 x 4矩阵将任意点（x，y，z）变换为另一个点（x'，y'，z'）。

对（x，y，z）和矩阵执行以下操作产生点（x'，y'，z'）。

最常见的变换是平移、旋转和缩放。可以将产生这些效果的矩阵合并成单个矩阵，这样就可以一次计算多种变换。例如，可以构造单个矩阵，对一系列的点进行平移和旋转。更多信息，请参阅矩阵串接。

矩阵以行列顺序书写。一个沿每根轴均匀缩放顶点的矩阵，也称为统一缩放，用如下数学符号表示。

在C++应用程序中，Microsoft® Direct3D®使用D3DMATRIX结构，将矩阵声明为一个二维数组。以下示例代码显示了如何初始化一个D3DMATRIX结构，使之成为一个统一缩放矩阵。

// 本例中，s为浮点类型的变量

D3DMATRIX scale = {

    s,               0.0f,            0.0f,            0.0f,

    0.0f,            s,               0.0f,            0.0f,

    0.0f,            0.0f,            s,               0.0f,

    0.0f,            0.0f,            0.0f,            1.0f

};

平移和缩放

平移

以下变换将点（x，y，z）平移到一个新的点（x'，y'，z'）。

可以在C++应用程序中手工创建一个平移矩阵。以下示例代码显示了的一个函数的源码，该函数创建一个矩阵用于平移顶点。

D3DXMATRIX Translate(const float dx, const float dy, const float dz) {

    D3DXMATRIX ret;

    D3DXMatrixIdentity(&ret); // 由Direct3DX实现

    ret(3, 0) = dx;

    ret(3, 1) = dy;

    ret(3, 2) = dz;

    return ret;

}    // 平移结束

为了方便，Direct3DX工具库提供了D3DXMatrixTranslation函数。

缩放

以下变换用指定值缩放点（x，y，z）的x-，y-和z-方向，产生新的点（x'，y'，z'）。

旋转

这里描述的变换是基于左手坐标系的，也许和别处见到的变换矩阵不同。更多信息，请参阅三维坐标系。

以下变换将点（x，y，z）围绕x轴旋转，产生新的点（x'，y'，z'）。

以下变换将点围绕y轴旋转。

以下变换将点围绕z轴旋转。

在这些示例矩阵中，希腊字母（θ）表示旋转的角度，以弧度为单位。当沿着旋转轴朝原点看时，角度以顺时针方向计量。

C++应用程序可以用Direct3D扩展（D3DX）工具库提供的D3DXMatrixRotationX，D3DXMatrixRotationX和D3DXMatrixRotationX函数创建旋转矩阵。以下示例是D3DXMatrixRotationX函数的源码。

D3DXMATRIX* WINAPI D3DXMatrixRotationX

    ( D3DXMATRIX *pOut, float angle )

{

#if DBG

    if(!pOut)

        return NULL;

#endif

    float sin, cos;

    sincosf(angle, &sin, &cos); // 计算角度的正弦和余弦值。

    pOut->_11 = 1.0f; pOut->_12 = 0.0f;   pOut->_13 = 0.0f; pOut->_14 = 0.0f;

    pOut->_21 = 0.0f; pOut->_22 = cos;    pOut->_23 = sin; pOut->_24 = 0.0f;

    pOut->_31 = 0.0f; pOut->_32 = -sin;    pOut->_33 = cos; pOut->_34 = 0.0f;

    pOut->_41 = 0.0f; pOut->_42 = 0.0f;   pOut->_43 = 0.0f; pOut->_44 = 1.0f;

    return pOut;

}

( D3DXMATRIX *pOut, float angle )

if(!pOut)

return NULL;

float sin, cos;

sincosf(angle, &sin, &cos); // Determine sin and cos of angle.

pOut->_11 = 1.0f; pOut->_12 = 0.0f;   pOut->_13 = 0.0f; pOut->_14 = 0.0f;

pOut->_21 = 0.0f; pOut->_22 = cos;    pOut->_23 = sin; pOut->_24 = 0.0f;

pOut->_31 = 0.0f; pOut->_32 = -sin;    pOut->_33 = cos; pOut->_34 = 0.0f;

pOut->_41 = 0.0f; pOut->_42 = 0.0f;   pOut->_43 = 0.0f; pOut->_44 = 1.0f;

return pOut;

矩阵串接

使用矩阵的一个优势就是可以通过把两个以上的矩阵相乘，将它们的效果合并在一起。这意味着，要先旋转一个建模然后把它平移到某个位置，无需使用两个矩阵，只要把旋转矩阵和平移矩阵相乘，产生一个包含了所有效果的合成矩阵。这个过程被称为矩阵串接，可以写成以下公式。

在这个公式中，C是将被创建的合成矩阵，M₁到M_n是矩阵C包含的单个矩阵。虽然大多数情况下，只需要串接两三个矩阵，但实际上并没有数量上的限制。

可以使用D3DXMatrixMultiply函数进行矩阵乘法。

进行矩阵乘法时先后次序是至关重要的。前面的公式反映了矩阵串接从左到右的规则。也就是说，用来创建合成矩阵的每个矩阵产生的直观效果会按从左到右的次序出现。下面显示了一个典型的世界变换矩阵。想象一下给一个旋转飞行的碟子创建世界变换矩阵。应用程序也许想让飞行的碟子绕它的中心——建模空间中的y轴——旋转，然后把它平移到场景中的另一个位置。要实现这样的效果，首先创建一个旋转矩阵，然后将它与平移矩阵相乘，如以下公式所示。

在这个公式中，R_y是绕y轴的旋转矩阵，T_w是平移到世界坐标中某个位置的矩阵。

矩阵相乘的顺序很重要，因为矩阵乘法是不可交换的，这和两个标量相乘不同。将矩阵以相反的顺序相乘会产生这样的直观效果：先把飞行中的碟子平移到世界空间中的某个位置，然后将它围绕世界坐标的原点旋转。

无论创建何种类型的矩阵，都要记住从左到右的规则，这样才能保证得到想要的效果。

世界变换

对世界变换的讨论介绍了基本概念，并提供了如何在Microsoft® Direct3D®应用程序中设置世界变换矩阵的细节。

什么是世界变换

世界变换将坐标从建模空间，在这个空间中的顶点相对于建模的局部原点定义，转变到世界空间，在这个空间中的顶点相对于场景中所有物体共有的原点定义。本质上，世界变换将一个建模放到世界中，并由此而得名。下图描绘了世界坐标系统和建模的局部坐标系统间的关系。

世界变换可以包含任意数量的平移、旋转和缩放的合并。有关对变换的数学讨论，请参阅三维变换。

设置世界矩阵

同任何其它变换一样，通过将一系列变换矩阵串接成单个矩阵，应用程序可以创建包含这些矩阵全部效果的世界矩阵。最简单的情况下，建模在世界的原点并且它的局部坐标轴与世界空间的方向相同，这时世界矩阵就是单位矩阵。更通常的情况下，世界矩阵是一系列矩阵的合成，包含一个平移矩阵，并且根据需要可能有一个以上的旋转矩阵。

以下示例，来自一个用C++编写的假想三维建模类，使用Direct3D扩展（D3DX）工具库提供的帮助函数创建了一个世界矩阵，这个世界矩阵包含了三个旋转矩阵，用于调整三维建模的方向，以及一个平移矩阵，用来根据建模在世界空间中的相对坐标重新确定它的位置。

/*

 * 根据本示例的目的，假设以下变量都是有效的并经过初始化。

*

 * 变量m_xPos，m_yPos，m_zPos包含了建模在世界坐标中的位置。

*

 * 变量m_fPitch，m_fYaw和m_fRoll为浮点数，包含了建模的方向，

 * 用pitch，yaw和roll旋转角表示，以弧度为单位。

 */

void C3DModel::MakeWorldMatrix( D3DXMATRIX* pMatWorld )

{

    D3DXMATRIX MatTemp; // 用于旋转的临时矩阵

    D3DXMATRIX MatRot;   // 最终的旋转矩阵，应用于pMatWorld.

    // 使用从左到右的矩阵串接顺序，在旋转之前对物体在世界空间中

    // 的位置进行平移。

    D3DXMatrixTranslation(pMatWorld, m_xPos, m_yPos, m_zPos);

    D3DXMatrixIdentity(&MatRot);

    // 现在将方向变量应用于世界矩阵

    if(m_fPitch || m_fYaw || m_fRoll) {

        // 产生并合成旋转矩阵。

        D3DXMatrixRotationX(&MatTemp, m_fPitch);         // Pitch

        D3DXMatrixMultiply(&MatRot, &MatRot, &MatTemp);

        D3DXMatrixRotationY(&MatTemp, m_fYaw);           // Yaw

        D3DXMatrixMultiply(&MatRot, &MatRot, &MatTemp);

        D3DXMatrixRotationZ(&MatTemp, m_fRoll);          // Roll

        D3DXMatrixMultiply(&MatRot, &MatRot, &MatTemp);

        // 应用旋转矩阵，得到最后的世界矩阵。

        D3DXMatrixMultiply(pMatWorld, &MatRot, pMatWorld);

    }

}

当准备好世界变换矩阵后，应该调用IDirect3DDevice9::SetTransform方法设置它，并把第一个参数指定D3DTS_WORLD宏。

注意    Direct3D使用应用程序设置的世界和观察矩阵配置许多内部数据结构。应用程序每次设置新的世界或观察矩阵时，系统都要重新计算相关的内部数据结构。频繁地设置这些矩阵——例如，每帧上千次——是计算量很大的。通过将世界矩阵和观察矩阵串接成一个世界/观察矩阵，并将该矩阵设置为世界矩阵，然后将观察矩阵设置为单位矩阵，应用程序可以将所需的计算次数减到最少。最好保存一份单独的世界矩阵和观察矩阵的副本在高速缓存中，这样就可以根据需要修改、串接及重置世界矩阵。为清晰起见，本文档中的Direct3D示例很少使用这项优化。

观察变换

本节介绍观察变换的基本概念，并提供有关如何在Microsoft® Direct3D®应用程序中设置观察矩阵的细节。信息被分为以下主题。

• 什么是观察变换？
• 设置观察矩阵

什么是观察变换？

观察变换根据观察者在世界空间中的位置，把顶点变换到摄像机空间。在摄像机空间中，摄像机，或观察者，位于原点，朝sz轴的正向看去。再次提醒一下，因为Direct3D使用左手坐标系，所以z轴的正向是朝着场景的。观察矩阵根据摄像机的位置——摄像机空间的原点——和方向重定位世界中的所有物体。

有两方法可以创建观察矩阵。所有情况下，摄像机在世界空间中的逻辑位置和方向会被用作起始点来创建观察矩阵，得到的观察矩阵会被应用于场景中的三维建模。观察矩阵平移并旋转物体，将它们放入摄像机空间中，摄像机位于原点。创建观察矩阵的一种方法是把平移矩阵和围绕每根坐标轴旋转的旋转矩阵合并。这种方法使用了以下通用矩阵公式。

在这个公式中，V是要创建的观察矩阵，T是在世界中重定位物体的平移矩阵，R_x到R_z分别是绕x轴，y轴和z轴旋转物体的旋转矩阵。平移和旋转矩阵基于摄像机在世界空间中逻辑位置和方向。因此，如果摄像机在世界中的逻辑位置是<10，20，100>，那么平移矩阵的目的是沿x轴移动物体-10单位，沿y轴移动-20单位，沿z轴移动-100单位。公式中的旋转矩阵基于摄像机的方向，根据摄像机空间的坐标轴与世界空间的坐标轴间的夹角决定。例如，如果前面提到的摄像机是垂直向下放的，那么它的z轴与世界空间的z轴有90度夹角，如下图所示。

旋转矩阵将角度相同但方向相反的旋转量应用于场景中的建模。这个摄像机的观察矩阵包含了一个绕x轴-90度的旋转。旋转矩阵与平移矩阵合并生成观察矩阵，观察矩阵调整物体在场景中的位置和方向，使它们的顶部朝着摄像机，看起来就好像摄像机在建模的上方一样。

设置观察矩阵

D3DXMatrixLookAtLH和D3DXMatrixLookAtRH辅助函数根据摄像机的位置和被观察点创建一个观察矩阵。

以下示例代码创建了一个用于右手系的观察矩阵。

D3DXMATRIX out;

D3DXVECTOR3 eye(2,3,3);

D3DXVECTOR3 at(0,0,0);

D3DXVECTOR3 up(0,1,0);

D3DXMatrixLookAtRH(&out, &eye, &at, &up);

Direct3D使用应用程序设置的世界矩阵和观察矩阵配置许多内部数据结构。每次应用程序设置一个新的世界矩阵或观察矩阵，系统都要重新计算相关的内部数据结构。频繁地设置这些矩阵——例如，每帧20,000次——计算量非常大。通过将世界矩阵和观察矩阵串接成一个世界/观察矩阵，并将之设置为世界矩阵，然后将观察矩阵设为单位矩阵，应用程序可以将所需的计算量减到最小。最好保存一份单独的世界矩阵和观察矩阵的副本在高速缓存中，这样就可以根据需要修改、串接及重置世界矩阵。为清晰起见，Direct3D示例很少使用这项优化。

投影变换

可以认为投影变换是控制摄像机的内部参数，这选择摄像机的镜头有些相似。这是三种类型的变换中最为复杂的。对投影变换的讨论被分为以下主题。

• 什么是投影变换？
• 设置投影矩阵
• W友好投影矩阵

什么是投影变换？

典型的投影变换就是一个缩放和透视投影。投影变换将视棱锥转变为一个立方体。因为视棱锥的近端比远端小，所以这就产生了离摄像机近的物体被放大的效果，这就是透视如何被应用于场景的。

在视棱锥中，摄像机与观察变换空间的原点之间的距离被定义为D，因此投影矩阵看起来是这样：

通过在z方向平移-D，观察矩阵将摄像机平移到原点。平移矩阵如下所示：

将平移矩阵与投影矩阵相乘（T*P），得到合成的投影矩阵。如下：

下图描绘了透视投影如何将视棱锥转变到新的坐标空间。注意棱锥变成了立方体，同时原点从场景的右上角移到了中心。（译注：应该是从前裁剪平面的中心移到了原点）

在透视变换中，x和y方向的边界值是-1和1。Z方向的边界值分别是，0对应于前平面，1对应于后平面。

这个矩阵根据指定的从摄像机到近裁剪平面的距离，平移并缩放物体，但没有考虑视角（fov），并且用它为远处物体产生的z值可能几乎相同，这使深度比较变得困难。以下矩阵解决了这些问题，并根据视区的纵横比调整顶点，这使它成为透视投影的一个很好的选择。

在这个矩阵中，Z_n是近裁剪平面的z值。变量w，h和Q有以下含义。注意fov_w和fov_h表示视区在水平和垂直方向上的视角，以弧度为单位。

对应用程序而言，使用视角的角度定义x和y的比例系数可能不如使用视区在水平和垂直方向上的大小（在摄像机空间中）方便。可以用数学推导，得出下面两个使用视区大小计算w和h的公式，它们与前面的公式是等价的。

在这两个公式中，Z_n表示近裁剪平面的位置，V_w和V_h变量表示视区在摄像机空间的宽和高。

对于C++应用程序而言，这两个大小直接对应于D3DVIEWPORT9结构的Width和Height成员。（译注：虽然直接对应，但是不等价的，因为V_w和V_h位于摄像机空间，而Width和Height位于屏幕空间）

无论决定使用什么公式，非常重要的一点是要尽可能将Z_n设得大，因为接近摄像机的z值变化不大。这使得用16位z缓存的深度比较变得有点复杂。

同世界变换和观察变换一样，应用程序调用IDirect3DDevice9::SetTransform方法设置投影矩阵。

设置投影矩阵

以下ProjectionMatrix示例函数设置了前后裁剪平面，以及在水平和垂直方向上视角的角度。此处的代码与什么是投影矩阵？主题中讨论的方法相似。视角应该小于弧度π。

D3DXMATRIX 

ProjectionMatrix(const float near_plane, // 到近裁剪平面的距离

                 const float far_plane, // 到远裁剪平面的距离

                 const float fov_horiz, // 水平视角，用弧度表示

                 const float fov_vert)   // 垂直视角，用弧度表示

{

    float    h, w, Q;

    w = (float)1/tan(fov_horiz*0.5); // 1/tan(x) == cot(x)

    h = (float)1/tan(fov_vert*0.5);   // 1/tan(x) == cot(x)

    Q = far_plane/(far_plane - near_plane);

    D3DXMATRIX ret;

    ZeroMemory(&ret, sizeof(ret));

    ret(0, 0) = w;

    ret(1, 1) = h;

    ret(2, 2) = Q;

    ret(3, 2) = -Q*near_plane;

    ret(2, 3) = 1;

    return ret;

}   // End of ProjectionMatrix

在创建矩阵之后，调用IDirect3DDevice9::SetTransform方法设置投影矩阵，要将第一个参数设为D3DTS_PROJECTION。

Direct3D扩展（D3DX）工具库提供了以下函数，帮助应用程序设置投影矩阵。

• D3DXMatrixPerspectiveLH
• D3DXMatrixPerspectiveRH
• D3DXMatrixPerspectiveFovLH
• D3DXMatrixPerspectiveFovRH
• D3DXMatrixPerspectiveOffCenterLH
• D3DXMatrixPerspectiveOffCenterRH

W友好投影矩阵

对于已经用世界、观察和投影矩阵变换过的顶点，Microsoft® Direct3D®使用顶点的W成员进行深度缓存中基于深度的计算或计算雾效果。类似这样的计算要求应用程序归一化投影矩阵，使生成的W与世界空间中的Z相同。简而言之，如果应用程序的投影矩阵包含的（3，4）系数不为1，那么为了生成适用的矩阵，应用程序必须用（3，4）系数的倒数缩放所有的系数。如果应用程序不提供符合这样要求的矩阵，那么会造成雾效果和深度缓存不正确。什么是投影矩阵？中推荐的矩阵符合基于w的计算的要求。

下图显示了不符合要求的投影矩阵，以及对同一个矩阵进行缩放，这样就可以启用基于视点的雾。

我们假设在前面的矩阵中，所有变量都不为零。更多有关相对于视点的雾的信息，请参阅基于视点的深度与基于Z的深度的比较。更多有关基于w的深度缓存，请参阅深度缓存。

注意 Direct3D在基于w的深度计算中使用当前设置的投影矩阵。因此，即使应用程序不使用Direct3D变换流水线，但是为了使用基于w的特性，应用程序必须设置一个符合要求的投影矩阵。