本节我们以红警2[共和国之辉]为上手的第一个游戏，首先是作为复习，其次是引入新内容：马上我将带领大家学习Win32编程。时间过得真快，希望你这段时间也有一定的进步。

首先给出源码和Bin文件，这次有控制台和Win32两个版本，阅读源码时候最好结合MSDN。
Win32版本的截图：


控制台版本的截图：

一个小Tip：红警窗口模式，红警安装完后有一个叫做Ra2.exe的文件，把它的快捷键发送到桌面，然后右键->属性，在路径名最后输入-win启动参数：

所有源码是在VC6上编写并编译的。下载完文件的读者很快会发现控制台的程序比Win32还大，这两个执行文件我没有做任何处理。前面的章节我们分析过一个文字性质的游戏Demo，这里涉及的大部分原理性知识是一样的。重复的知识我就不深入讲解了。
在使用CheatEngine定位需要修改的地址后，我们就开始动手了。这次不必像上次那样还得自己输入游戏进程的PID，我们交给程序来做。

源码还是比较简单的，有疑问的话看看前面的章节的那次讲解。如果还不明白，可以留言。下次开始我就要进入Windows应用程序设计的讲解了。

转载请注明出处：http://www.figoyao.com/blog/2009/12/10/190

本节承接上节继续讲汇编中的指令。

一、标志位操作指令

1、进位CF标志操作指令
清零标志位CLC：CF<-0
置位标志位STC：CF<-1
标志位取反CMC：CF<-NOT CF
2、方向位DF操作指令
清零方向位CLD：DF<-0
置位方向位STD：DF<-1
3、中断允许位IF操作指令
清零CLI：IF<-0
置位STI：IF<-1
4、取标志位操作指令
LAHF：AH<-EFlags低8位
SAHF：EFlags低八位<-AH
5、标志位堆栈操作指令
PUSHF/PUSHFD：16bit/32bit标志位进栈
POPF/POPFD：16bit/32bit标志位出栈

二、算术运算指令
1、加法指令
1）、普通加法指令ADD
ADD  reg/mem,reg/mem/imm
受影响标志位：AF/CF/OF/PF/SF/ZF
2）、带进位的加法ADC
ADC  reg/mem,reg/mem/imm
受影响标志位：AF/CF/OF/PF/SF/ZF
该指令和1）中唯一不同的是除了执行1）中加法外还要加上CF。
3）、加1指令INC
INC  reg/mem
受影响标志位：AF/OF/PF/SF/ZF
4）、交换加法指令XADD
XADD  reg/mem,reg
该指令首先交换两个操作数的值，然再做加法，相当于以下两条指令：
XCHG  reg/mem,reg
ADD  reg.mem,reg
2、减法指令[和加法指令相反]
1）、普通减法SUB
2）、带借位的减法SBB
除了1）中减法还有减去CF
3）、减1指令DEC
4）、求补指令NEG
NEG  reg/mem
受影响标志位：AF/CF/OF/PF/SF/ZF
执行结果：操作数=0-操作数
3、乘法指令
分为带符号乘法和无符号乘法，区别在于：数据的最高位是作为符号还是数值参与运算。
1）、无符号乘法MUL
MUL  reg/mem
受影响标志位：CF/OF
我们知道乘法要有乘数和被乘数，指令中只有一个操作数，所以我们必须知道第二个操作数在哪里。Intel处理的方式是，被乘数提前存在EAX中，然后与给出的乘数相乘，结果放在规定的寄存器中：

2)、有符号乘法IMUL
IMUL  reg/mem
受影响标志位：CF/OF
其操作数都作为有符号数相乘。
4、除法指令
1）无符号除法
DIV  reg/mem
不影响标志位
被除数默认存放规则如下：

2）有符号除法
IDIV  reg/mem
受影响标志位：AF/CF/OF/PF/SF/ZF

三、逻辑运算指令
1、逻辑与AND指令
AND  reg/mem,reg/mem/imm
受影响的标志位：CF(0)/OF(0)/SF/PF/ZF
执行过程：源操作数和目的操作数进行逻辑与运算，结果存放在目的操作数。
2、逻辑或OR指令
OR  reg/mem,reg/mem/imm
受影响的标志位：CF(0)/OF(0)/SF/PF/ZF
执行过程：源操作数和目的操作数进行逻辑或运算，结果存放在目的操作数。
3、逻辑非NOT指令
NOT  reg/mem
受影响的标志位：无
执行过程：把操作数按位取反。
4、逻辑异与XOR指令
XOR  reg/mem,reg/mem/imm
受影响的标志位：CF(0)/OF(0)/SF/PF/ZF
执行过程：源操作数和目的操作数进行逻辑异与运算，结果存放在目的操作数。
异或就是两数相同则结果为0，反之为1。
5、测试指令TEST
TEST  reg/mem,reg/mem/imm
受影响的标志位：SF/PF/ZF
test类似and指令，但只是逻辑与进行测试，根据结果修改标志位，却不改变操作数的值。

四、跳转指令
1、无条件跳转指令
JUMP  reg/mem/imm
执行结果是跳转到指定地址，然后继续执行代码。按照Intel指令手册上的说法，jump一共有4中不同的跳法，这比起跳大神的神棍的跳法可少多了：
1）、Near Jump
这种跳法为啥叫near呢，因为它跳来跳去都是在一个代码段跳，所以又称作段内转移。这就好比你遛狗，总是不出你的县城，这就叫near遛：）
2）、Short Jump
Short Jump是Near Jump的一种，但是比Near还有Near，它跳转的范围是[-128,127]。这时候你可能只是在你的村子溜溜狗而已，太Short了。
3）、Far Jump
一看Far就是那么有气势，此时跳转的范围已经扩大到其他段，你连其他段都能跳，本段当然更可以了，但是要注意，此时你可以跳转到的目标代码的特权级别必 须和当前代码相同：如果你是用户权限，你跳转到系统权限的代码就会出错。这时候你已经厌倦在小县城遛狗了，终于，你鼓起勇气，决定去丈母娘的县城遛狗 ╮(╯_╰)╭。
4）、Task Switch
这个跳转一下就从你当前任务的代码到别的任务里面执行代码了，可以说是跳的最远的。
2、条件跳转指令
顾名思义，得依据条件来跳转，在这里，条件指的是标志寄存器的一个或多个标志位，如果满足条件就跳转否则继续执行跳转指令下面的代码。在介绍指令的时候，首先说下助记符中字母的含义：
E：Equal[相等]
A：Above[大于]
B：Below[小于]
G：Greater Than[大于]
L：Less Than[小于]
N:Not[不]
条件跳转大体上分为2类：
直接标志位测试

间接标志位测试

以上是根据Intel指令手册（3-542 vol.2A）整理，有些教材的跳转条件是错误的。

五、其他指令
本教程不可能把所有指令都介绍完整，有些指令需要在实践的过程中自己查阅手册，学习一门技能从来都不是一蹴而就的。
1、nop指令
nop是空指令，就是占位，除此没有任何作用。
2、call指令
call  reg/mem/imm
call指令执行的过程是，首先把当前EIP或CS加EIP压入堆栈，然后跳转到call后操作数指定地址执行代码。手册里介绍了四种跳转，这里只讲下 Near Call和Far Call。前者call呼叫的函数在同一代码段，此时只需把EIP压栈即可；而后者call呼叫的是不同段，需要把当前段的选择子和EIP均压入栈。
3、ret/retn/retf
ret  reg/mem/imm[可选]
retn是近返回；retf是远返回。

