站在大世界

C++程序设计从零开始之语句

岚焕 — Wed, 22 Feb 2006 04:43:00 +0000

　　前面已经说过程序就是方法的描述，而方法的描述无外乎就是动作加动作的宾语，而这里的动作在C++中就是通过语句来表现的，而动作的宾语，也就是能够被操作的资源，但非常可惜地C++语言本身只支持一种资源——内存。由于电脑实际可以操作不止内存这一种资源，导致C++语言实际并不能作为底层硬件程序的编写语言（即使是C语言也不能），不过各编译器厂商都提供了自己的嵌入式汇编语句功能（也可能没提供或提供其它的附加语法以使得可以操作硬件），对于VC，通过使用__asm语句即可实现在C++代码中加入汇编代码来操作其他类型的硬件资源。对于此语句，本系列不做说明。

　　语句就是动作，C++中共有两种语句：单句和复合语句。复合语句是用一对大括号括起来，以在需要的地方同时放入多条单句，如：{ long a = 10; a += 34; }。而单句都是以“;”结尾的，但也可能由于在末尾要插入单句的地方用复合语句代替了而用“}”结尾，如：if( a ) { a–; a++; }。应注意大括号后就不用再写“;”了，因为其不是单句。

　　方法就是怎么做，而怎么做就是在什么样的情况下以什么样的顺序做什么样的动作。因为C++中能操作的资源只有内存，故动作也就很简单的只是关于内存内容的运算和赋值取值等，也就是前面说过的表达式。而对于“什么样的顺序”，C++强行规定只能从上朝下，从左朝右来执行单句或复合语句（不要和前面关于表达式的计算顺序搞混了，那只是在一个单句中的规则）。而最后对于“什么样的情况”，即进行条件的判断。为了不同情况下能执行不同的代码，C++定义了跳转语句来实现，其是基于CPU的运行规则来实现的，下面先来看CPU是如何执行机器代码的。

　机器代码的运行方式

　　前面已经说过，C++中的所有代码到最后都要变成CPU能够认识的机器代码，而机器代码由于是方法的描述也就包含了动作和动作的宾语（也可能不带宾语），即机器指令和内存地址或其他硬件资源的标识，并且全部都是用二进制数表示的。很正常，这些代表机器代码的二进制数出于效率的考虑在执行时要放到内存中（实际也可以放在硬盘或其他存储设备中），则很正常地每个机器指令都能有一个地址和其相对应。

　　CPU内带一种功能和内存一样的用于暂时记录二进制数的硬件，称作寄存器，其读取速度较内存要快很多，但大小就小许多了。为了加快读取速度，寄存器被去掉了寻址电路进而一个寄存器只能存放1个32位的二进制数（对于32位电脑）。而CPU就使用其中的一个寄存器来记录当前欲运行的机器指令的位置，在此称它为指令寄存器。

　　CPU运行时，就取出指令寄存器的值，进而找到相应的内存，读取1个字节的内容，查看此8位二进制数对应的机器指令是什么，进而做相应的动作。由于不同的指令可能有不同数量的参数（即前面说的动作的宾语）需要，如乘法指令要两个参数以将它们乘起来，而取反操作只需要一个参数的参与。并且两个8位二进制数的乘法和两个16位二进制数的乘法也不相同，故不同的指令带不同的参数而形成的机器代码的长度可能不同。每次CPU执行完某条机器代码后，就将指令寄存器的内容加上此机器代码的长度以使指令寄存器指向下一条机器代码，进而重复上面的过程以实现程序的运行（这只是简单地说明，实际由于各种技术的加入，如高速缓冲等，实际的运行过程要比这复杂得多）。

　语句的分类

　　在C++中，语句总共有6种：声明语句、定义语句、表达式语句、指令语句、预编译语句和注释语句。其中的声明语句下篇说明，预编译语句将在《C++从零开始（十六）》中说明，而定义语句就是前面已经见过的定义变量，后面还将说明定义函数、结构等。表达式语句则就是一个表达式直接接一个“;”，如：34;、a = 34;等，以依靠操作符的计算功能的定义而生成相应的关于内存值操作的代码。注释语句就是用于注释代码的语句，即写来给人看的，不是给编译器看的。最后的指令语句就是含有下面所述关键字的语句，即它们的用处不是操作内存，而是实现前面说的“什么样的情况”。

　　这里的声明语句、预编译语句和注释语句都不会转换成机器代码，即这三种语句不是为了操作电脑，而是其他用途，以后将详述。而定义语句也不一定会生成机器代码，只有表达式语句和指令语句一定会生成代码（不考虑编译器的优化功能）。

　　还应注意可以写空语句，即;或{}，它们不会生成任何代码，其作用仅仅只是为了保证语法上的正确，后面将看到这一点。下面说明注释语句和指令语句——跳转语句、判断语句和循环语句（实际不止这些，由于异常和模板技术的引入而增加了一些语句，将分别在说明异常和模板时说明）。

　注释语句——//、/**/

　　注释，即用于解释的标注，即一些文字信息，用以向看源代码的人解释这段代码什么意思，因为人的认知空间和电脑的完全不同，这在以后说明如何编程时会具体讨论。要书写一段话用以注释，用“/*”和“*/”将这段话括起来，如下：

    long a = 1;
    a += 1; /* a放的是人的个数，让人的个数加一 */
    b *= a; /* b放的是人均花费，得到总的花费 */

　　上面就分别针对a += 1;和b *= a;写了两条注释语句以说明各自的语义（因为只要会C++都知道它们是一个变量的自增一和另一个变量的自乘a，但不知道意义）。上面的麻烦之处就是需要写“/*”和“*/”，有点麻烦，故C++又提供了另一种注释语句——“//”：

    long a = 1;
    a += 1; // a放的是人的个数，让人的个数加一
    b *= a; // b放的是人均花费，得到总的花费

　　上面和前面等效，其中的“//”表示从它开始，这一行后面的所有字符均看成注释，编译器将不予理会，即：

    long a = 1; a += 1; // a放的是人的个数，让人的个数加一 b *= a;

　　其中的b *= a;将不会被编译，因为前面的“//”已经告诉编译器，从“//”开始，这一行后面的所有字符均是注释，故编译器不会编译b *= a;。但如果

    long a = 1; a += 1; /* a放的是人的个数，让人的个数加一 */ b *= a;

　　这样编译器依旧会编译b *= a;，因为“/*”和“*/”括起来的才是注释。

　　应该注意注释语句并不是语句，其不以“;”结束，其只是另一种语法以提供注释功能，就好象以后将要说明的预编译语句一样，都不是语句，都不以“;”结束，既不是单句也不是复合语句，只是出于习惯的原因依旧将它们称作语句。

　跳转语句——goto

　　前面已经说明，源代码（在此指用C++编写的代码）中的语句依次地转变成用长度不同的二进制数表示的机器代码，然后顺序放在内存中（这种说法不准确）。如下面这段代码：

    long a = 1; // 假设长度为5字节，地址为3000
    a += 1;      // 则其地址为3005，假设长度为4字节
    b *= a;      // 则其地址为3009，假设长度为6字节

　　上面的3000、3005和3009就表示上面3条语句在内存中的位置，而所谓的跳转语句，也就是将上面的3000、3005等语句的地址放到前面提过的指令寄存器中以使得CPU开始从给定的位置执行以表现出执行顺序的改变。因此，就必须有一种手段来表现语句的地址，C++对此给出了标号（Label）。

　　写一标识符，后接“:”即建立了一映射，将此标识符和其所在位置的地址绑定了起来，如下：

    long a = 1; // 假设长度为5字节，地址为3000

　　P1:

    a += 1;      // 则其地址为3005，假设长度为4字节

　　P2:

    b *= a;      // 则其地址为3009，假设长度为6字节
    goto P2;

　　上面的P1和P2就是标号，其值分别为3005和3009，而最后的goto就是跳转语句，其格式为goto <标号>;。此语句非常简单，先通过“:”定义了一个标号，然后在编写goto时使用不同的标号就能跳到不同的位置。

　　应该注意上面故意让P1和P2定义时独占一行，其实也可以不用，即：

    long a = 1; P1: a += 1; P2: b *= a; goto P2;

　　因此看起来“P1:”和“P2:”好象是单独的一条定义语句，应该注意，准确地说它们应该是语句修饰符，作用是定义标号，并不是语句，即这样是错误的：

    long a = 1; P1: { a += 1; P2: b *= a; P3: } goto P2;

　　上面的P3:将报错，因为其没有修饰任何语句。还应注意其中的P1仍然是3005，即“{}”仅仅只是其复合的作用，实际并不产生代码进而不影响语句的地址。

　判断语句——if else、switch

　　if else 前面说过了，为了实现“什么样的情况”做“什么样的动作”，故C++非常正常地提供了条件判断语句以实现条件的不同而执行不同的代码。if else的格式为：

    if(<数字>)<语句1>else<语句2> 或者 if(<数字>)<语句1>
    long a = 0, b = 1;
　P1:
    a++;
    b *= a;
    if( a < 10 )
        goto P1;
    long c = b;

　　上面的代码就表示只有当a的值小于10时，才跳转到P1以重复执行，最后的效果就是c的值为10的阶乘。

　　上面的<数字>表示可以在“if”后的括号中放一数字，即表达式，而当此数字的值非零时，即逻辑真，程序跳转以执行<语句1>，如果为零，即逻辑假，则执行<语句2>。即也可如此：if( a – 10 ) goto P1;，其表示当a – 10不为零时才执行goto P1;。这和前面的效果一样，虽然最后c仍然是10的阶乘，但意义不同，代码的可读性下降，除非出于效率的考虑，不推荐如此书写代码。

　　而<语句1>和<语句2>由于是语句，也就可以放任何是语句的东西，因此也可以这样：

    if( a ) long c;

　　上面可谓吃饱了撑了，在此只是为了说明<语句1>实际可以放任何是语句的东西，但由于前面已经说过，标号的定义以及注释语句和预编译语句其实都不是语句，因此下面试图当a非零时，定义标号P2和当a为零时书写注释“错误！”的意图是错误的：

    if( a ) P2:      或者    if( !a ) // 错误！
    a++;                     a++;

　　但编译器不会报错，因为前者实际是当a非零时，将a自增一；后者实际是当a为零时，将a自增一。还应注意，由于复合语句也是语句，因此：

    if( a ){ long c = 0; c++; }

　　由于使用了复合语句，因此这个判断语句并不是以“;”结尾，但它依旧是一个单句，即：

    if( a )
        if( a < 10 ) { long c = 0; c++; }
    else
        b *= a;

　　上面虽然看起来很复杂，但依旧是一个单句，应该注意当写了一个“else”时，编译器向上寻找最近的一个“if”以和其匹配，因此上面的“else”是和“if( a < 10 )”匹配的，而不是由于上面那样的缩进书写而和“if( a )”匹配，因此b *= a;只有在a大于等于10的时候才执行，而不是想象的a为零的时候。

　　还应注意前面书写的if( a ) long c;。这里的意思并不是如果a非零，就定义变量c，这里涉及到作用域的问题，将在下篇说明。

　　switch 这个语句的定义或多或少地是因为实现的原因而不是和“if else”一样由于逻辑的原因。先来看它的格式：switch(<整型数字>)<语句>。

　　上面的<整型数字>和if语句一样，只要是一个数字就可以了，但不同地必须是整型数字（后面说明原因）。然后其后的<语句>与前相同，只要是语句就可以。在<语句>中，应该使用这样的形式：case <整型常数1>:。它在它所对应的位置定义了一个标号，即前面goto语句使用的东西，表示如果<整型数字>和<整型常数1>相等，程序就跳转到“case <整型常数1>:”所标识的位置，否则接着执行后续的语句。

    long a, b = 3;
    switch( a + 3 )
    case 2: case 3: a++;
    b *= a;

　　上面就表示如果a + 3等于2或3，就跳到a++;的地址，进而执行a++，否则接着执行后面的语句b *= a;。这看起来很荒谬，有什么用？一条语句当然没意义，为了能够标识多条语句，必须使用复合语句，即如下：

    long a, b = 3;
    switch( a + 3 )
    {
        b = 0;
    case 2:
        a++;     // 假设地址为3003
    case 3:
        a–;     // 假设地址为3004
        break;
    case 1:
        a *= a; // 假设地址为3006
    }
    b *= a;      // 假设地址为3010

　　应该注意上面的“2:”、“3:”、“1:”在这里看着都是整型的数字，但实际应该把它们理解为标号。因此，上面检查a + 3的值，如果等于1，就跳到“1:”标识的地址，即3006；如果为2，则跳转到3003的地方执行代码；如果为3，则跳到3004的位置继续执行。而上面的break;语句是特定的，其放在switch后接的语句中表示打断，使程序跳转到switch以后，对于上面就是3010以执行b *= a;。即还可如此：

    switch( a ) if( a ) break;

　　由于是跳到相应位置，因此如果a为-1，则将执行a++;，然后执行a–;，再执行break;而跳到3010地址处执行b *= a;。并且，上面的b = 0;将永远不会被执行。

　　switch表示的是针对某个变量的值，其不同的取值将导致执行不同的语句，非常适合实现状态的选择。比如用1表示安全，2表示有点危险，3表示比较危险而4表示非常危险，通过书写一个switch语句就能根据某个怪物当前的状态来决定其应该做“逃跑”还是“攻击”或其他的行动以实现游戏中的人工智能。那不是很奇怪吗？上面的switch通过if语句也可以实现，为什么要专门提供一个switch语句？如果只是为了简写，那为什么不顺便提供多一些类似这种逻辑方案的简写，而仅仅只提供了一个分支选择的简写和后面将说的循环的简写？因为其是出于一种优化技术而提出的，就好象后面的循环语句一样，它们对逻辑的贡献都可以通过if语句来实现（毕竟逻辑就是判断），而它们的提出一定程度都是基于某种优化技术，不过后面的循环语句简写的成分要大一些。

