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

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

问题肯定较多，希望多多指教。


最近一直在构思与写一套游戏AI系统，主要是通过状态机响应事件，更多是想运用自己学习到的一些优秀的算法，以及一些高级

的AI以此来锻炼对一些复杂的数据结构的编写和设计思维的提升。

算法和数据结构方面:
1.2D和3D寻路(主要包括2D寻路的初始化条件优化 ，3D的空间划分以及多叉树的划分，以及堆维护)。
2.带有更多思维的角色系统(附带更多的数据信息)判断。
3.查询线段树和树状数数组的运用。
4.一个线性的字符串过滤程序。
5.一个动态基于角色的最优二叉查找树的动态维护。(主要解决不同的角色AI触发频率建立一颗最优二叉查找树)
6.追踪算法以及游戏的群集算法都会整合到现在的AI系统中。

设计方面：
1.尽量让类之间耦合性更小，复杂度更低，浅显明确。

注：Ai系统写完会把代码和网络库的最新代码更新都会上传，希望大家多多指教。

                例子如下:

                2个整数10，7，把第1位的数值交换。

               整数          二进制        交换后二进制       交换后的值

                10             0x1010        0x1011                   11

                7               0x0111        0x0110                   6

             我的思路如下:

              1.如果要对第n位数值交换，先求出第n位的值(1或者0),如果相等则不交换。

              2.交换第n位，通过通过原理发现只需通过加减法运算即可，如果1->0 则减   1<<(n-1)  ，否则加1<<(n-1)。

代码如下：

 1void   prjfun( int & des , int & src , int n)
 2{
 3    if( n <= 0 ) return ;
 4
 5    int x = (des & (1<<(n-1))) >>(n-1);   // 求出第n位的数值
 6    int y = (src & (1<<(n-1))) >>(n-1);   // 求出第n位的数值
 7    if ( x != y )
 8    {
 9        des += (y-x)*(1<<(n-1));          // 交换
10        stc += (x-y)*(1<<(n-1));          // 交换
11    }
12}

           是否有一种高效的算法，只是进行一，两步位与或运算即可。。

 1#pragma region 类DTest信息
 2
 3// 声明一个类
 4template<class Type , int dim>
 5class DTest
 6{
 7public:
 8    // 构造函数
 9    DTest()
10    {
11        memset(_cords,0,sizeof(_cords));
12    }
13    DTest(Type cord[dim])
14    {
15        memcpy(_cords,cord,sizeof(cord));
16    }
17
18    // 友元模板
19    friend ostream & operator << (ostream & out , const DTest<Type,dim> & data);
20
21private:
22  Type _cords[dim];
23};
24// 友元模板的实现
25template<class Type, int dim>
26ostream & operator << (ostream & out , const DTest<Type,dim> & data)
27{
28    for(int i = 0 ; i < dim-1 ; i++)
29        out << data._cords[i] <<" ";
30
31    out <<endl;
32    return out;
33}
34
35#pragma endregion

用devc++，Vs2005,vc2008都不能编译通过，报连接错误，或者报模板函数是一个普通非模板类，或者非模板函数。

于是翻开C++  Primer，在16.4节有详细的说明，
1.对于一个特化的类，声明一个友元模板必须对友元模板授予类的一个实例。
2.对特定实例化的友元关系时，必须在可以用于友元声明之前声明类或函数。

所以下面是修改后的代码

 1template<class Type , int dim>
 2class DTest;
 3template<class Type , int dim>
 4ostream & operator << (ostream &out ,const DTest<Type,dim> &sess);
 5
 6
 7#pragma region 类DTest信息
 8template<class Type , int dim>
 9class DTest
10{
11public:
12        // 构造函数
13    DTest()
14    {
15        memset(_cords,0,sizeof(_cords));
16    }
17    DTest(Type cord[dim])
18    {
19        memcpy(_cords,cord,sizeof(cord));
20    }
21
22        // 特化时，<Type,dim> 省略为<>
23    friend ostream & operator << <>(ostream & out , const DTest<Type,dim> & data);
24
25private:
26  Type _cords[dim];
27};
28
29// 友元模板的实现
30template<class Type, int dim>
31ostream & operator << (ostream & out , const DTest<Type,dim> & data)
32{
33    for(int i = 0 ; i < dim-1 ; i++)
34        out << data._cords[i] <<" ";
35
36    out <<endl;
37    return out;
38}
39#pragma endregion

B. 常见的几种内存泄漏
  1.分配空间未释放
  2.嵌套对象指针未释放，
       比如，一个类中包含另一个类的指针，在初始化的时候分配空间，缺没有在析构函数释放他。
  3.释放一个对象数组的时候没有使用[] ,
       delete m_pObj; 只是释放第一个&m_pObj[0] 对象，应该使用delete [] m_pObj;
  4.出现浅拷贝现象
  5.返回一个动态分配的对象，其实可以看【effective c++】 的条款23: 必须返回一个对象时不要试图返回一个引用
    

先总结这些，以后慢慢记录我的学习笔记。


     

 1template<class T>
 2class Array
 3{
 4public:
 5    explicit Array(int _size = 0);
 6    T & operator [](int index);
 7    
 8};
 9
10Array<int> a(10);
11Array<int> b(10);
12
13if (a == b[i])
14{
15    // 如果没有加explicit，可以编译通过，加了就不能通过
16}
17// 要转换可以使用
18if (a == static_cast<int> b[i])
19{
20    ..
21}