至此汇编语言的基本内容就介绍完了。

转载请注明出处：http://www.figoyao.com/blog/2009/12/09/182

本节主要讲解汇编中的指令。

下载一个指令查看器，用于初期查询之用。在讲指令之前，我先简单说下汇编中有关变量定义的相关内容。

一、标识符和表达式
汇编中，标号、内存变量、子程序名和宏定义名等都叫做标识符，最多由31个字母、数字和特殊字符（?、@、_、$）等组成，不能以数字开头。汇编中是不区分大小写的。并且标识符不能和编译器保留关键字重名，如：
正确的：msg、_Student、?iRand
错误的：2boys、mov、eax
这里需要注意的是，ABCH和0ABCH，前者是标识符，后者是16进制数。在实际编程中一般要求十六进制数以0或0x开头。
1、内存变量定义
一般我们常用的有字节(byte)、字(word)和双字(doubleword)，浮点数在后面会涉及。定义变量的一般形式是：
变量名 类型 表达式1,表达式2,……表达式n
表达式个数取决于实际定义；变量名命名规则上面已经介绍；类型常用的有db(byte)、dw(word)、dd(doubleword)。各表达式之间用逗号隔开，最后一个表达式没有逗号；如果变量没有在定义时初始，表达式用问号（?）代替。例子如下：
1）、定义一个名为iPlayerHP的单字变量，初始值为200
iPlayer  dw 200
2）、定义一个名为msgname的ASCII字符串变量，初始值为’I am Figo Yao.’
msgname  db ‘I am Figo Yao.’
3）、定义一个名为iTime的双字变量，初始值不确定
iTime  dd ?
4）、定义一个长度为100的，名为qqNUM的双字数组变量，初始值不确定
qqNum  dd 100  dup(?)
dup是关键字，用在重复定义的情形。
其一般用法如下：
次数  dup  (表达式1,表达式2,……表达式n)
括号中是被重复的部分，如
qqNum  dd 100  dup(10000,10010)
这个表达式的结果是：qqNum数组长度是200，数值是10000和10010交替重复。即
qqNum[200] = {10000,10010,10000,10010…10000,10010,10000,10010};
5）、结构类型定义
其语法为：
结构变量名  STRUC
数据定义
结构变量名  ENDS
比如我们先来定义一个时间结构：
stTime  struc
iHour  db  0    //偏移量是0
iMin     db  0    //偏移量是1
iSec      db  0    //偏移量是2
stTime  struc
对于没有名字的结构体，也可以用偏移量来访问。比如我们初始化一个stTime的结构体(假设eax指向分配的地址)和一个保存秒的变量：
TestTime    stTime <10,25,0>
TestSec    db ?
TestSec    equ TestTime.iSec
我们看到取结构体分量使用的是点(.)加变量名。equ是等于的意思，属于关键字。和上面最后一句等价的语句是：
TestHour    equ byte ptr [eax+2]
ptr是指明数据长度，属于关键字，一般用法为：
数据类型    ptr    地址
操作的结果是指明操作数的地址和类型。因为我们第二种获取结构体变量的方法使用了偏移量，得到存放数据的地址后，还需要告诉CPU从这个地址读取什么类型的数据，因为我们的秒变量是字节，所以ptr前面的是byte。

二、汇编指令
首先规定一些代号以便于讲解：
reg：寄存器
mem：内存单元
imm：立即数
这些代号后面如果跟数字，则表示是多少bit，如：reg16表示16bit的寄存器；立即数的意思是直接的具体的数值，如0×1234H。
下面的内容大体和教材分类一样：
1、数据传输指令
1）、mov指令（move）
mov指令的格式如下：
mov  op1,op2
[mov   reg/mem,reg/mem/imm]
执行的结果是op2的值被传送（复制）到op1。
如：
mov  eax,0×1234h
mov  dword ptr [40995b],ecx
mov  es,dx

但是mov有几条规定需要注意：
a、两个操作数类型必须相同，即同为db、dw或dd等类型。
b、mov指令不能用于改变cs寄存器，否则会导致程序异常错误。如mov  cs,ax 是禁止的;但mov  ax,cs 是允许的。
c、两个操作数不能同为下列段寄存器的组合：DS、ED、SS、FS、GS，如：mov  es,ds 是错误的用法，如果一定要把ds的数据传给es，可以如下操作：
mov  ax,ds
mov  es,ax
d、两个操作数不能同为内存单元，如mov  [1234h],[2345h] 是错误的用法。
e、指令指针EIP不能作为mov的操作数。
2）、movsx/movzx（传送填充指令）
2a）、movsx是符号填充指令（move with sign-extend）
movsx  op1,op2
一般op2的bit数比op1少，在mov中是禁止这么传送数据的，但是movsx可以，执行结果是op1低位由op2填充，op1剩下的高位由op2的符号位填充。
如：
movsx  eax,10H
执行完后，eax的低五位为二进制10000，从第六个bit起的高位均填充1。
2b）、movzx是零填充指令（move with zero-extend）
与符号填充唯一的区别是使用0来填充高位。
3）、交换指令xchg（Exchange）
格式如下：
xchg  reg/mem,reg/mem
xchg  op1,op2
执行结果是op1中存储原来op2的数据，op2中存储原来op1的数据。
4）、取有效地址指令lea（load effective address）
格式如下：
lea  reg,mem
lea  op1,op2
执行结果是内存单元op2的有效地址（偏移地址）赋给op1。
在汇编中还有一种获取有效地址的方法，使用offset伪指令，如：
lea  eax,dword ptr [1234H]和mov  eax,offset  dword ptr [1234H]是等价的，但是后者的执行速度更快。不过当去堆栈处地址时候是不可以用offset的，因为offset在编译时实际上编译器会先求出变量 地址，然后用地址作为立即数进而合成机器码；而lea是CPU的指令，是在程序运行时候求的，所以可以处理动态地址，如：lea  eax,dword ptr [ebp-5ch] 的情况就不可以用offset。
5）、堆栈操作指令
进出栈操作
push  reg/mem/imm
执行push指令后堆栈指针ESP依据进栈数据类型自动修改，如push  eax，因为eax是4个字节，所以push执行完后，esp=esp-4，[esp]<-eax。与之对应的是pop出栈指令。
pusha/pushad
执行该指令会依次把EAX、ECX、EDX、EBX、ESP、EBP、ESI、EDI存入堆栈，这些通用寄存器的值是执行指令前一瞬间的快照值，即要执行 这条指令的一瞬间，我们把此时的通用寄存器的值记录下来，那么这条指令就是把我们记录的值按照上面顺序依次存入堆栈。pusha是16bit的版 本，pushad是32bit的版本。与之对应的是popa和popad，这条指令是把刚才存储的快照依照和上面存储过程的逆序恢复。

这节就暂时讲到这里，下次我们接着讲指令。

转载请注明出处：http://www.figoyao.com/blog/2009/12/09/178/

本节主要讲解汇编中的操作数寻址。

先来一张IDA反汇编的截图：

