失乐园

>1

失乐园 — Fri, 8 Aug 2008 14:23:04 +0800

07.8 : http 半封闭

07.10 ：目录销售加班

07.12 ：彩票

08.3 ：lua脚本GUI方案

08.4 ：方案续

08.5 ：GUI框架软件

08.7 ：脚本空中营业厅

自从到公司以后有七次考核大于1，除了第一次，其他六次都是文件颁布之后获得，工资按照文件应该提升两级。

以上推论是理论情况，其实文件就是p。

LUA脚本不执行问题汇总（更新编辑）

失乐园 — Mon, 4 Aug 2008 20:37:57 +0800

1.语法错误无法解析。可以先用编辑器编译检查一下

2.互斥调用。同一时刻脚本内两个函数同时执行调用失败。这是由于脚本中函数A调用c接口a，a又调用脚本函数B，这时候A并没有返回，同时要求B要执行，在一个顺序执行的程序里面不可能成功。之后可以考虑脚本的并行执行。

3.函数不存在。返回nil。脚本函数不存在调用失败，但不会死掉。

4.脚本路径错误，导致无法解析文件。

5.脚本传输出错。在uclinux通过CRT的命令xrec下载会自动添加进行字节对齐，这样添加的乱码导致无法解析。自己进行字节对齐或者使用usb下载。

总之要保证各个环节都是正确的。

lua 编译到uClinux的库文件中

失乐园 — Fri, 1 Aug 2008 12:40:37 +0800

首先把lua原文件编译成静态库lualib.a，lua.h等三个主要头文件放到include文件夹中，链接lualib.a即可，注意-lm这个链接要放到 lualib这个库之后链接。

关于C++异常的理解 zz

失乐园 — Tue, 29 Jul 2008 10:22:53 +0800

潜心研究C++异常处理机制数日,有所得,与大家共享:

C++异常处理机制核心观点:

0.如果使用普通的处理方式:ASSERT,return等已经足够简洁明了,请不要使用异常处理机制.

1.比C的setjump,longjump优秀.

2.可以处理任意类型的异常.
  你可以人为地抛出任何类型的对象作为异常.
  throw 100;
  throw "hello";
  ...

3.需要一定的开销,频繁执行的关键代码段避免使用
  C++异常处理机制.

4.其强大的能力表现在:
  A.把可能出现异常的代码和异常处理代码隔离开,结构更清晰.
  B.把内层错误的处理直接转移到适当的外层来处理,化简了处理流程.传统的手段是通过一层层返回错误码把错误处理转移到上层,上层再转移到上上层,当层数过多时将需要非常多的判断, 以采取适当的策略.
  C.局部出现异常时,在执行处理代码之前,会执行堆栈回退,即为所有局部对象调用析构函数,保证局部对象行为良好.
  D.可以在出现异常时保证不产生内存泄漏.通过适当的try,catch布局,可以保证delete pobj;一定被执行.

  E.在出现异常时,能够获取异常的信息,指出异常原因.并可以给用户优雅的提示.
  F.可以在处理块中尝试错误恢复.保证程序几乎不会崩溃. 通过适当处理,即使出现除0异常,内存访问违例,也能让程序不崩溃,继续运行,这种能力在某些情况下及其重要.

以上ABCDEF可以使你的程序更稳固,健壮,不过有时让程序崩溃似乎更容易找到原因,程序老是不崩溃,如果处理结果有问题,有时很难查找.

5.并不是只适合于处理'灾难性的'事件.普通的错误处理也可以用异常机制来处理,不过如果将此滥用的话,可能造成程序结构混乱,因为异常处理机制本质上是程序处理流程的转移,不恰当的,过度的转移显然将造成混乱.许多人认为应该只在'灾难性的'事件上使用异常处理,以避免异常处理机制本身带来的开销,你可以认为这句话通常是对的.

6.先让程序更脆弱,再让程序更坚强.首先,它使程序非常脆弱,稍有差错,马上执行流程跳转掉,去寻找相应的处理代码,以求适当的解决方式.很像一个人身上带着许多药品,防护工具出行,稍有头晕,马上拿出清凉油;遇到蚊子立刻拿出电蚊拍灭之.
WINDOWS:
7.将结构化异常处理结合/转换到C++异常对象,可以更好地处理WINDOWS程序出现的异常.
8.尽一切可能使用try,catch,而不是win32本身的结构化异常处理或者MFC中的TRY,CATCH宏.用得恰到好处,方显C++异常之美妙!

图的广度/深度优先搜索

失乐园 — Mon, 28 Jul 2008 17:26:29 +0800

关键：队列、生成树、三种颜色。队列用来广度扩展，颜色记录当前状态，附加数据结构形成生成树。

