狠狠狠色丁香婷婷综合久久五月,国产精品一区二区久久不卡,久久综合色区

xlander — Wed, 12 Dec 2007 06:47:00 GMT

摘要: 使用位段可以��化很多东�?nbsp; 阅读全文

xlander 2007-12-12 14:47 发表评论

关于如何建立搜烦引擎的几��介�l�性的文章

xlander — Tue, 22 Aug 2006 02:35:00 GMT

��Z��JAVA技术的搜烦引擎的研�I�与实现
http://blog.csdn.net/fasttalk/archive/2004/12/23/227178.aspx
介绍了基于英特网的搜索引擎的�pȝ��l�构�Q�然后从�|�络机器人、烦引引擎、Web服务器三个方面进行详�l�的说明。利用Java开源代码Lucene、Tomcat�{�徏立自��q��搜烦引擎、易于理解�?/div>

怎么会是lucene?
http://blog.csdn.net/accesine960/archive/2004/12/23/227134.aspx
�q�篇文章提到了当前能搜烦到的介绍搜烦引擎的文章和站点�Q�以及简略情��c�?/div>

搜烦引擎�l�验�ȝ��
http://blog.csdn.net/xsc2001/archive/2006/04/03/649106.aspx
文中讲述了蜘蛛、切词、烦引、查询器�{�模块的一些概�q�和�l�节�Q�对搜烦引擎中的初学者的有一定帮�?/div>

xlander 2006-08-22 10:35 发表评论

Terrarium - �E�序�?上帝

xlander — Tue, 22 Aug 2006 02:33:00 GMT

早在2001�q�就有了�q�个��单却复杂的游戏，Terrarium�Q�即使最新的版本也是在一�q�前推出的。只是到了现在已�l�没有多��h玩了�Q�因��Z��GOOGLE上已�l�搜索不到可用的服务器了�Q�只能是在自��q��服务器上搞个试验�Q�感受一下做上帝的滋呻I��不过也就失去了生物多��h��的初衷�?/div>

Terrarium是微软公司开发的�C�Z��E�序�Q�它是一�Ƒ֐�软�g开发�h员全面展�C?NET框架应用开发技术的游戏。在Terrarium游戏中，开发�h员可以创��食动物、肉食动物或植物�Q��ƈ��它们放��C��个基�?#8220;适者生�?#8221;模型和对�{�网�l�结构的生态系�l�中。游戏既提供了一个可以测试开发�h员的软�g开发与�{�略设计水��^的竞争环境，也提供了一个近乎真实的�q�化生物学和人工��模型�Q�以��验具有不同行为和属性的生物在生存斗争中的适应能力�?br> 在创建生物时�Q�开发者可以自行决定生物的每一�U�基本属性（如眼睛的颜色、运动速度、防卫能力、攻击能力等�Q�，行�ؓ方式�Q�寻��N��物、活动和�q�攻的算法等�Q�以及繁�D�能力（每隔多长旉��J�殖一�ơ，把哪些基本信息遗传给后代�Q�。开发好一个生物的所有代码之后，开发者将代码�~�译�?NET�E�序集（Assembly�Q�以DLL动态链接库的方式存放）。本地的生态系�l�片断可以调入和�q�行该程序集�Q��ƈ在Terrarium控制��C��昄��一生物�?br>

开发一个生物的�q�程可能很容易，也可能充满挑战，可能很轻松，也可能需要全力以��_��关键是你惛_��C��么样的结果�?/div>

Terrarium的官方网�?/div>

http://www.microsoft.com/china/msdn/developercenter/smartclient/Terrarium.aspx

Terrarium的中文简�?/div>

http://www.contextfree.net/wangyg/b/tech/terrarium.html

Terrarium中几个比较优�U�的生物的代码片断

http://windowsforms.net/terrarium/farm/default.aspx?tabindex=6&tabid=42

xlander 2006-08-22 10:33 发表评论

xlander — Tue, 22 Aug 2006 02:32:00 GMT

在Hiker的blog上找到几��介�l�元胞自动机的文章，可以�_�略的了解一下�?/div>

http://www.xjtublog.com/user1/1034/subject/6351.shtml

元胞自动机可用来研究很多一般现象。其中包括通信、信息传�?Communicahon)、计��?(Compulation)、构�?(ConsTruction)、生�?(Growth)、复�?(Reproductionj、竞�?Competition)与进�?Evolutio�Q�])�{?Smith A.,1969;Perrier�Q�J.Y.,1996)。同时。它为动力学�pȝ��理论中有关秩�?(Ordering)、紊�?(Turbulence)、�؜�?(Chaos)、非对称(Symmetry-Breaking)、分�?Fractality)�{�系�l�整体行��Z��复杂现象的研�I�提供了一个有效的模型工具 (Vichhac。G�Q?984; Bennett�Q�C,1985)�?br>

GOOGLE搜烦到的几个元胞自动机的应用�Q?/div>

http://nlsc.ustc.edu.cn/

中国�U�技大学非线性科学中�?/div>

http://lgisrs.nju.edu.cn/project.htm

农村城市化的元胞自动机模型研�I?/div>

http://pandeng.dlut.edu.cn/NewsView.asp?id=154

传染病的二维元胞自动机模�?br>��Z��元胞自动机和Penna模型的生态系�l�模拟模�?/div>

http://www.zydl.net/Article_Show.asp?ArticleID=2914

都市区城市扩展模�?/div>

周成虎，�U�学出版�C�《地理元胞自动机研究》中有基于元胞自动机的林火模�?/div>

http://www.cnblogs.com/maweifeng/articles/255344.html

��Z��MA和CA的交通空间决�{�模�?/div>

http://www.ncgia.ucsb.edu/projects/gig/project_gig.htm

城市扩散模型�Q�英文）

http://www.swarmagents.com/complex/models/caintro.htm

元胞自动机全�ȝ��

http://gz.house.sina.com.cn/news/2005-11-26/1929689.html

黎夏�Q�元胞自动机与多只能体在城市规划中的应用

xlander 2006-08-22 10:32 发表评论

xlander — Fri, 21 Jul 2006 02:13:00 GMT

思�\�Q?br />用图��Z��的最短�\径来解决问题�?/div>

囄��创徏�Q?br />�l�点�Q�公交站炏V�?br />边：公交路线在两个站点之间的行��路线�?/div>

路线的求解：
��法可以参考最短�\径算法�?br />以经�q�的路线的距��L��旉��作�ؓ评�h标准�Q�优先选择同一条公交线路的下一站点�Q�如果发生换乘，以换乘的�ơ数辑ֈ�限制作�ؓ局部中止条�Ӟ��以便抛弃不必要的遍历�q�程�?/div>

xlander 2006-07-21 10:13 发表评论

xlander — Fri, 21 Jul 2006 02:12:00 GMT

人机界面的重要性是无庸�|�疑的，��观、�h性化的界面给人带来的是美的��n受和工作的乐��。但�q��ƈ不是说要把界面开发放在不可替代的重要位置�?/p>

在��Y件开发的初期�Q�不应过度关注界面开发，而应��侧重点攑֜��pȝ��功能、系�l�流�E�的实现上。这样可以快速的实现�pȝ��模型的实玎ͼ��系�l�调试尽量早的提前，��那些由界面开发所带来的大量BUG控制在模型搭建完成之后，减少界面BUG对系�l�模型的影响�?/p>

xlander 2006-07-21 10:12 发表评论

软�g中应对全部工作完成的旉��做出预测

xlander — Fri, 21 Jul 2006 02:11:00 GMT

如果一个计��过�E�比较费�Ӟ��除了要给出所有运��的工作量、当前已�l�完成的工作量，

�q�要对全部工作完成的旉��做出预测�?/div>

如果工作是现行的当然好办了，如果是非�U�性的�Q�比方说冒��排序�Q�在排序的后期，工作量越来越��。所以，�q�个预测�Q�还要从全局着��|��l�合��法的结构才行�?/div>

xlander 2006-07-21 10:11 发表评论

集装��q��攄��问题

xlander — Fri, 21 Jul 2006 02:09:00 GMT

在网上看到的题目�Q�一直没有思�\�Q�留记�?/p>

��有四种规格�?0个小��子�Q�放于两�U�规格的大箱�?有无��C��)中，
要如何放�|�才会��大箱使用最��而且分配最合理,
需考虑横放竖放

��箱子有三种规格:
5*3*2�?0个　
5*3*1 5�?
10*3*2 15�?　
2*3*2 20个　

大箱子有两种规格�Q?br />10*10*6 　
8*5*6

xlander 2006-07-21 10:09 发表评论

�~�写高效的C代码

xlander — Fri, 21 Jul 2006 02:07:00 GMT

�~�写高效的C代码

原文标题�Q�Writing Efficient C and C Code Optimization
原文地址�Q?a >http://www.codeproject.com/cpp/C___Code_Optimization.asp
原文作者：Koushik Ghosh
译文作者：zhigang

前言
前段旉��Q�我开发了一个轻量��的JPEG库，用来在某�U�移动设备上不失真地昄��囑փ�。我注意��C��些技巧可以�ɽE�序�q�行的更快。在�q�篇文章里，我收集和整理了所有的�q�些�Ҏ��Q�用来在�q�行速度和内存占用方面对C代码�q�行优化�?br />��管�~�写C代码�Q�已�l�有了许多指导原则可以参考，但这�q�不表示你已�l�彻底的了解你正在��用的�~�译器和CPU�?br /> �l�常的，��Z��使代码运行的更快�Q�会��D��代码长度的增加，所谓以�I�间换时��_��但是代码长度的增加有一�U�负面作用就是�ɽE�序的复杂度增加、可��L��减弱。尤其是当你的程序最�l�运行环境是手机、PDA之类的对内存要求比较苛刻的设备的时候，�q�将会是不可接受的。所以，我们优化的宗旨就是�ɽE�序在内存占用和�q�行速度两个斚w��都要得到优化�?/p>

声明
实际上，在我的那个项目中�Q�我使用了ARM公司的一��文章中提到的技巧，因�ؓ我的�E�序是基于ARM�q�_��的，你可以从�q�里http://www.arm.com/pdfs/DAI0034A_efficient_c.pdf取得�q�篇文章�Q�我也从Internet上收集了许多其它的文章。但�q�不是每��文章中提到的所有技巧都有用�Q�所以，在这里，我只攉��了有用且有效的，�q�有�Q�我修改了其中的一些技巧��它几乎适用于所有情况，而不仅仅是ARM�?br />我所作的工作只是��各个站点的技巧收集到一��P��其是我在上面提到的那个PDF文�g�Q�我从来没有说过�q�些技巧��我自��q��发明。在本文末尾的参考文献部分，我罗列了所有技巧的来源�?/p>

哪里需要优�?br />没有�q�一点，所有的讨论都无从谈赗��首先也是最重要的是要找出哪里需要优化，�E�序的那一部分或者那个模块运行速度慢或者��用大量内存。程序的每个部分都被分别优化�Q�自然而然的整个程序又会变得运行的比较快了�?br />优化应该主要针对�E�序中最�l�常�q�行的部分，��其是被内部循环反复调用的函数�?br /> 一个经验丰富的�E�序员会很容易找出程序中需要着重优化的部分�Q�另外，�q�有许多工具可以用来��定�q�些部分。我曄��用Visual C++ 的IDE内徏的Profiler�Q�另外一个我用过的工��h��Intel Vtune�Q�这是一个非常好用的Profiler�Q�都可以用来��L��E�序中最�Ҏ��的地斏V��以我的�l�验来看�Q�导致程序运行速度慢得�|�魁��R��可能��是某个内部或嵌套��@环，也可能是对第三方库函数的调用�?/p>

整型�?/ Integers
　　如果一个变量的取��D��围是非负的，我们应该使用unsigned int�Q�而不是int。一些处理器在处理无�W�号整型数要比处理符��h��型数快得多，�q�也是一个好的习惯，有利于代码的自我文档�?self-documenting)�?br />　　那么�Q�在一个小循环�Q�tight loop�Q�中�Q�定义一个整型变量，最好类��D��P��
register unsigned int variable_name;
然而，我们不能保证�~�译器会注意到那个register关键字，也有可能�Q�对某种处理器来��_��有没有unsigned是一��L��。这两个关键字�ƈ不是可以在所有的�~�译器中应用�?br />��C��Q�整形数�q�算要比��点数运��快得多�Q�因为处理器可以直接�q�行整型数运��，��点数运��需要依赖于外部的��Q�Ҏ��处理器或者��Q�Ҏ��数学库�?br />我们处理��数的时候要�_�ֿ�些，比方说我们在做一个简单的�l�计�E�序�Ӟ��要限制结果不能超�q?00�Q�要��可能晚的把它�{化成��点数�?/p>

除法和余�?/ Division and Remainder
　　在一般的处理器中�Q�根据分子和分母的不同，一�?2位的除法需�?0-140个时钟周期，�{�于一个固定的旉��加上每个位被除的旉��?br />Time (分子/ 分母) = C0 + C1* log2 (分子/分母)
= C0 + C1 * (log2 (分子) - log2 (分母)).
　　现在的ARM处理器需要消�?0+4.3N个时钟周期，�q�是一个非常费时的操作�Q�要��可能的避免。在有些情况下，除法表达式可以用乘法表达是来重写。比方说�Q?a/b)>c可以写成a>(c*b),条�g是我们已�l�知道b为非负数而且b*c不会��过整型数的取��D��围。如果我们能够确定其中的一个操作数为unsigned�Q�那么��用无�W�号除法��会更好�Q�因为它要比有符号除法快得多�?/p>

合�ƈ除法�q�算和取余运��?/ Combining division and remainder
　　在一些情况下�Q�除法运��和取余�q�算都需要用刎ͼ�在这�U�情况下�Q�编译器会将除法�q�算和取余运��合�qӞ��因�ؓ除法�q�算��L��同时�q�回商和余数。如果两个运��都要用刎ͼ�我们可以��他们写��C��P��译者：不要�l�究下面的代码的含义�Q�只是阐�q�写�?#8220;一�?#8221;�Q?br />int func_div_and_mod (int a, int b) {
return (a / b) + (a % b);
}