我们看到汇编代码的形式为：
指令 操作数1[可选],操作数2[可选]
中括号（[]）内的可选，指的是操作数的个数取决于指令的类型：如果是单操作数指令，比如push指令，那么操作数2（下简称op2）是没有的；如果是双操作数指令，比如mov，两个操作数都有；如果是无操作数指令则后面什么也不跟。在进一步讲解之前，我先简单讲下mov指令，该指令的作用是把op2的值复制到op1。从…到…是一个具有方向的句式，我们以后把op1叫做目的操作数，op2则叫源操作数，因为是从op2到op1╮(╯_╰)╭。虽然下面是以mov指令作为讲解的对象，以下规则是可以拓展到所有指令的。

毛主席教导我们：有的放矢，抓住老鼠的猫就是好猫！哎，抓老鼠不是邓爷爷教导的吗？汗…下面我的讲解和大部分教科书的方式有很大不同，但是我可以保证你看完之后获得的信息量>=教科书。相信我，没错的：）。

首先思考一下：指令存在的目的是什么？CPU是做什么的？我们一般称CPU为中央处理器，处理什么呢？当然是二进制数据了，我偷偷告诉你，其实CPU只会加减法而已。这样说来，Intel也不是什么高科技公司嘛[龙芯大笑]。我们小学就学过加减法，不就是两个数相加减吗？是的，所谓寻址，就是告诉CPU做加减法的数存在哪里，仅此而已。前面已经讲过，计算机里面能存储数据的地方有：硬盘等外部存储设备、内存、高速缓存和寄存器。我们可以无视硬盘和高速缓存：前者不直接和CPU打交道，后者暂时不直接和我们打交道。这样的话就我们关心的就只有内存和寄存器了，那我们要做的就是搞明白在汇编里面是如何表示内存地址的.为什么不管寄存器寻址呢？因为寄存器属于CPU内部固件，所以CPU可以直接访问。就好比，你去别人家拜访的话首先要知道别人的地址；在自己家里的话，想去哪个房间直接去喽，当然不要地址了！那么我们下面主要讲的就是内存地址的表示，上节教程说过，32位CPU表示地址的格式为：

第一个是段选择子，第二个是偏移地址[又叫有效地址]。至于得到这2个参数后如何寻址上节已经说过了。对于这2个参数在汇编语言中是如何给出的呢？比如我把op2复制到op1，按道理说，应该这样写：mov eax,ds:[1234H]。这句中的ds是数据段寄存器作为选择子，后面的[1234]表示偏移地址，记住一定要加中括号！不过，Intel的游戏规则是这么说的：你这么做，是可以的，但经过我们砖家的研究发现啊，大部分情况使用默认的段选择子更省事。说完这些，Inte在它的指令手册（参见：Vol1 3-29页）中给出了默认的段选择子的规则（下面的英语比高考阅读简单多了）：

由上表我们看到：代码段默认的选择子是CS，堆栈段默认的选择子是SS，数据段默认的选择子是DS，字符串默认的选择子是ES。返回来看最上面那张反汇编图，我们看下地址为00401004处的汇编代码：mov     esi, [esp+48h+hInstance]。中括号里面的是偏移地址（hInstance和48H一样，都是数值，在运行时由Windows系统传递具体数值进行初始化），但是没有指明选择子，由于是要把堆栈中的数据复制到ESI中，结合上面的规定，我们知道选择子是SS。所以还原一下这个语句应该这么写：mov     esi, ss:[esp+48h+hInstance]。有同学发问了：“你怎么知道复制的数据在堆栈呢？”能提出这个说明这位同学是认真思考了，我来回答一下：凡是看到中括号第一个是ESP或EBP，那么选择子就是SS，别忘了ESP可是叫做堆栈指针寄存器，那可不是盖的！再来看下地址为00401036处的汇编代码：call ds:LoadIconA。这句是呼叫函数LoadIconA载入图标，函数一般存放在代码段，但是这个函数存放的地址却是数据段，因为Intel规定的代码段默认的选择子是cs，所以此处必须指明为ds，CPU才知道此处以ds作为选择子。其它的情况如果是字符串指令，则是ES，否则都用DS。

呵呵，我认为还算通俗易懂啊。今天先到这里。

转载请注明出处：http://www.figoyao.com/blog/2009/12/08/159/

本节主要讲解汇编中的内存管理。

CPU对内存的管理的最小单元是字节（8个bit），为了标识不同单元，就给每个单元一个编号，这个编号就是我们下面说的物理地址：地址是一个无符 号的二进制整数，但为了书写方便一般写成十六进制形式，如0×410234等。下面首先讲解32位CPU的内存管理模式：实模式和保护模式。

一、实模式
物理地址=段地址×16+偏移量
段地址存储在段寄存器中，即CS（代码段寄存器）、DS（数据段寄存器）、ES（附加段寄存器）、SS（堆栈段寄存器）、FS（附加段寄存器）、GS（附加段寄存器），其中FS和GS是80386及以后型号的CPU增加的寄存器。在实际编程中，遵循的原则如下表所示：

简单解释一下上表，比如取操作数，缺省用DS作为段寄存器，偏移量为有效地址，DS:[100H]，方括号中的是有效地址，冒号前的DS作为段基地址，假设此时DS的值为0×23E6H，那么内存单元的物理地址为：0×23E6H×16+100H=0×23F60H。所谓缺省的段寄存器，是说如果地址表达式为[100H]，就认为DS是段基地址。为了便于理解，你可以这么去想：你要去宿舍楼找小明，首先需要知道楼层（段基地址），到楼层后再通过房间号（偏移地址），这样就找到小明了。
内存最小单元式字节，但是我们经常接触的是字（2个字节）或双字（4个字节）。前面讲过，内存最小单元的编号就是地址，那么寻址字或双字的时候以哪个最小单元的地址为准呢？先来看个示意图：

地址为23451H的字节的数值为：12H；
地址为23451H的字的数值为：3412H；
地址为23451H的双字的数值为：78563412H。
Intel的CPU规定：高(低)地址存储单元存储高(低)字节。所以地址为23451H的字的数值的低字节为低地址23451H处的12H，高字节为23452H处的34H。

二、保护模式
此时的地址计算与实模式完全不同，段寄存器存储的不再是段基地址。对于32位CPU来讲，可以使用32根地址线访问内存，排列组合一下可以算出总共可以访 问2^32Byte，即4GB。顾名思义，保护模式涉及到地址空间优先级等安全属性的描述，段寄存器就用来保存这些安全描述信息，但由于信息太多，需要 64位长的数据才可存储完整，这个存储安全信息的64位长的数据有个专门的称谓：段描述符（Segment Descriptor）。16位的段寄存器是不够用的，为了解决这个问题。80X86CPU引入了两个新的寄存器：全局描述符表寄存器GDTR（48位）和局部描述符表寄存器LDTR（16位）。原理就是充分利用内存空间，实现机制如下：

在操作系统启动后，GDTR指向一块内存区域，该区域的起始地址为GDTR的16到47位指示的地址，长度为GDTR的0到15位指示的长度。这块内存被称作全局描述符表（GDT）， 因为它存储了操作系统使用的代码段、数据段和堆栈段的全部信息；同时还存储了用户建立的执行任务的信息（局部描述符表LDT索引），该信息记录了各个任务 内部代码段、数据段等的描述表的起始地址，可以理解成各个任务描述表的起始地址都存在这里，通过它可以定位所有任务的内存相关信息。
在保护模式下，地址格式为XXXX:YYYYYYYY，XXXX表示段选择器，为DS、CS、FS等段寄存器；YYYYYYYY为偏移地址。我们要做的是通过XXXX确定描述符，然后找到基地址，加上偏移地址，进而得到有效的线性地址，此时才能定位内存单元。步骤如下：
首先检查XXXX的第2位是否为0：为0表示描述符在GDT中，其位置由XXXX的高13位确定；不为0表示描述符在LDT中，要找LDT首先需要找到它 的基址，而基址存储在GDT中，其位置由LDTR的高13位确定，得到LDT基址后，我们进一步通过XXXX的高13位在LDT中确定目标内存单元的基 址，然后结合偏移地址就得到了线性地址。