算法分为三部分：

1.所有节点颜色标记为white，父节点为空。

2.根入队，颜色为灰。

3.循环，队首出队，将队首周围白色节点涂灰、指定父节点、并且入队，队首出队并且涂黑，继续循环到全部变黑。

最后搜索完毕。因为所有节点都入队过，出队过，所以最后变成全黑，只有灰色才入队。图用邻接表存储。

把队列去掉就是深度优先了。

排序二叉树操作

失乐园 — Fri, 11 Jul 2008 22:28:45 +0800

排序二叉树的创建实际是插入操作，这时候二叉树只有一个根。show操作可以采用中序遍历，删除操作一样是中序遍历。数据结构比较简单，明白原理编写代码也很容易。

树的内容基本被我自如掌握了，cheers！

#include
using namespace std ;

template
class stree
{
private:
struct node
{
  node *toFa ;
  node *toLeft ;
  node *toRight ;
  T data ;
};
node *root ;
public:
stree(){} ;
stree(T RootDat) ;
virtual ~stree() ;

int BuildTree(T* array, int n) ;
int InsertNode(T dat) ;
int ShowAll() ;
int Show(node *temp) ;
int Destroy(node *temp) ;
protected:

};

template
stree::stree(T RootDat)
{
root = new node ;
root->toFa = NULL ;
root->toLeft = NULL ;
root->toRight = NULL ;
root->data = RootDat ;

}

template
stree::~stree()
{
Destroy(root) ;
}

template
int stree::BuildTree(T* array, int n)
{

return 0 ;
}

template
int stree::InsertNode(T dat)
{
node * x = root ;
while (1)
{
  if (dat >= x->data)
  {
   if (x->toLeft == NULL) //左子树空则插入
   {
    x->toLeft = new node ;
    x->toLeft->toFa = x ;
    x->toLeft->data = dat ;
    cout<<"Insert!!" ;
    x->toLeft->toLeft = NULL ;
    x->toLeft->toRight = NULL ;
    break ;
   }
   else //非空则需要递归
   {
    x = x->toLeft ;
    continue ;
   }
  }
  else //右子树同左子树
  {
   if (x->toRight == NULL)
   {
    x->toRight = new node ;
    x->toRight->toFa = x ;
    x->toRight->data = dat ;
    x->toRight->toLeft = NULL ;
    x->toRight->toRight = NULL ;
    break ;
   }
   else
   {
    x = x->toRight ;
    continue ;
   }
  }
}
return 0 ;
}
template
int stree::Show(node *temp) //中序遍历
{
cout<<" "<data ;
if (temp->toLeft != NULL)
{
  Show(temp->toLeft) ;
}
if (temp->toRight != NULL)
{
  Show(temp->toRight) ;
}
return 0 ;
}

template
int stree::ShowAll()
{
return Show(root) ;
}

template
int stree::Destroy(node *temp) //一样是遍历
{
if (temp->toLeft != NULL)
{
Destroy(temp->toLeft) ;
}
if (temp->toRight != NULL)
{
Destroy(temp->toRight) ;
}
cout<<"delete "<data ;
delete temp ;
return 0 ;
}

void main()
{
streetr(2) ;
tr.InsertNode(3) ;
tr.InsertNode(1) ;
tr.InsertNode(32) ;
tr.InsertNode(34) ;
tr.InsertNode(30) ;
tr.ShowAll() ;
}

栈

失乐园 — Mon, 7 Jul 2008 14:26:54 +0800

#include
using namespace std ;

// 栈

template
class stack
{
public:
stack(int size) ;
virtual ~stack() ;
int push(T item) ;
T pop() ;
int leftsize() ;
T show(int n) ;
protected:
private:
int s_size ;
int s_used ;
T* st ;
};

template
stack::stack(int size)
{
s_size = size ;
s_used = 0 ;
st = new T[size] ;
}

template
stack::~stack()
{
delete []st ;
cout<<"in ~stack()"<}

template
int stack::push(T item)
{
if (s_used == s_size)
{
return -1 ;
}
st[s_used++] = item ;
return 0 ;
}

template
T stack::pop()
{
return st[--s_used] ;
}

template
int stack::leftsize()
{
return s_size - s_used ;
}

template
T stack::show(int n)
{
if (n<=s_used)
{
return st[n] ;
}
else
{
return st[0];
}
}

void main()
{
stacks(10) ;
s.push(1) ;
s.push(2) ;
s.push(3) ;
cout< cout< cout< cout< cout<

}

快速排序

失乐园 — Sat, 5 Jul 2008 14:41:05 +0800

