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


最近一直在构思与写一套游戏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;
}