今天就讲到这里，下节将开始寻址方式的讲解。

转载请注明出处：http://www.figoyao.com/blog/2009/12/07/147/

讲了这么多天理论知识有的同学可能有些迷茫和厌倦了，你看，教室后门那个穿夹克的同学都睡着了。所以今天我们来小小的演习一下，囿于目前大家的知识储备，下面的练习只能归为局部演习，等你们羽翼丰满的时候我会领着大家实战。千万记住：欲速则不达。

首先我们需要自己编一个小游戏：玩家和怪物打斗，通过文字输出战斗情况。代码如下：

SimpleGame

执行界面如下，怪物和玩家的血量依次递减：

包括以后真正的实战，我们要非常明确自己的目标：这里的目标是把玩家血量改为递增，即玩家被怪物攻击一次血量增加一个伤害值大小的数值。在上节教程，我们讲过与CPU交互的数据主要存储在内存中，那我们要做的就是找到内存中存储玩家血量数据的地址，因为CPU是通过地址总线来定位数据，这也就是我们第一步要做的事情：找地址，工具使用大家耳熟能详的CheatEngine。步骤如下：

视频中的相关代码和程序打包下载：点击下载。
视频的清晰版下载：点击下载。

下面讲解一下外挂程序的细节：

需要讲解的函数有2个：OpenProcess和WriteProcessMemory。
1、OpenProcess(dwDesiredAccess,bInheritHandle,dwProcessId)
第一个参数：对被打开进程的访问权，设置为PROCESS_ALL_ACCESS，即所有访问权；
第二个参数：打开进程创建的子进程是否可以继承该访问权限，设置为NULL；
第三个参数：要打开的进程的ID值，即我们在任务管理器里看到的PID（看不到的同学，通过查看->选择列->勾选PID）。
此函数执行成功的话我们就得到了目标进程的句柄，你可以暂时把句柄理解系统为进程指定的身份证号。
2、WriteProcessMemory(hProcess,lpBaseAddress,lpBuffer,nSize,lpNumberOfBytesWritten)
第一个参数：要写入内存的目标进程句柄，已经通过上面函数得到了；
第二个参数：要写入内存的地址指针，就是我们通过OllyDbg得到的那个地址；
第三个参数：要写入的数据，即我们修改sub指令为add指令；
第四个参数：要写入数据的大小；
第五个参数：可选参数，与本处无关，设置为NULL。

本节我们给出了一个完整的Demo演示，实战中不会这么顺利很简单。希望这篇教程能够提起大家的兴趣，以迎接真正的挑战：当你掌握了足够技术后，如果说还有什么能够阻挡你，只有你的想象力！

转载请注明出处：http://www.figoyao.com/blog/2009/12/06/135/

本篇起我们开始讲解汇编语言，最终目标是能读懂OllyDbg或IDA等反汇编工具得到的汇编代码，并可进行基本的高级语言嵌入汇编程序设计。我假设A1系列文章你已经读过，并掌握基本的高级语言程序设计方法。

对任何事物都要从ta产生的来龙去脉去研究，这样才能获得全面深刻的理解。话说上世纪40年代产生了第一代计算机，由于是基于二进制数制逻辑，人们可以和计算机交流的语言限于机器语言，你完全可以把它理解为某种外星语言：机器语言完全由0和1组成，当然，这属于人家计算机内部交流语言。我们都知道詹姆士.邦德代号007，知道周星星代号9527， 知道圣诞节1225，情人节214…说这么多，其实是为了告诉大家：每个人的记忆力都很好的，相信我，汇编里面要你记住的常用代号不会比节日多：）。最 初，为了要计算机按照人们意图行事，不得不通过机器语言与之交流，这就使得当时的程序员和远古时期的巫师一样稀少和神秘，因为机器语言容易出错，比如，你 找出下面两个数字的不同：
1000110100011101001100011100011和1000110100011101001101011100011。
这还属于最简单的，如果是十几张纸都是0和1，让你找错，恐怕效率和正确率都不会太高。当人们意识到这个问题时，开始构造一种机制来简化编程，这样就有了汇编语言，它的思想就是互相替换：在人编写程序时候，用邦德替换007，周星星替换9527，…；在计算机执行时候，用007替换邦德，9527替换周星星，…。虽然这里说的是替换，但实际属于编译原理的东西，操作起来比较复杂，此处就不深入了。

永远记住，汇编语言是处理器相关的，此处主要以X86系列处理器为原型讲解，AMD公司的CPU一般都是兼容IA-32架构的，所以满足X86规则的汇编程序在AMD兼容芯片一样可以运行。

我们知道计算机几个主要配件：CPU、内存和硬盘等，而把这些配件整合到一起的就是主板，上面有各种形式的导线。下面是一张逻辑图：

上图中的I/O设备是 指输入（Input）输出（Output）设备，如鼠标、键盘和摄像头等；I/O接口指的是USB、COM等接口；存储器主要指内存。从上图我们看到由 CPU引出三种总线：控制、地址和数据总线，这是CPU坐阵指挥的途径，也就是说所有CPU指令最终都要表现在总线的操作上，而汇编语言本质上就是学会通 过CPU操作总线的方法。那么，好奇的你就没有什么想问的吗？记住，有时候，好奇是比知识更重要的想象力！虽然好奇害死加菲猫。那么，CPU里面是怎么个组成呢？在我们学校有这么一个传说：胡伟武同学本科毕业设计就是用单片机搭出一个类8086芯片系统，这从一个侧面表达出X86的复杂。幸运的是，大家暂时不必了解太多；不幸的是，如果你打算像我的那个去360的师兄一样坚持走底层技术路线的话，你还是有必要读读Intel指令手册的。不过，我们暂时只需做个“幸运儿”：）。

当我们要求计算机对两个数执行求和运算时，CPU处理的流程是怎样的呢？假设要对a与b求和，a、b均已经存在于内存了。结合上面架构图来看：CPU通过控制总线发出读数据的指令，通过地址总线指明要读数据在内存中的地址，通过数据总线把数据传给CPU，CPU把数据存储在自己的寄存器中，然后通过算术逻辑部件（ALU）完成运算。这里多了两个名词：寄存器和算术逻辑部件，我将逐一讲解。

任何事物不能凭空存在，包括数据，CPU要交互的数据大部分放在内存和硬盘：硬盘向内存传输数据的速率远低于内存向CPU传输数据的速率；内存向 CPU传输数据的速率远低于CPU的处理速率，现在的CPU为了缓解这个矛盾，一般都使用高速缓存机制，因为高速缓存向CPU传输数据的速率更快。那么， 问题来了：CPU接收数据后把数据存放在哪里呢？答案是寄存器，寄存器的存取速率比内存快很多，主要用来存放运算过程中的数据地址、数据及中间结果等。本 篇教程是以32位处理器为原型讲解，首先要讲的是最常用的通用寄存器：EAX、EBX、ECX和EDX。这就是寄存器代号，类似9527代表周星星：