快速排序分两个步骤：1.分队，以某个元素为标准左边比ta小，右边比ta大；2.递归，两边继续分。

#include

using namespace std ;

template
class QuikSort
{
public:
  QuikSort(){} ;
  virtual ~QuikSort(){} ;

  int QuikPartition(T* Array, int nLower, int nUpper) ;
  int DoSort(T *array , int p , int r) ;
protected:
private:

};

template
int QuikSort::QuikPartition(T* Array, int nLower, int nUpper)
{
int nLeft = nLower + 1;
T Pivot = Array[nLower];

int nRight = nUpper;

T Swap;
while (nLeft <= nRight)
{
  while (nLeft <= nRight && Array[nLeft]<= Pivot)
  {
   nLeft = nLeft + 1;
  }
  while (nLeft <= nRight && Array[nRight] >Pivot)
  {
   nRight = nRight - 1;
  }
  if (nLeft < nRight)
  {
   Swap = Array[nLeft];
   Array[nLeft] = Array[nRight];
   Array[nRight] = Swap;
   nLeft = nLeft + 1;
   nRight = nRight - 1;
  }
}

Swap = Array[nLower];
Array[nLower] = Array[nRight];
Array[nRight] = Swap;
return nRight;

}

template
int QuikSort::DoSort(T *array , int p , int r)
{
if (p < r)
{
  int j = QuikPartition(array , p , r ) ;
  DoSort(array, p , j-1) ;
  DoSort(array, j+1 , r) ;
  return 0 ;
}
else
{
  return -1 ;
}
}

int main()
{
QuikSortq ;
int a[8] = {5,31,2,6,4,31,3,7} ;

q.DoSort(a, 0 ,7) ;

for (int k = 0 ; k<8 ; k++)
{
cout<<" "< }

return 0 ;
}

堆排序

失乐园 — Fri, 4 Jul 2008 17:32:34 +0800

将无序数组看成完全二叉树，1.在这个二叉树上建立堆；2.去头剩下部分看成新数组重建堆——去下来的头依次有序。

12,32,1,3,6看成二叉树

32 1

3 6

建堆

12 1

3 6

去头32，剩下 12，1，3，6看成二叉树

1 3

建堆

6 3

之后同上。

代码如下，不消费多于空间，完全在原有空间上操作。

#include
using namespace std ;

template
class HeapSort
{
public:
  HeapSort(){} ;
  virtual ~HeapSort(){} ;

  int BuildHeap(T *array, int n) ;
  int DoSort(T *array , int n) ;
protected:
private:

};

template
int HeapSort::BuildHeap(T *array,int n)
{
for(int i =n ; i>1 ; i--)
{
  if (array[i-1]> array[i/2-1])
  {
   T temp = array[i/2-1] ;
   array[i/2-1] = array[i-1] ;
   array[i-1] = temp ;
  }
}
return 0 ;
}
template
int HeapSort::DoSort(T *array , int n)
{
T *p = array ;
for (int i = n ; i >0 ; i--)
{
  BuildHeap(p++ , i) ;
}
return 0 ;
}

int main()
{
HeapSort h ;
int a[5] = {12,32,1,3,6} ;

h.DoSort(a,5) ;
for (int i =0 ; i<5 ; i++)
{
cout< }

return 0 ;
}

好的算法是何其重要

失乐园 — Sat, 8 Mar 2008 18:54:56 +0800

//再看《计算机程序设计艺术》好书！盖茨说：如果你能看懂，来我微软工作吧！

#include
using namespace std;

class SharedSon
{
public:
SharedSon(int a , int b )
{
fatherA = a ;
fatherB = b ;
} ;
~SharedSon(){} ;
int GetMaxSon() ;
int GetMaxSonQ() ;
protected:
private:
int fatherA ;
int fatherB ;
};

int SharedSon:: GetMaxSon()
{
int Son = 0 , count = 0;
Son = (fatherA<=fatherB)? fatherA : fatherB ;

while (Son > 0)
{
  if (fatherA%Son == 0 && fatherB%Son == 0)
  {
   break ;
  }
  count++ ;
  Son-- ;
}
cout<<"count = "< return Son ;
}

int SharedSon::GetMaxSonQ()
{
int Son = 0 ,A = (fatherA<=fatherB)? fatherA : fatherB ,
B = (fatherA>=fatherB)? fatherA : fatherB, count = 0 ;

while (1)
{
  Son = B%A ;
  if (Son != 0)
  {
   B = A ;
   A = Son ;
   count++ ;
  }
  else
  {
   break ;
  }
}
cout<<"count(Q) = "<

return A ;
}
void main()
{
SharedSon a(23, 140) ;
cout< cout<}