　　我们给出一个数组，数组的每个元素都是4个字节大小，则对于上面的switch语句，如下：

    unsigned long Addr[3]; Addr[0] = 3006; Addr[1] = 3003; Addr[2] = 3004;

　　而对于switch( a + 3 )，则使用类似的语句就可以代替：goto Addr[ a + 3 – 1 ];

　　上面就是switch的真面目，应注意上面的goto的写法是错误的，这也正是为什么会有switch语句。编译器为我们构建一个存储地址的数组，这个数组的每个元素都是一个地址，其表示的是某条语句的地址，这样，通过不同的偏移即可实现跳转到不同的位置以执行不同的语句进而表现出状态的选择。

　　现在应该了解为什么上面必须是<整型数字>了，因为这些数字将用于数组的下标或者是偏移，因此必须是整数。而<整型常数1>必须是常数，因为其由编译时期告诉编译器它现在所在位置应放在地址数组的第几个元素中。

　　了解了switch的实现后，以后在书写switch时，应尽量将各case后接的整型常数或其倍数靠拢以减小需生成的数组的大小，而无需管常数的大小。即case 1000、case1001、case 1002和case 2、case 4、case 6都只用3个元素大小的数组，而case 0、case 100、case 101就需要102个元素大小的数组。应该注意，现在的编译器都很智能，当发现如刚才的后者这种只有3个分支却要102个元素大小的数组时，编译器是有可能使用重复的if语句来代替上面数组的生成。

　　switch还提供了一个关键字——default。如下：

    long a, b = 3;
    switch( a + 3 )
    {
    case 2:
        a++;
        break;
    case 3:
        a += 3;
        break;
    default:
        a–;
    }
    b *= a;

　　上面的“default:”表示当a + 3不为2且不为3时，则执行a–;，即default表示缺省的状况，但也可以没有，则将直接执行switch后的语句，因此这是可以的：switch( a ){}或switch( a );，只不过毫无意义罢了。

　循环语句——for、while、do while

　　刚刚已经说明，循环语句的提供主要是出于简写目的，因为循环是方法描述中用得最多的，且算法并不复杂，进而对编译器的开发难度不是增加太多。

　　for 其格式为for(<数字1>;<数字2>;<数字3>)<语句>。其中的<语句>同上，即可接单句也可接复合语句。而<数字1>、<数字2>和<数字3>由于是数字，就是表达式，进而可以做表达式语句能做的所有的工作——操作符的计算。for语句的意思是先计算<数字1>，相当于初始化工作，然后计算<数字2>。如果<数字2>的值为零，表示逻辑假，则退出循环，执行for后面的语句，否则执行<语句>，然后计算<数字3>，相当于每次循环的例行公事，接着再计算<数字2>，并重复。上面的<语句>一般被称作循环体。

　　上面的设计是一种面向过程的设计思想，将循环体看作是一个过程，则这个过程的初始化（<数字1>）和必定执行（<数字3>）都表现出来。一个简单的循环，如下：

    long a, b;
    for( a = 1, b = 1; a <= 10; a++ )
        b *= a;

　　上面执行完后b是10的阶乘，和前面在说明if语句时举的例子相比，其要简单地多，并且可读性更好——a = 1, b = 1是初始化操作，每次循环都将a加一，这些信息是goto和if语句表现不出来的。由于前面一再强调的语句和数字的概念，因此可以如下：

    long a, b = 1;
    for( ; b < 100; )
        for( a = 1, b = 1; a; ++a, ++b )
            if( b *= a )
                switch( a = b )
                {
                case 1:
                    a++; break;
                case 2:
                    for( b = 10; b; b– )
                    {
                        a += b * b;
                        case 3: a *= a;
                    }
                    break;
                }

　　上面看着很混乱，注意“case 3:”在“case 2:”后的一个for语句的循环体中，也就是说，当a = b返回1时，跳到a++;处，并由于break;的缘故而执行switch后的语句，也就是if后的语句，也就是第二个for语句的++a, ++b。当返回2时，跳到第三个for语句处开始执行，循环完后同样由break;而继续后面的执行。当返回3时，跳到a *= a;处执行，然后计算b–，接着计算b的值，检查是否非零，然后重复循环直到b的值为零，然后继续以后的执行。上面的代码并没什么意义，在这里是故意写成这么混乱以进一步说明前面提过的语句和数字的概念，如果真正执行，大致看过去也很容易知道将是一个死循环，即永远循环无法退出的循环。

　　还应注意C++提出了一种特殊语法，即上面的<数字1>可以不是数字，而是一变量定义语句，即可如此：for( long a = 1, b = 1; a < 10; ++a, ++b );。其中就定义了变量a和b。但是也只能接变量定义语句，而结构定义、类定义及函数定义语句将不能写在这里。这个语法的提出是更进一步地将for语句定义为记数式循环的过程，这里的变量定义语句就是用于定义此循环中充当计数器的变量（上面的a）以实现循环固定次数。

　　最后还应注意上面写的<数字1>、<数字2>和<数字3>都是可选的，即可以：for(;;);。

　　while 其格式为while(<数字>)<语句>，其中的<数字>和<语句>都同上，意思很明显，当<数字>非零时，执行<语句>，否则执行while后面的语句，这里的<语句>被称作循环体。

　　do while 其格式为do<语句>while(<数字>);。注意，在while后接了“;”以表示这个单句的结束。其中的<数字>和<语句>都同上，意思很明显，当<数字>非零时，执行<语句>，否则执行while后面的语句，这里的<语句>被称作循环体。

　　为什么C++要提供上面的三种循环语句？简写是一重要目的，但更重要的是可以提供一定的优化。for被设计成用于固定次数的循环，而while和do while都是用于条件决定的循环。对于前者，编译器就可以将前面提过的用于记数的变量映射成寄存器以优化速度，而后者就要视编译器的智能程度来决定是否能生成优化代码了。

　　while和do while的主要区别就是前者的循环体不一定会被执行，而后者的循环体一定至少会被执行一次。而出于简写的目的，C++又提出了continue和break语句。如下：

    for( long i = 0; i < 10; i++ )
    {
        if( !( i % 3 ) )
            continue;
        if( !( i % 7 ) )
            break;
        // 其他语句
    }

　　上面当i的值能被3整除时，就不执行后面的“其他语句”，而是直接计算i++，再计算i < 10以决定是否继续循环。即continue就是终止当前这次循环的执行，开始下一次的循环。上面当i的值能被7整除时，就不执行后面的“其他语句”，而是跳出循环体，执行for后的语句。即break就是终止循环的运行，立即跳出循环体。如下：

    while( –i )                         do
    {                                    {
        if( i == 10 )                        if( i == 10 )
            continue;                            continue;
        if( i > 20 )                         if( i > 20 )
            break;                               break;
        // 其他语句                           // 其他语句
    }                                    }while( –i );
    a = i;                               a = i;

　　上面的continue;执行时都将立即计算—i以判断是否继续循环，而break;执行时都将立即退出循环体进而执行后继的a = i;。

　　还应注意嵌套问题，即前面说过的else在寻找配对的if时，总是找最近的一个if，这里依旧。

    long a = 0;
P1:
    for( long i = a; i < 10; i++ )
        for( long j = 0; j < 10; j++ )
        {
            if( !( j % 3 ) )
                continue;
            if( !( j % 7 ) )
                break;
            if( i * j )
            {
                a = i * j;
                goto P1;
            }
            // 其他语句
        }

　　上面的continue;执行后，将立即计算j++，而break;执行后，将退出第二个循环（即j的循环），进而执行i++，然后继续由i < 10来决定是否继续循环。当goto P1;执行时，程序跳到上面的P1处，即执行long i = a;，进而重新开始i的循环。

　　上面那样书写goto语句是不被推荐的，因为其破坏了循环，不符合人的思维习惯。在此只是要说明，for或while、do while等都不是循环，只是它们各自的用处最后表现出来好象是循环，实际只是程序执行位置的变化。应清楚语句的实现，这样才能清楚地了解各种语句的实际作用，进而明确他人写的代码的意思。而对于自己书写代码，了解语句的实现，将有助于进行一定的优化。但当你写出即精简又执行效率高的程序时，保持其良好的可读性是一个程序员的素养，应尽量培养自己书写可读性高的代码的习惯。

　　上面的long j = 0在第一个循环的循环体内，被多次执行岂不是要多次定义？这属于变量的作用域的问题，下篇将说明。

　　本篇的内容应该是很简单的，重点只是应该理解源代码编译成机器指令后，在执行时也放在内存中，故每条语句都对应着一个地址，而通过跳转语句即可改变程序的运行顺序。下篇将对此提出一系列的概念，并重点说明类型的意义。

用C++实现跨平台游戏引擎开发

岚焕 — Wed, 22 Feb 2006 04:05:00 +0000

　　你是否梦想写一部格斗游戏但却无从着手呢？是否你只因游戏开发好玩而对之感兴趣？本文我们将分析一个通用的跨平台游戏引擎，每个游戏开发新手都可以自由地使用它。

　　1. 3D游戏引擎的简短历史

　　在游戏开发中，从一开始就确定正确的开发平台是很重要的。是否你的游戏支持Windows，Linux和OS X?是否你的游戏开发只使用OpenGL就足够了？OpenGL是十九世纪九十年代初期设计的，起初只运行于价值约$25，000的Unix CAD工作站上，后来移植到Windows和其它一些低端平台上。与此同时，随着游戏工业的发展，图形加速器价格从$2,000剧跌到你今天看到的价值约$150的大众市场价格。

　　确实，许多人都会援引在1996年用OpenGL开发成功的革命性的游戏Quake，作为以上急速发展现象的直接的原因。然而，成功的Quake级的游戏开发标准要求更多：世界级音频支持，网络连接，用户输入设备支持，以及实时的管理能力等。既需要实现跨平台支持又能使游戏效果激动人心，要实现这样的解决方案最好建立一个体面的游戏开发站台。

　　2. 用于C++，Java和其它开发语言的简单DirectMedia层

　　对，历史就是这样有趣，但并不是每一部游戏都要做成Quake的克隆品。一直被业界许多人吹捧有着许多优点的选择是简单DirectMedia层(SDML)。这是一套跨平台的多媒体库，它提供对于音频，键盘，鼠标，游戏杆，OpenGL和2D视频帧缓冲的低级存取。SDML支持几乎我能想像出的每一个平台，包括Linux，Windows，所有的MacOS变异物，WinCE，Dreamcast还有另外一些操作系统。它被广泛应用于开发MPEG播放器，硬件仿真器，和许多流行的游戏，包括获奖的运行于Linux平台的Civilization:Call to Power。

　　SDML用C写成，但生来就与C++一起工作，已经绑定到了另外许多语言，包括Ada，Eiffel，Java，Lua，ML，Perl，PHP，Pike，Python和Ruby。SDML的应用环境简直就没有什么限制，而且它碰巧是我最喜爱的开源飞行模拟器GL-117(见图1)的开发引擎。事实上，513游戏的当前开发已经基于SDML引擎而且被注册到了SDML的主页。

图1.GL-117中的一个视图

　　3. 通道视觉效果演示程序

　　研究游戏引擎的最好方法是看一些示例程序代码。简单地看一下图2中用SDML实现的2D通道类型演示图，你就能发现你仅用几行代码所能完成的工作。你可以使用该实例作为一个保护屏程序，音乐可视化动画效果，等等。篇幅所限，我已经整理了实际的绘制代码。请跟随我的注释分析下面对SDML的工作原理的描述:

#include "Tunnel.h"
// SDL 相关变量定义
SDL_Surface *screen,*bBuffer,*Image;
SDL_Rect rScreen,rBuffer;
int main (int argc, char **argv)
{
　int flag = SDL_SWSURFACE;// 请求一个软件表面.
　//软件表面处于系统内存中，
　// 一般不如硬件表面速度快
　#ifdef WIN32
　int fullscreen = MessageBox(NULL, "Show Full Screen (y/n):","Screen Setting", MB_YESNO);
　if (fullscreen==IDYES) {
　　flag |= SDL_FULLSCREEN; // 如果用户需要，接管整个屏幕
　}
　#endif
　Tunnel_Timer(); // 读取起始的系统时钟值
　SDL_Init( SDL_INIT_VIDEO ); // 初始化视频子系统
　//把屏幕设置到 320×240，32位颜色
　screen = SDL_SetVideoMode( 320, 240, 32, flag);
　// 如果可用的话，为屏幕表面请求硬件缓冲
　bBuffer = SDL_CreateRGBSurface( SDL_HWSURFACE, screen->w,screen->h,screen->format->BitsPerPixel,
　　　　screen->format->Rmask,
　　　　screen->format->Gmask,
　　　　screen->format->Bmask,
　　　　screen->format->Amask);
　// 这是种子图像，一旦开始它就会盘旋起来
　Image = SDL_LoadBMP( "tunnel_map.bmp" );
　Image = SDL_ConvertSurface(Image, screen->format, SDL_HWSURFACE);
　rBuffer.x = 0;
　rBuffer.y = 0;
　rBuffer.w = bBuffer->w;
　rBuffer.h = bBuffer->h;
　// 忽视大多数事件, 包括鼠标动作，并取消光标
　SDL_EventState(SDL_ACTIVEEVENT, SDL_IGNORE);
　SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
　SDL_ShowCursor( SDL_DISABLE );
　Tunnel.Set( 320, 240 ); // 通道将填充整个的缓冲区
　Tunnel.Precalc( 16 ); //内部的圆圈直径
　while (SDL_PollEvent(NULL)==0) {
　　float fTime = Tunnel_GetTime();
　　//在修改前，必须锁定表面，特别当缓冲区处于图形硬件内存中时
　　SDL_LockSurface(bBuffer);
　　SDL_LockSurface(Image);
　　Tunnel.Draw(bBuffer, Image, 180*sin(fTime), fTime*100);
　　SDL_UnlockSurface(bBuffer); // 在更新以后你可以开锁
　　SDL_UnlockSurface(Image);
　　// 把缓冲区中的数据输出到屏幕绘图区域并强迫进行重画
　　SDL_BlitSurface( bBuffer, NULL, screen, &rBuffer );
　　SDL_UpdateRect( screen, 0, 0, 0, 0 );
　}
　Tunnel.Free();
}