有的同学看到上面的图可能像魔兽争霸一样：混乱之至了，怎么又有AH、AL和AX，这是什么啊？我们来论资排辈一下，《天龙八部》里面少林觉字辈高于玄字辈，因为他们老师的辈分不同所导致；那么把从AL到EAX按照位数排 下辈：（AL、AH[8位]）<AX[16位]<EAX[32位]。其实它们指的是同一个东西的不同部分，好比一个手由5个指头组成，一个人 有2个手：但自始自终都是指的一个人，只是范围不同而已。同理EBX、ECX和EDX与EAX结构和命名类似，比如EBX也有BX、BH和BL。这样做的 目的是提供最大的灵活性，比如有时你只需要存一个8位的值，那么就没必要占用全部寄存器，只需要用一部分即可：这与宿舍类似，一个宿舍假设可以容纳4个 人，那么只有一个学生的时候占一张床即可，不必全部占满。

除了通用寄存器，还有变址和指针寄存器(EDI/ESI/ESP/EBP)、指令指针寄存器(EIP)、标志寄存器(EFlags)：这些都是32位的寄存器。CPU中16位的寄存器是段寄存器，也就是说段寄存器这个房子的平米数比前面的寄存器要少，最大可以存16bit。

各种寄存器的主要用途如下表：

这节暂时讲到这里。

转载请注明出处：http://www.figoyao.com/blog/2009/12/05/124/

本篇讲解一些杂项：预处理命令、typedef定义新类型以及推荐书目。

1、预处理命令
该类命令一般以#（井字符）开头：#include；#define、#undef；#if、#ifdef、#ifndef、#else、#elif；#pragma。
1）、#include 记号序列
记号序列必须被解释为<…>或”…”之一，如：
#include <stdio.h> //包含标准输入输出头文件
#include “userdefine.h” //包含用户自定义头文件
这两者的区别在于，<…>指示编译器去系统目录或环境变量寻找头文件；而”…”指示首先去当前目录寻找头文件，如果找不到再按照前者规则寻找。
2）、#define 标示符 记号序列 或 #define 标示符
#define的第一种用法主要用在定义宏，如：
#define PI 3.1415926
上面就定义PI为3.1415926，但实际上我们推荐使用const方式来定义。
#define的第二种用法主要用在编译不同版本及指示标志，如：
#define _UNICODE
这样定义的话当我们编写windows应用程序时候，里面函数版本会被替换为UNICODE版本。而#undef的作用在于抵消#define定义的指示标志：
#undef _UNICODE
这会导致上面的#define语句失效。
3）、#if 系列主要用在debug和防止头文件重复包含方面：
4）、#pragma
该预处理指令是比较复杂的一个，你只需暂时记住有即可，当你遇到也不会生疏。如需详细用法可查阅手册。

2、typedef
主要用来定义新类型别名，其用法如下：
typedef 原数据类型名 新数据类型名
比如wchar_t的定义为：typedef unsigned short wchar_t。

3、推荐书目
《C程序设计语言》
《C缺陷与陷阱》
《C和指针》
《C++ Primer》
《C++标准程序库》

至此C++基础就讲完了，下面开始的章节将讲解汇编语言程序设计。

转载请注明出处：http://www.figoyao.com/blog/2009/12/04/116/

本篇讲解类的使用。

当谈到类的时候，我们经常听到的是面向对象编程（oop），其实呢，面向对象是一种编程思想，只不过类机制较好的支持这种想法，但是并不代表要编写面向对象的程序一定要用C++或类似语言（如Java等），即使用传统的C，依然可以写出面向对象的程序。

class的成员除了可以是数据外，最大的变化是，函数也可以作为其成员，对于其成员按照访问属性的不同有：private、public和 protected三种。按照来源不同，其成员可分为：用户自定义、语言默认和强制系统定义。我们可以把一个类理解为一个功能完整的小麻雀：除了具有数据 成员外，还有具有类提供给用户的功能函数。下面设计一个动物类：
class animal
{
    private：
        void  eat();//吃饭
        void  sleep();//睡觉
        void  run();//跑
        int  age;
        bool  alive;
    public:
        bool  feed();//喂食
        bool  blood();//血型
        void  state();//状态信息
        int  foodlimit;//饮食控制
};
animal类呢其实是定义了一个模板，因为大部分陆地动物都具有上面的属性，类的成员函数通常在类外 完成具体实现，实际编程时，我们一般都把类声明放在头文件中，而把类实现放在包含头文件的同名cpp源文件中，如，我们在define.h中定义了要实现 的类和数据结构以及系统头文件预处理，那么我们需要新建一个名为define.cpp的源文件，该源文件要在文件开始包含define.h文件，这样我们 在其他文件中如果要使用这个类，只要包含define.h即可，建议大家有意识的建立自己的个人类库，随着时间的推移，你会发现你的开发效率会大大提高。

下面我们实际开始动手，本教程使用的工具是Visual C++6.0：
第一步：新建文件

第二步：工程类型

第三步：建立空工程【我给工程起名字是ClassDefine】

第四步：添加头文件和源文件

上面两项建立好后左侧目录如下：

第五步：添加类定义和实现
类的定义

类的实现：

建立main函数文件

完整源文件下载。
类成员的三种不同属性主要用来限制成员的访问方式，读者可以看到上面当定义一个类对象smFish后，我们使用.(点)运算符来访问成员，能够使用此种方 式被访问的只有被指明是public的成员，凡是private属性的成员是不能这样被访问的，此时只能在成员内部使用。关于friend（友元）属性本 教程不涉及，读者可以参考C++ primer或其他书籍进一步研究。

下次我们将讲解类的继承派生和虚函数。

转载请注明出处：http://www.figoyao.com/blog/2009/12/03/68/

本篇讲解类的继承派生和虚函数。

一、继承派生机制
在古装片里我们经常看到某某太子继承王位，太子继承王位的结果就是他首先拥有了皇帝的权利并要原则上承担义务；又或某张三继承富翁老爹的财产，那么这个某张三就拥有了富翁对于财产的支配权等等。在类里面的继承和这些很类似，比如我们上节定义了一个叫做Fish的类，鱼分很多种，有金鱼、草鱼、武昌鱼（╮(╯_╰)╭）等等，当我们需要实现一个电鳗类的定义时，我们可以从已经定义好的Fish类派生一个电鳗类，派生的子类就继承了Fish所以的特征；同时，因为电鳗有自己的特点，比如放电，因此我们还要定义电鳗自身的特征函数和特征数据：

此时电鳗类就简单定义完成了，继承时候需要制定继承参数类型：public、private和protected。继承类型的不同会影响成员的属性：

具体到电鳗类，我们看下Fish类的定义：

因为电鳗的继承方式是public，对照上面表格，可知电鳗中的Eat()等函数依旧是public属性。下面给出代码，大家可以看下用法：

二、虚函数
在继承的机制中存在这样的问题，子类成员函数如果有何父类同名的话应该如何处理呢？C++中引入了虚函数机制，多态性就是通过虚函数来体现的。
我们先来看下不用虚函数机制，直接在子类中定义同名函数：

父类Fish类中Eat的定义如下：

执行结果如下：

注意上图红色方框处的指示。我们本来的想法是当指针pFish指向不同的类时执行不同的成员函数，但实际是，未强制类型转换前执行的依旧是父类Eat函数，为了避免类型转换的麻烦，引进的虚函数：