1#define  STR(ST) #ST

 1对于ma等关联容器的元素删除
 2map<int,int> mp;
 3for (map<int,int>::iterator it = mp.begin(); it != mp.end();)
 4{
 5    if ()  //满足删除条件
 6    {
 7        mp.erase(it++);//删除当前节点，并返回下一个元素，自加
 8    }
 9    else
10    {
11        it++;
12    }
13}
14对于vector等标准容器的元素删除
15vector<int> ve;
16for (vector<int>::iterator it = ve.begin(); it != ve.end();)
17{
18    if ()  //满足删除条件
19    {
20        it = ve.erase(it);
21    }
22    else
23    {
24        it++;
25    }
26}
27
28关于2者区别主要是erase返回值问题，可以在网上查相关的说明，

   根据 Boost 文档所述，当您分配和释放许多小型对象时，建议使用池。使用池的另一个不太明显的优点在于，作为程序员，您不必担心内存泄露：内存由 Boost 库在内部自动进行管理。要使用 pool 库，您不必在链接时提供特定的库——单凭头文件就足以完成链接了。 有多个接口对 pool 库可用：
   关于Boost pool可以阅读
  http://www.ibm.com/developerworks/cn/aix/library/au-util_boost_lib/

 1template<typename TyVal>
 2class Lock
 3{
 4public:
 5    explicit Lock()
 6    {}
 7    explicit Lock(TyVal val):_val(val)
 8    {
 9        //加锁
10    }
11    ~Lock(){//释放}
12private:
13    TyVal _val;
14};
15
16如果我们有一段代码需要加锁，则可以直接使用
17vector<int> Vint;
18Lock<vector<int> > lock(Vint);
19可以直到lock的声明周期结束，释放资源

 1struct Test
 2{
 3    //
 4    
 5    Test & operator = (const Test &_t)
 6    {
 7        //关于此处是否需要增加一个 _t与*this的判断,
 8       memcpy(this,&t,sizeof(t));      
 9        return *this;
10    }
11    
12    //
13};

1、关于初始化:

deque<string> Deque;// 一个deque容器

deque<string> Deque2(Deque.begin(),Deque.end());                // 一种初始化

copy(Deque.begin(),Deque.end(),back_inserter(Deque2) );         // 一种初始化

deque<string> Deque3(istream_iterator<string>(cin),istream_iterator<string>()); // 一种初始化

typedef istream_iteraor<string> (Func)();

deque<string> Deque3(istream_iteraotr<string> cin, Func);  
看上去像一个函数声明，

typedef istream_iteraor<string> (Func)();
deque<string> f(stream_iteraor<string> ,Func);
现在比较清晰了吧，很像一个函数声明了，

所以第三种初始化方式根本就不能做任何事情.

//如果真的要达到初始化的目标，可以通过括号来消除二义性
deque<string> Deque3( (istream_iterator<string> (cin)) , istream_iterator<string>() );

int main()
{

  double  x = 1e8;
  
  while(x >0)
      x--;


   return 0;
}

 

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    int x = 1;
    for (int i =0 ; i < 100; i++)
    {
        ;
    }

    //  下面这行代码会干些什么？递增???????/
    ++x;
    std::cout << x << std::endl; 
    return 0;
}

struct X 
{
    static bool f(int *p)
    {
        return p &&0[p] and not p[1:>>p[2];
    }
};

先一步一步的分析
1:0[p] 其实和p[0]一样
2: and not都是有效关键字 ，他们分别是&& 和!
3::>竟然也是合法的，他是]的双字符写法。

所以这个语句会被解析为 return p && p[0] && !p[1]>p[2] ，没有语法错误。
很诡异。

# include <iostream>
using namespace std;
#define Q(x)  x*x
int main()
{
    int a =10;
    int b = 2;
    int c = 1;

    a /=Q(b+c)/Q(b+c);

    cout << a <<endl;
    return 0;
}

因为 宏Q(x) 不规范，
所以结果 很迷惑人

a   /=Q(b+c)/Q(b+c);的执行顺序是从右到左

tmp = Q(b+c)/Q(b+c) =  2+1*2+1 / 2+1*2+1 =2+2+0+2+1=7  没有对宏加括号是经常容易犯错！

a = a/tmp = 10/7 = 1

所以  a = 1;








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

题目2
反转一个字符串（西山居笔试题）：
题目：写一个函数，把一个以0字符结尾的字符串str中的'A'字符移到str的末尾！

分析：
1：以时间换空间   从后向前循环查找字符A
2：以空间换时间   一次循环

算法1代码：

void Deal(char *str )
{
    int len = strlen(str);
    int a= len-1,b=0;
    if (str[a] != '0')
    {
        return;             //如果最后一个字符不为'0'
    }
    while (a>=0)
    {
        if (str[a] == 'A')
        {
            int n = a;
            while (n < len-b-1)
            {
                str[n] = str[n+1];  //
                n++;
            }
            str[n] ='A';
            b++;           //b累加，表示有b个字符A
        }
        a--;
    }
}

void Deal(char *str )
{
    int len = strlen(str);
    int a= len-1,b=0,i=0,j=0;
    if (str[a] != '0')
    {
        return;             //如果最后一个字符不为'0'
    }
    char * tmp = new char[len+1];
    while(i<len)
    {
        if(str[i] !='A')
            tmp[j++] = str[i];
        else
            b++;          //多少个字符A
        i++;
    }

    while (j<len)
    {
        tmp[j++] = 'A';
    }
    tmp[len] = '\0';
    strcpy(str,tmp);

    
    delete tmp;   //释放空间
    tmp = NULL;
}