图 2. 演示旋转和扭曲的2D通道

　　4. 对另外一些游戏引擎的探索

　　让我们看一下另外一些开源的游戏引擎。

　　a) ALLEGRO(Allegro低级游戏开发例程)

　　Allegro是一个开源的可移植的库，主要针对视频游戏和多媒体编程。Allegro由Shawn Hargreaves(近来称为Climax)创建，现在成长为一个能够跨越许多操作系统如Linux，Windows，MacOS，MS-DOS和许多另外的流行平台等的游戏系统。

　　除了具有一个高级的2D图形库，它能容易地存取鼠标，键盘，游戏杆和高精度定时器中断。Allegro并没有包装或替换OpenGL，但是通过参观他们广阔的开发站点(http://www.allegro.cc/)，你能学习怎样把OpenGL集成到Allegro游戏程序中。

　　大约有700种不同的游戏工程，与Allegro一起发行，其中最为杰出的两类是街机游戏和谜题游戏。我特别地喜欢经典的街机游戏Zaxxon(见图3)的重制品。

图3.酷毙的Zaxxon的重制品

　　b) Irrlicht:点燃快速实时的3D引擎

　　这个Irrlicht 引擎是一个跨平台，高性能实时引擎，用C++写成。你可以选择Direct3D，OpenGL或基于软件的着色技术。高端特点包括动态阴影，粒子系统，人物动画，进门和出门技术和碰撞检测(见图4)。Irrlicht支持Windows和Linux并提供到语言Java，Perl，Ruby等的绑定。业界先驱Nikolaus Gebhardt在他的朋友的少部分帮助下完成的这个引擎工。

图4.在Irrlicht中的一个十分逼真的场景

　　c) ClanLib:为多玩家游戏设计的引擎

　　ClanLib提供了一个平台独立的接口来书写游戏-它们有一个共同的到低级库如DirectX和OpenGL的接口。借助于ClanLib，你只需编写少量代码即可在Windows，Linux和OSX系统上开发游戏程序。ClanLib包括一个广泛的声音库，2D碰撞检测，动画，GUI框架和网络库。图5显示了游戏XenoHammer中的一个场景。

图5.XenoHammer屏幕快照

用C++实现跨平台游戏开发之Allegro引擎

岚焕 — Wed, 22 Feb 2006 04:03:00 +0000

要：本文重点讨论开源游戏开发库Allegro(Allegro低级游戏例程)，同时涉及到一些深度技术并提供了一个简单的示例程序，帮你进一步确定它是否是适合你的开发平台。

　　一、一个适于多环境的引擎

　　Allegro最开始被研发于八十年代后期古老的Atari ST平台上，随后被快速地移植到流行的DJGPP环境（一个在九十年代早期流行的32位的MS-DOS扩展程序）。此后，Allegro被移植到最为流行的Windows C++开发环境中，包括VS，MinGW，Cygwin和Borland C++。另外的支持它的平台包括Linux，BeOS，QNX，Mac OSX以及几乎任何其它带有X11库的Unix平台上。

　　Allegro能着色到各种类型的位图和硬件加速的环境中，例如DirectX，XWindows，SVGAlib，FreeBE/AF，CGDirectDisplay，QuickDraw，等等。Allegro并不想提供它自己的3D环境或模拟器，但是OpenGL可以被容易地集成，这是通过使用AllegroGL库-它提供了一个类似于GLUT的接口（包括扩展管理）-实现的。

　　二、性能概要

　　在进一步使用API开发前，让我们看一下Allegro提供的总体功能：

　　·具体到像素级的绘图函数，包括平坦阴影，gouraud阴影，纹理贴图，z缓冲的多边形和圆绘制，填充，贝塞尔样条曲线，图案填充，精灵，blitting（位图复制），位图计算缩放和旋转，半透明/光效果以及比例字体支持的文本输出

　　·FLI/FLC（在计算机生成的动画方面，这种格式比MPEG有更高的压缩性能）动画播放器

　　·播放后台MIDI音乐，可达64种同时的声音效果，并能录制样本波形和MIDI输入(声音平台支持，包括WaveOut，DirectSound，OSS，ESD，CoreAudio和QuickTime，等等)

　　·容易地存取鼠标，键盘，游戏杆等设备，还支持高分辨率定时器中断，包括一个DOS版本的垂直折回中断模拟器

　　·读/写LZSS压缩文件的例程

　　·数学函数，包括定点算术，表查找和3D矢量/矩阵/四元数操作

　　·GUI对话框管理器和文件选择器

　　·内建地支持16位和UTF-8格式的Unicode字符

　　三、使用引擎

　　使用Allegro进行开发，就象在许多其它游戏场合下一样，游戏的总体结构都包括游戏开始前的初始化，游戏循环以及游戏完成后的清理。初始化意味着既包含Allegro启动代码也包含在开始的位置实现基本地装载或生成你的游戏级别。在创建你的初始化代码时，启动Allegro基本上没有什么代价付出(见图1).

　　如果你需要很多屏幕相关的真实性能，建议你首先礼貌地用get_gfx_mode_list()函数查询一下最大可用方式：

#include //必须放于系统头文件的引用之后
set_color_depth(32); // 缺省情况下使用8位颜色
if (set_gfx_mode(GFX_AUTODETECT, 640, 480, 0, 0) != 0) {
　abort_on_error("Couldn’t set a 32 bit color resolution");
}

　　set_gfx_mode()的最后两个参数用于指定虚拟缓冲区的大小-我们的图形屏幕存储于其中。这可以使创建一个卷边游戏-其中地形是连续移动的-变得容易。例如，你可能要使虚拟缓冲区，比方说，宽出20%以留出足够的空间来平滑卷动新的精灵和地形。

　四、一个完整的Allegro实例

　　本教程将使用Kee-Yip Chan的SnookerClone演示程序，它是基于James Lohr的另一个具有相同名字的演示程序。图1显示了演示程序的基本屏幕快照。

图1.Kee-Yip Chan的"SnookerClone"演示程序

　　这个工程向你展示了许多不同的Allegro技术，包括动画，键盘输入和鼠标输入，碰撞和游戏物理知识(例如重力)。它利用了三个主要的元素:一个有8个扶手的旋转的车轮，一个用箭头键来控制的大红球，还有一些从顶部往下坠落的蓝球。车轮以接触方式推动红球，而当红球碰上蓝球时，它们之间相互影响。

　　下列是完整的Allegro演示程序的代码:

1 #include
2 vector g_points; //aka球上点的列表
3 vector g_joints; //物理对象列表，如车轮和缓冲器
4 kVec g_accControl;
6 int main(void)
7 {
8 　allegro_init(); // 初始化allegro.
9 　install_keyboard(); // 启动键盘.
10　install_mouse(); // 启动鼠标.
11　install_timer(); //过程show_mouse()所需要;
13　// 创建一个800×600的非全屏窗口.
14　set_gfx_mode(GFX_AUTODETECT_WINDOWED, 800, 600, 0, 0);
16　set_window_title("Kee-Yip Chan’s Snooker Clone");
17　text_mode(-1); // 文本将被画在透明的背景之上
19　BITMAP* buffer = create_bitmap(SCREEN_W, SCREEN_H);
　　//创建一张位图用于双缓冲.
21　 // 初始化数据.
22 create_joints(g_joints); //注册车轮、地板和缓冲器的硬编码的屏幕位置
25 // 创建顶点以组成aka球：玩家所用球和三个蓝球
26 // 的位置, 速度, 大小和质量.
27 g_points.push_back(Point(kVec(100, 300),kVec(0, 0),16, 10));
// 玩家.
28 g_points.push_back(Point(kVec(50, 40), kVec(0, 0),12, 5));
// 中等的球.
29 g_points.push_back(Point(kVec(80, 40), kVec(0, 0) 12, 5));
//中等的球.
30 g_points.push_back(Point(kVec(110, 40),kVec(0, 0),6, 1));
// 小球.
32 //主循环,在按ESC键后退出
33 while(!key[KEY_ESC]) { //检查输入.
34 　if(key[KEY_UP])
35 　　g_accControl.y = -0.07; //Jet pack.向上加速
36 　if(key[KEY_LEFT])
37 　　g_accControl.x = -0.07; //左走.向左加速
38 　if(key[KEY_RIGHT])
39 　　g_accControl.x = 0.07; //右走.向右加速
41 　　static bool leftMousePressed = false,
　　　　rightMousePressed = false;
42 　if(mouse_b & 1) { //鼠标左键按下
43 　　if(!leftMousePressed){
44 　　　leftMousePressed = true; // 创建一个新球.
45 　　　g_points.push_back(Point(kVec(mouse_x, mouse_y),kVec(0, 0), 12, 5));
46 　　}
47 　}
48 　if(!(mouse_b & 1))
49 　//保证不重复鼠标按键
50 　//否则,就会出现许多的新球
51 　leftMousePressed = false;
52 　if(mouse_b & 2) { //鼠标右键按下
53 　　if(!rightMousePressed){
54 　　　rightMousePressed = true; // 创建一个新球
55 　　　g_points.push_back(Point(kVec(mouse_x, mouse_y),kVec(0, 0), 6, 1));
56 　　}
57 　}
58 　if(!(mouse_b & 2))
59 　　//保证不重复鼠标按键
60 　　//否则,就会出现许多的新球.
61 　　rightMousePressed = false;
63 　　doPhysics();
65 　　// 着色:如果我们能再次使用缓冲区，则清除它;
　　　　//否则,旧图像将滞留显示
66 　　//用白色进行清除.
67 　　clear_to_color(buffer, makecol(255, 255, 255));
68 　　for(unsigned i = 0; i < g_points.size(); i++) {
　　　　　//画点.
69 　　　//画一个实心球
70　　　 circlefill(buffer, //画向缓冲区
71　　　 g_points[i].position.x,g_points[i].position.y,// aka 球的中心点的位置
72　　　 g_points[i].size, // 半径.
73　　　 (i == 0) ? makecol(255, 0, 0) : makecol(0, 0, 255)); //红色如果是玩家;否则为蓝色
75 　　　// 画一个轮廓球.
76　　　 circle(buffer, //画向缓冲区
77　　　　 g_points[i].position.x,g_points[i].position.y, // aka 球的中心点的位置.
78　　　　 g_points[i].size, // 半径.
79　　　　 makecol(0, 0, 0)); //红色如果是玩家;否则为蓝色.
81 　　}
83　　 // 画接合点
84　　 for (unsigned i = 0; i < g_joints.size(); i++)
85　　　 line(buffer, //画向缓冲区
86　　　　 g_joints[i].p1.x, g_joints[i].p1.y, // 点 1.
87 　　　　g_joints[i].p2.x, g_joints[i].p2.y, // 点 2.
88 　　　　makecol(0, 0, 0)); // 黑颜色.
89 　　　);
91 　　// 打印指令.
92　　 textout(buffer, font, "Left Mouse Button – new big ball Right Mouse Button – new small ball",
93 　　　　125, 1, makecol(0, 0, 0));
95 　　textout(buffer, font, "Arrow Keys – move red ball",
96　　　　 300, 592, makecol(0, 0, 0));
98　　 show_mouse(buffer); // 画鼠标光标.
100　　 draw_sprite(screen, buffer, 0, 0);// 把缓冲区中的数据画向屏幕.
101 　} // while循环结束
103 　return 0;
105 }END_OF_MAIN();

　　33-101行包括了典型的游戏编程循环模式。游戏继续进行直到玩家按下ESC键退出为止。34-39行支持同时进行的键盘输入，因为你可以按下向上和向左箭头键来获取粗略的斜向运动。

　　在41-61行,鼠标动作被捕获到全局变量mouse_b(用于按钮)，mouse_x和mouse_y。如果你一直在使用一滚轮鼠标，你还可以使用变量mouse_z。我们对反向弹跳逻辑进行了一点硬编码以确保每次鼠标按下事件只有一个球下落。

　　第63行调用doPhysics()，其目的是旋转车轮的线段，更新球位置，检测球碰撞和适当地改变它们的方向矢量。这个模块(350行的数学代码)有点深入了些，但它确实是一个一流的实现，值得你深入研究。

　　余下的代码，65-101行，开始着色，在典型的示例程序中这属于常规实现部分。这里的着色用典型的双缓冲区技术，下一次屏幕变化被计算出来并进行脱屏绘制并在最的一毫秒进行缓冲交换(第100行)。这确保了视觉的连续性又减少了烦人的闪烁-对象看上去是随机地绘制的。在着色代码部分，对line()和circlefill()的调用是相当直接的：circlefill()以x，y，半径和填充颜色作为参数。

　　textout_ex()函数的功能稍强于textout()(示于92-96行)，允许你指定前景和背景颜色。Allegro提供例程以直接从GRX格式.fnt文件，8×8或8×16 BIOS格式.fnt文件，位图图象以及数据文件格式中装入字体。作为选择，你能导入一种大范围的Unicode字体，这可以通过写一个.txt脚本-它为每一范围的字符指定相应的不同的源文件-来实现。如果你想要支持TrueType，那么你需要AllegroTTF或相同功能的插件。
最后，在第100行的draw_sprite()实现一个覆盖性复制新生成的位图到第14行创建的屏幕对象上。覆盖性复制意指只有非透明的颜色像素被复制。在本例中，我确信它已被退化成一个"blit"(块复制)转储。