此时执行的结果如下：

下一节将把一些杂项讲解一下，然后C++精简教程就完结了。

转载请注明出处：http://www.figoyao.com/blog/2009/12/03/74/

本篇讲解指针和函数。

一个运行的程序，其指令和数据主要存储位置是内存。当我们定义好数据后，如何取用该数据呢。比如：
int  iTest = 0;
上面我们定义了iTest，任何事物不能凭空存在，包括数据，iTest的存储位置就是内存中一个4字节的单元，那么当我们要使用iTest的时候计算机 如何知道去哪里找它呢，实际上是使用了指针机制。指针本质上是索引，可以理解为学号，在一个学校里面，所有人的学号都是不同的，有些人可能生日啊、名字的 相同，但学号是不会相同的；在内存中，有些数据的值可能一样，但是指示这些数据存储位置的指针却不可能相同（我们在此暂不考虑Window系统中私有内存 机制）。在家乐福等大型超市里面我们要自助存包的时候，每个储物箱对应着唯一编号（即指针），当我们存包后（即定义变量），储物箱中有了内容物（即数 据），购物完毕，我们可以依据储物箱编号准确找到自己的物品，指针的机制就是如此。

由上段我们看到指针类型可以多种多样：在C++中，当要指示不同数据类型时候指针类型也是不同的。其定义方法如下：
1、定义一个指向int类型的指针
int* piNum;
2、定义一个指向char型的指针
char *pcCh;
通用定义格式如下，其中*指的是星号：
[数据类型]* 变量名;
定义指针完毕我们可以给指针赋值：
int iNum = 3;
piNum = &iNum;
上面定义中，&为取地址符，求出iNum的存储地址后，把地址的值赋给piNum，此时piNum指向就是存储单元中的内容物就是3。

指针的运算
我们假设p和q均为指向char类型数据的指针
1、加法
q = p+1：q指向p为起点向后数1个存储位置的数据单元，即紧邻p位置的但地址大于p数据单元。
q = p+n：q指向p为起点向后数n个存储位置的数据单元。
2、减法
q = p-1：q指向p为起点向前数1个存储位置的数据单元，即紧邻p位置的但地址小于p数据单元。
q = p-n：q指向p为起点向前数n个存储位置的数据单元。
3、指针相减
q->|’A'| [0x0410000h]
       |’B'| [0x0410002h]
p->|’C'| [0x0410004h]
上面中括号中数值表示指针p和q的实际取值，C++中规定两个指针相减并不是在用地址作减法，而是两个指针所代表的地址位之间的数据个数的减法。以上面示意图为例，p-q的数值并不是0×4h，而是0×2h，因为q指的是第1个数据，p指的是第3个数据，3-1=2。

指针就暂时讲到这里，下面开始讲解函数。
我们可以这样理解函数，如果学校的大门属于入口函数main的话，学校的设施就是这个函数中的内容，而各个班级则可以理解为自定义函数，班级内部的实现过程只和本班级有关系。比如我要定义一个加法函数addnum( )，那么一个函数的标准格式如下：
返回类型 函数名(参数类型 参数1, 参数类型 参数2,…)
{
    函数体;
}
int addnum(int iNum1, int iNum2)
{
    return iNum1+iNum2;
}

为什么要把指针和函数放在一起讲呢，因为函数的识别过程和指针有很大关联。函数名实际上就是指针变量的值：
int (*paddnum)(int iNum1, int iNum2);
paddnum = addnum;
上面我们定义了一个指向addnum()函数的函数指针paddnum。

下节主要讲解构造类型数据。

转载请注明出处：http://www.figoyao.com/blog/2009/12/02/62/

本篇讲解构造类型数据。

构造类型数据包括以下几种：
指针类型、数组类型、结构体类型（struct）、共用体类型（union）、枚举类型（enum）、类类型（class）

1、指针类型
上节已经讲解过了。

2、数组类型
组，就是把相同的个体集合为一个整体，以便于处理。数组其实除了由各种数组成的集合，其字面意义已经延伸至任何相同类型的个体组成的集合，如，字符数组、指针数组等等。数组的定义及表示方法如下：
类型 数组名[个数];
一个例子：
1）、int  isNum[10];//定义一个拥有10个元素的整数数组
2）、char  szName[] = “Figo”;//定义一个内容为Figo的字符数组
C++中注释部分需要使用//或/* */。注意到前者下标明确指出是10，但在C++中下标是从0开始表示，直至9，即isNum[10]指的是isNum[0]、isNum[1]、…isNum[8]、isNum[9]，没有isNum[10]！后者没有指出确切的下标，系统将按照实际长度分配下标，Figo是4个字符，所以char  szName[] = “Figo”;等价于char  szName[4] = “Figo”;
数组初始化有2种方法：
1）、int isNum[10] = {1,2,3,4,5};
从isNum[0]到isNum[4]依次为1到5，而isNum[5]到isNum[9]全部为0。
2）、int isNum[10];
           int isNum[0] = 1;
           int isNum[1] = 2;
           …  …
就是依次给个体赋值。
数组维数一般常用的是一维数组、二维数组和三维数组，使用频率依次降低。
二维数组就是下面有2个：
类型 数组名[下标1][下标2];
int  iClass[6][4];//一个学校6个年级，每年级有4个班

3、结构体类型
其格式为：
struct  结构体名
{
      数据类型1  成员1;
      数据类型2  成员2;
      …    …
      数据类型n  成员n;
};
struct  StuInfo
{
    int iID;
    wchar_t szName[255];
    bool bReg;
};
结构体本身的目的是为了使得功用相同的数据能够被归为一体从而便于处理，并使得数据流程结构清晰。当定义一个结构体后，可以使用结构体名去最为新类型的类型声明新变量：
StuInfo  XiaoMing = {20091202,”小明”,true};
使用方法如下：
XiaoMing.bReg = false;

4、共用体类型
定义的一般形式如下：
union  结构体名
{
      数据类型1  成员1;
      数据类型2  成员2;
      …    …
      数据类型n  成员n;
};
union StuInfo
{
    int iID;
    wchar_t szName[255];
    bool bReg;
};
union和struct的区别在于内存空间的分配：union共用体在声明时候，系统只会按照其成员变量中占用存储空间最大作为分配空间的标准，上面种szName占用最大，所以StuInfo的大小事255个字符的大小。你可以这样去理解，三个人轮流站岗，但是每8小时只能有一人上床休息，为了合理的节约资源，只制作了一张床，我们把床按照个子最高的人的身高作为标准制作才行。

5、枚举类型
枚举类型用在switch的时候较多，如其名，枚举类型要求在定义的时候把所有可能的取值都列出来：
enum 枚举类型名 {枚举元素1,枚举元素2,…,枚举元素n};
enum Day {Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday};
如果没有明确指出变量元素的具体数值，系统将自动按照从0开始依次加1的规则来赋值，即Monday = 0，Sunday = 6。从习惯来说，我们希望Monday = 1，那么我们需要这么定义：
enum Day {Monday = 1,Tuesday,Wednesday,Thursday,Friday,Saturday,Sunday};
系统除了按照上面规则自动赋值外，如果程序员规定了具体数值后，系统将从规定数值的变量开始依次加1，即Monday = 1的话，Tuesday是Monday+1为2。