除数是２的幂的除法和取余 / Division and remainder by powers of two
　　如果除法�q�算中的除数是２的幂�Q�我们对�q�个除法�q�算�q�可以进一步优化，�~�译器会使用�U�M��q�算来进行这�U�除法运��。所以，我们要尽可能�~�放比例为２的幂(比方说要用６�Q�而不用６�Q?。如果是无符��h��Q�它要比有符��L��快得多�?br />    typedef unsigned int uint;
    uint div32u (uint a) {
     return a / 32;
    }
    int div32s (int a){
     return a / 32;
    }
�q�两个除法都会避免调用除法函敎ͼ�另外�Q�无�W�号的除法要比有�W�号的除法��用更��的指��o。有�W�号的除法要耗费更多的时��_��因�ؓ除法是��最�l�结果趋向于零的�Q�而移位则是趋向于负无�I��?/p>

取模�q�算的变�?/ An alternative for modulo arithmetic
我们一般��用取余运��进行取模，不过�Q�有时候��用if语句也是可行的。考虑下面的两个例子：
    uint modulo_func1 (uint count)
    {
       return (++count % 60);
    }
    uint modulo_func2 (uint count)
    {
       if (++count >= 60)
      count = 0;
      return (count);
    }
�W�二个例子要比第一个更可取�Q�因为由它��生的代码会更快，注意�Q�这只是在count取��D��围在0 – 59之间的时候才行�?/p>

使用数组索引 / Using array indices
假设你要依据某个变量的��|��讄��另一个变量的取��gؓ特定的字�W�，你可能会�q�样做：
    switch ( queue ) {
    case 0 :   letter = 'W';
       break;
    case 1 :   letter = 'S';
       break;
    case 2 :   letter = 'U';
       break;
    }
或者这��P��
    if ( queue == 0 )
      letter = 'W';
    else if ( queue == 1 )
      letter = 'S';
    else
      letter = 'U';
有一个简�z�且快速的方式是简单的��变量的取值做成一个字�W�串索引�Q�例如：
static char *classes="WSU";
letter = classes[queue];

全局变量 / Global variables
全局变量不会被分配在寄存器上�Q�修改全局变量需要通过指针或者调用函数的方式间接�q�行。所以编译器不会��全局变量存储在寄存器中，那样会带来额外的、不必要的负担和存储�I�间。所以在比较关键的��@环中�Q�我们要不��用全局变量�?br />如果一个函数要频繁的��用全局变量�Q�我们可以��用局部变量，作�ؓ全局变量的拷贝，�q�样��可以��用寄存器了。条件是本函数调用的��M��子函��C��使用�q�些全局变量�?br />举个例子�Q?br />    int f(void);
    int g(void);
    int errs;
    void test1(void)
    {
      errs += f();
      errs += g();
    }

    void test2(void)
    {
      int localerrs = errs;
      localerrs += f();
      localerrs += g();
      errs = localerrs;
    }
可以看到test1()中每�ơ加法都需要读取和存储全局变量errs�Q�而在test2()中，localerrs分配在寄存器上，只需要一条指令�?/p>

使用别名 / Using Aliases
考虑下面的例子：
    void func1( int *data )
    {
        int i;
        for(i=0; i<10; i++)
        {
              anyfunc( *data, i);
        }
    }
即��*data从来没有变化�Q�编译器却不知道anyfunc()没有修改它，于是�E�序每次用到它的时候，都要把它从内存中��d��来，可能它只是某些变量的别名�Q�这些变量在�E�序的其他部分被修改。如果能够确定它不会被改变，我们可以�q�样写：
    void func1( int *data )
    {
        int i;
        int localdata;
        localdata = *data;
        for(i=0; i<10; i++)
        {
              anyfunc ( localdata, i);
        }
    }
�q�样会给�~�译器优化工作更多的选择余地�?/p>

�zȝ��变量和泄�?/ Live variables and spilling
寄存器的数量在每个处理器当中都是固定的，所以在�E�序的某个特定的位置�Q�可以保存在寄存器中的变量的数量是有限制的�?br />有些�~�译器支�?#8220;生命周期分割”�Q�live-range splitting�Q�，也就是说在程序的不同部分�Q�变量可以被分配��C��同的寄存器或者内存中。变量的生命范围被定义成�Q��v�Ҏ��对该变量的一�ơ空间分配，�l�点是在下次�I�间分配之前的最后一�ơ��用之间。在�q�个范围内，变量的值是合法的，是活的。在生命范围之外�Q�变量不再被使用�Q�是�ȝ��Q�它的寄存器可以供其他变量��用，�q�样�Q�编译器��可以安排更多的变量到寄存器当中�?br />可分配到寄存器的变量需要的寄存器数量等于经�q�生命范围重叠的变量的数目，如果�q�个数目��过可用的寄存器的数量，有些变量��必��被暂时的存储到内存中。这�U�处理叫�?#8220;泄漏(spilling)”�?br />�~�译器优先泄漏最不频�J��用的变量�Q�将泄漏的代价降到最低。可以通过以下方式避免变量�?#8220;泄漏”�Q?br />�?#160;限制�z�d��量的最大数目：通常可以使用��单小巧的表达式，在函数内部不使用太多的变量。把大的函数分割成更加简单的、更加小巧的多个函数�Q�也可能会有所帮助�?br />�?#160;使用关键字register修饰最�l�常使用的变量：告诉�~�译器这个变量将会被�l�常用到�Q�要求编译器使用非常高的优先�U�将此变量分配到寄存器中。尽��如此，在某些情况下�Q�变量还是可能被泄漏�?/p>

变量�c�d�� / Variable Types
C�~�译器支持基本的变量�c�d��Q�char、short、int、long(signed、unsigned)、float、double。�ؓ变量定义最恰当的类型，非常重要�Q�因��样可以减��代码和数据的长度，可以非常显著的提高效率�?/p>

局部变�?/ Local variables
如果可能�Q�局部变量要避免使用char和short。对于char和short�c�d��Q�编译器在每�ơ分配空间以后，都要��这�U�局部变量的��寸减少�?位或16位。这对于�W�号变量来说�U�Cؓ�W�号扩展�Q�对无符号变量称为无�W�号扩展。这�U�操作是通过��寄存器左移24�?6位，然后再有�W�号�Q�或无符��L��Q�右�U�d��L��位数来实现的�Q�需要两条指令（无符号字节变量的无符��h��展需要一条指令）�?br />�q�些�U�M��操作可以通过使用int和unsigned int的局部变量来避免。这对于那些首先��数据调到局部变量然后利用局部变量进行运��的情况��其重要。即使数据以8位或16位的形式输入或输出，把他们当�?2位来处理仍是有意义的�?br />我们来考虑下面的三个例子函敎ͼ�
    int wordinc (int a)
    {
       return a + 1;
    }
    short shortinc (short a)
    {
        return a + 1;
    }
    char charinc (char a)
    {
        return a + 1;
    }
他们的运��结果是相同的，但是�W�一个代码片断要比其他片断运行的要快�?/p>

指针 / Pointers
如果可能�Q�我们应该��用结构体的引用作为参敎ͼ�也就是结构体的指针，否则�Q�整个结构体��׃��被压入堆栈，然后传递，�q�会降低速度。程序适用��g��递可能需要几K字节�Q�而一个简单的指针也可以达到同��L��目的�Q�只需要几个字节就可以了�?br />　　如果在函数内部不会改变结构体的内容，那么��应该将参数声明为const型的指针。�D个例子：
    void print_data_of_a_structure ( const Thestruct *data_pointer)
    {
        ...printf contents of the structure...
    }
　　�q�个例子代码告知�~�译器在函数内部不会改变外部�l�构体的内容�Q�访问他们的时候，不需要重诅R��还可以��保�~�译器捕捉�Q何修改这个只�ȝ��构体的代码，�l�结构体以额外的保护�?/p>

指针�?/ Pointer chains
指针铄��常被用来讉K��l�构体的信息�Q�比如，下面的这�D�常见的代码�Q?br /> typedef struct { int x, y, z; } Point3;
typedef struct { Point3 *pos, *direction; } Object;

    void InitPos1(Object *p)
    {
       p->pos->x = 0;
       p->pos->y = 0;
       p->pos->z = 0;
    }
代码中，处理器在每次赋值操作的时候都要重新装载p->pos�Q�因为编译器不知道p->pos->x不是p->pos的别名。更好的办法是将p->pos�~�存成一个局部变量，如下�Q?br />    void InitPos2(Object *p)
    {
       Point3 *pos = p->pos;
       pos->x = 0;
       pos->y = 0;
       pos->z = 0;
    }
另一个可能的�Ҏ��是将Point3�l�构体包含在Object�l�构体中�Q�完全避免指针的使用�?/p>

有条件的执行 / Conditional Execution
条�g执行主要用在if语句中，同时也会用到由关�p�运��?<,==,>�{?或bool�q�算(&&,!�{?�l�成的复杂的表达式�?br />��可能的保持if和else语句的简单是有好处的�Q�这��h��能很好的条�g化。关�p�表辑ּ�应该被分成包含相似条件的若干块�?br />下面的例子演�C�Z��~�译器如何��用条件执行：
    int g(int a, int b, int c, int d)
    {
       if (a > 0 && b > 0 && c < 0 && d < 0)
       //分组化的条�g被捆�l�在一�?br />          return a + b + c + d;
       return -1;
    }
条�g被分�l�，便以其能够条件化他们�?/p>

Boolean表达式和范围��?/ Boolean Expressions & Range checking
有一�U�常见的boolean表达式被用来��查是否一个变量取值在某个特定的范围内�Q�比方说�Q�检查一个点是否在一个窗口内�?br />    bool PointInRectangelArea (Point p, Rectangle *r)
    {
       return (p.x >= r->xmin && p.x < r->xmax &&
                          p.y >= r->ymin && p.y < r->ymax);
    }
�q�里�q�有一个更快的�Ҏ��Q�把(x >= min && x < max) 转换�?(unsigned)(x-min) < (max-min). ��其是min�?�Ӟ��更�ؓ有效。下面是优化后的代码�Q?br />    bool PointInRectangelArea (Point p, Rectangle *r)
    {
        return ((unsigned) (p.x - r->xmin) < r->xmax &&
       (unsigned) (p.y - r->ymin) < r->ymax);
    }

Boolean表达�?amp;与零的比�?/ Boolean Expressions & Compares with zero
在比�?CMP)指��o后，相应的处理器标志位就会被讄��。这些标志位也可以被其他的指令设�|�，诸如MOV, ADD, AND, MUL, 也就是基本的数学和逻辑�q�算指��o�Q�数据处理指令）。假如一条数据处理指令要讄��q�些标志位，那么N和Z标志位的讄��Ҏ��跟把数字和零比较的设�|�方法是一��L��。N标志位表�C�结果是不是负数�Q�Z标志位表�C�结果是不是零�?br />在C语言中，处理器中的N和Z标志位对应的有符��h��的关�p�运��符是x < 0, x >= 0, x == 0, x != 0�Q�无�W�号数对应的是x == 0, x != 0 (or x > 0)�?br />C语言中，每用��C��个关�p�运��符�Q�编译器��׃��产生一个比较指令。如果关�p�运��符是上面的其中一个，在数据处理指令紧跟比较指令的情况下，�~�译器就会将比较指��o优化掉。比如：
    int aFunction(int x, int y)
    {
       if (x + y < 0)
          return 1;
      else
         return 0;
    }
�q�样做，会在关键循环中节省比较指令，使代码长度减��，效率增加。C语言中没有借位(carry)标志位和溢出(overflow)标志位的概念�Q�所以如果不使用内嵌汇编语言�Q�要讉K��C和V标志位是不可能的。尽��如此，�~�译器支持借位标志位（无符��h��溢出�Q�，比方��_��
    int sum(int x, int y)
    {
       int res;
       res = x + y;
       if ((unsigned) res < (unsigned) x) // carry set? //
         res++;
       return res;
    }

Lazy Evaluation Exploitation
In a if(a>10 && b=4) type of thing, make sure that the first part of the AND expression is the most likely to give a false answer (or the easiest/quickest to calculate), therefore the second part will be less likely to be executed.

用switch() 代替if...else...
在条仉��择比较多的情况下，可以用if…else…else…�Q�像�q�样�Q?br />    if( val == 1)
        dostuff1();
    else if (val == 2)
        dostuff2();
    else if (val == 3)
        dostuff3();
使用switch可以更快�Q?br />    switch( val )
    {
        case 1: dostuff1(); break;
        case 2: dostuff2(); break;
        case 3: dostuff3(); break;
    }
在if语句中，即��是最后一个条件成立，也要先判断所有前面的条�g是否成立。Switch语句能够去除�q�些额外的工作。如果你不得不��用if…else�Q�那��把最可能的成立的条�g攑֜�前面�?/p>

二进制分�?/ Binary Breakdown
把判断条件做成二�q�制的风��|��比如�Q�不要��用下面的列表�Q?br />    if(a==1) {
    } else if(a==2) {
    } else if(a==3) {
    } else if(a==4) {
    } else if(a==5) {
    } else if(a==6) {
    } else if(a==7) {
    } else if(a==8)
    {
    }
而采用：
    if(a<=4) {
        if(a==1)     {
        } else if(a==2) {
        } else if(a==3) {
        } else if(a==4)   {
        }
    }
    else
    {
        if(a==5) {
        } else if(a==6)   {
        } else if(a==7) {
        } else if(a==8) {
        }
    }
甚至�Q?br />    if(a<=4)
    {
        if(a<=2)
        {
            if(a==1)
            {
                /* a is 1 */
            }
            else
            {
                /* a must be 2 */
            }
        }
        else
        {
            if(a==3)
            {
                /* a is 3 */
            }
            else
            {
                /* a must be 4 */
            }
        }
    }
    else
    {
        if(a<=6)
        {
            if(a==5)
            {
                /* a is 5 */
            }
            else
            {
                /* a must be 6 */
            }
        }
        else
        {
            if(a==7)
            {
                /* a is 7 */
            }
            else
            {
                /* a must be 8 */
            }
        }
    }
慢速、低�?#160;快速、高�?br />       c=getch();
       switch(c){
           case 'A':
           {
               do something;
               break;
           }
           case 'H':
           {
               do something;
               break;
           }
           case 'Z':
           {
                do something;
                break;
            }
        } c=getch();
        switch(c){
            case 0:
            {
                do something;
                break;
            }
            case 1:
            {
                do something;
                break;
            }
            case 2:
            {
                do something;
                break;
            }
        }
以上是两个case语句之间的比�?/p>

switch语句和查找表 / Switch statement vs. lookup tables
switch语句通常用于以下情况�Q?br />�?#160;调用几个函数中的一�?br />�?#160;讄��一个变量或�q�回�?br />�?#160;执行几个代码片断中的一�?br />如果case表示是密集的�Q�译者：�q�箋的？�Q�，在��用switch语句的前两种情况中，可以使用效率更高的查找表。比如下面的两个实现汇编代码转换成字�W�串的例�E�：
    char * Condition_String1(int condition) {
      switch(condition) {
         case 0: return "EQ";
         case 1: return "NE";
         case 2: return "CS";
         case 3: return "CC";
         case 4: return "MI";
         case 5: return "PL";
         case 6: return "VS";
         case 7: return "VC";
         case 8: return "HI";
         case 9: return "LS";
         case 10: return "GE";
         case 11: return "LT";
         case 12: return "GT";
         case 13: return "LE";
         case 14: return "";
         default: return 0;
      }
    }

    char * Condition_String2(int condition) {
       if ((unsigned) condition >= 15) return 0;
          return
          "EQ\0NE\0CS\0CC\0MI\0PL\0VS\0VC\0HI\0LS\0GE\0LT\0GT\0LE\0\0" +
           3 * condition;
    }
�W�一个例�E�需�?40个字节，�W�二个只需�?2个�?/p>

循环 / Loops
在大多数�E�序中，循环是一�U�常见的�l�构�Q�相当数量的执行旉��被消耗在循环上，因此在时间苛�ȝ��循环上付出注意是值得的�?/p>

循环�l�止 / Loop termination
如果�~�写循环�l�止条�g是不加留意，��可能会�l�程序带来明昄��负担。我们应该尽量��?#8220;倒数到零”的��@环，使用��单的循环�l�止条�g。��@环终止条件相对简单，�E�序在执行的时候也会消耗相对少的时间。拿下面两个计算n!的例子来��_��W�一个例子��用递增循环�Q�第二个使用递减循环�?br />    int fact1_func (int n)
    {
        int i, fact = 1;
        for (i = 1; i <= n; i++)
          fact *= i;
        return (fact);
    }

    int fact2_func(int n)
    {
        int i, fact = 1;
        for (i = n; i != 0; i--)
           fact *= i;
        return (fact);
    }
�l�果是，�W�二个例子要比第一个快得多�?/p>

更快的for()循环 / Faster for() loops
�q�是一个简单而有效的概念�Q�通常情况下，我们习惯把for循环写成�q�样�Q?br />for( i=0; i<10; i++){ ... }
i��g��ơ�ؓ�Q?,1,2,3,4,5,6,7,8,9
在不在乎循环计数器顺序的情况下，我们可以�q�样�Q?br />for( i=10; i--; ) { ... }
i��g��ơ�ؓ: 9,8,7,6,5,4,3,2,1,0,而且循环要更�?br />�q�种�Ҏ��是可行的�Q�因为它是用更快的i--作�ؓ��试条�g的，也就是说“i是否为非零数�Q�如果是减一�Q�然后��l?#8221;。相对于原先的代码，处理器不得不“把i减去10�Q�结果是否�ؓ非零敎ͼ�如果是，增加i�Q�然后��l?#8221;�Q�在紧密循环(tight loop)中，�q�会产生显著的区别�?br /> �q�种语法看�v来有一炚w��生，却完全合法。��@环中的第三条语句是可选的�Q�无限��@环可以写成这样for(;;)�Q?下面的写法也可以取得同样的效果：
for(i=10; i; i--){}
或�?
for(i=10; i!=0; i--){}
我们唯一要小心的地方是要��C��循环需要停止在0�Q�如果��@环是�?0-80�Q�这样做��׃��行了�Q�，而且循环的计数器为倒计数方式�?br />另外�Q�我们还可以把计数器分配到寄存器上，可以产生更�ؓ有效的代码。这�U�将循环计数器初始化成��@环次敎ͼ�然后递减到零的方法，同样适用于while和do语句�?/p>

混合循环/ Loop jamming
在可以��用一个��@环的场合�Q�决不要使用两个。但是如果你要在循环中进行大量的工作�Q�超�q�处理器的指令缓冲区�Q�在�q�种情况下，使用两个分开的��@环可能会更快�Q�因为有可能�q�两个��@环都被完整的保存在指令缓冲区里了�?br />        //原先的代�?br />        for(i=0; i<100; i++){
            stuff();
        }

        for(i=0; i<100; i++){
            morestuff();
        }
         //更好的做�?br />        for(i=0; i<100; i++){
            stuff();
            morestuff();
        }

函数循环 / Function Looping
调用函数的时候，在性能上就会付��Z��定的代�h。不光要改变�E�序指针�Q�还要将那些正在使用的变量压入堆栈，分配新的变量�I�间。�ؓ了提高程序的效率�Q�在�E�序的函数结构上�Q�有很多工作可以做。保证程序的可读性的同时�Q�还要尽量控制程序的大小�?br /> 如果一个函数在一个��@环中被频�J�调用，��可以考虑��这个��@环放在函数的里面�Q�这样可以免去重复调用函数的负担�Q�比如：
    for(i=0 ; i<100 ; i++)
    {
        func(t,i);
    }

    void func(int w,d)
    {
        lots of stuff.
    }
可以写成…
    func(t);

    void func(w)
    {
        for(i=0 ; i<100 ; i++)
        {
            //lots of stuff.
        }
    }

循环的拆�?/ Loop unrolling
��Z��提高效率�Q�可以将��的循环解开�Q�不�q�这样会增加代码的尺寸。��@环被拆开后，会降低��@环计数器更新的次敎ͼ�减少所执行的��@环的分支数目。如果��@环只重复几次�Q�那它完全可以被拆解开�Q�这��P��由��@环所带来的额外开销��׃��消失�?/p>

比如:
        for(i=0; i<3; i++){
            something(i);
        }

        //更高效的方式
         something(0);
        something(1);
        something(2);
因�ؓ在每�ơ的循环中，i的值都会增加，然后��查是否有效。编译器�l�常会把�q�种��单的循环解开�Q�前提是�q�些循环的次数是固定的。对于这��L��循环�Q?br />for(i=0;i< limit;i++) { ... }
��׃��可能被拆解，因�ؓ我们不知道它循环的次数到底是多少。不�q�，��这�U�类型的循环拆解开�q�不是不可能的�?/p>

与简单��@环相比，下面的代码的长度要长很多�Q�然而具有高得多的效率。选择8作�ؓ分块大小�Q�只是用来演�C�，��M��合适的长度都是可行的。例子中�Q��@环的成立条�g每八�ơ才被检验一�ơ，而不是每�ơ都要检验。如果需要处理的数组的大��是��定的，我们��可以��用数�l�的大小作�ؓ分块的大��（或者是能够整除数组长度的数��|��。不�q�，分块的大��跟�pȝ��的缓存大��有兟�?br />    //�?
    #include
    #define BLOCKSIZE (8)
    void main(void)
    {
    int i = 0;
    int limit = 33; /* could be anything */
    int blocklimit;

    /* The limit may not be divisible by BLOCKSIZE,
     * go as near as we can first, then tidy up.
     */
    blocklimit = (limit / BLOCKSIZE) * BLOCKSIZE;

    /* unroll the loop in blocks of 8 */
    while( i < blocklimit )
    {
        printf("process(%d)\n", i);
        printf("process(%d)\n", i+1);
        printf("process(%d)\n", i+2);
        printf("process(%d)\n", i+3);
        printf("process(%d)\n", i+4);
        printf("process(%d)\n", i+5);
        printf("process(%d)\n", i+6);
        printf("process(%d)\n", i+7);
        /* update the counter */
        i += 8;
    }
    /*
     * There may be some left to do.
     * This could be done as a simple for() loop,
     * but a switch is faster (and more interesting)
     */
    if( i < limit )
    {
        /* Jump into the case at the place that will allow
         * us to finish off the appropriate number of items.
         */
        switch( limit - i )
        {
            case 7 : printf("process(%d)\n", i); i++;
            case 6 : printf("process(%d)\n", i); i++;
            case 5 : printf("process(%d)\n", i); i++;
            case 4 : printf("process(%d)\n", i); i++;
            case 3 : printf("process(%d)\n", i); i++;
            case 2 : printf("process(%d)\n", i); i++;
            case 1 : printf("process(%d)\n", i);
        }
    }
    }
人口�l�计-计算非零位的个数 / Population count - counting the number of bits set
�?��试单个的最低位�Q�计敎ͼ�然后�U�M��。例2则是先除4�Q�然后计��被4处的每个部分。��@环拆解经�怼��l�程序优化带来新的机会�?br />    //Example - 1
    int countbit1(uint n)
    {
      int bits = 0;
      while (n != 0)
      {
        if (n & 1) bits++;
        n >>= 1;
       }
      return bits;
    }
    //Example - 2
    int countbit2(uint n)
    {
       int bits = 0;
       while (n != 0)
       {
          if (n & 1) bits++;
          if (n & 2) bits++;
          if (n & 4) bits++;
          if (n & 8) bits++;
          n >>= 4;
       }
       return bits;
    }

及早的退出��@�?/ Early loop breaking
通常没有必要遍历整个循环。�D例来��_��在数�l�中搜烦一个特定的��|��我们可以在找到我们需要��g��后立刻退出��@环。下面的例子�?0000个数字中搜烦-99�?br />    found = FALSE;
    for(i=0;i<10000;i++)
    {
        if( list[i] == -99 )
        {
            found = TRUE;
        }
    }
    if( found ) printf("Yes, there is a -99. Hooray!\n");
�q�样做是可行的，但是不管�q�个被搜索到的项目出现在什么位�|�，都会搜烦整个数组。跟好的�Ҏ��是，再找到我们需要的数字以后�Q�立刻退出��@环�?br />    found = FALSE;
    for(i=0; i<10000; i++)
    {
        if( list[i] == -99 )
        {
            found = TRUE;
            break;
        }
    }
    if( found ) printf("Yes, there is a -99. Hooray!\n");
如果数字出现在位�|?3上，循环��׃��l�止�Q�忽略剩下的9977个�?/p>

函数设计 / Function Design
保持函数短小�_�悍�Q�是对的。这可以使编译器能够跟高效地�q�行其他的优化，比如寄存器分配�?/p>

调用函数的开销 / Function call overhead
对处理器而言�Q�调用函数的开销是很��的�Q�通常�Q�在被调用函数所�q�行的工作中�Q�所占的比例也很��。能够��用寄存器传递的函数参数个数是有限制的。这些参数可以是整型兼容的（char,short,int以及float都占用一个字�Q�，或者是4个字以内的结构体�Q�包�?个字的double和long long�Q�。假如参数的限制�?�Q�那么第5个及后面的字都会被保存到堆栈中。这会增加在调用函数是存储这些参数的�Q�以及在被调用函��C��恢复�q�些参数的代仗��?br />    int f1(int a, int b, int c, int d) {
       return a + b + c + d;
    }
    int g1(void) {
       return f1(1, 2, 3, 4);
    }
    int f2(int a, int b, int c, int d, int e, int f) {
      return a + b + c + d + e + f;
    }
    ing g2(void) {
     return f2(1, 2, 3, 4, 5, 6);
    }
g2函数中，�W?�?个参数被保存在堆栈中�Q�在f2中被恢复�Q�每个参数带�?�ơ内存访问�?/p>

最��化参数传递开销 / Minimizing parameter passing overhead
��Z��传递参数给函数的代价降��x��低，我们可以�Q?br />��可能确保函数的形参不多于四个，甚至更少�Q�这样就不会使用堆栈来传递参数�?br />如果一个函数�Ş参多于四个，那就��保在这个函数能够做大量的工作，�q�样��可以抵消由传递堆栈参数所付出的代仗��?br />用指向结构体的指针作形参�Q�而不是结构体本��n�?br />把相关的参数攑ֈ�一个结构里里面�Q�然后把它的指针传给函数�Q�可以减��参数的个数�Q�增加程序的可读性�?br />��long�c�d��的参数的个数降到最��，因�ؓ它��用两个参数的�I�间。对于double也同样适用�?br />避免出现参数的一部分使用寄存器传输，另一部分使用堆栈传输的情��c��这�U�情况下参数��被全部压到堆栈里�?br />避免出现函数的参��C��C��定的情况。这�U�情况下�Q�所有参数都使用堆栈�?/p>

叶子函数 / Leaf functions
如果一个函��C��再调用其他函敎ͼ��q�样的函数被�U�Cؓ叶子函数。在许多应用�E�序中，大约一半的函数调用是对叶子函数的调用。叶子函数在所有��^��C��都可以得到非帔R��效的�~�译�Q�因��Z��们不需要进行参数的保存和恢复。在入口压栈和在出口退栈的代�h�Q�跟一个��够复杂的需�?个或�?个参数的叶子函数所完成的工作相比，是非常小的。如果可能的话，我们��p��量安排�l�常被调用的函数成�ؓ叶子函数。函数被调用的次数可以通过模型工具�Q�profiling facility�Q�来��定。这里有几种�Ҏ��可以��保函数被编译成叶子函数�Q?br />不调用其他函敎ͼ�包括那些被�{换成调用C语言库函数的�q�算�Q�比如除法、��Q点运��?br />使用关键字__inline修饰��的函数�?/p>

内嵌函数 / Inline functions
对于所有调试选项�Q�内嵌函数是被禁止的。��用inline关键字修饰函数后�Q�跟普通的函数调用不同�Q�代码中对该函数的调用将会被函数体本�w�代�ѝ��这会是代码更快�Q�另一斚w��它会影响代码的长度，��其是内嵌函数比较大而且�l�常被调用的情况下�?br />    __inline int square(int x) {
       return x * x;
    }
    #include
    double length(int x, int y){
        return sqrt(square(x) + square(y));
    }
使用内嵌函数有几个优点：
没有调用函数的开销。因为函数被直接代替�Q�没有�Q何额外的开销�Q�比如存储和恢复寄存器�?br />更低的参数赋值开销。参��C��递的开销通常会更低，因�ؓ它不需要复制变量。如果其中一些参数是帔R��Q�编译器�q�可以作�q�一步的优化�?br />内嵌函数的缺�Ҏ��如果函数在许多地方被调用�Q�将会增加代码的长度。长度差别的大小显著依赖于内嵌函数的大小和调用的�ơ数�?br />仅将��数关键函数讄��成内嵌函数是明智的。如果设�|�得当，内嵌函数可以减少代码的长度，一�ơ函数调用需要一定数量的指��o�Q�但是，使用优化�q�的内嵌函数可以�~�译成更��的指��o�?/p>

使用查找�?/ Using Lookup Tables
有些函数可以�q�似成查找表�Q�这样可以显著的提高效率。查找表的精度一般比计算公式的精度低�Q�不�q�在大多数程序中�Q�这�U�精度就��_��了�?br />许多信号处理软�g�Q�比如MODEM调制软�g�Q�会大量的��用sin和cos函数�Q�这些函��C��带来大量的数学运��。对于实时系�l�来��_��_�ֺ�不是很重要，sin/cos查找表显得更加实用。��用查找表的时候，��量��相�q�的�q�算合�ƈ成一个查找表�Q�这栯��比��用多个查找表要更快和使用更少的空间�?/p>

��点�q�算 / Floating-Point Arithmetic
��管��点�q�算对于��M��处理器来讲都是很�Ҏ��间的�Q�有的时候，我们�q�是不得不用到负点运��，比方说实��C��号处理。尽��如此，�~�写��点�q�算代码的时候，我们要牢讎ͼ�
��点除法是慢的。除法要比加法或者乘法慢两倍，我们可以把被一个常数除的运��写成被�q�个数的倒数乘（比如�Q�x=x/3.0写成x=x*(1.0/3.0)�Q�。倒数的计��在�~�译阶段��p��完成�?br />使用float代替double。Float型变量消耗更��的内存和寄存器�Q�而且因�ؓ它的低精度所以具有更高的效率。在�_�ֺ��_��的情况下�Q�就要��用float�?br />不要使用先验函数�Q�transcendental functions�Q�，先验函数�Q�比如sin�Q�cos�Q�log�Q�是通过使用一�p�d��的乘法和加法实现的，所以这些运��会比普通的乘法�?0倍以上�?br />��化��Q点表辑ּ�。编译器在整型跟��点型�؜合的�q�算中不会进行太多的优化。比�? * (x / 3) 不会被优化成x�Q�因为��Q点运��通常会导致精度的降低�Q�甚臌��辑ּ�的顺序都是重要的�Q?(a + b) + c 不等�?a + (b + c)。因此，�q�行手动的优化是有好处的�?br />不过�Q�在特定的场合下�Q��Q点运��的效率达不到指定的水��^�Q�这�U�情况下�Q�最好的办法可能是放弃��Q点运��，转而��用定点运��。当变量的变化范围��够的��，定点�q�算要比��点�q�算�_�ֺ�更高、速度更快�?/p>

其他的技�?/ Misc tips
一般情况下�Q�可以用存储�I�间换取旉��。你可以�~�存那些�l�常用到的数据，而不是每�ơ都重新计算、或者重新装载。比如sin/cos表，或者伪随机数的表（如果你不是真的需要随机数�Q�你可以在开始的时候计��?000个，在随后的代码中重复利用就是了�Q?br />��量��的使用全局变量�?br />��一个文件内部的变量声明成静态的�Q�除非它有必要成为全局的�?br />不要使用递归。递归可以使代码非常整齐和��观�Q�但会��生大量的函数调用和开销�?br />讉K��单维数组要比多位数组�?br />使用#defined宏代替经常用到的��函数�?/p>

参考文�?/ References
�Q�译者略�Q?/p>

其他�|�络资源 / Other URLs
http://www.xs4all.nl/~ekonijn/loopy.html
http://www.public.asu.edu/~sshetty/Optimizing_Code_Manual.doc
http://www.abarnett.demon.co.uk/tutorial.html

译者声明：作者对我的�q�片译文�q�不知情�Q�我在完全不知会作者的情况下翻译了其发表于www.codeproject.com的文章，但我保留了原文的作者信息。请您仅��此文用于学术研�I�目的。如果您要将此文用于其它目的�Q�请与原作者联�p�R��如果您认�ؓ文章��译的有问题�Q�译者将非常高兴看到您提出的宝贵意见�?br />

xlander 2006-07-21 10:07 发表评论

狠狠狠色丁香婷婷综合久久五月,国产精品一区二区久久不卡,久久综合色区

关于如何建立搜烦引擎的几���介�l�性的文章

Terrarium - �E�序�?上帝

软�g中应对全部工作完成的旉���做出预测

集装���q��攄���问题

�~�写高效的C代码

关于如何建立搜烦引擎的几��介�l�性的文章

软�g中应对全部工作完成的旉��做出预测

集装��q��攄��问题