　　五、 Allegro的音频

　　这个snooker演示程序只涉及到了一些最基本的图形和I/O函数，但是并没有用到Allegro的音频开发包。该包中的MIDI混频，音响效果和录音API，其效果达到或超过几乎每一个我所见过的专业的声音库。Allegro音频应用软件大量存在，包括WinCab-一个MP3和OGG Vorbis音乐唱片机，还有LouTronic Rhythm Box-一个鼓声生成合成器，它具有可全面融合到一起的snare鼓，低音鼓和hi hat的效果。下面我们简单地回顾Allegro音频API的一小部分。

　　每一个使用音频的程序都应该调用reserve_voices()来指定数字和MIDI声音驱动程序分别使用的声音的数目。接下去，你能控制这些音频轨道的混合.

　　你可以非常容易地象下面这样插入一个音轨：

MIDI *midFile = load_midi("myfile.mid’);
play_midi(midFile, TRUE);//连续循环

　　对于更复杂的需要，你可以安装三个钩子函数之一，它们可以使你拦截MIDI玩家事件。如果被设置为非NULL，这些例程将在每次MIDI消息，元事件和系统独占的数据块中被分别调用。

　　Allegro的数字音频系统被设计为从最基本的配置到可高度扩展的。你能容易安装读取器和写入器来处理新的或者不同的音频文件类型，例如:

register_sample_file_type("mp3",load_mp3,NULL);//安装MP3读取器

　　当正播放数字音频时，你可以随时编辑它。下列代码改变将在播放一个样本参数时改变该样本(用于操作循环播放的声音):

void adjust_sample(const SAMPLE *spl, int vol, int pan, int freq, int loop);

　　你能改变音量，平移音频数据并清除循环标志，在下次执行到循环末尾时，这将停止该样本。如果在播放相同样本的好几个副本，这会调整它遇到的第一个副本。如果该样本没有播放，对它没有任何影响。

用C++实现跨平台游戏开发之Irrlicht引擎

岚焕 — Wed, 22 Feb 2006 04:02:00 +0000

　　Irrlicht引擎是一个用C++书写的高性能实时的3D引擎，可以应用于C++程序或者.NET语言中。通过使用Direct3D（Windows平台），OpenGL 1.2或它自己的软件着色程序，可以实现该引擎的完全跨平台。尽管是开源的，该Irrlicht库提供了可以在商业级的3D引擎上具有的艺术特性，例如动态的阴影，粒子系统，角色动画，室内和室外技术以及碰撞检测等(见图1)。

图1.Irrlicht 3D引擎

　　Irrlicht是一个德国神话故事中的一种动物的名字，它能够发光和飞翔，可以在大部分的沼泽地附近发现它。单词"Irrlicht"是两个德国单词（"irr"意思是疯狂的；而"Licht"意思是光）的组合。在英语中，它被译为"鬼火"。

　　Irrlicht十分幸运地为一个巨大的活跃的开发团队以大量的工程所支持。然而，因为Irrlicht主要由游戏名家Nikolaus Gebhardt所设计，所以该游戏在设计上十分连贯。你可以在网上到处发现有Irrlicht的增强程序，如可选用的地形生成器，入口生成器，输出器，world层生成器，相关教程和编辑器等。而且，它独立地创建了到Java，Perl，Ruby，BASIC，Python，LUA甚至更多种语言的绑定。而最为重要的是，它是完全自由的。

　　二、 Irrlicht特性

　　在深入分析API之前，请让我更具体地介绍一下Irrlicht提供给了3D游戏开发者哪些功能：

　　·一个可以运行于Linux以及Windows 98，ME，NT，2000和XP（MacOS在计划之中）等操作系统之上的引擎

　　·针对Direct3D 8生成器或Direct3D 9生成器(可选)提供了Anti-aliasing支持

　　·可换肤的GUI环境(包括一个很酷的具有金属质地的带阴影的皮肤)，给一些老式的对话框加上漂亮的外观

　　·场景管理系统，它允许无缝的室内/室外过渡

　　·角色动画系统，带有骨骼和变形目标动画功能

　　·一个特殊的效果系统，包括粒子效果(雨，烟，火，雪，等等)，告示板，灯光贴图，环境，地图，模板缓冲区阴影，雾，纹理动画，视差贴图，凹凸贴图，还有更多

　　·内建的材质支持，包括支持Pixel and Vertex Shaders版本1.1到3.0，ARB Fragment and Vertex程序以及HLSL（GLSL正在计划中）

　　·.NET语言绑定，这使得引擎可用于所有的.NET语言例如C#，Visual Basic.NET以及Delphi.NET

　　·一内建的平台独立的软件生成器，特性有：z-缓冲，Gouraud阴影，alpha混合和透明性，还有快速的2D绘图(见图2)

　　·你久已期待的2D绘图功能，例如alpha混合，基于关键色的位图复制，字体绘制，以及混合3D与2D图形

　　·能直接导入常见的建模文件格式:Maya，3DStudio Max，COLLADA，DeleD，Milkshape，Quake 3 levels，Quake2 models，DirectX，Pulsar，My3DTools，FSRad以及Cartography Shop

　　·能直接从BMP，PNG，Photoshop，JPEG，Targa和PCX导入纹理

　　·快速而易用的碰撞检测与响应

　　·为快速的3D运算和容器模板库进行了优化处理

　　·直接读取档案(可能是压缩的，如.zip文件)

　　·集成了快速的XML分析器

　　·为实现容易的本地化开发提供Unicode支持

图2:基于Irrlicht的游戏Yet Another Space Shooter(YASS)，这里显示的是一个静态游戏帧中的令人吃惊的着色效果

　　三、在Irrlicht中的特殊效果

　　在本文的例子中，我将向你展示怎样使用模板缓冲区影子技术，还有粒子系统，告示板，动态光以及水表面场景结点等技术。参见图3。

图3.结合动态的光和水进行的场景着色

　　Irrlicht引擎自动地检查是否你的硬件支持模板缓冲；而如果不支持，则不启动阴影。在这个演示程序中，在方法createDevice()中的’shadows’标志被置位，以产生从一个动画角色投下的动态影子。如果这个实例程序在你的PC上运行太慢，可以把这个标志设置为false或者干脆再买一块更好些的图形加速卡。

　　为能够使用Irrlicht.DLL文件，你需要链接到Irrlicht.lib库文件。你可以在工程设置对话框中设置这个选项；但是为了容易实现，你可以使用一个pragma预编译注释命令。方法createDevice()负责实例化根对象-它使用引擎完成一切事情。参数如下:

　　·deviceType:设备类型。当前你可选取Null设备以及软设备，如DirectX8，DirectX9或OpenGL。

　　·windowSize:要创建的窗口的大小或全屏幕模式。这个例子中使用512×384。

　　·bits:每像素位数(当在全屏幕情况时)。仅允许值为16或者32。

　　·fullscreen:指定是否你想使设备运行于全屏幕方式。

　　·stencilbuffer:指定是否你想使用模板缓冲区以用于绘制阴影。

　　·vsync:指定是否你想启动vsync(仅在全屏幕情况)，可选。

　　·eventReceiver:一个接收事件的对象，可选。

　　为适合于本实例环境，你将装载一个3D Studio Max文件（一幢房子）。该房子看起来并没有什么特别的，但是Irrlicht引擎能为你创建一个相当酷的纹理贴图。只需使用造型操纵器并为之创建一个planar纹理贴图即可：

#include
#include
using namespace irr;
#pragma comment(lib, "Irrlicht.lib")
int main()
{
　//让我们假定用户在本例中使用OpenGL
　//当然，也可以指定DirectX 8, 9, 等等.
　video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;
　//创建设备，如果创建失败立即退出。
　IrrlichtDevice *device = createDevice(driverType,
　core::dimension2d(640, 480), 16, false, true);
　if (device == 0)
　　return 1;
　video::IVideoDriver* driver = device->getVideoDriver();
　scene::ISceneManager* smgr = device->getSceneManager();

　　我对从这个导入文件产生的发射光线颜色的效果并不满意。下列代码显示怎样实现这些步骤：

scene::IAnimatedMesh* mesh = smgr->getMesh("room.3ds");
smgr->getMeshManipulator()->makePlanarTextureMapping(
mesh->getMesh(0), 0.008f);
scene::ISceneNode* node = 0;
node = smgr->addAnimatedMeshSceneNode(mesh);
node->setMaterialTexture(0, driver->getTexture("wall.jpg"));
node->getMaterial(0).EmissiveColor.set(0,0,0,0);

　　四、水动画

　　你将添加的第一个特殊的效果是水动画。为此，WaterSurfaceSceneNode导入一个造型文件并使之象水表面一样地波动。如果你让这个场景结点使用一种相当好的材质如MT_REFLECTION_2_LAYER，那么它看起来相当酷：

mesh = smgr->addHillPlaneMesh("myHill",
core::dimension2d(20,20),
core::dimension2d(40,40), 0, 0,
core::dimension2d(0,0),
core::dimension2d(10,10));
node = smgr->addWaterSurfaceSceneNode(mesh->getMesh(0),3,300,30);
node->setPosition(core::vector3df(0,7,0));
node->setMaterialTexture(0,driver->getTexture("water.jpg"));
node->setMaterialTexture(1,driver->getTexture("stones.jpg"));
node->setMaterialType(video::EMT_REFLECTION_2_LAYER);

　　作为输入造型，你可以创建一个陡峭的平面造型，但是你也可以为此使用任何其它的造型。你甚至能重用room.3ds输入文件(它看上去确实很奇怪)。该实例还用一个普通的石头纹理模型来绘制所有另外的表面。

　　五、透明的告示板和灯光

　　第二个特殊的效果是很基本的但是非常有用:一个透明的告示板，伴之有一个动态的灯光。为产生这种效果，你只需要产生一个灯光场景结点，并让它四处飞行；而且，为了让它看起来更酷一些，可以把一个告示板场景结点依附到它上面：

//创建灯光
node = smgr->addLightSceneNode(0, core::vector3df(0,0,0),
video::SColorf(1.0f, 0.6f, 0.7f, 1.0f), 600.0f);
scene::ISceneNodeAnimator* anim = 0;
anim = smgr->createFlyCircleAnimator(core::vector3df(0,150,0),250.0f);
node->addAnimator(anim);
anim->drop();
// 把告示板依附到灯光
node = smgr->addBillboardSceneNode(node, core::dimension2d(50, 50));
node->setMaterialFlag(video::EMF_LIGHTING, false);
node->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR);
node->setMaterialTexture(0,driver->getTexture("particlewhite.bmp"));

　六、粒子系统

　　下面介绍的这个特别效果更有趣：一个粒子系统。在Irrlicht引擎中，粒子系统既是组件化的，也是可扩展的，但是仍然易于使用。你只需要简单地把粒子发射器放到一个粒子系统场景结点，这样以来粒子看上去没有产生源。这些发射器可以据需要进行灵活配置，并经常带有许多参数，如粒子方向，粒子数量，以及粒子颜色等。

　　当然，发射器类型有区别(例如，一个点发射器能够使粒子从一个固定的点上发出粒子)。如果该引擎提供的粒子发射器还不能满足你的要求，你可以容易地创建你自己的发射器。这只需简单地从IParticleEmitter接口派生一个新类并使用setEmitter()方法把它依附到粒子系统上去即可。

　　下一个实例将创建一个盒子粒子发射器。你可能已经猜出，它从一个跳跃的盒中随机生成粒子。由参数来定义盒子，粒子的方向，每秒产生粒子的最小和最大数目，颜色以及粒子的最小和最大生命周期。

　　一个完全由发射器组成的粒子系统将是令人生厌的，因为缺乏真实感。因此，Irrlicht支持粒子影响器-它负责在粒子到处飞扬时予以修整。一旦添加到粒子系统上，它们就能模仿另外的更真实的效果，象重力或风。在本例中的粒子影响器只是简单地修改粒子的颜色来产生一种淡出效果。

　　可能你已经猜出，粒子影响器是通过派生IParticleAffector接口实现的，然后通过使用addAffector()方法把它添加到粒子系统上去。在你为该粒子系统设置了一种好看的材质后，你就有了一个看上去相当酷的野外宿营火的效果。通过调整材质，纹理，粒子发射器，还有影响器参数，你能容易地创建烟雾，下雨，爆炸，下雪等效果：

scene::IParticleSystemSceneNode* ps = 0;
ps = smgr->addParticleSystemSceneNode(false);
ps->setPosition(core::vector3df(-70,60,40));
ps->setScale(core::vector3df(2,2,2));
ps->setParticleSize(core::dimension2d(20.0f, 10.0f));
scene::IParticleEmitter* em = ps->createBoxEmitter(
core::aabbox3d(-7,0,-7,7,1,7),
core::vector3df(0.0f,0.03f,0.0f),
80,100,
video::SColor(0,255,255,255), video::SColor(0,255,255,255),
800,2000);
ps->setEmitter(em);
em->drop();
scene::IParticleAffector* paf =ps->createFadeOutParticleAffector();
ps->addAffector(paf);
paf->drop();
ps->setMaterialFlag(video::EMF_LIGHTING, false);
ps->setMaterialTexture(0, driver->getTexture,"particle.bmp"));
ps->setMaterialType(video::EMT_TRANSPARENT_VERTEX_ALPHA);

　　七、影子投射