6、类类型
类类型与上面最大的不同是可以规定变量的访问属性：public、private和protected，早没有规定访问属性时候默认为private。
定义形式如下：
class  类名
{
    public:
    ……;
    private:
    ……;
    protected:
    ……;
};
class  Fish
{
    public:
    bool Born();
    int iNum;
    private:
    void eat();
    void dead();
    int iAge;
};
关于类的详细内容会在下一节来讲解。

转载请注明出处：http://www.figoyao.com/blog/2009/12/02/64/

• 上一篇: 游戏辅助工具[外挂]开发教程-从入门到精通之A1_3篇

本篇讲解三种不同类型的控制语句：顺序结构语句、选择结构语句和循环结构语句。

计算机语言理论已经证明，使用上面的三种语句结构已足以表示所有问题，不同的是复杂度而已。这也就是我们常常听到的面向过程编程方法，因为是基于控制的。我们已经知道，计算机是很愚钝的，在知道了基本的数据类型和运算符后，当我们需要计算机为我们的意志服务时，必须把它需要做什么交代的一清二楚它才会按照指令行事，而这中间的媒介主要就是这3种语句。

一、顺序结构语句
本语句不涉及关键字，只要相同语义范围内处于先后的语句自然构成了顺序结构。比如我们排队买票，假设你是售票员，你执行买票的过程就是顺序执行：先来的先 买到票。在编程中，每个函数体内，先出现的语句单位总是会先被执行。所谓函数体，值的就是编程中把相同功能的语句集合封装起来的一种逻辑结构。比如在QQ 里面，我们会根据好友与自己的不同关系而把好友归为不同的组，并为每组起名，有的叫同学，有的叫同事等等。但不论你怎么分组，总会有一组叫做我的好友。 而在我们写程序的时候，不论我们分不分组或怎么分组，系统都要求有一组叫做main，即所谓main函数，当然，我们会根据程序要完成的不同功能再自己定 义一些函数，把执行相同功能的语句归为一组，这就是我们的自定义函数。下面就是最简单的一个函数，它的作用是打印出”你好，游戏！”。
#include <stdio.h>
void main()
{
    printf(”%s\n”,”你好，游戏！”);
}
上面红色的都是函数名，main属于程序的入口函数，可以理解为计算机执行程序的时候首先会从main开始执行，即所谓入口；而printf属于打印函数，这个函数的实现在stdio.h文件中，正如电影有.wmv、.rmvb等格式，代码文件有.h、.cpp等格式，.h表示该文件是头文件，.cpp表示该文件时C++源码文件：头文件内容一般为函数声明，全局变量声明等，源码文件一般为函数具体的实现过程。#include关键字表示包含文件的意思，后面接要包含的文件，编译器在处理时，会用指示包含文件的内容替换掉#include声明。

二、选择结构语句
选择语句主要有if实现和switch实现2种。
1、if语句的基本形式
1）、if(表达式) 语句
2）、if(表达式) 语句
           else 语句
3）、if(表达式1) 语句
           else if(表达式2)语句
           else 语句
括号里面的表达式就是判断条件，我举个例子：
if(是美女) 要手机号;
else if(是美女的朋友) 考虑要手机号;
else 我是打酱油的…;

2、switch语句
switch语句的存在主要是为了弥补if语句面对很多判断条件时候的不足，比如你要根据不同日期来做不同的事情，使用if语句作为判断的实现的话就会非常繁琐：
if(1号) 走路;
else if(2号) 睡觉;
else if(3号) 游戏;
….
else if(31号) 回家;
看到了吧，相当的繁琐，而switch的实现就很条理清晰，它的用法为：
switch(表达式)
{
    case 情况1: 语句1;
                           break;
case 情况2: 语句2;
                           break;
case 情况3: 语句3;
                           break;
case 情况4: 语句4;
                           break;
case 情况5: 语句5;
                           break;
…
case 情况n: 语句n;
                           break;
default: 万金油语句;
}
当进入switch语句时候，满足条件的情况就会执行，其中break的作用在于执行完本情况语句后跳出switch语句。

三、循环语句
1、do-while
do
{
    语句;
}while(条件表达式);
该循环的特点是第一次执行不判断条件，后面的执行一旦条件不满足就立即停止循环。
2、while语句
while(条件表达式)
{
    语句;
}
该循环语句的特点是首先判断条件是否满足，满足才执行语句，否则不执行。
3、for语句
for(表达式1;表达式2;表达式3)
{
    语句;
}
for语句的特点是，首先求解表达式1，然后判断表达式2的真假，如果真则执行，否则for循环结束；表达式3在每次循环结束后求解，当求解完毕后再次判 断表达式2是否满足。糊涂了不要紧，我举个例子，比如你要上大学，在你第一去学校报到的时候，需要注册学籍，这就是求解表达式1，只需在开始的时候求一次 即可；然后每年的开学之初你都要去教学秘书那里报到，这就是求解表达式3；每次你报到完毕呢，班主任会检查你是否满足毕业的条件，这就是求解表达式2，一 旦满足，ok，你可以毕业了，这就是所谓for循环结束。写成语句如下：
for(第一次注册学籍;是否毕业;开学注册)
{
    宿舍;
    教室;
    食堂;
}

今天的讲解就先到这里，下次我们开始讲解函数和指针。

转载请注明出处：http://www.figoyao.com/blog/2009/11/29/56/

A1篇主要讲解C++程序设计基础。

任何一门语言本质上都是用来交流，所谓编程语言，你交流的最终对象是CPU，通过对CPU下达指令来操纵整个计算机甚至互联网。为什么是C++呢？因为这是我的入门语言（倒下一片）…其实有的人甚至用易语言去编外挂，这再次说明，达到和CPU交流的目的即可，不要太在乎外皮。下面的讲解是在不对你之前的基础做太多假设的前提下进行的。闻道有先后，术业有专攻，先走过这条路的人，你们怀念下就好，别在这里充小牛，没啥意思，当然，我眼中的大牛也不会来看我的博客的，比如Kunth大叔。我尽量让整个教程浅显易懂、生动诙谐，但是任何技能在达到精通级别之前，都需要大量的付出。

语言是用来传递信息的，但是计算机对于信息的识别是很迟钝的，比如，任何时候，当你要对一个对象操作前，你得告诉计算机关于这个对象所有信息，比如 你要操作的是一个图片还是一个视频，是整数还是小数，是做加法还是做减法等等，这些都是数据。计算机的英文叫做computer，是单词 compute（v.计算）的名词，因为计算机主要的功能就是数据处理，而为了方便它处理数据，人为的把数据分成不同的类型，类似于为了方便收费，人为地 按照排量把汽车分为小排量和大排量等类型，因为这样的话交流起来就很方便，这也是为什么每个程序设计语言的开篇都会首先说说在本语言的范畴，都涉及哪些数 据类型以及基本的运算符号。在C++里，基本的数据类型有以下几种：
【基本的】整数类型（int/short int/long int/unsigned int）、浮点数类型（float/double/long double）
【引申的】字符类型（char）、布尔类型（bool）、空类型（void）
【构造的】指针类型、数组类型、结构体类型（struct）、共用体类型（union）、枚举类型（enum）、类类型（class）
所谓基本的类型，是指CPU层次的支持，引申的类型都是在基本层次上人为的赋予数据不同的含义：比如字符类型，本质上在内存中存储的也是数字而不是字符， 打个比方，监狱里面每个犯人都有唯一编号，比如9527代表的是周星星；而在计算机世界，人们把目前已知的符号进行整理，进而为每个符号规定一个数字，当 告诉计算机一个数字的集合代表字符时候，计算机就会把数字转换为字符，所以字符本质上也是数字。其它类型会在下面的教程依次讲解。

