int   test( int value )
{
     if ( value > 0 ) return value;
}

   调用 int value = test( -1 );

   看下test的汇编代码.

关于8个程序寄存器一般只有esp寄存器作为入栈，出栈，调用和返回指令作为栈指针，其余

比如eax,exc等寄存器都没有固定的含义和固定值.
看下面test汇编代码.
int   test( int value )
{

; 4个寄存器入栈
; ebp 用于存放函数栈的栈顶指针
; esp 用于存放函数栈的栈底指针

004113A0  push        ebp              ;将寄存器ebp的内容压入程序栈
004113A1  mov         ebp,esp             ;保留esp寄存器
004113A3  sub         esp,0C0h             ;为该函数留出临时存储区
004113A9  push        ebx  
004113AA  push        esi  
004113AB  push        edi  

; 用0CCCCCCCCh初始化堆栈                
004113AC  lea         edi,[ebp-0C0h]        ;lea直接寻址
004113B2  mov         ecx,30h             ;利用编译器的offset立即寻址
004113B7  mov         eax,0CCCCCCCCh         ;eax=0CCCCCCCCh
004113BC  rep stos    dword ptr es:[edi]     ;根据edi的大小来重复指令执行次数

; 如果 cmp为真则把value的值保存到eax寄存器中
; 否则跳转到地址4113C7h,并没有对eax做处理

     if ( value > 0 ) return value;
004113BE  cmp         dword ptr [value],0 
004113C2  jle         test+27h (4113C7h) 
004113C4  mov         eax,dword ptr [value] 
}

;各指针出栈，对应前面3条push

004113C7  pop         edi              ;弹出edi
004113C8  pop         esi              ;弹出esi
004113C9  pop         ebx              ;弹出ebx
004113CA  mov         esp,ebp             ;把esp重新指向ebp(函数栈的栈顶指

针，test函数栈顶)
004113CC  pop         ebp              ;ebp重新指向test调用函数返回地址
004113CD  ret

调用汇编代码

int value = test ( 1 );
004113FE  push        1    
00411400  call        test (4110AFh) 
00411405  add         esp,4             ;Call test 函数时将压入栈数据，

由于只有一个参数，所以只有4字节
00411408  mov         dword ptr [value],eax 

当test 调用小于0时最后value指向的eax是一个0CCCCCCCCh，而对于基本数据类型大多value得到的是0CCCCCCCCh值.
如果我们的test函数:

int   test( int value )
{
     if ( value > 0 ) return value;
     return 0;
}

那么汇编代码会如下:

     if ( value > 0 ) return value;
004113EE  cmp         dword ptr [value],0 
004113F2  jle         test+29h (4113F9h) 
004113F4  mov         eax,dword ptr [value] 
004113F7  jmp         test+2Bh (4113FBh) 
     return 0;
004113F9  xor         eax,eax   ;将eax清零,作为返回值

   2 )如果返回的是一个引用对象
    

obj &  test( type value )
{
    if( type2 ) return obj;
}

obj & ob = test( type1 );

   如果ob是个空引用的话，就出出错，关于这种出错是否可以通过什么方式避免呢？

   我觉得warning C4715就应该是error C4715.让开发者从最开始就避免这种错误的发生。

关于内存池的设计和实现网上遍地都是，本文不具体介绍关于内存池的具体实现和方式，主要是介绍设计一个内存池怎样去测试其性能和安全处理，有一个开源的内存池项目tcmalloc也有介绍很多，但是为了满足多种需求，代码过于庞大，最后我用来测试分配性能测试。

1个内存池的测试用例应该包含：
1）该项目内存分配概率随机性.
2）同时保证释放的随机性.
3）可以支持多种分配方式（不同大小，不同对象参数等）.

要达到上面要求则可以设计
1.一个数组来设定需要分配的大小。
   long  arr[ ] = { 16,32,64,128,256,512,1024,2048,5120,5130,7000,6000,10240,15000,20000};

2.根据需求来指定各个大小的分配几率，这好比有多少概率选中某个数（需特定的分配）:
   

 A.针对这个需求可以设定定一个概率数组Odds,数组值arrArr的索引。
    B.针对Odds指定数组数据，使其数据分配达到arr需要分配概率。
       /**////   被分配的概率
       long  Odds[ ] = { 0,0,0,1,1,2,2,2,3,3,4,4,4,4,5,5,5,5,6,6,,7,7,7,8,8,8,8,9,9,9,10,10,11,12,12};
    C.随机Odds数组，然后得到其值分配，其值则为Arr的索引。
        long  Asize= arr[ Odds[ rand()%size ] ] ;

3.释放保证随机性。
     什么时候释放，以及分配了做什么用，都是又应用层决定的，所以需要把分配出来的内存通过一个容器来存储.
     由于分配是随机性，那么释放的时候也保证了随机性。

4.支持多种分配方式。
     A. 对象分配:     