　　最后但也不容忽视一个问题是，你需要为一个动画角色产生一个动态的影子。为此，你装载一个Quake2.md2模型文件并把它放到你的world上去。为了创建影子，你只需要调用方法addShadowVolumeSceneNode()。你可能通过调用ISceneManager::setShadowColor()来控制影子的颜色；注意，这仅是全局可调整的，并影响所有的影子。好，下面就是你的产生动态影子效果的代码：

mesh = smgr->getMesh("../../media/faerie.md2");
scene::IAnimatedMeshSceneNode* anode = 0;
anode = smgr->addAnimatedMeshSceneNode(mesh);
anode->setPosition(core::vector3df(-50,45,-60));
anode->setMD2Animation(scene::EMAT_STAND);
anode->setMaterialTexture(0, driver->getTexture("../../media/Faerie5.BMP"));
anode->addShadowVolumeSceneNode();
smgr->setShadowColor(video::SColor(220,0,0,0));

　　八、游戏循环

　　最后，你能进入由device->run()方法控制的游戏循环。该循环将不断运行，直到通过获取一个关闭窗口事件(例如在Windows操作系统下的ALT-F4击键)来退出设备。你必须在一个beginScene()和endScene()命令对之间绘制每样东西。beginScene()用指定的一种颜色清屏，如果需要的话，可以同时清除深度缓冲区。然后你就可以让场景管理器和GUI环境来绘制它们的内容。随着调用endScene()，每一样东西都被绘制到屏幕上去。在本例中，你还可以动态地在标题栏上显示帧每秒（FPS）数，这对于严肃的游戏开发者是十分重要的事情：

scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS();
camera->setPosition(core::vector3df(-50,50,-150));
int lastFPS = -1;
while(device->run())
{
　driver->beginScene(true, true, 0);
　smgr->drawAll();
　driver->endScene();
　int fps = driver->getFPS();
　if (lastFPS != fps)
　{
　　core::stringw str = L"Campfire FX example [";
　　str += driver->getName();
　　str += "] FPS:";
　　str += fps;
　　device->setWindowCaption(str.c_str());
　　lastFPS = fps;
　}
}
device->drop();

　　结束循环后，你必须删除先前用createDevice()方法创建的Irrlicht设备。通过使用Irrlicht引擎，你应该删除所有你用以’create’开头的方法或函数创建的所有对象。你可以通过简单地调用device->drop()来删除该设备对象。

　　九、你可能喜欢的Irrlicht插件

　　正如在前面所介绍的，Irrlicht有一群勤奋的独立开发人员并为之产生了大量的插件，也用之开发了相当多的游戏。这些开发者中提出的许多的改进被再次集成到Irrlicht的随后的发行版本中。下面我列举其中的几个例子，我想这会吸引许多颇有前程的开发者感兴趣：

　　·OCTTools，是一套用于Irrlicht的工具，由Murphy McCauley所创建，用于操作OCT文件相关的:输出器，加载器，甚至更多。

　　·ICE(Irrlicht通用引擎)是一个开发框架，它提供了一个工程的轮廓实现，从而加快了新工程的开发。

　　·MIM，由Murphy McCauley所创建，是一个非常有用的基于XML的文件格式，可用于Irrlicht的加载器，转换器及其各种工具。

　　·My3D是一个开发工具包，它能够使你把来自于各种3D包(3DStudio MAX，Giles，等等)中的灯光贴图场景直接输出到Irrlicht中。

　　·Dusty引擎允许程序员创建"任务"-这些"任务"可以完成程序员想做的任何事情。之后，这些任务被添加到一棵普通的任务树上去，而每个任务可以有它们希望数目的孩子任务。任务"组"允许游戏设计者在一棵完整的树上执行普通的操作，例如暂停，继续或破坏等。

　　·Irrlicht RPG(Erring Light)是一个3D 绕行走游戏引擎，最初是针对RPG类游戏开发的。

　　·2 D 图像和精灵类组成了一个很有用的库，它扩展了Irrlicht的2D能力。

　　·Zenprogramming站点，提供第一个针对Irrlicht的非正式的外部地形生成器，此处也提供很多相关的教程。

C++跨平台游戏开发之ClanLib SDK

岚焕 — Wed, 22 Feb 2006 03:59:00 +0000

　一、简介

　　ClanLib是一个主要针对游戏开发者的跨平台C++框架。尽管API主要为游戏开发设计，你照样可以容易地使用ClanLib来开发一个科学的3D可视化工具或多媒体应用程序(例如Gecko多媒体系统)。

　　ClanLib拥有各种API-2D和3D图形，声音，网络，I/O，输入，GUI以及资源管理。它还提供透明的OpenGL支持，因此你可以使用本机OpenGL命令而让ClanLib处理依赖于操作系统的窗口管理和其它一切事情。ClanLib通过DirectX或简单的Direct Media Layer(一平台独立的多媒体库)生成2D图形。ClanLib游戏主页上列举了约50多个开发非常成功的游戏，包括以2D和3D形式完成的难题、策略以及射手类游戏。例如，Asteroid Arena(见图1)使用了ClanLib和OpenGL技术，实现了胜人一筹的经典街机游戏。

图1.Asteroid Arena屏幕快照

　　ClanLib可以工作在Windows，Linux和MacOS操作系统之上，并且提供源码级的zip或tar文件支持。Windows开发者可以使用微软Visual Studio，Borland C++或者MinGW(小型GNU for Windows)编译器和环境。第三方的对于Ruby和Perl语言的绑定支持也是可用的。可选的特效程序包括一个Lua插件(流行的小脚本编程语言)和FreeType(一个免费的TrueType字体库)。

　　二、 ClanLib特征集

　　在具体使用API之前，让我们看一下ClanLib的主要特征:

　　·基本跨平台运行时刻库(GUI，多线程，文件I/O，等等)

　　·基于模板的C++信号/槽库(类型安全的回调/代理)

　　·综合的资源管理

　　·声音混合器支持。WAV文件，Ogg Vorbis，以及由MikMod库(MOD，S3M，XM，等等)支持的任何类型文件

　　·文档对象模型(DOM)XML分析器支持

　　·高级2D图形API，支持OpenGL，DirectX和SDL作为着色目标

　　·高性能的批量着色引擎，当用OpenGL着色2D时

　　·2D碰撞检测

　　·2D精灵动画支持

　　·高度可定制的GUI框架

　　·从低级到高级的网络库接口

　　三、 ClanLib基本的游戏模型

　　现在，让我们仔细分析一下ClanLib API模型。我发现最好的教程是一个完全自解释的示例程序。具体地，让我们分析一下Luke Worth的盒子游戏，这是一个有两个玩家的纸和铅笔游戏(见图2)。这个盒子游戏包含一些格子点，在任意两点间玩家都可以画线。谁用最后一条线画成一个封装的矩形，谁就得一分，并进入到下一轮中。

图2.一个进行中的盒子游戏，得分情况是蓝8/红3

　　我特意使程序的main函数尽可能简短，这样我们可能集中注意力于高亮处的"游戏循环"：

1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8
9 const int boardsize = 6, spacing = 50, border = 20;
10 const int numsquares = int(pow(float(boardsize – 1), 2));
11
12 enum coloursquare { off, blue, red };
13 struct cursor {
14 　int x, y;
15 　bool vert;
16 };
17
18 class Boxes: public CL_ClanApplication {
19 　bool ver[boardsize][boardsize - 1];
20 　bool hor[boardsize - 1][boardsize];
21 　coloursquare squares[boardsize - 1][boardsize - 1];
22 　bool redturn;
23 　bool fullup;
24 　cursor curs;
25
26 　void inputHandler(const CL_InputEvent &i);
27 　bool findsquares(void);
28 　inline int numaroundsquare(int x, int y);
29 　void init();
30 　void drawBoard();
31 　void endOfGame();
32
33 public:
34 　virtual int Boxes::main(int, char **);
35 } app;
36
37 using namespace std;
40
41 int Boxes::main(int, char **)
42 {
43 　int winsize = spacing * (boardsize – 1) + border * 2;
44 　try {
45 　　Boxes::init();
46 　　while (!CL_Keyboard::get_keycode(CL_KEY_ESCAPE)) {
47 　　　Boxes::drawBoard();
48 　　　if (fullup) break;
49 　　　　CL_System::keep_alive(20);
50 　　}
51 　　Boxes::endOfGame();
52
53 　　CL_SetupVorbis::deinit();
54 　　CL_SetupSound::deinit();
55 　　CL_SetupGL::deinit();
56 　　CL_SetupDisplay::deinit();
57 　　CL_SetupCore::deinit();
58 　}
59 　catch (CL_Error err) {
60 　　std::cout << "Exception caught: "<< err.message.c_str() << std::endl;
61 　}
62
63 　return 0;
64 }

　　关于这个应用程序，应注意的第一事情是main()函数(见行41)并不是一个最顶层的函数，而是嵌入到一个从CL_ClanApplication派生的对象中。该对象封装了不少难以避免的平台依赖性-这可能包含一个传统的::main()实现(例如在Win32应用程序中必须使用WinMain())。

　　而且还应注意，事实上所有的可执行的代码(行43-58)被封装在一个try{}/catch{}异常处理器块中。如果需要的话，ClanLib将引发异常，你可以重启一游戏,等等。基本上，所有的游戏逻辑包含在init()，drawBoard()，endOfGame()和inputHandler()这几个方法中。如果board不再移动(fullup==true)，则退出游戏循环(行48)。CL_System::keep_alive()更新所有的输入和系统事件(象关闭窗口或者移动它)。这在老式的Win16 API ::Yield()或者Linux上的sleep()中将会释放CPU周期。