当我们提及一个人时，根据分类标准的不同可以把人分成不同的类别，根据性别可以分为男人和女人；根据国别可以分为地球人和火星人等等。对于数据来 说，除了依据其类型把它分成上面的类型外，我们还根据一个数据会不会改变自己的值把数据分为常量和变量：比如举个不恰当的比方，你下载一个电影时，在下载 完成之前，存储这个电影的文件是个变量，但是一旦下载完成，这个文件就是常量了。在编程过程中，我们把在程序运行中不改变数值的量叫做常量，否则叫做变量。程序中的每个数据总是属于这两者之一，所以当我们需要使用数据时候，必须告诉计算机这个数据是常量还是变量，对应于实际的“单词”就是，使用const和#define来告诉计算机，语法如下：
1）定义一个数值为7的整数
const int DAY = 7;
2）定义一个数值为7的符号
#define DAY 7
两者的区别在于前者可以指明数据类型，而后者则不能，推荐采用第一种方法定义常量。常量最好用全部大写字母组合表示，在C++中是区分大小写的。Day和day就表示不同的名称。

每一个变量对应一个内存单元，至于对应多大的单元要看是什么类型的变量，都叫单元楼，其大小还有不同呢。在计算机中基本的单元度量单位叫做比特 （bit），它可以存多少数字呢，0或1！你可以这样去理解，计算机内存由大量的灯泡组成的，灯泡亮表示1，不亮表示0，那么灯泡就是最基本的表示单位， 每个灯泡叫做一个比特(bit），这就是二进制。我们的计算机大厦就是建立在一堆灯泡的二进制上，神奇吧：），据说是莱布尼兹从太极图得到启发后发现二进制的。但人们习惯的还是十进制，虽然有人习惯二进制，以至于搞出二进制表：

有了二进制我们可以表示任何进制的数，计算机常用的进制有：
十进制：由0到9的数字组成，不能以0开始，如110，25；
八进制：由0到7的数字组成，以0（零）为前缀，如0125，098；
十六进制：由0到9和a到f（大小写均可）组成，以0x或0X（0为零）为前缀，如0×1025，0X2009。
在C++中后两者没有正负之分。并且在给变量及常量取名字的时候有如下限制：
1）、只能以26个字母或下划线_为前缀；
2）、前缀确定后，后面部分除了1）中范围还可以用数字组成。
下面举几个例子：
正确的：_gold、Blood、mana；
错误的：91China、5party。

下面开始讲解数据类型的一些细节：
1、整型（integral type），数值范围如下表：

上表中关键字一栏中括号中的表示可以省略；1byte = 8bit。

2、浮点类型（floating-point number type）
有三种不同范围

在实际编程中，常用的是double。要表示float必给数字加上f或F后缀；要表示long double必给数字加上l(字母L的小写)或L后缀，如:
float fHit = 329.78F;
long double lbExp = 7894.45L;

3、字符类型（character type）
上文中说了，字符本质上是整数通过对应关系在表示，由于计算机最初产生在邪恶的资本主义国家，主要是欧美语系，所以开始的时候没有考虑到伟大的天朝的象形文字，这就导致第一代整数-字符关系表如下：

ASCII

 随着科技春风吹拂天朝大地，问题出来了，不是每个天朝子民都懂殖民语言English，为了解决这个办法，Unicode被提了出来，本质上就是一张更大的表而已。等到人类统治火星的时候估计还会有比Unicode大的表出来。再后面，你会越来越多的见到Unicode这个单词。要定义一个字符，有以下2种方法：
1）、char happy = ‘H’;
2）、wchar_t happy = ‘乐’;
区别在于，前者占用1个字节（byte），是ASCII；后者占2个字节（byte），而后者是Unicode。wchar_t是什么呢，其实就是 unsigned short，自己看上面给出的范围，这个范围就是Unicode最多表示的符号个数范围。表示单个字符时候必须用单引号括起来或者给出符号对应的数值，比 如0×41表示A，那么下面的定义是等价的，shellcode经常用到：
char set = ‘A’;
char set = 0×41;

 4、布尔类型（bool type）
布尔类型数据取值只有2个：真（true）或假（false）。主要用在程序中控制数据处理流程。
声明一个bool变量如下：
bool bLive = false;
在实际的程序设计中，任何非零的量都被认为是true，否则为false。

5、void类型
当你要定义一个不属于以上任何类型的数据时候，可以把它定义为void，其本质上是指针。

以上5种类型是最基本的数据类型，构造类型的数据将放在后续章节介绍。类型讲完后就轮到运算符了，像我们以前接触的加减乘除就属于运算符，在C++中涉及的运算符列表如下：

在后面的应用中会详细讲解，这里了解即可。
今天暂时到这里，我会保持每天一篇左右的进度来完成这个系列的文章。

转载请注明出处：http://www.figoyao.com/blog/2009/11/28/34/

所谓游戏辅助工具通俗的说就是外挂，比如珊瑚虫也是一种外挂。外挂本质上是通过修改目标的硬盘文件、内存映像数据、数据封包等[当然有时还得修改逻辑校验部分]，以达到个性化定制目标程序目的的一种辅助工具。其本质上还是计算机程序。但是，那些用病毒伪称外挂的程序编写不在我们的探讨范围。

在后面的教程中，我将陆续讲解的内容list如下：
—————————-
一、程序设计基础
1.1 C++程序设计精简篇
1.2 汇编程序设计入门篇
1.3 Win32程序设计之SDK篇
1.4 Win32程序设计之网络篇
1.5 Win32程序设计之文件驱动篇

二、计算机系统理论基础
2.1 数据结构篇
2.2 加密解密算法篇
2.3 深入Windows系统篇

三、工具使用基础
3.1 OllyDbg
3.2 SoftICE
3.3 WPE Pro和CheatEngine[涉及源码个性定制部分]
3.4 自制工具篇

四、实际应用基础
4.1 QQ游戏篇
4.2 魔兽世界篇
—————————-

 以上各部分无需依次阅读，依据个人实际情况选取部分章节进行阅读即可。借用PJF的一句话，动手写代码才是硬道理。 绝大多数在计算机应用领域有所成就的人，至少曾经是个代码高手，那些宣扬写代码层次低之类论点的人是很可笑的，因为整个计算机架构的基础从CPU的指令到 操作系统的构架没有一个环节可以离开代码的。这个社会需要高屋建瓴的指挥者，也需要代码高手，尤其是嘲笑写代码低级的人，你首先应该自问是否达到了高屋建 瓴的层次，但这个国度最不缺的就是小丑。

我还是那个观点，防御者永远不要幻想你面对的是风平浪静的计算机，在编写游戏或者其他程序的时候，你要假设一双双虎视眈眈的眼睛已经在打你程序的主 意才行，我们也不要寄希望于用户不作弊，除了大自然的规则，任何人为制定规则的游戏都会有玩家作弊，要学会心平气和的接受这个事实。有矛才会促进盾的升 级。

限于我知识储备集合的有限，难免有不当和错误的地方，在整个讲解的过程中，希望读者老师们能够不吝赐教。

完毕。

转载请注明出处： http://www.figoyao.com/blog/2009/11/28/24/