韩国av一区二区三区,国模一区二区三区,在线日韩电影

Freetype学习�W�记

HUYU — Thu, 10 Jul 2008 14:22:00 GMT

摘要: 转蝲时请注明出处和作者联�p�L��式：http://blog.csdn.net/absurd 作者联�p�L��式：Li XianJing 更新旉��Q?006-12-19 GTK+(��Z��DirectFB)的字体绘制是通过pango+freetype+fontconfig三者协作来完成的，其中�Q�fontconfig负责... 阅读全文

HUYU 2008-07-10 22:22 发表评论

写operator new和operator delete时要遵��@常规

HUYU — Tue, 22 Jan 2008 01:42:00 GMT

自己重写operator new�Ӟ��很重要的一�Ҏ��函数提供的行��和系�l�缺省的operator new一致。实际做��h��也就是：要有正确的返回��|��可用内存不够时要调用出错处理函数�Q�处理好0字节内存��h��的情��c��此外，�q�要避免不小心隐藏了标准形式的new�?

非类成员形式的operator new的伪代码�Q?

void * operator new(size_t size) // operator new�q�可能有其它参数
{

if (size == 0) // 处理0字节��h��Ӟ��
{

size = 1; // 把它当作1个字节请求来处理

}
while (1)

{
分配size字节内存;

if (分配成功)
return (指向内存的指�?;

    // 分配不成功，扑և�当前出错处理函数
      new_handler globalhandler = set_new_handler(0);
     set_new_handler(globalhandler);

if (globalhandler) (*globalhandler)();
else throw std::bad_alloc();
}
}

为特定类写的new往往没有考虑该类被��承的情况�Q��用sizeof(父类)获得大小�Q�但是如果发生子�c�调用父�cȝ��new�Ӟ��往往

会出错，子类的size往往大于父类的size。最好父�cȝ��new应该�q�么写：

void * base::operator new(size_t size)
{
if (size != sizeof(base)) // 如果数量“错误”�Q�让标准operator new�Q�精华部分�?/font>
return ::operator new(size); // ��d��理这个请�?br> //

... // 否则处理�q�个��h��
}

对于operator delete(以及它的伙伴operator delete[])�Q�情冉|��单。所要记住的只是�Q�c++保证删除�I�指针永�q�是安全的，所以你要充分地应用�q�一保证�?/p>

下面是非�c�L��员�Ş式的operator delete的伪代码�Q?br>void operator delete(void *rawmemory)
{
if (rawmemory == 0) return; //如果指针为空�Q�返�?br> //

释放rawmemory指向的内�?

return;
}

�q�个函数的类成员版本也简单，只是�q�必��L��查被删除的对象的大小。假讄��的operator new��?#8220;错误”大小的分配请求�{�l?:operator new�Q�那么也必须��?#8220;错误”大小的删除请求�{�l?:operator delete�Q?

void base::operator delete(void *rawmemory, size_t size)
{
if (rawmemory == 0) return; // ��查空指针

if (size != sizeof(base)) // 如果size"错误"�Q?/p>

{
::operator delete(rawmemory); // 让标准operator来处理请�?br> return;
}

释放指向rawmemory的内�?

return;
}

有关operator new和operator delete(以及他们的数�l��Ş�?的规定不是那么麻烦，重要的是必须遵守它。只要内存分配程序支持new-handler函数�q�正��地处理了零内存��h��Q�就差不多了�Q�如果内存释攄��序又处理了空指针�Q�那��没其他什么要做的了。至于在�c�L��员版本的函数里增加��承支持，那将很快��可以完成�?/p>

HUYU 2008-01-22 09:42 发表评论

堆和栈的区别

HUYU — Thu, 10 Jan 2008 05:22:00 GMT

一、预备知识—程序的内存分配
    一个由c/C++�~�译的程序占用的内存分�ؓ以下几个部分
    1、栈区（stack�Q��?��q��译器自动分配释放 �Q�存攑և�数的参数��|��局部变量的值等。其操作方式�c�M��于数据结构中的栈�?br>    2、堆区（heap�Q?�?一般由�E�序员分配释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式倒是�c�M��于链表，呵呵�?br>    3、全局区（静态区�Q�（static�Q�—，全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域�?- �E�序�l�束后有�pȝ��释放
    4、文字常量区—常量字�W�串��是攑֜��q�里的�?�E�序�l�束后由�pȝ��释放
    5、程序代码区—存攑և��C��的二�q�制代码�?/font>

例子�E�序
�q�是一个前辈写的，非常详细
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化�?br>main()
{
int b; �?br>char s[] = "abc"; �?br>char *p2; �?br>char *p3 = "123456"; 123456\0在常量区�Q�p3在栈上�?br>static int c =0�Q?全局�Q�静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来�?0�?0字节的区域就在堆区�?br>strcpy(p1, "123456"); 123456\0攑֜�帔R��区，�~�译器可能会��它与p3所指向�?123456"优化成一个地斏V�?br>}

二、堆和栈的理论知�?/font>

2.1甌��方式
stack:
��q��l�自动分配�?例如�Q�声明在函数中一个局部变�?int b; �pȝ��自动在栈中�ؓb开辟空�?br>heap:
需要程序员自己甌��Q��ƈ指明大小�Q�在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new�q�算�W?br>如p2 = (char *)malloc(10);
但是注意p1、p2本��n是在栈中的�?br>
2.2甌��后系�l�的响应
栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?br>堆：首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ��
会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的大小�Q�这��P��代码中的delete语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?br>
2.3甌��大小的限�?/strong>
栈：在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是�pȝ��预先规定好的�Q�在WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?br>堆：堆是向高地址扩展的数据结构，是不�q�箋的内存区域。这是由于系�l�是用链表来存储的空闲内存地址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效的虚拟内存。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?br>

2.4甌��效率的比�?/strong>
栈由�pȝ��自动分配�Q�速度较快。但�E�序员是无法控制的�?br>堆是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片,不过用�v来最方便.
另外�Q�在WINDOWS下，最好的方式是用VirtualAlloc分配内存�Q�他不是在堆�Q�也不是在栈是直接在�q�程的地址�I�间中保留一快内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��?br>
2.5堆和栈中的存储内�?/strong>
栈：在函数调用时�Q�第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的地址�Q�然后是函数的各个参敎ͼ�在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是函数中的局部变量。注意静态变量是不入栈的�?br>当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��的下一条指令，�E�序��p��点��l�运行�?br>堆：一般是在堆的头部用一个字节存攑֠�的大��。堆中的具体内容有程序员安排�?br>
2.6存取效率的比�?/strong>
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在�q�行时刻赋值的�Q?br>而bbbbbbbbbbb是在�~�译时就��定的；
但是�Q�在以后的存取中�Q�在栈上的数�l�比指针所指向的字�W�串(例如�?快�?br>比如�Q?br>�Q�i nclude
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇�~�代�?br>10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
�W�一�U�在��d��时直接就把字�W�串中的元素��d��寄存器cl中，而第二种则要先把指针��D��到edx中，在根据edx��d��字符�Q�显然慢了�?br>
2.7��结
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜�Q�发出申��P��、付钱、和吃（使用�Q�，吃饱了就赎ͼ�不必理会切菜、洗菜等准备工作和洗��、刷锅等扫尾工作�Q�他的好处是快捷�Q�但是自由度��?br>使用堆就象是自己动手做喜�Ƣ吃的菜��_��比较�ȝ��Q�但是比较符合自��q��口味�Q�而且自由度大�?br>

windows�q�程中的内存�l�构

在阅��L��文之前，如果你连堆栈是什么多不知道的话，请先阅读文章后面�?/font>基础知识�?br>
接触�q?/font>�~�程的�h都知道，高��语言都能通过变量名来讉K��内存中的数据。那么这些变量在内存中是如何存放的呢�Q�程序又是如何��用这些变量的呢？下面��׃��Ҏ��q�行深入的讨论。下文中的C语言代码如没有特别声明，默认都��用VC�~�译的release版�?br>
首先�Q�来了解一�?C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变�?Local)�Q�静态变�?Static)、寄存器变量(Regeister)。每�U�变量都有不同的分配方式。先来看下面�q�段代码�Q?br>
�Q�i nclude

int g1=0, g2=0, g3=0;

int main()
{
static int s1=0, s2=0, s3=0;
int v1=0, v2=0, v3=0;

//打印出各个变量的内存地址

printf("0x%08x\n",&v1); //打印各本地变量的内存地址
printf("0x%08x\n",&v2);
printf("0x%08x\n\n",&v3);
printf("0x%08x\n",&g1); //打印各全局变量的内存地址
printf("0x%08x\n",&g2);
printf("0x%08x\n\n",&g3);
printf("0x%08x\n",&s1); //打印各静态变量的内存地址
printf("0x%08x\n",&s2);
printf("0x%08x\n\n",&s3);
return 0;
}

�~�译后的执行�l�果是：

0x0012ff78
0x0012ff7c
0x0012ff80

0x004068d0
0x004068d4
0x004068d8

0x004068dc
0x004068e0
0x004068e4

输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量，g1,g2,g3是全局变量�Q�s1,s2,s3是静态变量。你可以看到�q�些变量在内存是�q�箋分布的，但是本地变量和全局变量分配的内存地址差了十万八千里，而全局变量和静态变量分配的内存是连�l�的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的�l�果。对于一个进�E�的内存�I�间而言�Q�可以在逻辑上分�?个部份：代码区，静态数据区和动态数据区。动态数据区一般就�?#8220;堆栈”�?#8220;�?stack)”�?#8220;�?heap)”是两�U�不同的动态数据区�Q�栈是一�U�线性结构，堆是一�U�链式结构。进�E�的每个�U�程都有�U�有�?#8220;�?#8221;�Q�所以每个线�E�虽然代码一��P��但本地变量的数据都是互不�q�扰。一个堆栈可以通过“基地址”�?#8220;栈顶”地址来描�q�。全局变量和静态变量分配在静态数据区�Q�本地变量分配在动态数据区�Q�即堆栈中。程序通过堆栈的基地址和偏�U�量来访问本地变量�?br>

├———————┤低端内存区域
�?…… �?br>├———————┤
�?动态数据区 �?br>├———————┤
�?…… �?br>├———————┤
�?代码�?�?br>├———————┤
�?静态数据区 �?br>├———————┤
�?…… �?br>├———————┤高端内存区域

堆栈是一个先�q�后出的数据�l�构�Q�栈��地址��L��于�{�于栈的基地址。我们可以先了解一下函数调用的�q�程�Q�以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定�Q�这些因素有参数的压入规则和堆栈的��^衡。windows API的调用规则和ANSI C的函数调用规则是不一��L��Q�前者由被调函数调整堆栈�Q�后者由调用者调整堆栈。两者通过“__stdcall”�?#8220;__cdecl”前缀区分。先看下面这�D�代码：

�Q�i nclude

void __stdcall func(int param1,int param2,int param3)
{
int var1=param1;
int var2=param2;
int var3=param3;
printf("0x%08x\n",?m1); //打印出各个变量的内存地址
printf("0x%08x\n",?m2);
printf("0x%08x\n\n",?m3);
printf("0x%08x\n",&var1);
printf("0x%08x\n",&var2);
printf("0x%08x\n\n",&var3);
return;
}

int main()
{
func(1,2,3);
return 0;
}

�~�译后的执行�l�果是：

0x0012ff78
0x0012ff7c
0x0012ff80

0x0012ff68
0x0012ff6c
0x0012ff70

├———————┤<—函数执行时的栈��Ӟ��ESP�Q�、低端内存区�?br>�?…… �?br>├———————┤
�?var 1 �?br>├———————┤
�?var 2 �?br>├———————┤
�?var 3 �?br>├———————┤
�?RET �?br>├———————┤<�?#8220;__cdecl”函数�q�回后的栈顶�Q�ESP�Q?br>�?parameter 1 �?br>├———————┤
�?parameter 2 �?br>├———————┤
�?parameter 3 �?br>├———————┤<�?#8220;__stdcall”函数�q�回后的栈顶�Q�ESP�Q?br>�?…… �?br>├———————┤<—栈底（基地址 EBP�Q�、高端内存区�?br>

上图��是函数调用�q�程中堆栈的样子了。首先，三个参数以从又到左的�ơ序压入堆栈�Q�先�?#8220;param3”�Q�再�?#8220;param2”�Q�最后压�?#8220;param1”�Q�然后压入函数的�q�回地址(RET)�Q�接着跌��{到函数地址接着执行�Q�这里要补充一点，介绍UNIX下的�~�冲溢出原理的文章中都提到在压入RET后，�l�箋压入当前EBP�Q�然后用当前ESP代替EBP。然而，有一��介�l�windows下函数调用的文章中说�Q�在windows下的函数调用也有�q�一步骤�Q�但�Ҏ��我的实际调试�Q��ƈ未发现这一步，�q�还可以从param3和var1之间只有4字节的间隙这点看出来�Q�；�W�三步，��栈��?ESP)减去一个数�Q��ؓ本地变量分配内存�I�间�Q�上例中是减�?2字节(ESP=ESP-3*4�Q�每个int变量占用4个字�?�Q�接着��初始化本地变量的内存空间。由�?#8220;__stdcall”调用��p��调函数调整堆栈，所以在函数�q�回前要恢复堆栈�Q�先回收本地变量占用的内�?ESP=ESP+3*4)�Q�然后取��回地址�Q�填入EIP寄存器，回收先前压入参数占用的内�?ESP=ESP+3*4)�Q��l�执行调用者的代码。参见下列汇�~�代码：

;--------------func 函数的汇�~�代�?------------------

:00401000 83EC0C sub esp, 0000000C //创徏本地变量的内存空�?br>:00401003 8B442410 mov eax, dword ptr [esp+10]
:00401007 8B4C2414 mov ecx, dword ptr [esp+14]
:0040100B 8B542418 mov edx, dword ptr [esp+18]
:0040100F 89442400 mov dword ptr [esp], eax
:00401013 8D442410 lea eax, dword ptr [esp+10]
:00401017 894C2404 mov dword ptr [esp+04], ecx

……………………�Q�省略若�q�代码）

:00401075 83C43C add esp, 0000003C ;恢复堆栈�Q�回收本地变量的内存�I�间
:00401078 C3 ret 000C ;函数�q�回�Q�恢复参数占用的内存�I�间
;如果�?#8220;__cdecl”的话�Q�这里是“ret”�Q�堆栈将��p��用者恢�?br>
;-------------------函数�l�束-------------------------

;--------------�ȝ��序调用func函数的代�?-------------

:00401080 6A03 push 00000003 //压入参数param3
:00401082 6A02 push 00000002 //压入参数param2
:00401084 6A01 push 00000001 //压入参数param1
:00401086 E875FFFFFF call 00401000 //调用func函数
;如果�?#8220;__cdecl”的话�Q�将在这里恢复堆栈，“add esp, 0000000C”

聪明的读者看到这里，差不多就明白�~�冲溢出的原理了。先来看下面的代码：

�Q�i nclude
�Q�i nclude

void __stdcall func()
{
char lpBuff[8]="\0";
strcat(lpBuff,"AAAAAAAAAAA");
return;
}

int main()
{
func();
return 0;
}

�~�译后执行一下回怎么��P��哈，“"0x00414141"指��o引用�?0x00000000"内存。该内存不能�?read"�?#8221;�Q?#8220;非法操作”喽！"41"��是"A"�?6�q�制的ASCII码了�Q�那明显��是strcat�q�句出的问题了�?lpBuff"的大��只�?字节�Q�算�q�结��\0�Q�那strcat最多只能写�?�?A"�Q�但�E�序实际写入�?1�?A"外加1个\0。再来看看上面那�q�图�Q�多出来�?个字节正好覆盖了RET的所在的内存�I�间�Q�导致函数返回到一个错误的内存地址�Q�执行了错误的指令。如果能�_�ֿ�构造这个字�W�串�Q��它分成三部分�Q�前一部䆾仅仅是填充的无意义数据以辑ֈ�溢出的目的，接着是一个覆盖RET的数据，紧接着是一�D�shellcode�Q�那只要着个RET地址能指向这�D�shellcode的第一个指令，那函数返回时��p��执行shellcode了。但是��Y件的不同版本和不同的�q�行环境都可能媄响这�D�shellcode在内存中的位�|�，那么要构造这个RET是十分困隄��。一般都在RET和shellcode之间填充大量的NOP指��o�Q��得exploit有更强的通用性�?br>

├———————┤<—低端内存区�?br>�?…… �?br>├———————┤<—由exploit填入数据的开�?br>�?�?br>�?buffer �?lt;—填入无用的数据
�?�?br>├———————┤
�?RET �?lt;—指向shellcode�Q�或NOP指��o的范�?br>├———————┤
�?NOP �?br>�?…… �?lt;—填入的NOP指��o�Q�是RET可指向的范围
�?NOP �?br>├———————┤
�?�?br>�?shellcode �?br>�?�?br>├———————┤<—由exploit填入数据的结�?br>�?…… �?br>├———————┤<—高端内存区�?br>

windows下的动态数据除了可存放在栈中，�q�可以存攑֜�堆中。了解C++的朋友都知道�Q�C++可以使用new关键字来动态分配内存。来看下面的C++代码�Q?br>
�Q�i nclude
�Q�i nclude
�Q�i nclude

void func()
{
char *buffer=new char[128];
char bufflocal[128];
static char buffstatic[128];
printf("0x%08x\n",buffer); //打印堆中变量的内存地址
printf("0x%08x\n",bufflocal); //打印本地变量的内存地址
printf("0x%08x\n",buffstatic); //打印静态变量的内存地址
}

void main()
{
func();
return;
}

�E�序执行�l�果为：

0x004107d0
0x0012ff04
0x004068c0

可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC�~�译器是通过windows下的“�?heap)”来实现new关键字的内存动态分配。在�?#8220;�?#8221;之前�Q�先来了解一下和“�?#8221;有关的几个API函数�Q?br>
HeapAlloc 在堆中申请内存空�?br>HeapCreate 创徏一个新的堆对象
HeapDestroy 销毁一个堆对象
HeapFree 释放甌��的内�?br>HeapWalk 枚�D堆对象的所有内存块
GetProcessHeap 取得�q�程的默认堆对象
GetProcessHeaps 取得�q�程所有的堆对�?br>LocalAlloc
GlobalAlloc

当进�E�初始化�Ӟ��pȝ��会自动�ؓ�q�程创徏一个默认堆�Q�这个堆默认所占内存的大小�?M。堆对象��q��l�进行管理，它在内存中以铑ּ��l�构存在。通过下面的代码可以通过堆动态申请内存空��_��

HANDLE hHeap=GetProcessHeap();
char *buff=HeapAlloc(hHeap,0,8);

其中hHeap是堆对象的句柄，buff是指向申��L��内存�I�间的地址。那�q�个hHeap�I�竟是什么呢�Q�它的值有什么意义吗�Q�看看下面这�D�代码吧�Q?br>
#pragma comment(linker,"/entry:main") //定义�E�序的入�?br>�Q�i nclude

_CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf
/*---------------------------------------------------------------------------
写到�q�里�Q�我们顺便来复习一下前面所讲的知识�Q?br>(*�?printf函数是C语言的标准函数库中函敎ͼ�VC的标准函数库由msvcrt.dll模块实现�?br>由函数定义可见，printf的参��C��数是可变的，函数内部无法预先知道调用者压入的参数个数�Q�函数只能通过分析�W�一个参数字�W�串的格式来获得压入参数的信息，�׃��q�里参数的个数是动态的�Q�所以必��ȝ��调用者来�q��堆栈�Q�这里便使用了__cdecl调用规则。BTW�Q�Windows�pȝ��的API函数基本上是__stdcall调用形式�Q�只有一个API例外�Q�那��是wsprintf�Q�它使用__cdecl调用规则�Q�同printf函数一��P��q�是�׃��它的参数个数是可变的�~�故�?br>---------------------------------------------------------------------------*/
void main()
{
HANDLE hHeap=GetProcessHeap();
char *buff=HeapAlloc(hHeap,0,0x10);
char *buff2=HeapAlloc(hHeap,0,0x10);
HMODULE hMsvcrt=LoadLibrary("msvcrt.dll");
printf=(void *)GetProcAddress(hMsvcrt,"printf");
printf("0x%08x\n",hHeap);
printf("0x%08x\n",buff);
printf("0x%08x\n\n",buff2);
}

执行�l�果为：

0x00130000
0x00133100
0x00133118

hHeap的值怎么和那个buff的值那么接�q�呢�Q�其实hHeap�q�个句柄��是指向HEAP首部的地址。在�q�程的用户区存着一个叫PEB(�q�程环境�?的结构，�q�个�l�构中存攄��一些有兌��E�的重要信息�Q�其中在PEB首地址偏移0x18处存攄��ProcessHeap��是�q�程默认堆的地址�Q�而偏�U?x90处存放了指向�q�程所有堆的地址列表的指针。windows有很多API都��用进�E�的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中甌��内存来�{换ANSI字符串到Unicode字符串的。对一个堆的访问是��序�q�行的，同一时刻只能有一个线�E�访问堆中的数据�Q�当多个�U�程同时有访问要求时�Q�只能排队等待，�q�样侉K��成�E�序执行效率下降�?br>
最后来说说内存中的数据寚w��。所位数据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存�v始地址能被4除尽�Q�WORD数据的内存�v始地址能被2除尽�Q�x86 CPU能直接访问对齐的数据�Q�当他试图访问一个未寚w��的数据时�Q�会在内部进行一�p�d��的调��_��q�些调整对于�E�序来说是透明的，但是会降低运行速度�Q�所以编译器在编译程序时会尽量保证数据对齐。同样一�D�代码，我们来看看用VC、Dev-C++和lcc三个不同�~�译器编译出来的�E�序的执行结果：

�Q�i nclude

int main()
{
int a;
char b;
int c;
printf("0x%08x\n",&a);
printf("0x%08x\n",&b);
printf("0x%08x\n",&c);
return 0;
}

�q�是用VC�~�译后的执行�l�果�Q?br>0x0012ff7c
0x0012ff7b
0x0012ff80
变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)�?br>
�q�是用Dev-C++�~�译后的执行�l�果�Q?br>0x0022ff7c
0x0022ff7b
0x0022ff74
变量在内存中的顺序：c(4字节)-中间盔R��3字节-b(�?字节)-a(4字节)�?br>
�q�是用lcc�~�译后的执行�l�果�Q?br>0x0012ff6c
0x0012ff6b
0x0012ff64
变量在内存中的顺序：同上�?br>
三个�~�译器都做到了数据对齐，但是后两个编译器昄��没VC“聪明”�Q�让一个char占了4字节�Q�浪费内存哦�?br>

基础知识�Q?/font>
堆栈是一�U�简单的数据�l�构�Q�是一�U�只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈��Ӟ��另一端称为栈底，对堆栈的插入和删除操作被�U�Cؓ入栈和出栈。有一�l�CPU指��o可以实现对进�E�的内存实现堆栈讉K��。其中，POP指��o实现出栈操作�Q�PUSH指��o实现入栈操作。CPU的ESP寄存器存攑ֽ�前线�E�的栈顶指针�Q�EBP寄存器中保存当前�U�程的栈底指针。CPU的EIP寄存器存放下一个CPU指��o存放的内存地址�Q�当CPU执行完当前的指��o后，从EIP寄存器中��d��下一条指令的内存地址�Q�然后��l�执行�?

堆（Heap�Q�栈�Q�Stack�Q?

1、内存分配方面：

    堆：一般由�E�序�?/strong>分配释放�Q?若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式是�c�M��于链表。可能用到的关键字如下：new�?strong>malloc�?strong>delete�?strong>free�{�等�?

    栈：�?strong>�~�译�?/strong>(Compiler)自动分配释放�Q�存�?strong>函数的参数�?/strong>�Q?strong>局部变�?/strong>的值等。其操作方式�c�M��于数据结构中的栈�?

2、申��h��式方面：

    堆：需要程序员自己甌��Q��ƈ指明大小。在c中malloc函数如p1 = (char *)malloc(10)�Q�在C++中用new�q�算�W�，但是注意p1、p2本��n是在栈中的。因��Z��们还是可以认为是局部变量�?

    栈：��q��l�自动分配�?例如�Q�声明在函数中一个局部变�?int b�Q�系�l�自动在栈中为b开辟空间�?

3、系�l�响应方面：

    堆：操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ��会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序，另外�Q�对于大多数�pȝ��Q�会在这块内存空间中的首地址处记录本�ơ分配的大小�Q�这样代码中的delete语句才能正确的释放本内存�I�间。另外由于找到的堆结点的大小不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?

    栈：只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?

4、大��限制方面：

    堆：�?strong>向高地址扩展的数据结构，�?strong>不连�l?/strong>的内存区域。这是由于系�l�是用链表来存储的空闲内存地址的，自然是不�q�箋的，而链表的遍历方向是由低地址向高地址。堆的大��受限于计算机系�l�中有效的虚拟内�?/strong>。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?

    栈：在Windows�? 栈是向低地址扩展的数据结构，是一�?strong>�q�箋的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是�pȝ��预先规定�?/strong>的，在WINDOWS下，栈的大小是固定的�Q�是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?

5、效率方面：

    堆：是由new分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片�Q�不�q�用��h��最方便�Q�另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存�Q�他不是在堆�Q�也不是在栈是直接在�q�程的地址�I�间中保留一快内存，虽然用�v来最不方�ѝ��但是速度快，也最灉|��?

    栈：��q��l�自动分配，速度较快。但�E�序员是无法控制的�?

6、存攑ֆ��Ҏ��面：

    堆：一般是在堆的头部用一个字节存攑֠�的大��?strong>堆中的具体内�Ҏ��E�序员安排�?/strong>

    栈：在函数调用时�W�一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句�Q�的地址然后是函数的各个参数�Q�在大多数的C�~�译器中�Q?strong>参数是由叛_��左入�?/strong>�Q�然后是函数中的局部变量�?注意: 静态变量是不入栈的。当本次函数调用�l�束后，局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��的下一条指令，�E�序��p��点��l�运�?/strong>�?

7、存取效率方面：

    堆：char *s1 = "Hellow Word"�Q�是�?strong>�~�译�?/strong>��q��定的�Q?

    栈：char s1[] = "Hellow Word"�Q?是在�q�行�?/strong>赋值的�Q�用数组比用指针速度要快一些，因�ؓ指针在底层汇�~�中需要用edx寄存器中转一下，而数�l�在栈上直接��d��?/p>

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1925576

HUYU 2008-01-10 13:22 发表评论

Variable Parameters Print Example

HUYU — Fri, 19 Jan 2007 09:55:00 GMT

#include
#include
#include

#include "drm_korea_def.h"

#ifdef __KDRM_FSTRACE

#define LOG_BUFFER_SIZE 512
#define LOG_LINE_NUM  16

#ifdef WIN32
#define LOG_FILE     FILE *
#define LOG_OPEN(s, m)   fopen(s, m)
#define LOG_CLOSE(hLog)   fclose(hLog)
#define LOG_READ (hLog, p, x)  fread (p, x, 1, hLog)
#define LOG_WRITE(hLog, p, x) fwrite(p, x, 1, hLog)
#define LOG_PUTC(hLog, c)  fputc(c, hLog)
#define LOG_PUTS(hLog, s)  fputs(s, hLog)
#else
#define LOG_FILE     int32_t
#define LOG_OPEN(s, m)   Fopen((uint8_t *)s, (uint8_t *)m)
#define LOG_CLOSE(hLog)   Fclose(hLog)
#define LOG_READ (hLog, p, x)  Fread (hLog, p, x)
#define LOG_WRITE(hLog, p, x) Fwrite(hLog, p, x)
#define LOG_PUTC(hLog, c)  Fputc(hLog, c)
#define LOG_PUTS(hLog, s)  Fputs(hLog, (uint8_t *)s)
#endif

static LOG_FILE fpLogfile;
static char logBuffer[LOG_BUFFER_SIZE];

void log_Init(char *logName)
{
fpLogfile = LOG_OPEN(logName, "w+");

if(fpLogfile > 0)
{
  log_Print("\r\n====> Starting ... :%s %s\r\n", __TIME__, __FILE__);
}
}

void log_Print(char *logFormat, ...)
{
if(fpLogfile > 0)
{
  va_list va;
  int len;

  va_start(va, logFormat);
  len = vsprintf(logBuffer, logFormat, va);
  va_end(va);

  logBuffer[len+1] = 0;

  LOG_PUTS(fpLogfile, logBuffer);
}
}

char Hex2Dec(unsigned char bHex)
{
bHex &= 0x0F;
bHex += bHex<10? '0': 'A' - 10;

return bHex;
}

void log_Dump(const unsigned char *pCache, int u32Size, bool bBinary)
{
int i, stride;
unsigned char *p = (unsigned char *)pCache;
char cTmp;

if(fpLogfile < 0)
  return;

if(bBinary)
{
  for(; p  {
   stride = (p+LOG_BUFFER_SIZE <= pCache+u32Size)? LOG_BUFFER_SIZE: u32Size%LOG_BUFFER_SIZE;
   LOG_WRITE(fpLogfile, p, stride);
  }
}
else
{
  for(; p  {
   stride = (p+LOG_LINE_NUM <= pCache+u32Size)? LOG_LINE_NUM:u32Size%LOG_LINE_NUM;

   for(i=0; i   {
    cTmp = Hex2Dec((p[i]&0xF0) >> 4);
    LOG_PUTC(fpLogfile, cTmp);
    cTmp = Hex2Dec(p[i]&0x0F);
    LOG_PUTC(fpLogfile, cTmp);
    LOG_PUTC(fpLogfile, ' ');
    if(i== (LOG_LINE_NUM/2 - 1))
    {
     LOG_PUTC(fpLogfile, '-');
     LOG_PUTC(fpLogfile, ' ');
    }
   }

   LOG_PUTC(fpLogfile, '\n');
  }
}
}

void log_Terminate(void)
{
if(fpLogfile > 0)
{
  log_Print("<==== Stopping ... :%s\r\n", __TIME__);
  LOG_CLOSE(fpLogfile);
}
}

#endif //__KDRM_FSTRACE

HUYU 2007-01-19 17:55 发表评论

FreeType2研究

HUYU — Fri, 10 Nov 2006 15:00:00 GMT

FreeType2研究

最�q�学习状态不佻I��感觉什么都惛_��却什么也做不下去�Q��Q�w�之极。大的库一下子研究不下来，索性找一下小库来看看�?br />游戏里面一般都涉及到文本、压�~�、图像、脚本的概念�Q��ؓ了将来有��Z��研究游戏所以先下手�q�些��库�Q�不求甚解只求用好�?br />
先从字体着手，FreeType字体作�ؓ一�U�字体文件编�E�开发包�Q�广泛易用在游戏里面。网上汉语资料比较少�Q�只能看它的faq。翻译了部分如下�Q?br />

FreeType 2 Library

FAQ

�Q�当前下载地址�Q?/span> http://sourceforge.net/project/showfiles.php?group_id=3157 版本 2.2.1 �Q?/span>

1�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 是什么？

它是一个�ؓ各种应用�E�序提供通用的字体文件访问的软�g包。尤其值得注意的以下特性：

l         提供�l�一的字体文件访问接口。支持位囑֒�向量格式�Q�包�?/span> TrueType �?/span> OpenType �?/span> Typel �?/span> CID �?/span> CFF �?/span> Windows FON/FNT �?/span> X11 PCF �?/span>

l         提供高效反走��L��Z�� 256 灰度�U�的位图字�Ş的生产�?/span>

l         模块清晰�Q�每�U�字体格式对于一个模块。类库的构徏可以按照你需要支持的格式�q�行裁减以减��代码尺寸。（最��的反走�?/span> FreeType �?/span> <30Kb �Q?/span>

2�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 能做什么？

FT2 已经易用于许多领域。例如：

l         囑�Ş子系�l�和文本昄��?/span>

l         文本排版�Q�布局、分��c��渲染）

l         字体识别和�{换工�?/span>

一般来��_��该库使得你能��L��的操�U�字体文件�?/span>

3�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 不能做什么？

FT2 �q�不包含大量丰富的高�U�特性，它只定位于出色的字体服务。也��是说下面的一些特�?/span> FT2 �c�d��q�不直接提供支持�Q�然而你可以以它为基��在上层进行实玎ͼ�

l         ��L��表面的文字渲�?/span>

FT2 不是囑�Ş库所以它仅支持两�U�象素格式的文本渲染�Q?/span> 1-bit 的单色位囑֒� 8-bit 的灰度象素�?/span>

如果你需要绘制其它格式的表面�Q�例�?/span> 24-bit RGB 象素�Q�，你就得选择其它你喜��q��囑�Ş库来做�?/span>

注意�Q��ؓ了渲染向量轮廓文本而不是放走样的象素，应用�E�序可以提供自己的渲染回调以�l�制或者直接组合反走样文本��C�Q意目标表面�?/span>

l         文本�~�存

每次从字体中��h��文本图象�Q?/span> FT2 都要解析字体文�g / ��相关部分，通过它的字体格式�q�行解释。对于某些特�D�格式可能会很慢包括�?/span> TrueType �Q�或�?/span> Type1 �Q�这��L��向量字体�?/span>

注意�Q�自�?/span> 2.0.1 版本开�?/span> FT2 提供了一�?/span> beta 版本的缓存子�pȝ��。当然你�q�是可以写自��q��~�存来满��x��U�特�D�需求�?/span>

l         文本布局

不支持文本布局操作。高�U�操作例如文本替换、字距调整、两端调整等都不属于字体服务本��n职责�?/span>

4�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 可移植性？

FT2 源码可移植性很好由于以下原因：

l         代码书写遵��@ ANSI C 标准

l         对于各种�~�译警告我们都�}慎的避免。当前代码在很多�~�译器上�~�译通过且没有��生一条警告�?/span>

l         库没有��用�Q何硬�~�码�Q�是嵌入式系�l�开发的一个好的选择。（例如它能够直接在 ROM 中运行）

同时�Q�我们尽最大努力确保库的高效、紧凑和友好性�?/span>

5�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 �?/span> FreeType1.x 的区别？

最大的区别��是�Q?/span>

l         FT1 仅支�?/span> TrueType 格式�Q��?/span> FT2 支持很多格式�?/span>

l         FT2 APIs �?/span> FT1 APIs ��单且强大�?/span>

l         FT1 包括 OpenType 文本布局处理扩展�Q��?/span> FT2 中则不包括而是�U�d��独立的工�E�里面―�?/span> FreeType Layout 。（ FT 布局目前无法获取�Q?/span>

6�?span style="FONT: 7pt 'Times New Roman'"> FreeType2 是否兼容 FreeType 1.x �Q?/span>

FreeType2 不直接兼�?/span> FreeType 1.x �Q�但是我们可以提供一个二�q�制兼容层��得应用程序重链接到新版本。我们最�l�放弃了�q�种��x��因�ؓ两个版本可以共存在一个系�l�中。（没有命名冲突�Q?/span>

FT2 API �?/span> 1.x ��单且强大�Q�所以我们鼓�׃��采用新版本，�q�样可以使你减少很多不必要的工作�?/span>

7�?span style="FONT: 7pt 'Times New Roman'"> 是否可以使用 FreeType2 �~�辑字体或者创建新字体�Q?/span>

�{�案是明��的�Q�不可以。因��库设计明��，用较��代码和内存��d��字体文�g。所以我们不打算以�Q何方式在字体引擎里面支持�~�辑或者创建功能，因�ؓ�q�样��导致整个代码重写。这�q�不意味我们��来不会引入字体�~�辑 / 创徏功能库，�q�取决于需求（或者说有多��h愿意为此买单�Q��?/span>

在我们正式发布前不要在这斚w��q�行揣测�Q�对我们而言�q�个��目存在其他一些更重要的部分需要解冻I��像文字布局、文本缓存）�?/span>

�~�译 & 配置

1�?span style="FONT: 7pt 'Times New Roman'"> 如何�~�译 FreeType2 库？

可以采取多种�~�译方式�Q�在 freetype2/docs/build 下有详细说明文��?/span>

�q�里介绍最��单的��Z�� VS IDE 的编译方式�?/span> freetype\builds\win32\visualc 下有 VC6 �?/span> VC7.1 的工作区文�g�?/span> VC6 打开后直接编译，有几个警告�?br />

光看或许无法到感性认识，于是来两个demo。网上比较少�Q�我是参考nehe教程写的。��M��来说会简单��用了�Q�如果想深入了解怕是非看他的document不可�?br />��单��用示�?/span>

FT_Library    pFTLib         = NULL;
    FT_Face        pFTFace         = NULL;
    FT_Error    error         = 0 ;
     // Init FreeType Lib to manage memory
    error = FT_Init_FreeType( & pFTLib);
     if (error)
     {
        pFTLib = 0 ;
        printf( " There is some error when Init Library " );
         return - 1 ;
    }

     // create font face from font file
    error = FT_New_Face(pFTLib, " C:\\WINDOWS\\Fonts\\arial.ttf " , 0 , & pFTFace);
     if ( ! error)
     {
        FT_Set_Char_Size(pFTFace, 16 << 6 , 16 << 6 , 300 , 300 );
        FT_Glyph    glyph;
         // load glyph 'C'
        FT_Load_Glyph(pFTFace, FT_Get_Char_Index(pFTFace, 67 ), FT_LOAD_DEFAULT);
        error = FT_Get_Glyph(pFTFace -> glyph, & glyph);
         if ( ! error)
         {
             // convert glyph to bitmap with 256 gray
            FT_Glyph_To_Bitmap( & glyph, ft_render_mode_normal, 0 , 1 );
            FT_BitmapGlyph    bitmap_glyph = (FT_BitmapGlyph)glyph;
            FT_Bitmap &     bitmap = bitmap_glyph -> bitmap;
             for ( int i = 0 ; i < bitmap.rows; ++ i)
             {
                 for ( int j = 0 ; j < bitmap.width; ++ j)
                 {
                     // if it has gray>0 we set show it as 1, o otherwise
                    printf( " %d " , bitmap.buffer[i * bitmap.width + j] ? 1 : 0 );
                }
                printf( " \n " );
            }
             // free glyph
            FT_Done_Glyph(glyph);
            glyph = NULL;
        }
         // free face
        FT_Done_Face(pFTFace);
        pFTFace = NULL;
    }

     // free FreeType Lib
    FT_Done_FreeType(pFTLib);
    pFTLib = NULL;

HUYU 2006-11-10 23:00 发表评论

从笑话中悟出C++开发管理之"�?

HUYU — Mon, 30 Oct 2006 00:49:00 GMT

1. �E�序员写��认�ؓ没有Bug的代码�?

2. 软�g��试�Q�发��C��20个Bug�?

3. �E�序员修改了10个Bug�Q��ƈ告诉��试�l�另�?0个不是Bug�?

4. ��试�l�发现其�?个改动根本无法工作，同时又发��C��15个新Bug�?

5. 重复3�ơ步�?和步�?�?

6. 鉴于市场斚w��的压力，��Z��配合当初制定的过分乐观的发布旉��表，产品�l�于上市了�?

7. 用户发现�?37个新Bug�?

8. 已经领了��目奖金的程序员不知跑到哪里��M��?

9. 新组建的��目�l�修正了差不多全�?37个Bug�Q�但又发��C��456个新Bug�?

10. 最初那个程序员从斐��给饱受拖欠工资之苦的测试组寄来了一张明信片。整个测试组集体辞职.

11. 公司被竞争对手恶意收购。收购时�Q��Y件的最�l�版本包�?83个Bug�?

12. 新CEO走马上�Q。公叔R��了一名新�E�序员重写该软�g�?

13. �E�序员写��认�ؓ没有Bug的代码�?

　　要我��_��如果真有�q�样的公司，不倒闭对不起�h民�?

　�q�个�W�话从程序员开始，到程序员�l�束�Q�从头到��N��在说�E�序员的不是。但是我要说的是�Q�这完全是管理者的��p�|�Q�从整个�q�程中，看不��C�Q何管理工作。这�U�管理者不但无知无能，�q�很无耠Z��—将自己的失败责��L��l�程序员�?

　1、程序员凭什么证明他的代码没有BUG�Q�有Test case吗？有Code review吗？�q�个环节��理�~�失�?

　2、测试发现BUG有进行BUG��理吗？有跟�t�吗�Q�这个环节管理缺失�?br />　3、凭什么证明程序员已经把那10个BUG修改好了�Q�另10个又��Z��么不是BUG�Q�BUG的评��h��准难道是�E�序员说了算�Q�这个环节管理缺失�?

　4�?个不能工作的BUG修改问题有没有追�I�责任？增加新BUG是修改过�E�中不可避免的事情，但是如果有有效的单元��试机制�Q�可以大大减��这�U�情��c��这个环节管理缺失�?

　5、�P代是正常的，但是问题处理于发散而不是收敛发展，可见没有有效的管理调控。这个环节管理缺失�?

　6、过于乐观的旉��表和不可能达到的最后期限，都表现出��理者的无知和无能。而在�q�样的情况下��推出产品�Q�那��是无知者无畏了�?

　7、这是对用户的不负责任，��理者要负最大的责�Q�?

　8、这��L��情况�q�能发项目奖金，只能说管理者不是一般的愚蠢�?

　9、管理工作没有�Q何的改进�Q�问题仍然处于发散�P代状态。管理工作依然没有到位�?

　10、拖�Ơ测试部门工资体现出��理者对质量��理工作的忽视以及对人力资源��理斚w��一无所知�?

　11、送被收购者两个字�Q�活该。送收购者两个字�Q�瞎眹{�?

　12、可见新��理者与原管理者半斤八两，都没有认识到问题的根本所在。不�q�也只有�q�样的管理者才会作出收购这�U�公司的决策�?

　13、历史的重演是必然的�?

　一个正常的企业或是��目�Q�其�q�作必须应该是��@环向上进行的。而保障这�U�运行的工作��是��理。而管理工作的主要内容��是控制�Q�包括控制��@环的节奏——不能太快也不能太慢�Q�控制发展的方向——只能向上不能向下，控制�q�作的稳定——不能大起大落或时聚时散�{��?br />　而这一切，在这个例子中都看不到�?

　在这个笑话的例子中，一切都是以开发工作在驱动�Q�这首先��是一个方向性错误，产品是�ؓ用户服务的，当然应该是以用户和市��Z��为驱动，�q�且�l�合自��n的能力最�l?��定工作的重炏V��这一错误折射出管理者对被管理的内容很不了解�Q�只好�Q由比较了解的�E�序员摆布——事实上他们除了技术，�q�不会了解更多�?

　一个管理者如果对自己所��理的内容不了解�Q�他��׃��可能��理得好�?

　�q�是一件毫无疑问的事，可是国内的��Y件业��g��L��不相信这一炏V��中国��Y件业中流毒最��q��谎言之一��是�Q?

　��理者只要懂��理��可以，不需要懂技术�?

其实�q�不�q�是那些无知无能无�ȝ��理者�ؓ了骗��p��编出来的，�怿��q�句话的人必��付出金��q��代�h�?

　其次是质量管理。基本的质量��理常识告诉我们�Q�每�ơ��@环结束前�Q�最重的工作��是�ȝ��改进。只有这��h��能保证��@环运作是向上发展�Q�而不是失��L��制地向下发展�?也只有有效的质量��理�Q�才能保证�P代过�E�是收敛发展�Q��ƈ最�l�达到目标。但在这个例子中�Q�这个部分显然是�~�失的——其中虽然有��试部门�Q�但是他们的作用仅仅是质量管理中的质量检��环节，��理部分�q�是�~�失的�?

　然后是�h力资源管理。��Y件开发是一��劳动密集型的工作，虽然�q�是脑力力_��Q�但同样意味着人在因素在其中占有决定性的��C��。而例子中未改完BUG的程序员拿到��目奖金�Q�而同栯��苦工作的��试人员却被拖欠薪资�Q�除了表现出��理者对他们的工作内容的不了解，以及对质量管理工作的不重视以外，�q�表现出��理�?完全不会��h�Q�这是一�U�谋杀团队的行为——谋杀一个团队远比徏设要�Ҏ��得多�?

　最后，�q�个��p�|的管理者把他的�l�历�~�成�q�个�W�话�Q�让大家看到他被�E�序员们宛_��多惨�Q�把�E�序员妖��化��Z��骗子。但只要�E�懂��理的�h��单分析一下就可以看出来，只不�q�是�q�个人的无知和无能造成了他现在的结果，而把责�Q推给别�h的行为更是表现出他的无者R�?

　作�ؓ�w�居高位的管理者，如果�q�应该承担的责�Q都要推卸�Q�他们还能胜��M��么事情呢?

HUYU 2006-10-30 08:49 发表评论

HUYU — Fri, 13 Oct 2006 05:56:00 GMT
��x��对TinyXML的应�?br />http://sourceforge.net/projects/tinyxml/

HUYU 2006-10-13 13:56 发表评论

strlen & strcmp

HUYU — Tue, 03 Oct 2006 16:02:00 GMT

unsigned int strlenW(const wchar_t *wcs)
{
const wchar_t *eos = wcs;

while (*eos)
     ++eos;

return eos-wcs;
}

int strcmpW(const wchar_t *pwc1, const wchar_t *pwc2)
{
int ret = 0;

while ( !(ret = *pwc1 - *pwc2) && *pwc2)
  ++pwc1, ++pwc2;
return ret;
}

HUYU 2006-10-04 00:02 发表评论

HUYU — Tue, 03 Oct 2006 16:01:00 GMT

如果哪一天你的程序收��C��D�不明编码的字符�Ԍ��或者别人给了一个你看不懂的文本文�g�Q�你应该如何去识别字�W�串的编码呢�Q?br />
一�U�是�E�序中用的方法，可以使用ICU之类的库来帮你识别，如果你的字符串越长，它所能猜到的概率��p��大�?br />
另外一�U�方法是使用IE来帮助你查看。��用IE打开不明�~�码的文�Ӟ��然后选择Encoding�Q�不停的切换�~�码�Q�基本上看�v来像文字的时候，��是那个�~�码�?).�q�个�Ҏ��很简单，比较实用�?br />
另外对于unicode的编码，观察其BOM�Q�也有助于你�ȝ��编码�?br />UTF-8: EF BB BF E6 B5 8B E8 AF 95 31 32 33 34
UTF-16: FF FE 4B 6D D5 8B 31 00 32 00 33 00 34 00
UTF-16 Big endian : FE FF 6D 4B 8B D5 00 31 00 32 00 33 00 34

最后附上两个小工具�Q�能帮你生成各种文字的字�W�和识别字符在不同code page下的�~�码。just have fun

http://m.shnenglu.com/Files/sandy/encoding_tools.rar

HUYU 2006-10-04 00:01 发表评论

c++中的string用法(�?

HUYU — Mon, 04 Sep 2006 10:49:00 GMT
     摘要: basic_string::max_size �q�回string 能放的最大元素个数。（不同于capacity�Q? size _ type max _ ...  阅读全文

HUYU 2006-09-04 18:49 发表评论