66 void Boxes::init()
67 {
68 　CL_SetupCore::init();
69 　CL_SetupDisplay::init();
70 　CL_SetupGL::init();
71 　CL_SetupSound::init();
72 　CL_SetupVorbis::init();
73
74 　CL_DisplayWindow window("Boxes", winsize, winsize);
75 　CL_SoundOutput output(44100); //选择44Khz采样
76
77 　CL_Surface *cursimg = new CL_Surface("cursor.tga");
78 　cursimg->set_alignment(origin_center);
79 　CL_Surface *redpict = new CL_Surface("handtransp.tga");
80 　redpict->set_alignment(origin_center);
81 　redpict->set_scale(float(spacing)/float(redpict->get_width()),
82 　float(spacing)/float(redpict->get_height()));
83 　CL_Surface *bluepict = new CL_Surface("circlehandtransp.tga");
84 　bluepict->set_alignment(origin_center);
85 　bluepict->set_scale(float(spacing) / float(bluepict->get_width()),
86 　float(spacing) / float(bluepict->get_height()));
87

　　这里的init()方法完成大部分的游戏初始化工作。当然，在此需要ClanLib子系统以用于处理图形和声音(行68-72)，然后构建一个窗口用于显示所有的图形(行75)。

　　CL_Surface(行77-87)是一个2D位图类，用于绘制光标，用蓝色填充的方格和用红色填充的方格。

　　TGA文件是一种位图文件格式。ClanLib有一个集成的PNG库，因此它可以读写最流行的位图文件格式化。

　　下一步，你必须把板子初始化成一个空状态(行87-103)并执行类似的其它的清理工作以实现新的游戏计数器。

89
90 redturn = true;
91 curs.vert = false;
92 fullup = false;
93 curs.x = curs.y = 1;
94
95 srand(CL_System::get_time()); //启动随机数字生成器
96
97 for (int x = 0; x < boardsize – 1; x++) {
98 　for (int y = 0; y < boardsize; y++)
99 　hor[x][y] = ver[y][x] = false;
100
101　 for (int y = 0; y < boardsize – 1; y++)
102　　 squares[x][y] = off;
103
104

　　ClanLib的一个特别突出的方面是它避开传统型应用于许多框架中的回调模型，而引入了"信号和槽"模型。这种模型广泛应用于Boost C++库中，并在QT中得到实现。信号代表具有多个目标的回调函数，又在一些类似的系统中称作"出版者"或者"事件"。信号被连接到一些槽上，它们是回调函数接收器(也称作事件目标或者订户)，当信号被"发出"时即被调用。信号具有类型安全的优点，它们避开了在传统型的框架中的不可避免的cast操作。

　　信号和槽被统一管理。在信号和槽中(或者更准确些说是，作为槽的一部分出现的对象)跟踪所有的连接，并当任何其一被破坏时能够自动地断开信号/槽连接。这能够使用户建立信号/槽连接而不需要花费多大的代价来管理那些连接以及所有包含于其中的对象的生命周期。在行105中，你只要捕获所有的键击("down")事件并确保使用了你自己的inputHandler()(见行168-216)。

105 CL_Slot keypress =
CL_Keyboard::sig_key_down().connect(this,
&Boxes::inputHandler);

　　现在，你将开始初始化程序的音乐部分。首先，你用一个.wav格式的("binary")音乐文件装载一个CL_SoundBuffer，然后准备一个会话句柄以为玩游戏之用。下一步，你应用一个淡入淡出过滤器来异步地调整音量-在五秒(行 108-112)内把音量从零变化到最大音量的百分之六十。

106 CL_SoundBuffer *music = new CL_SoundBuffer("linemusic.ogg");
107 CL_SoundBuffer_Session session = music->prepare();
108 CL_FadeFilter *fade = new CL_FadeFilter(0.0f);
109 session.add_filter(fade);
110 session.set_looping(true);
111 session.play();
112 fade->fade_to_volume(0.6f, 5000);
113 }

　　drawBoard()方法绘制线段所在的点画格子图案，如，每个玩家赢得的红色的西红柿和蓝色的矢车菊框出的方格，还有模仿的光标。而最重要的代码行是第165行。CL_Display::flip()交换前后台缓冲区。后台缓冲区是在该帧中你绘制所有图形的地方，而前台缓冲区是显示在屏幕上的内容。

115 void Boxes::drawBoard()
116 {
117 　CL_Display::clear(redturn ? CL_Color::red : CL_Color::blue);
118 　CL_Display::fill_rect(CL_Rect(border/2, border/2,
119 　　　winsize – border/2, winsize – border/2),CL_Color::black);
120
121 　//画方框
122 　for (int x = 0; x < boardsize – 1; x++)
123 　　for (int y = 0; y < boardsize – 1; y++) {
124 　　　if (squares[x][y] == red) {
125 　　　　CL_Display::fill_rect(CL_Rect(x * spacing + border,y * spacing + border, x * spacing + border +
　　　　　　　　spacing,
127 　　　　　　y * spacing + border + spacing),CL_Gradient(CL_Color::red,
128 　　　　　　CL_Color::red, CL_Color::tomato, CL_Color::tomato));
129 　　　　redpict->draw(x * spacing + border + spacing / 2,
130 　　　　　　　y * spacing + border + spacing / 2);
131 　　　}
132 　　　else if (squares[x][y] == blue) {
133 　　　　　CL_Display::fill_rect(CL_Rect(x * spacing + border,
134 　　　　　y * spacing + border,x * spacing + border +spacing,
135 　　　　　　　y * spacing + border +spacing),CL_Gradient(CL_Color::blue,
136 　　　　　　　CL_Color::blue, CL_Color::cornflowerblue,CL_Color::cornflowerblue));
137 　　　　　bluepict->draw(x * spacing + border + spacing / 2,y * spacing + border + spacing / 2);
139 　　　}
140 　　}
141
142 　　//画线
143 　　for (int x = 0; x < boardsize; x++) {
144 　　　for (int y = 0; y < boardsize – 1; y++) {
145 　　　　if (ver[x][y]) CL_Display::draw_line(x * spacing + border,
146 　　　　　　y * spacing + border,x * spacing + border,
147 　　　　　　y * spacing + border+ spacing,CL_Color::yellow);
148 　　　　if (hor[y][x]) CL_Display::draw_line(y * spacing + border,
149 　　　　　　x * spacing + border,y * spacing + border+ spacing,x * spacing + border,CL_Color::yellow);
151 　　　　}
152 　　}
153
154 　　//画格子
155 　　for (int x = 0; x < boardsize; x++)
156 　　　for (int y = 0; y < boardsize; y++)
157 　　　　CL_Display::draw_rect(CL_Rect(x * spacing + border,
158 　　　　　　y * spacing + border,x * spacing + border + 2,159 y * spacing + border + 2),CL_Color::white);
160
161 　　　　//画光标
162 　　　　if (curs.vert) cursimg->draw((curs.x – 1) * spacing + border,int((curs.y – 0.5) * spacing + border));
163 　　　　else cursimg->draw(int((curs.x – 0.5) * spacing + border),(curs.y – 1) * spacing + border);
164
165 　　　　　CL_Display::flip();
166 　　　}

　　你安装的inputHandler()函数用于观察在行105的按键信号。这个函数负责处理细节问题-把键击变成游戏运动，还有最重要的空格或者回车键-用于指示当前玩家的一个选择(行200-210)。然后，你要检查一下是否已完成了一个"方形"并把控制返回到原来的玩家。

168 void Boxes::inputHandler(const CL_InputEvent &i)
169 {
170 　if (redturn) {
171 　　switch(i.id) {
172 　　　case CL_KEY_LEFT:
173 　　　case CL_KEY_G:
174 　　　　if (curs.x > 1) curs.x–;
175 　　　　break;
176 　　　case CL_KEY_RIGHT:
177 　　　case CL_KEY_J:
178 　　　　if (curs.x < boardsize) curs.x++;
179 　　　　break;
180 　　　case CL_KEY_UP:
181 　　　case CL_KEY_Y:
182 　　　　if (!curs.vert && curs.y > 1) {
183 　　　　　curs.y–;
184 　　　　　curs.vert = !curs.vert;
185 　　　　}
186 　　　　else if (curs.vert) curs.vert = false;
187 　　　　break;
188 　　　case CL_KEY_DOWN:
189 　　　case CL_KEY_H:
190 　　　　if (curs.vert && curs.y < boardsize) {
191 　　　　　curs.y++;
192 　　　　　curs.vert = !curs.vert;
193 　　　　}
194 　　　　else if (!curs.vert) curs.vert = true;
195 　　　　break;
196 　　　}
197 　　　if (curs.x == boardsize && !curs.vert) curs.x–;
198 　　　if (curs.y == boardsize && curs.vert)
　　　　　　curs.vert = false;
199
200 　　　if (i.id == CL_KEY_SPACE || i.id == CL_KEY_ENTER) {
201 　　　　if (curs.vert) {
202　　　　　if (!ver[curs.x-1][curs.y-1]) {
203 　　　　　　ver[curs.x-1][curs.y-1] = true;
204 　　　　　　if (!findsquares()) redturn = !redturn;
205 　　　　　}
206 　　　}
207 　　　else {
208 　　　　if (!hor[curs.x-1][curs.y-1]) {
209 　　　　　hor[curs.x-1][curs.y-1] = true;
210 　　　　　if (!findsquares()) redturn = !redturn;
211 　　　　}
212 　　　}
213 　　}
214 　}
215 }

　　最后，由endOfGame()方法计算最后的得分。记住游戏还没有结束，直到板子满了为止(见行48)或者某人通过按下ESC键(见行46)退出。最后，你用大约1秒的时间把音量淡出到0。

217 void Boxes::endOfGame()
218 {
219 　// 计数得分
220 　int redscore, bluescore;
221 　redscore = bluescore = 0;
222 　for (int x = 0; x < boardsize – 1; x++)
223 　　for (int y = 0; y < boardsize – 1; y++) {
224 　　　if (squares[x][y] == red) redscore++;
225 　　　else if (squares[x][y] == blue) bluescore++;
226 　　}
227
228 　cout << "Red: " << redscore << "\nBlue: " << bluescore << endl;
229 　if (bluescore != redscore)
230 　　cout << (bluescore > redscore ? "Blue" : "Red") << " player wins\n";
231 　else cout << "It was a tie\n";
232
233 　if (fullup) {
234 　　fade->fade_to_volume(0.0f, 1000);
235 　　CL_System::sleep(1000);
236 　}
237 }

[转帖]编程修养（二)

岚焕 — Tue, 10 Jan 2006 07:33:00 +0000

编程修养（二)
6、if 语句对出错的处理
———————————
我看见你说了，这有什么好说的。还是先看一段程序代码吧。
if ( ch >= ‘0′ && ch <= ‘9′ ){
/* 正常处理代码 */
}else{
/* 输出错误信息 */
printf("error ……\n");
return ( FALSE );
}

这种结构很不好，特别是如果“正常处理代码”很长时，对于这种情况，最好不要用else。先判断错误，如：

if ( ch < ‘0′ || ch > ‘9′ ){
/* 输出错误信息 */
printf("error ……\n");
return ( FALSE );
}

/* 正常处理代码 */
……

这样的结构，不是很清楚吗？突出了错误的条件，让别人在使用你的函数的时候，第一眼就能看到不合法的条件，于是就会更下意识的避免。

7、头文件中的#ifndef
——————————
千万不要忽略了头件的中的#ifndef，这是一个很关键的东西。比如你有两个C文件，这两个C文件都include了同一个头文件。而编译时，这两个C文件要一同编译成一个可运行文件，于是问题来了，大量的声明冲突。

还是把头文件的内容都放在#ifndef和#endif中吧。不管你的头文件会不会被多个文件引用，你都要加上这个。一般格式是这样的：

#ifndef <标识>
#define <标识>

……
……

#endif

<标识>在理论上来说可以是自由命名的，但每个头文件的这个“标识”都应该是唯一的。标识的命名规则一般是头文件名全大写，前后加下划线，并把文件名中的“.”也变成下划线，如：stdio.h

#ifndef _STDIO_H_
#define _STDIO_H_

……

#endif

（BTW：预编译有多很有用的功能。你会用预编译吗？）

8、在堆上分配内存
—————————
可能许多人对内存分配上的“栈 stack”和“堆 heap”还不是很明白。包括一些科班出身的人也不明白这两个概念。我不想过多的说这两个东西。简单的来讲，stack上分配的内存系统自动释放，heap上分配的内存，系统不释放，哪怕程序退出，那一块内存还是在那里。stack一般是静态分配内存，heap上一般是动态分配内存。

由malloc系统函数分配的内存就是从堆上分配内存。从堆上分配的内存一定要自己释放。用free释放，不然就是术语——“内存泄露”（或是“内存漏洞”）—— Memory Leak。于是，系统的可分配内存会随malloc越来越少，直到系统崩溃。还是来看看“栈内存”和“堆内存”的差别吧。

栈内存分配
—————
char*
AllocStrFromStack()
{
char pstr[100];
return pstr;
}

堆内存分配
—————
char*
AllocStrFromHeap(int len)
{
char *pstr;

if ( len <= 0 ) return NULL;
return ( char* ) malloc( len );
}

对于第一个函数，那块pstr的内存在函数返回时就被系统释放了。于是所返回的char*什么也没有。而对于第二个函数，是从堆上分配内存，所以哪怕是程序退出时，也不释放，所以第二个函数的返回的内存没有问题，可以被使用。但一定要调用free释放，不然就是Memory Leak！

在堆上分配内存很容易造成内存泄漏，这是C/C++的最大的“克星”，如果你的程序要稳定，那么就不要出现Memory Leak。所以，我还是要在这里千叮咛万嘱付，在使用malloc系统函数（包括calloc，realloc）时千万要小心。

记得有一个UNIX上的服务应用程序，大约有几百的C文件编译而成，运行测试良好，等使用时，每隔三个月系统就是down一次，搞得许多人焦头烂额，查不出问题所在。只好，每隔两个月人工手动重启系统一次。出现这种问题就是Memery Leak在做怪了，在C/C++中这种问题总是会发生，所以你一定要小心。一个Rational的检测工作——Purify，可以帮你测试你的程序有没有内存泄漏。

我保证，做过许多C/C++的工程的程序员，都会对malloc或是new有些感冒。当你什么时候在使用malloc和new时，有一种轻度的紧张和惶恐的感觉时，你就具备了这方面的修养了。

对于malloc和free的操作有以下规则：

1) 配对使用，有一个malloc，就应该有一个free。（C++中对应为new和delete）
2) 尽量在同一层上使用，不要像上面那种，malloc在函数中，而free在函数外。最好在同一调用层上使用这两个函数。
3) malloc分配的内存一定要初始化。free后的指针一定要设置为NULL。

注：虽然现在的操作系统（如：UNIX和Win2k/NT）都有进程内存跟踪机制，也就是如果你有没有释放的内存，操作系统会帮你释放。但操作系统依然不会释放你程序中所有产生了Memory Leak的内存，所以，最好还是你自己来做这个工作。（有的时候不知不觉就出现Memory Leak了，而且在几百万行的代码中找无异于海底捞针，Rational有一个工具叫Purify，可能很好的帮你检查程序中的Memory Leak）

9、变量的初始化
————————
接上一条，变量一定要被初始化再使用。C/C++编译器在这个方面不会像JAVA一样帮你初始化，这一切都需要你自己来，如果你使用了没有初始化的变量，结果未知。好的程序员从来都会在使用变量前初始化变量的。如：

1) 对malloc分配的内存进行memset清零操作。（可以使用calloc分配一块全零的内存）
2) 对一些栈上分配的struct或数组进行初始化。（最好也是清零）

不过话又说回来了，初始化也会造成系统运行时间有一定的开销，所以，也不要对所有的变量做初始化，这个也没有意义。好的程序员知道哪些变量需要初始化，哪些则不需要。如：以下这种情况，则不需要。

char *pstr; /* 一个字符串 */
pstr = ( char* ) malloc( 50 );
if ( pstr == NULL ) exit(0);
strcpy( pstr, "Hello Wrold" );

但如果是下面一种情况，最好进行内存初始化。（指针是一个危险的东西，一定要初始化）

char **pstr; /* 一个字符串数组 */
pstr = ( char** ) malloc( 50 );
if ( pstr == NULL ) exit(0);

/* 让数组中的指针都指向NULL */
memset( pstr, 0, 50*sizeof(char*) );

而对于全局变量，和静态变量，一定要声明时就初始化。因为你不知道它第一次会在哪里被使用。所以使用前初始这些变量是比较不现实的，一定要在声明时就初始化它们。如：

Links *plnk = NULL; /* 对于全局变量plnk初始化为NULL */

10、h和c文件的使用
—————————
H文件和C文件怎么用呢？一般来说，H文件中是declare（声明），C文件中是define（定义）。因为C文件要编译成库文件（Windows下是.obj/.lib，UNIX下是.o/.a），如果别人要使用你的函数，那么就要引用你的H文件，所以，H文件中一般是变量、宏定义、枚举、结构和函数接口的声明，就像一个接口说明文件一样。而C文件则是实现细节。

H文件和C文件最大的用处就是声明和实现分开。这个特性应该是公认的了，但我仍然看到有些人喜欢把函数写在H文件中，这种习惯很不好。（如果是C++话，对于其模板函数，在VC中只有把实现和声明都写在一个文件中，因为VC不支持export关键字）。而且，如果在H文件中写上函数的实现，你还得在makefile中把头文件的依赖关系也加上去，这个就会让你的makefile很不规范。

最后，有一个最需要注意的地方就是：带初始化的全局变量不要放在H文件中！

例如有一个处理错误信息的结构：

char* errmsg[] = {
/* 0 */ "No error",
/* 1 */ "Open file error",
/* 2 */ "Failed in sending/receiving a message",
/* 3 */ "Bad arguments",
/* 4 */ "Memeroy is not enough",
/* 5 */ "Service is down; try later",
/* 6 */ "Unknow information",
/* 7 */ "A socket operation has failed",
/* 8 */ "Permission denied",
/* 9 */ "Bad configuration file format",
/* 10 */ "Communication time out",
……
……
};