MemFactory  Memory;

    A* a = Memory.Alloc<A>( );
    B* b = Memory.Alloc<B,int>( 2 );

    Memory.FreeObj( a );
    Memory.FreeObj( b );

    B.直接分配

void* p1 = Memory.Alloc( Asize );

5.性能测试
   为了测试性能，我选择了分配1000W次，其中用一个容器保存分配的数据，然后当容器到达100W的时候释放60W数据(保证数据正在使用，随机释放)。
   下面的Alloc time 只是统计的Alloc时间累加，Free time只是统计的Free 时间累加，Total time记录这次测试总共花费时间。

 1测试结果如下:
 2MemPool Alloc time 3242 ms  Free time: 2412 ms Total time 22535 ms
 3System    Alloc time 33616 ms Free time: 6676 ms Total time 55013 ms
 4TCMalloc Alloc time 3451 ms   Free time 1896 ms  Toal  time 21078 ms
 5
 6可以看到TCMalloc的分配和释放都比较快。。
 7
 8其中arr每个分配的大小命中概率。
 9Count[ 1 ] = 2436395
10Count[ 2 ] = 1281728
11Count[ 3 ] = 1026009
12Count[ 4 ] = 769123
13Count[ 5 ] = 768911
14Count[ 6 ] = 769335
15Count[ 7 ] = 640757
16Count[ 8 ] = 640974
17Count[ 9 ] = 512378
18Count[ 10 ] = 384841
19Count[ 11 ] = 256135
20Count[ 12 ] = 257367
21Count[ 13 ] = 256047

PS：
1.内存池的使用：
  

   一般情况下内存池，是整理一整块内存，然后通过一个list串连起来，然后分配的时候从链表中获取，释放也是插入到链表中。
    为了方便多对象的多参数以及无参数的分配，可以一些列宏和模板来实现:
    
    具体的可以参考后面附带的内存池实现的代码:
    
    #define DEFINE_CALL_CON( paramcount ) template <class T, DP_STMP_##paramcount( typename, tp ) >\
    inline T * Alloc(DP_MTMP_##paramcount( tp, p ) ){\
           unsigned long lSize = sizeof(T);\
           void* ptMem = Alloc(lSize);\
          if( !ptMem) return NULL; \
          T * pt = new(ptMem)T( LP_SNMP_##paramcount( p ) );\
          return pt;\
      }
    
    A. 对象分配:      
    MemFactory  Memory;

    A* a = Memory.Alloc<A>( );
    B* b = Memory.Alloc<B,int>( 2 );
    C* c = Memory.Alloc<C,int,const char*>(1,"dd");
    Memory.FreeObj( a );
    Memory.FreeObj( b );
       Memory.FreeObj( c );

    B.直接分配
    void* p1 = Memory.Alloc( Asize );
        memset(p1,0,ASize);

2.内存池的代码：
   1)   实现全是利用的freelist,减少内存开销，分配速度，直接定位。
   2)   管理都是通过工厂类来同一的管理。
   3)   指定分配策略.

   源码为Vs2008版本...

   /Files/expter/Pool.rar

关于实现有疑问和建议，可以提出宝贵的意见。。

        一个简单的游戏的具体环境如下:
         1.一个足球场(FootBallPitch)
         2.一个足球     FootBall
         3.二个球门     Goal
         4.二个球队     FootBallTeam
         5.场上12名足球队员（每队6名，期中5名为球员2名后卫3名前锋，还有1名守门员）
         6.球员             FootBaller    守门员  GoalKeeper
  
     然后只要理清上面的描述然后把具体的实现封装到每个类中，就实现了1个简单的足球仿真模拟，实现上面的功能代码还是简单，但是如何组织强大攻击性强大，防御性强的AI还是挺复杂的。
    
       下面将给出具体ＵＭＬ实现类图：   
       
          
         由于是基于智能体的足球ＡＩ所以还是借鉴了ＦＳＭ模型，我们可以把每个Player处于不同的状态进行不同的操作，具体把操作类型和事件处理都放在具体的状态中。
         基于球场上运球的FootBaller有下列状态ChaseBall 追球状态，Dribble运球  Gohome 归位   KickBall 踢球  ReceviveBall传球 
         基于守门员GoalKeeper有InterceptBall 拦截  PutBallBackInPlay发球.
  
        这里为了区分队员是前锋还是后卫，我们给队员增加一个行为Behaviors，让其根据自己的行为做相应的事情.。

        其中所有的图像处理都是用的GDI的绘制，程序采用的Win32编写方式。

       上面的设计基本是现在程序的设计方案和流程图。

        后期完善部分：
        1.引入基于事件响应，FootBaller 可以通知同队FootBaller 的接收响应的消息处理，比如A发现B的位置很好，A可以通知B我要传球到一个坐标点。
       2.加强防御和攻击AI。
       3.完成具体方案后，公布所有的方案设计和具体算法，后期引入脚本机制，通过外部编写脚本实现不同队伍AI模拟。