请不要把这个东西放在头文件中，因为如果你的这个头文件被5个函数库（.lib或是.a）所用到，于是他就被链接在这5个.lib或.a中，而如果你的一个程序用到了这5个函数库中的函数，并且这些函数都用到了这个出错信息数组。那么这份信息将有5个副本存在于你的执行文件中。如果你的这个errmsg很大的话，而且你用到的函数库更多的话，你的执行文件也会变得很大。

正确的写法应该把它写到C文件中，然后在各个需要用到errmsg的C文件头上加上 extern char* errmsg[]; 的外部声明，让编译器在链接时才去管他，这样一来，就只会有一个errmsg存在于执行文件中，而且，这样做很利于封装。

我曾遇到过的最疯狂的事，就是在我的目标文件中，这个errmsg一共有112个副本，执行文件有8M左右。当我把errmsg放到C文件中，并为一千多个C文件加上了extern的声明后，所有的函数库文件尺寸都下降了20%左右，而我的执行文件只有5M了。一下子少了3M啊。

［备注］
—————
有朋友对我说，这个只是一个特例，因为，如果errmsg在执行文件中存在多个副本时，可以加快程序运行速度，理由是errmsg的多个复本会让系统的内存换页降低，达到效率提升。像我们这里所说的errmsg只有一份，当某函数要用errmsg时，如果内存隔得比较远，会产生换页，反而效率不高。

这个说法不无道理，但是一般而言，对于一个比较大的系统，errmsg是比较大的，所以产生副本导致执行文件尺寸变大，不仅增加了系统装载时间，也会让一个程序在内存中占更多的页面。而对于errmsg这样数据，一般来说，在系统运行时不会经常用到，所以还是产生的内存换页也就不算频繁。权衡之下，还是只有一份errmsg的效率高。即便是像logmsg这样频繁使用的的数据，操作系统的内存调度算法会让这样的频繁使用的页面常驻于内存，所以也就不会出现内存换页问题了。

11、出错信息的处理
—————————
你会处理出错信息吗？哦，它并不是简单的输出。看下面的示例：

if ( p == NULL ){
printf ( "ERR: The pointer is NULL\n" );
}

告别学生时代的编程吧。这种编程很不利于维护和管理，出错信息或是提示信息，应该统一处理，而不是像上面这样，写成一个“硬编码”。第10条对这方面的处理做了一部分说明。如果要管理错误信息，那就要有以下的处理：

/* 声明出错代码 */
#define ERR_NO_ERROR 0 /* No error */
#define ERR_OPEN_FILE 1 /* Open file error */
#define ERR_SEND_MESG 2 /* sending a message error */
#define ERR_BAD_ARGS 3 /* Bad arguments */
#define ERR_MEM_NONE 4 /* Memeroy is not enough */
#define ERR_SERV_DOWN 5 /* Service down try later */
#define ERR_UNKNOW_INFO 6 /* Unknow information */
#define ERR_SOCKET_ERR 7 /* Socket operation failed */
#define ERR_PERMISSION 8 /* Permission denied */
#define ERR_BAD_formAT 9 /* Bad configuration file */
#define ERR_TIME_OUT 10 /* Communication time out */

/* 声明出错信息 */
char* errmsg[] = {
/* 0 */ "No error",
/* 1 */ "Open file error",
/* 2 */ "Failed in sending/receiving a message",
/* 3 */ "Bad arguments",
/* 4 */ "Memeroy is not enough",
/* 5 */ "Service is down; try later",
/* 6 */ "Unknow information",
/* 7 */ "A socket operation has failed",
/* 8 */ "Permission denied",
/* 9 */ "Bad configuration file format",
/* 10 */ "Communication time out",
};

/* 声明错误代码全局变量 */
long errno = 0;

/* 打印出错信息函数 */
void perror( char* info)
{
if ( info ){
printf("%s: %s\n", info, errmsg[errno] );
return;
}

printf("Error: %s\n", errmsg[errno] );
}

这个基本上是ANSI的错误处理实现细节了，于是当你程序中有错误时你就可以这样处理：

bool CheckPermission( char* userName )
{
if ( strcpy(userName, "root") != 0 ){
errno = ERR_PERMISSION_DENIED;
return (FALSE);
}

…
}

main()
{
…
if (! CheckPermission( username ) ){
perror("main()");
}
…
}

一个即有共性，也有个性的错误信息处理，这样做有利同种错误出一样的信息，统一用户界面，而不会因为文件打开失败，A程序员出一个信息，B程序员又出一个信息。而且这样做，非常容易维护。代码也易读。

当然，物极必反，也没有必要把所有的输出都放到errmsg中，抽取比较重要的出错信息或是提示信息是其关键，但即使这样，这也包括了大多数的信息。

12、常用函数和循环语句中的被计算量
—————————————————
看一下下面这个例子：

for( i=0; i<1000; i++ ){
GetLocalHostName( hostname );
…
}

GetLocalHostName的意思是取得当前计算机名，在循环体中，它会被调用1000次啊。这是多么的没有效率的事啊。应该把这个函数拿到循环体外，这样只调用一次，效率得到了很大的提高。虽然，我们的编译器会进行优化，会把循环体内的不变的东西拿到循环外面，但是，你相信所有编译器会知道哪些是不变的吗？我觉得编译器不可靠。最好还是自己动手吧。

同样，对于常用函数中的不变量，如：

GetLocalHostName(char* name)
{
char funcName[] = "GetLocalHostName";

sys_log( "%s begin……", funcName );
…
sys_log( "%s end……", funcName );
}

如果这是一个经常调用的函数，每次调用时都要对funcName进行分配内存，这个开销很大啊。把这个变量声明成static吧，当函数再次被调用时，就会省去了分配内存的开销，执行效率也很好。

13、函数名和变量名的命名
————————————
我看到许多程序对变量名和函数名的取名很草率，特别是变量名，什么a,b,c,aa,bb,cc，还有什么flag1,flag2, cnt1, cnt2，这同样是一种没有“修养”的行为。即便加上好的注释。好的变量名或是函数名，我认为应该有以下的规则：

1) 直观并且可以拼读，可望文知意，不必“解码”。
2) 名字的长度应该即要最短的长度，也要能最大限度的表达其含义。
3) 不要全部大写，也不要全部小写，应该大小写都有，如：GetLocalHostName 或是 UserAccount。
4) 可以简写，但简写得要让人明白，如：ErrorCode -> ErrCode, ServerListener -> ServLisner，UserAccount -> UsrAcct 等。
5) 为了避免全局函数和变量名字冲突，可以加上一些前缀，一般以模块简称做为前缀。
6) 全局变量统一加一个前缀或是后缀，让人一看到这个变量就知道是全局的。
7) 用匈牙利命名法命名函数参数，局部变量。但还是要坚持“望文生意”的原则。
与标准库（如：STL）或开发库（如：MFC）的命名风格保持一致。

编程修养（一）

岚焕 — Tue, 10 Jan 2006 07:32:00 +0000

编程修养（一）
什么是好的程序员？是不是懂得很多技术细节？还是懂底层编程？还是编程速度比较快？我觉得都不是。对于一些技术细节来说和底层的技术，只要看帮助，查资料就能找到，对于速度快，只要编得多也就熟能生巧了。

我认为好的程序员应该有以下几方面的素质：

1、有专研精神，勤学善问、举一反三。
2、积极向上的态度，有创造性思维。
3、与人积极交流沟通的能力，有团队精神。
4、谦虚谨慎，戒骄戒燥。
5、写出的代码质量高。包括：代码的稳定、易读、规范、易维护、专业。

这些都是程序员的修养，这里我想谈谈“编程修养”，也就是上述中的第5点。我觉得，如果我要了解一个作者，我会看他所写的小说，如果我要了解一个画家，我会看他所画的图画，如果我要了解一个工人，我会看他所做出来的产品，同样，如果我要了解一个程序员，我想首先我最想看的就是他的程序代码，程序代码可以看出一个程序员的素质和修养，程序就像一个作品，有素质有修养的程序员的作品必然是一图精美的图画，一首美妙的歌曲，一本赏心悦目的小说。

我看过许多程序，没有注释，没有缩进，胡乱命名的变量名，等等，等等，我把这种人统称为没有修养的程序，这种程序员，是在做创造性的工作吗？不，完全就是在搞破坏，他们与其说是在编程，还不如说是在对源程序进行“加密”，这种程序员，见一个就应该开除一个，因为他编的程序所创造的价值，远远小于需要在上面进行维护的价值。

程序员应该有程序员的修养，那怕再累，再没时间，也要对自己的程序负责。我宁可要那种动作慢，技术一般，但有良好的写程序风格的程序员，也不要那种技术强、动作快的“搞破坏”的程序员。有句话叫“字如其人”，我想从程序上也能看出一个程序员的优劣。因为，程序是程序员的作品，作品的好坏直截关系到程序员的声誉和素质。而“修养”好的程序员一定能做出好的程序和软件。

有个成语叫“独具匠心”，意思是做什么都要做得很专业，很用心，如果你要做一个“匠”，也就是造诣高深的人，那么，从一件很简单的作品上就能看出你有没有“匠”的特性，我觉得做一个程序员不难，但要做一个“程序匠”就不简单了。编程序很简单，但编出有质量的程序就难了。

我在这里不讨论过深的技术，我只想在一些容易让人忽略的东西上说一说，虽然这些东西可能很细微，但如果你不注意这些细微之处的话，那么他将会极大的影响你的整个软件质量，以及整个软件程的实施，所谓“千里之堤，毁于蚁穴”。

“细微之处见真功”，真正能体现一个程序的功底恰恰在这些细微之处。

这就是程序员的——编程修养。我总结了在用C/C++语言（主要是C语言）进行程序写作上的三十二个“修养”，通过这些，你可以写出质量高的程序，同时也会让看你程序的人渍渍称道，那些看过你程序的人一定会说：“这个人的编程修养不错”。

————————————————————————

01、版权和版本
02、缩进、空格、换行、空行、对齐
03、程序注释
04、函数的[in][out]参数
05、对系统调用的返回进行判断
06、if 语句对出错的处理
07、头文件中的#ifndef
08、在堆上分配内存
09、变量的初始化
10、h和c文件的使用
11、出错信息的处理
12、常用函数和循环语句中的被计算量
13、函数名和变量名的命名
14、函数的传值和传指针
15、修改别人程序的修养
16、把相同或近乎相同的代码形成函数和宏
17、表达式中的括号
18、函数参数中的const
19、函数的参数个数
20、函数的返回类型，不要省略
21、goto语句的使用
22、宏的使用
23、static的使用
24、函数中的代码尺寸
25、typedef的使用
26、为常量声明宏
27、不要为宏定义加分号
28、||和&&的语句执行顺序
29、尽量用for而不是while做循环
30、请sizeof类型而不是变量
31、不要忽略Warning
32、书写Debug版和Release版的程序

1、版权和版本
———————
好的程序员会给自己的每个函数，每个文件，都注上版权和版本。

对于C/C++的文件，文件头应该有类似这样的注释：
/************************************************************************
*
* 文件名：network.c
*
* 文件描述：网络通讯函数集
*
* 创建人： Hao Chen, 2003年2月3日
*
* 版本号：1.0
*
* 修改记录：
*
************************************************************************/

而对于函数来说，应该也有类似于这样的注释：

/*================================================================
*
* 函数名：XXX
*
* 参数：
*
* type name [IN] : descripts
*
* 功能描述:
*
* …………..
*
* 返回值：成功TRUE，失败FALSE
*
* 抛出异常：
*
* 作者：ChenHao 2003/4/2
*
================================================================*/

这样的描述可以让人对一个函数，一个文件有一个总体的认识，对代码的易读性和易维护性有很大的好处。这是好的作品产生的开始。

2、缩进、空格、换行、空行、对齐
————————————————
i) 缩进应该是每个程序都会做的，只要学程序过程序就应该知道这个，但是我仍然看过不缩进的程序，或是乱缩进的程序，如果你的公司还有写程序不缩进的程序员，请毫不犹豫的开除他吧，并以破坏源码罪起诉他，还要他赔偿读过他程序的人的精神损失费。缩进，这是不成文规矩，我再重提一下吧，一个缩进一般是一个TAB键或是4个空格。（最好用TAB键）

ii) 空格。空格能给程序代来什么损失吗？没有，有效的利用空格可以让你的程序读进来更加赏心悦目。而不一堆表达式挤在一起。看看下面的代码：

ha=(ha*128+*key++)%tabPtr->size;

ha = ( ha * 128 + *key++ ) % tabPtr->size;

有空格和没有空格的感觉不一样吧。一般来说，语句中要在各个操作符间加空格，函数调用时，要以各个参数间加空格。如下面这种加空格的和不加的：

if ((hProc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid))==NULL){
}

if ( ( hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid) ) == NULL ){
}

iii) 换行。不要把语句都写在一行上，这样很不好。如：

for(i=0;i’9′)&&(a[i]<’a'||a[i]>’z')) break;

我拷，这种即无空格，又无换行的程序在写什么啊？加上空格和换行吧。

for ( i=0; i if ( ( a[i] < ‘0′ || a[i] > ‘9′ ) &&
( a[i] < ‘a’ || a[i] > ‘z’ ) ) {
break;
}
}

好多了吧？有时候，函数参数多的时候，最好也换行，如：

CreateProcess(
NULL,
cmdbuf,
NULL,
NULL,
bInhH,
dwCrtFlags,
envbuf,
NULL,
&siStartInfo,
&prInfo
);

条件语句也应该在必要时换行：

if ( ch >= ‘0′ || ch <= ‘9′ ||
ch >= ‘a’ || ch <= ‘z’ ||
ch >= ‘A’ || ch <= ‘Z’ )

iv) 空行。不要不加空行，空行可以区分不同的程序块，程序块间，最好加上空行。如：

HANDLE hProcess;
PROCESS_T procInfo;

/* open the process handle */
if((hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid)) == NULL)
{
return LSE_MISC_SYS;
}

memset(&procInfo, 0, sizeof(procInfo));
procInfo.idProc = pid;
procInfo.hdProc = hProcess;
procInfo.misc |= MSCAVA_PROC;

return(0);

v) 对齐。用TAB键对齐你的一些变量的声明或注释，一样会让你的程序好看一些。如：

typedef struct _pt_man_t_ {
int numProc; /* Number of processes */
int maxProc; /* Max Number of processes */
int numEvnt; /* Number of events */
int maxEvnt; /* Max Number of events */
HANDLE* pHndEvnt; /* Array of events */
DWORD timeout; /* Time out interval */
HANDLE hPipe; /* Namedpipe */
TCHAR usr[MAXUSR];/* User name of the process */
int numMsg; /* Number of Message */
int Msg[MAXMSG];/* Space for intro process communicate */
} PT_MAN_T;

怎么样？感觉不错吧。

这里主要讲述了如果写出让人赏心悦目的代码，好看的代码会让人的心情愉快，读起代码也就不累，工整、整洁的程序代码，通常更让人欢迎，也更让人称道。现在的硬盘空间这么大，不要让你的代码挤在一起，这样它们会抱怨你虐待它们的。好了，用“缩进、空格、换行、空行、对齐”装饰你的代码吧，让他们从没有秩序的土匪中变成一排排整齐有秩序的正规部队吧。

3、程序注释
——————
养成写程序注释的习惯，这是每个程序员所必须要做的工作。我看过那种几千行，却居然没有一行注释的程序。这就如同在公路上驾车却没有路标一样。用不了多久，连自己都不知道自己的意图了，还要花上几倍的时间才看明白，这种浪费别人和自己的时间的人，是最为可耻的人。

是的，你也许会说，你会写注释，真的吗？注释的书写也能看出一个程序员的功底。一般来说你需要至少写这些地方的注释：文件的注释、函数的注释、变量的注释、算法的注释、功能块的程序注释。主要就是记录你这段程序是干什么的？你的意图是什么？你这个变量是用来做什么的？等等。

不要以为注释好写，有一些算法是很难说或写出来的，只能意会，我承认有这种情况的时候，但你也要写出来，正好可以训练一下自己的表达能力。而表达能力正是那种闷头搞技术的技术人员最缺的，你有再高的技术，如果你表达能力不行，你的技术将不能得到充分的发挥。因为，这是一个团队的时代。

好了，说几个注释的技术细节：

i) 对于行注释（“//”）比块注释（“/* */”）要好的说法，我并不是很同意。因为一些老版本的C编译器并不支持行注释，所以为了你的程序的移植性，请你还是尽量使用块注释。

ii) 你也许会为块注释的不能嵌套而不爽，那么你可以用预编译来完成这个功能。使用“#if 0”和“#endif”括起来的代码，将不被编译，而且还可以嵌套。

4、函数的[in][out]参数
———————————

我经常看到这样的程序：
FuncName(char* str)
{
int len = strlen(str);
…..
}

char*
GetUserName(struct user* pUser)
{
return pUser->name;
}

不！请不要这样做。

你应该先判断一下传进来的那个指针是不是为空。如果传进来的指针为空的话，那么，你的一个大的系统就会因为这一个小的函数而崩溃。一种更好的技术是使用断言（assert），这里我就不多说这些技术细节了。当然，如果是在C++中，引用要比指针好得多，但你也需要对各个参数进行检查。

写有参数的函数时，首要工作，就是要对传进来的所有参数进行合法性检查。而对于传出的参数也应该进行检查，这个动作当然应该在函数的外部，也就是说，调用完一个函数后，应该对其传出的值进行检查。

当然，检查会浪费一点时间，但为了整个系统不至于出现“非法操作”或是“Core Dump”的系统级的错误，多花这点时间还是很值得的。

5、对系统调用的返回进行判断
——————————————
继续上一条，对于一些系统调用，比如打开文件，我经常看到，许多程序员对fopen返回的指针不做任何判断，就直接使用了。然后发现文件的内容怎么也读出不，或是怎么也写不进去。还是判断一下吧：

fp = fopen("log.txt", "a");
if ( fp == NULL ){
printf("Error: open file error\n");
return FALSE;
}

其它还有许多啦，比如：socket返回的socket号，malloc返回的内存。请对这些系统调用返回的东西进行判断。

【转】程序员成长最快的环境

岚焕 — Fri, 30 Dec 2005 03:31:00 +0000

除开五大这种要什么有什么，进去做打字也能光耀门楣的不谈。如果是嫁到一个普通软件公司，怎样的环境才能最快的成长呢？
   首先基本的公司项目管理水平是必要的；其次是稳健而不保守的公司技术选型; 还有一班能沟通的同事。

    更重要的，是要有一个严苛的环境，那些古训说的都没错，越是严苛，成长越快。
    然后有些引导与助力，让你在严寒中节省体力，过得好些的，就是最佳的成长环境了。

    一，最复杂多变的业务规则，最难侍候的客户
         大多数人碰上这两样东西都是愁眉苦脸，天天抱怨。其实应该把它视为入门锻炼的：
         第一阶是努力用细密的编码迎合复杂的业务，以金牌服务的态度接受客户的善变和每样需求都要24小时有取的bt。充分打磨过的眼耳口心，才是个合格的IT 人。如果业务规则都清的像水，项目时时都是以我为主的，反是在做toy application，不算入了IT的门。
       打磨之后，如果肯静下心来总结，设计架构如何适应改变，流程如何做到快速更新部署，就是第二阶段的进步了。
       一直做ERP，自问有足够复杂的业务(因为不熟悉业务，有些不复杂的也变复杂了)和麻烦的客户(自己不是大公司，麻烦的客户就会很多)，但在第二阶段还是不很静得下心。

    二，最严格的性能要求，准确性要求，错误恢复要求
        最好是那种每天N万人访问，几亿条数据。还有准确性很严格，分分钟几十万上下，如果崩机又要迅速完全恢复状态的项目。
         每天几万人访问的项目没做过，遗憾。
         几千万条数据的项目倒是每天面对，优化学了一点，但没有充分利用严格的环境去追求改进，遗憾。
         ERP的报表倒是经常会搞到几十万上下的差额，但一直重视不足，以后要以历练来对待之。
         崩机恢复是最近的项目要求，更爽是这个项目澳国政府居然有一份规范，我说的助力就是指这些了，不用自己慢慢摸索而且经常摸错地方。

    三，最底层的编码
         不要老是高高在上的搞ERP搞.com，偶然尝试一下用到起码C一级的语言，和硬件打打交道，直接写IO口阿，中断阿，都是有就不要放过的锻炼。
         没做过底层编码，只会纯软件的IT人的感觉是不完整的。
         刚好公司最近的项目有要求，捧一本〈Linux Device Driver〉看看。

    四，最高层的设计
        设计、框架–技术人一听就眼红的字眼。但不是每个公司都搞很产品化的项目，或者在项目里自写类库重做轮子。所以，除了刚入行的那段疯狂日子，很高阶的设计其实我也没做多少，多数时间都是应用层的开发。

        虽然自己不写，但却经常都要进行框架选型，也算是蒸发智力的一个地方。Promatic Programmer里说的critical的态度很重要，Spring好么？一定要想清楚它好在哪里，不要糊里糊涂的看着quick start就入局了，浑忘了如果不用Spring的世界是怎样的。

       另外，因为有时候要开源软件有bug，或者要增强它来吻合项目需求，或者有错了不明就里时直接读源码会更快找到错误。这样就接触到不少优秀开源项目的源码，比如Spring，无形中也会学到他的设计。

       如果说Java盛产框架型的项目，php的项目则多是熟透了的Web应用。最近发现php不是以前的php了，应该算入python,ruby一类的动态OO语言，它的那些著名项目一样有着很好的MVC框架。细看之下学到应用设计方面的不少东西。


     一阵发呆打了这篇字，其实也是提醒自己，目前的环境可以，应该以更好的心态接受更严苛的历练，那些古训说的都没错。

走进CG专业绘画勾勒的虚拟世界

岚焕 — Mon, 12 Dec 2005 03:57:00 +0000

　　“CG”原为“Computer Graphics”的英文缩写。简单地说就是利用计算机进行视觉设计和绘画。包括有CG艺术与设计、游戏（Game）软件、动画（Animation）、漫画（Comic）的创作，创作手法有计算机绘画、平面印刷品的设计、网页设计、三维动画、影视特效、多媒体技术、以计算机辅助设计为主的建筑设计及工业造型设计等。如今随着计算机技术的发展，CG的概念正逐步在扩大，由CG和虚拟真实技术制作的媒体文化，都可以归于CG范畴，它们已经形成一个可观的经济产业，掌握一手高超的“CG”绘画技术，更是令人羡慕。下面就来介绍几个有关CG的网站。

[被屏蔽广告]　　CG中国

　　http://www.cgercn.com

　　CG中国是一家非常专业的CG网站，网站既有精彩的CG设计欣赏，又有详细的CG教程可供学习。在互动教程中有人们教学、理论方法和CG建模，每一个实例都有从图片到文字的详细过程，让你能够从中找到学习CG的技巧；资源下载也是CG中国网站的一项重要内容，提供3D模型、Flash源码、材质素材、矢量/PSD源码、PC软件下载、Mac软件下载、字体字库的下载，是一个内容丰富的CG网站。

　　中国CG网

　　http://www.chinacg.com/01_home/index.asp

　　号称中国CG网络媒体第一站，是中国CG界数字艺术的资讯门户网站之一，它集国内外影视动画艺术、三维艺术、平面设计、游戏及建筑、电影电视、CG高等院校、CG培训学堂、网络技术、CG人才招聘应聘、图形软件、图形硬件、艺术图书等为一体，该网站还推出了CG培训学堂河CG培训机构加盟业务，以国际标准整合打造并提供全方位的开放式数字网络媒体资讯平台。

　　中国CG联盟

　　http://www.chinavfx.net/home/index.php

　　中国CG联盟主要致力于国内数字内容创作、电影电视制作，视觉娱乐设计，工业辅助设计等领域的发展，致力于CG数字视觉设计是该网站的一大特色。行业访谈栏目不仅有最新的CG新闻和CG评论，还有许多业内人士对CG技术、前景等方面综合的探讨，我们可以从中找到一些灵感。中国CG联盟的教程栏目推出了视频教学，使喜欢学习CG的朋友能够得到更加直观形象的学习资料。

　　CG酒吧

　　CG98（酒吧）其实是一个CG论坛，基于影视栏目包装，主要以艺术设计、三维动画、影视片头以及生活各个方面的专业性、生活性为内容的CG论坛。在专业性方面，开设了众多板块，平面设计、三维软件、电视影视包装、“ CG 对话厅”行业讨论区等空间。在非专业性方面，开设的独有的“视觉笔记”、“ CG98 俱乐部”、“原创文学社”、“吧友相册”等特有的生活化空间。给大家展示爱好，特长的区域。并在“视觉笔记”内形成了独特的摄影爱好群体。CG98 的用户至少目前已经达到15万左右。

　　中国CG资讯网

　　http://www.cgtimes.com.cn

　　中国CG资讯网是一个以传播CG资讯、发展中国CG产业为主的网站。该网站提供有重大的国际、国内CG赛事和活动，在作品中心栏目中，有影视特效、三维动画、游戏、产品设计；CG画廊为大家提供了许多经典优秀的CG作品，如血、孙悟空、虚拟空间、蜘蛛等等；教程中心有后期应用、二维应用、三维应用、动画理论，从实践到概念一系列的服务。

　　CG王国

　　http://www.cgbbs.com/

　　走进CG王国，黑色的背景让人感觉到正在进入一个神秘的世界，这个网站是CG迷们经常聚会的地方。网站提供大量CG资源，如后期合成软件Digital Fusion 5.0、3DsMax渲染插件之MAXWELL、免费图形编辑软件-Paint.NET的最新版等等很多CG需要的工具软件。CG王国的教程很多，分类也非常详细，如3DSMAX、MAYA、综合三维、建筑室内、数码影视、平面设计等等。在网站的下方还提供了CG人才的求职、招聘信息，总之，与CG有关的资料应有尽有，确实是一个CG爱好者的好去处。

成为软件高手之自我约束规范（原创）

岚焕 — Fri, 09 Dec 2005 03:54:00 +0000

中国软件需要高手，高手，高高手！

为此本人给自己立下成为高手的必备条件如下：

１）立大志，做大事，求大智！即使做不了大事，也要拥有大的志向，大的智慧！

２）学习为主要，要靠自己，各种好书要快快地看，拼命地看！

３）学很多别人怕学的东西，写很多别人不敢写的代码，算法！世界真理：物以稀为贵！

４）要懂得并行学习，如cpu的并行处理，好好挖掘大脑的多功能潜力！俗话说：如果你不能让人生的道路变长，就让它变宽！

５）要融会贯通，边工作边锻炼！要嚣张，只有嚣张才能博得别人的指责，只有拥有别人的指责，你才能更快的发现自己的不足！

６）“欲练神功，必先自宫”！尽量避免一切无意义的活动！要懂得寂寞，懂得忘记金钱，名义，美女，要知道等你成为高手后这些全部不在话下！

总之，在成为软件行业高手的过程中，需不断创新，要有激情，对待生活要始终保持热情，要循序渐进，要持之以恒！！