博客园_混沌的世界

基数排序的一个变形应用

2011-12-19T16:28:00Z

说起排序，大多数人在实际项目中很少自己去写一个排序，一般来说，qsort一行话就可以了。我也很少在实际项目中用到过基数排序，最近，写了一篇博客文章叫做：字符串之全文索引，这篇文章的下一篇文章要用到一个倍增算法。这个倍增算法，就可以非常巧妙的运用基数排序。作为那篇文章的一个铺垫，我专门写了一篇基数排序的文章。这篇文章里面的基数排序肯定是一个变形。

大多数网上或者书上的基数排序都是从下面的例子开始的：

排序下面的数列：

73 22 93 43 55 14 28 65 39 81

然后对这些数字，用个位数进行排序：

0
1	81
2	22
3	73	93	43
4	14
5	55	65
6
7
8	28
9	39

从这个二维的数组里面顺序取出：

81 22 73 93 43 14 55 65 28 39

再对10位数进行排序：

0
1	14
2	22	28
3	39
4	43
5	55	65
6
7	73
8	81
9	93

从这个二维数组里面顺序取出：

14 22 28 39 43 55 65 73 81 93

上面的思路写成代码也非常的容易写：

     #include <stdio.h>

    #include <stdlib.h>

    int main()

    {

    int data[10]={73,22,93,43,55,14,28,65,39,81};

    int temp[10][10]= {0};

    int order[10]={0};

    int i,j,k,n,lsd;

    printf("\n排序前: ");

    for (i=0; i<10; i++) printf("%d ",data[i]);

    putchar('\n');

    n=1;

    while (n<=10)

    {

    for (i=0;i<10;i++) 

    {

    lsd=((data[i]/n)%10);

    temp[lsd][order[lsd]]=data[i];

    order[lsd]++;

    }

    printf("\n重新排列: ");

    k = 0;

    for (i=0;i<10;i++)

    {

    if(order[i]!=0)

    {

    for (j=0;j<order[i];j++)

    {

    data[k]=temp[i][j];

    printf("%d ",data[k]);

    k++;

    }

    order[i]=0;

    }

    }

    n *= 10;

    }

    putchar('\n');

    printf("\n排序后: ");

    for (i=0; i<10; i++) printf("%d ",data[i]);

    return 0;

    }

既然这个基数排序理论上性能比较的高，这样的话，我们就写个程序比较一下实际上快速排序和基数排序的速度。


    #include <stdio.h>

    #include <stdlib.h>

    #include <string.h>

    #include <time.h>

    #include <algorithm>

    #define MAX_N 5000000

    int sort[10][MAX_N];

    int data[MAX_N];

    int data2[MAX_N];

    int data3[MAX_N];

    int radix_sort(int data[], int max_index, int max_number);

    static int range_rand(int min, int max);

    int intcmp(const void *a, const void *b)

    {

    return *((int *)a) - *((int *)b);

    }

    int main()

    {

    int i;

    int max = -1;

    clock_t t;

    for (i = 0; i < MAX_N; i++)

    {

    data[i] = range_rand(1, 0xFFFFFFF);

    if (max < data[i]) max = data[i];

    }

    memcpy(data2, data, sizeof(data));

    memcpy(data3, data, sizeof(data));

    t = clock();

    qsort(data, MAX_N, sizeof(int), intcmp);

    printf("qsort cost : %d \n", clock() - t);

    t = clock();

    radix_sort(data2, MAX_N, max);

    printf("radix cost : %d \n", clock() - t);

    t = clock();

    std::sort(data3, data3 + MAX_N);

    printf("std::sort cost : %d \n", clock() - t);

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data[i]);

    }

    printf("\n");

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data2[i]);

    }

    printf("\n");

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data3[i]);

    }

    printf("\n");

    }

    int radix_sort(int data[], int max_index, int max_number)

    {

    int number[10];

    int lsd, i, k, j, n;

    n = 1;

    memset(number, 0, sizeof(number));

    while (n <= max_number)

    {

    for (i = 0; i < max_index; i++)

    {

    lsd = (data[i]/n) % 10;

    sort[lsd][number[lsd]] = data[i];

    number[lsd]++;

    }

    k = 0;

    for (i = 0; i < 10; i++)

    {

    if(number[i] != 0)

    {

    for (j = 0; j < number[i];j++)

    {

    data[k] = sort[i][j];

    k++;

    }

    number[i] = 0;

    }

    }

    n *= 10;

    }

    return 0;

    }

    static int range_rand(int min, int max)

    {

    double r = 0;

    int    i;

    double mul = 1;

    for (i = 0; i < 3; i++)

    {

    mul *= 0.0001;

    r += (rand() % 10000) * mul;

    }

    //0 - 1 中的一个随机数

    return (int)(r * (max - min)) + min;

    }

我用了500万数据进行测试，在我电脑上的运行结果是：

你会发现C++ stl 里面的sort 是最快的（没有函数调用的损失）。radix sort 和 qsort 性能差不多。所以，在某个数字可能很大的时候，上面的这个算法没有任何性能上的优势，还会浪费非常多的内存。

基数排序大多数情况下面只适用于下面的情景，一组数，这组数的最大值不是很大，更加准确的说，是要排序的对象的数目 和 排序对象的最大值之间相差不多。比如，这组数 1 4 5 2 2，要排序对象的数目是 5 ，排序对象的最大值也是 5. 这样的情况很适合。我们原来的排序的数，默认是以10为基数，现在，这个改进算法是这样的，我以最大的那个数为基数，这样，所有的数都是“个位数”，问题就简单了。

说了这样多，我觉得还是用程序来表达比较的清晰：


    #include <stdio.h>

    #include <stdlib.h>

    #include <string.h>

    #include <time.h>

    #include <algorithm>

    #define MAX_N 5000000

    int sort[10][MAX_N];

    int quick_radix_sort[MAX_N];

    int data[MAX_N];

    int data2[MAX_N];

    int data3[MAX_N];

    int data4[MAX_N];

    int qradix_sort(int data[], int max_index);

    int radix_sort(int data[], int max_index, int max_number);

    static int range_rand(int min, int max);

    int intcmp(const void *a, const void *b)

    {

    return *((int *)a) - *((int *)b);

    }

    int main()

    {

    int i;

    int max = -1;

    clock_t t;

    //初始化随机数种子

    srand ( time(NULL) );

    for (i = 0; i < MAX_N; i++)

    {

    data[i] = range_rand(1, MAX_N - 1);

    if (max < data[i]) max = data[i];

    }

    memcpy(data2, data, sizeof(data));

    memcpy(data3, data, sizeof(data));

    memcpy(data4, data, sizeof(data));

    t = clock();

    qsort(data, MAX_N, sizeof(int), intcmp);

    printf("qsort cost : %d \n", clock() - t);

    t = clock();

    radix_sort(data2, MAX_N, max);

    printf("radix cost : %d \n", clock() - t);

    t = clock();

    std::sort(data3, data3 + MAX_N);

    printf("std::sort cost : %d \n", clock() - t);

    t = clock();

    qradix_sort(data4, MAX_N);

    printf("quick radix sort cost : %d \n", clock() - t);

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data[i]);

    }

    printf("\n");

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data2[i]);

    }

    printf("\n");

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data3[i]);

    }

    printf("\n");

    for (i = 0; i < 20; i++)

    {

    printf("%d ", data4[i]);

    }

    printf("\n");

    }

    int qradix_sort(int data[], int max_index)

    {

    int i, j, n = 0;

    for (i = 0; i < max_index; i++)

    {

    quick_radix_sort[data[i]]++;

    }

    for (i = 0; i < max_index; i++)

    {

    for (j = 0; j < quick_radix_sort[i]; j++)

    {

    data[n++] = i;

    }

    }

    return 0;

    }

    int radix_sort(int data[], int max_index, int max_number)

    {

    int number[10];

    int lsd, i, k, j, n;

    n = 1;

    memset(number, 0, sizeof(number));

    while (n <= max_number)

    {

    for (i = 0; i < max_index; i++)

    {

    lsd = (data[i]/n) % 10;

    sort[lsd][number[lsd]] = data[i];

    number[lsd]++;

    }

    k = 0;

    for (i = 0; i < 10; i++)

    {

    if(number[i] != 0)

    {

    for (j = 0; j < number[i];j++)

    {

    data[k] = sort[i][j];

    k++;

    }

    number[i] = 0;

    }

    }

    n *= 10;

    }

    return 0;

    }

    static int range_rand(int min, int max)

    {

    double r = 0;

    int    i;

    double mul = 1;

    for (i = 0; i < 3; i++)

    {

    mul *= 0.0001;

    r += (rand() % 10000) * mul;

    }

    //0 - 1 中的一个随机数

    return (int)(r * (max - min)) + min;

    }

这个代码其实就是在上面的测试代码的基础上加上了一个qradix_sort 函数，这个函数非常的简单：

int qradix_sort(int data[], int max_index)

int i, j, n = 0;

for (i = 0; i < max_index; i++)

quick_radix_sort[data[i]]++;

for (i = 0; i < max_index; i++)

for (j = 0; j < quick_radix_sort[i]; j++)

data[n++] = i;

return 0;

循环体里面就两句话，和我们前面的那个基数排序不是很一样，这里，已经不用一个二维数组保存排序的数字了，只是标记一下这个数字有几个，因为，下标其实就是被排序的数字。

重新排序这个循环也很简单，仔细冥想一下怎么回事，不懂就在草稿纸上画画草图吧。这里主要的思想还是，下标就是排序的数字。

最后的排序测试结果：

我们发现，现在普通的radix性能也提高了，因为，现在数字变小了，循环的次数也变少了。快速基数排序的性能提高还是非常的明显。普通基数排序的两倍，std::sort 的3倍，qsort的 5倍，最重要的是代码非常的简单，基本上是你见过的最简单的一个排序了。

对一个真正的程序员来说，很少这样要死抠一个程序的性能，一般情况下，也是得不偿失。只有，在某个东西真正成了一个性能瓶颈的时候，我们才需要去关心一下：是不是可以这样改进一下。

这个排序算法，将来会应用到字符串处理的倍增算法里面，这个倍增算法，要反复的进行排序。如果，排序能快一点，这个程序就能快很多。

本文链接

如何学习Yii

2011-12-09T15:13:00Z

我是在Yii的官方wiki上看到这篇文章的。读的第一遍觉得很不错，还有一种想翻译出来的冲动。虽然，本人英文很烂，但是毕竟写了这样多年的代码，估计大概的意思是能有的吧。英文原文：http://www.yiiframework.com/wiki/268/how-to-learn-yii/

下面是针对Yii的初学者的一个一步一步如何学习Yii的列表。这个列表列出了一些文档，教程，希望你能够阅读，这些文档，教程有助于我们理解Yii这个框架。

1. 学习PHP。当然，你需要先学习PHP编程。w3cschool 上有一个很好的教程，教程分成语言基础高级功能数据库操作三个部分。有一个小技巧，永远要使用php.net 来查找一个函数的用法。（个人觉得初学者一定要经常的翻翻PHP的手册，每个函数都去仔细的读一下，包括下面的评论，一定会让你受益匪浅）

2. 学习面向对象编程。你至少要懂一些基本的面向对象编程的东西。这里有一个基本教程（这个教程很不错，当然不要忘记php.net上的教程），如果你很懒，这里还有个视屏教程

3. MVC 。 你要非常深刻的理解MVC 这个设计模式。如果你不知道MVC是何物，你一定会觉得Yii框架是什么玩意啊，怎么这样混乱，还不如老子自己写的框架呢？当然，如果你突然顿悟了，啥是MVC，你会发现一切是那么的自然。要学习MVC，推下面几篇文章：Model–view–controller ，还有YY官方的两篇很出名的： MVC 最佳实践 MVC基础

4. 简单入门。这里有一个非常好的视频教程（看这个视频国内看不了，怎么做，你懂的），看过这个教程之后就可以看 Larry 的博客上提供的教程。

5. 阅读手册。Yii 的手册非常的有用。非常建议你从头到尾看一遍手册，并且好好的看手册里面的评论。

6. 上面的准备工作已经完成了，你应该要开始动手了。你可以先读读： Yii Agile Web Application Development 这本书，或者跟着这个博客教程做。你阅读上面这本书的时候，注意阅读下面的勘误表

7. 其他。Yii Application Development Cookbook 这本书里面有很多有用的小技巧。同时，你可以阅读 Yii wiki 和 Yii 类库手册（API 文档,这些文档是代码中的注释自动生成的）。如果你有问题，就去论坛提问吧。

8. 更多工具。这里有很多 Yii 的扩展。这些是Yii社区贡献的一些额外的工具箱，可以在你的应用程序里面重用。

第一步和第二步可能要花费几天，几个星期，或者几年
第三步到第五步只要花费几个小时就够了
第六步可能要花个几天，如果你只是利用业余时间进行学习的话。

这些都完成之后，当然，你就可以开始编写自己的Yii 应用了。

我的一些建议：

在实际做了一些项目之后，我想比较重要的是，阅读Yii的源代码。
作为一个面向对象的框架，一定要绘制出UML图，这样可以加深对这个框架的理解。
Yii的思想不仅仅是 MVC，其中有一个非常重要两个概念是
"组件" 和 "事件"，他们贯穿Yii的整个设计。

本文链接

如何在apache启动的时候不输入ssl的密码

2011-11-30T02:12:00Z

今天突然发现网站挂掉了。原因就是机房意外的重启了我的机器，因为apache 要输入ssl密码才能启动，所以就启动不起来。

用下面的方法就可以避免这个问题：

ee /usr/local/etc/apache22/httpd.conf

找到：

加入这样一行：

SSLPassPhraseDialog exec:/usr/local/etc/apache22/ssl_pass.sh

ee /usr/local/etc/apache22/ssl_pass.sh

加入一个echo语句

#!/bin/sh

echo “password”

然后让它有执行权限：

chmod +x /usr/local/etc/apache22/ssl_pass.sh

再重启一下服务器测试一下看看有没有问题。

本文链接

字符串之全文索引

2011-11-27T08:55:00Z

字符串，我现在正在写的就是一个字符串。我们的源代码就是一个字符串，计算机科学里面，一大部分问题都是字符串处理的问题。比如，编译器，就是一个字符串处理程序。还有，搜索引擎，也在处理一个字符串问题。数据库，最难处理的还是字符串部分。索引，一般是一种预处理的中间程序。在我们写代码的时候，往往需要对一个对象进行预处理。这个预处理时间可能比较长，但是，处理完了以后，就能很快的多次的在上面进行查询。比如，你要在一组数里面进行查找，可能先要进行排序，这样速度就会快一些, 排序可以看做是建立索引的一个过程。

字符串的全文索引，怎么样才能非常的省空间，查找速度也还可以，我这里介绍一种数据结构，叫做后缀数组。

概念不多说，我就在例子中说明什么东西是后缀数组吧。

step 1. 所有的后缀：

string a = ‘aabbaa’;

找到所有的后缀：

0 aabbaa

1 abbaa

2 bbaa

3 baa

4 aa

5 a

step 2. 对所有的后缀进行排序：

0 (5)a

1 (4)aa

2 (0)aabbaa

3 (1)abbaa

4 (3)baa

5 (2)bbaa

小括号里面的就是原来的索引值。

排序后的这个数组就叫做后缀数组。

下面这个程序，我想让大家更加感性的认识一下后缀数组是什么东西：
#include <stdio.h>
#include <stdlib.h>
//5M
#define MAX_LEN 1024 * 1024 * 5
char str[MAX_LEN + 1], *suffix_array[MAX_LEN + 32];
int readstr();
int cmpnum, charcmpnum;
int pstrcmp(const void *a, const void *b);
int main()
{
int n, i;
n = readstr();
printf("string = %s\n", str);
printf("All Suffix:\n");
for (i = 0; i < n; i++)
{
suffix_array[i] = str + i;
printf("%d %s\n", i, suffix_array[i]);
}
qsort(suffix_array, n , sizeof(char *), pstrcmp);
printf("Suffix Array:\n");
for (i = 0; i < n; i++)
{
printf("%d (%d) %s\n", i, suffix_array[i] - str, suffix_array[i]);
}
return 0;
}
int readstr()
{
int ch;
int n = 0;
while ((ch = getchar()) != EOF)
{
str[n++] = (char)ch;
if (n >= MAX_LEN) {
break;
}
}
while (str[n-1] == '\r' || str[n-1] == '\n')
{
n--;
}
str[n] = 0;
return n;
}
int pstrcmp(const void *a, const void *b)
{
unsigned char *p = *((unsigned char **)a), *q = *((unsigned char **)b);
unsigned char c1 , c2;
cmpnum++;
do {
c1 = (unsigned char)*p++;
c2 = (unsigned char)*q++;
charcmpnum++;
if (c1 == '\0') {
return c1 - c2;
}
} while (c1 == c2);
return c1 - c2;
}
运行这个程序的方法是输入一个字符串，然后输入EOF 字符串

比如输入 aabbaa[回车][ctrl+z][回车] 的结果是

后缀数组就是将所有的字符串后缀进行排序，注意，代码空间复杂度，每一个后缀只是保存了一个指针，并没有复制整个字符串。

啰嗦了半天，到底这个东西怎么做全文索引呢？你看非常简单的代码，核心的代码就几行，你肯定觉得这个东西没有用。编程珠玑的第15章字符串有关于这个话题的讨论，大家可以去看看。介绍算法不是我写这篇博客的目的，我想写一些超越算法了一些东西，这篇只是开一个头。

这个后缀数组的所有前缀就是所有的substring(子串)。用过数据库的人可能知道数据库里面的 like 查询查前缀(like prefix% )要比查后缀(like %suffix )或者任意的查询(like %query%)快很多.原因就是数据库里面是按照字母顺序存储的，这样前缀查询可以二分查找，速度就快了。后缀数组的原理也是这样。一个查询问题转换为一个前缀查询的问题，但是转换的方法却是通过后缀, 很有老庄哲学的韵味。

下面的程序是读入一个很长的字符串，我测试的是一本23万个英语单词的字典。先随机从这本英文字典里面抽取了5000个单词，然后，把正本字典看做一个字符串，在这本字典里面进行查询，分别用系统自带的 strstr (kMP算法) 和我们的全文索引(后缀数组进行查询) 看看性能会差多少：
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <windows.h>
//5M
#define MAX_LEN 1024 * 1024 * 5
//一个单词的最大长度
#define MAX_WORD 255
#define MAX_DICT 500000
//路径的最大长度
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
#define TEST_NUM 5000
//函数列表
static int read_str();
static int read_dict(const char * filepath);
static int pstrcmp(const void *a, const void *b);
static char * dirname(const char *path, int count);
static int range_rand(int min, int max);
static int prefixcmp(const void *a, const void *b);
static void test_full_index();
static void test_strstr();
//全局变量
char str[MAX_LEN + 1]; //原始字符串
char *suffix_array[MAX_LEN + 32]; //后缀数组
char *dict[MAX_DICT]; //测试字典
int  cmpnum, charcmpnum; //以后可能用来测试性能的计数
char *query[TEST_NUM];  //查询表达式
int dictn, strn;
int main(int argc, char *argv[])
{
int i;
if (argc < 2) {
printf("usage: %s dict_path", argv[0]);
exit(0);
}
//读取字典，构建测试查询
printf("dict path is: %s\n", argv[1]);
dictn = read_dict(argv[1]);
for (i = 0; i < TEST_NUM; i++)
{
query[i] = dict[range_rand(0, dictn)];
}
//最好free掉dict的内存，对于这样简单的程序，没有多少必要，程序结束以后，自动释放。
//创建后缀数组, 从stdin读取
strn = read_str();
for (i = 0; i < strn; i++)
{
suffix_array[i] = str + i;
}
qsort(suffix_array, strn, sizeof(char *), pstrcmp);
//测试通过后缀数组建立的索引进行全文查找
test_full_index();
//测试通过普通子串查询, 这些算法一般用KMP算法。
test_strstr();
return 0;
}
static void test_full_index()
{
int i , t, nofind = 0, find = 0; 
t = clock();
for (i = 0; i < TEST_NUM; i++)
{
char **index;
index = (char **)bsearch(query[i], suffix_array, strn, sizeof(char *), prefixcmp);
if (index == NULL) {
nofind++;
} else {
find++;
}
}
printf("full index, find : %d , not find: %d, cost: %d ms\n", find, nofind, clock() - t);
}
static void test_strstr()
{
int i , t, nofind = 0, find = 0; 
t = clock();
for (i = 0; i < TEST_NUM; i++)
{
char *index;
index = strstr(str, query[i]);
if (index == NULL) {
nofind++;
} else {
find++;
}
}
printf("strstr, find : %d , not find: %d, cost: %d ms\n", find, nofind, clock() - t);
}
static int read_str()
{
int ch;
int n = 0;
while ((ch = getchar()) != EOF)
{
str[n++] = (char)ch;
if (n >= MAX_LEN) {
break;
}
}
while (str[n-1] == '\r' || str[n-1] == '\n')
{
n--;
}
str[n] = 0;
return n;
}
static int read_dict(const char * filepath)
{
char buffer[MAX_WORD];
FILE *fp = fopen(filepath, "r");
int n = 0;
if (fp == NULL) return 0;
while (fscanf(fp, "%s", buffer) != EOF)
{
int word_len = strlen(buffer) + 1;
if (n >= MAX_DICT) {
break;
}
dict[n++] = (char *)malloc(word_len);
memcpy(dict[n-1], buffer, word_len);
}
return n;
}
static int pstrcmp(const void *a, const void *b)
{
unsigned char *p = *((unsigned char **)a), *q = *((unsigned char **)b);
unsigned char c1 , c2;
cmpnum++;
do {
c1 = (unsigned char)*p++;
c2 = (unsigned char)*q++;
charcmpnum++;
if (c1 == '\0') {
return c1 - c2;
}
} while (c1 == c2);
return c1 - c2;
}
static int prefixcmp(const void *a, const void *b)
{
unsigned char *p = (unsigned char *)a, *q = *(unsigned char **)b;
unsigned char c1 , c2;
do {
c1 = (unsigned char)*p++;
c2 = (unsigned char)*q++;
if (c1 == '\0') {
return 0; //match
}
} while (c1 == c2);
return c1 - c2;
}
static int range_rand(int min, int max)
{
double r = 0;
int    i;
double mul = 1;
for (i = 0; i < 3; i++)
{
mul *= 0.0001;
r += (rand() % 10000) * mul;
}
//0 - 1 中的一个随机数
return (int)(r * (max - min)) + min;
}
后面的一些小函数大概比较多，其实主要看main函数就可以了。

命令行运行：suffix_array dict.txt < dict.txt , 用了一个文件重定向到stdin，附件中有这本测试字典。

测试结果是：

可以发现，性能差的挺多了，有1000倍。如果字符串更加的长，差别会更加的大。

这篇博客还只是个引子，实际上，理论上来说，我们采用qsort的方法来排序后缀数组性能比较低。但是，实际用起来这几乎是最好的方法。这是一个典型的一行顶一万行的例子。后缀数组的应用也不仅仅是做全文索引这样一种功能，欲知详情，请关注下一篇博客：字符串之后缀数组倍增算法。

本文链接

2011 october calendar wallpapers

2011-10-11T03:09:00Z

Wallpaperfox contain many anime wallpapers, such as Fairy Tail wallpapers, bleach wallpapers, naruto wallpapers, one piece wallpapers, and so on.

October is a busy season, the anime wallpaper site posts a series of 2011 calendar wallpapers, divided into two topics, one topic is about Halloween, another topic is about international music.

The two part of the calendar special wallpaper are our design elaborated, Halloween Wallpapers show the Halloween element fully, and the international music wallpapers will fully demonstrate the beauty of music. You can download the 2011 october calendar wallpapers for your desktop, or recommend to your friends.

本文链接

深入PHP内核（1）引用

2011-04-28T13:53:00Z

最近，和一个网友交流的时候，给我提了一个非常奇怪的问题。那就是，在一个运算中，加了一个引用之后，发现性能慢了一万倍。在我的脑海里面，引用是一个非常容易出错的问题，特别是PHP里面的引用，有非常多的陷阱。因为，以前专门研究过这一块PHP的源代码，所以，我可以比较清晰的解析引用到底是怎么一回事，希望，读了我这篇博客的PHP开发者，能彻底理解这个问题。如果，有任何疑问，或者有一些你想了解的问题，可以给我留言。

先来看一段代码:

class RefferTest
{
    private $data;
    private $testKey;
    function __construct()
    {
        $key = "hello";
        $this->data[$key] = range(0, 10000);
        $this->testKey = $key;
    }

    function reffer($key)
    {
        $reffer = &$this->data[$key];
        return count($reffer);
    }

    function noreffer($key)
    {
       return count($this->data[$key]);
    }

    function test()
    {
        $t1 = microtime(true);
        for ($i = 0; $i < 5000; $i++)
        {
            $this->reffer($this->testKey);
        }
        $t2 = microtime(true) - $t1;
        var_dump("reffer: " . round($t2, 4));
        
        $t1 = microtime(true);
        for ($i = 0; $i < 5000; $i++)
        {
            $this->noreffer($this->testKey);
        }
        $t2 = microtime(true) - $t1;
        var_dump("noreffer: " . round($t2, 4));
    }
}
$test = new RefferTest();
$test->test();

如果你完这个代码，能说出，为了reffer 和 noreffer会差一万倍的性能，那下面的也就没有必要往下看了。这篇博客针对的是，PHP的新手。你可以运行一下这个代码试试看，的确差了一万倍。当然，那个网友遇到的问题的代码要比上面的复杂，上面的代码是我为了说明问题，特意简化的。或许你已经从代码里面看出问题了，但是，至于为什么会这样。我想，还是有必要分析一下。这样，以后，在使用PHP的时候，才不会犯相同的错误。

PHP为了减少复制，采用了一种copy on writer的机制。我想，这是一种非常常见的机制，你也一定听说过。比如，gcc 的 stl string 的实现，就是采用这样的机制，字符串赋值，不是真正的复制，而且，在修改的时候才会进行复制。我们先来举个最简单的例子：

   1:  $a = str_repeat("0", 10000);

   2:  $b = $a;

   3:  $a[0] = "1";

$a 是一个非常大的字符串，如果 $b = $a 的时候，进行复制，那要耗费很多内存和 cpu，这样非常的不划算，万一，下面的代码并不修改$a 和 $b 那复制根本没有必要。当然，$a 在后面又被修改了，这个时候，必须进行复制了，否则就不符合逻辑了。但是，现在问题来了，怎么知道，$a 在修改的时候，要进行复制呢，必须要有这样一个标记。方法就是采用引用计数。引用计数还被用来进行内存的管理。

基本的流程是这样的：

1: 创建一个变量，可以保存 10000 个 0 的这样一个字符串。

2: 创建一个变量符号 a ，这个变量符号引用这个变量。注意，变量符号和变量不是一回事情，这两者是分离的。

如果从C语言的角度来说，PHP大概完成这样一件事情：

   1:  char *varname = "a";

   2:  size_t varname_len = strlen(varname);

   3:  zend_hash_add(EG(active_symbol_table), varname, varname_len + 1, &var, sizeof(zval*), NULL);

active_symbol_table 是PHP的一个符号表，所有能访问到的变量都在这个里面，他是一个哈希表。var 这个变量，保存了 10000 个 0 这个字符串。而且是zval的结构，zval的结构如下：

typedef struct _zval_struct {
    zvalue_value value;
    zend_uint refcount;
    zend_uchar type;
    zend_uchar is_ref;
} zval;

typedef union _zvalue_value {
    long lval;
    double dval;
    struct {
        char *val;
        int len;
    } str;
    HashTable *ht;
    zend_object_value obj;
} zvalue_value;

zvalue_value 是一个联合，可以保存 long， double，字符串，哈希表（PHP Array），还有就是对象。也就是所有的PHP的类型。 zval 其实就是对 zvalue_value ，加入了类型type 和引用is_ref，引用计数refcount三个功能。这就是PHP中的普通变量。要是用PHP做比较大型的东西，就会发现，内存占用非常厉害。就是因为，他一个变量不是传统C语言的那个变量了，它加了很多东西。

好了，第一句完成了，下面是第二句。第二句很简单，会产生一个新的变量符号b，把他加入 active_symbol_table ，但是不会增加新的一个变量，而只是，refcount++。赋值就完成了。如图：

首先我们要注意的是，a ，b 只是一个符号，他是active_symbol_table 表里面的一个key，都有一个指针指向一个zval，所以，a 和b 在 C语言层面上是完全一致的。我们就得出PHP变量第一定律：

PHP变量第一定律：如果两个变量指向同一个zval，那么这两个变量是无差别的。也就是说，任何对a 的操作相对b 都是对称的。这里的对称，是这样理解的。就是镜子中的你，而不是等同。比如，对 a 进行赋值，a 就会产生 copy。同样的，如果对b进行赋值，也会进行相同的操作，那就是b产生一个copy。也就是说，a 和b的行为是一样的。

第三句，当writer发生的时候，PHP会判断一下refcount 是否大于2，如果大于2，那么就复制一下zval，然后，把原来那个zval refcount--。这就是copy on writer 的全部了，你一定觉得，这一切你都是非常的熟悉，你都懂。

但是，PHP不仅仅是copy on writer 这样简单，它还有一个引用的问题。引入引用的概念，这样，问题就变的有些复杂了。因为，引用这个标记，意思就是说，writer 的时候，你也不需要复制。这样，会修改原来的那个变量。从我们在学校里面以前经常学习的哲学上来说，这是一对矛盾。他们是对立的，又是统一的，各有各的用处。所谓，存在的就是合理的。

好，下面我们来看看这对矛盾，我们只考虑两种组合的情况。多种组合都是类似的。两种组合的话，就是赋值在前，引用在后。

或者引用在前，赋值在后。我们会分别讨论，先来看：就是赋值在前，引用在后的情况。

   1:      $a = 1;

   2:      $b = $a;

   3:      $c = &$a;

$b = $a, 是copy on writer 行为的赋值。而 $c 和 $a 是引用赋值。我们假设在上面这样的情况下，我们可以用一个zval表示，也就是不需要复制，那么情况是这样的：

根据我们的PHP变量第一定律，那，就是说，a，b，c的操作是对称的，但是非常明显，对 b 操作要产生复制行为，而对a操作不会产生复制，操作行为不相同，和第一定律矛盾。也就是说，要使得上面的操作没有矛盾，必须，进行分离。分离的原则就是，谁制造矛盾，谁复制。显然是第三句话，$c = &$a; 在制造矛盾。所以，内部变量的复制过程如下图：

上面情况是赋值在前，引用在后的情况。还有一种情况是，引用在前赋值在后：

   1:      $a = 1;

   2:      $b = &$a;

   3:      $c = $a;

按照PHP变量的第一定律，a，b，c 必须进行分离，才能保证定律的正确。可以发现，b 和 a 明显是一伙人，就是说，b 和 a 的操作是对称的，他们可以指向同一个zval ，而c 的行为和 a，b 不一样，改变c 需要进行复制。看到这里，我想，如果你看懂了的话，为什么刚开始，贴出来的那段代码的，那个两个count差异如此之大，你也应该明白了。当我和那个网友讨论的时候，它最后说，那这样的话，PHP设计的不好，我完全可以，$c先不进行复制，等c被write 了，再进行复制。看来要说懂一个东西，还是一件很难的事情，好好想想那个PHP第一定律吧。你可以假设不进行分离，c指向同一个zval，所以，c 和 a，b的行为是一样的，是is_ref = 1，所以，c 不会进行复制。最后一种内部执行情况可以用下图表示：

我以前也进行搞混这个引用，现在，你可以用那个第一定律来分析所有的情况了。PHP内核分析的文章，以后我还会写一些，如果你想深入了解PHP的某些方面，可以给我留言。

最后再补充一点，也是一个隐性的错误。

function count_bigarray()
{
    global $bigarray;
    return count($bigarray);
}

这里，没有显示的引用，但是这里隐藏了一个引用。PHP会自动创建一个引用全局变量 $bigarray 的代码，如果你在这里使用count，那么这个效率会非常的慢。最好直接通过$GLOBAL 数组进行引用。

本文链接

IP快速查找数据库

2011-03-07T06:03:00Z

最近一段时间，在研究PHP的共享内存。于是，我想尝试一下共享内存和普通文件相比，能提高多少的性能。本来想简单的把纯真IP数据库导入到共享内存然后查询。

但是，后来发现这个数据库设计过于复杂，查询IP速度非常的慢，于是我对这个数据库的结构重新进行了设计。

头部：4 * 4 个字节。就记录一个总数

//总数|0|0|0

//string1|string2|string3|string4...

这样简单化了查找：首先是读取总数，然后确定二分查找区域。查找到数据后，根据区域ID读取区域信息。

最后，经过测试，

纯真IP的原版查找速度是 1504个/s

改进IP查询文件版本查找速度是 3977 个/s

共享内存版本的查找速度是 6325个/s

因为涉及的文件太多，我不直接在这里拷贝代码，大家去google code 上去下载。

http://code.google.com/p/quickip

[

这个项目的开发计划：

0.5 版：发布一个PHP扩展，更加快速的查找IP，目前的速度是每秒 44万次查询。（目前已经开发完成，但是要做兼容linux 和相关的文档工作）

1.0 版：发布查询的时候，分离：国家省市区详细地区五个部分。（目前省份已经完成，但是市，和区还没有处理）

后面的版本现在没有计划。

]

运行：

先运行：qqwry_tool/build_csv.php ，从纯真IP导出数据

然后运行：test/bulid_index.php，创建数据和索引

如果要测试 shmop 请先安装shmop这个PHP扩展,然后运行： shmop/shmop.create.php

接下来运行测试文件： test/ip_find.test.php test/ip_find_qqwry.php

原版的PHP版本的纯真IP有bug，导致不能完整的导出区域2. 我这里没有做修改，

所以data 目录下面生成的测试结果的区域2，可能会不一致。

注意：

qqwry 这个文件夹是纯真IP的代码。不是本人写的。要符合纯真IP 的licence。

本文链接

用PHP dom 处理xml,增加或者修改节点

2011-02-28T13:18:00Z

今天有人在PHP的群里面问这样一个问题：

<?xml version="1.0" coding="utf-8"?>
<country>
<city>北京</city>
<city>香港</city>
<city>上海</city>
</country>

如果在香港前面加上一个<city>杭州</city>。今天请假在家，就花了几分钟，解决了这个问题。

<?php
$xml = <<<XML
<?xml version="1.0" encoding="utf-8"?>
<country>
<city>北京</city>
<city>香港</city>
<city>上海</city>
</country>
XML;

$dom = new DOMDocument('1.0', 'utf-8');
$dom->loadXML($xml);
$city = $dom->getElementsByTagName('city');
$element = $dom->createElement('city', '杭州');
$textNode = $dom->createTextNode("\n");
foreach ($city as $node)
{
    $value = $node->nodeValue;
    if (trim($value) == '香港')
    {
        //insert before
        $node->parentNode->insertBefore($element, $node);
        $node->parentNode->insertBefore($textNode, $node);
    }
}
echo $dom->saveXML();

本文链接

汉字转拼音问题

2011-01-26T11:29:00Z

这是一个非常经典的问题，同时，也是一个很难解决的问题。经典是因为，这个问题非常常见，而且有很多解决方案。

难以解决是因为，存在多音字。可以发现很多股票软件都有这问题，比如zgyh 出来的不是中国银行，而是找不到，

这是因为，中国银行的 “行” 查出来读的是 "xing" 。我篇文章我只是提供了一个原始的转换方法，就是查表。

和你以前看过的算法可能不一样的是，我加了一个二分查找，我看到的一个开源的解决方案是顺序查找的。

关于，多音字问题，我只有一个小规模的多音字表，从所有股票名称里面纠正过来的。解决方案是这样的：在查找拼音的时候，

查找一下这个字是否在多音字表里面，如果是，那么查找前后组成的词，来决定读什么。如果有谁有完整的多音字表，或者有更好的

解决方案，请给我留言。我一定拜谢。

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

--><?php
/**
* 初始化
*
* @param string $file 拼音代码对应表
* @return array 把这个对应表映射成array的格式
*/
function pinyin_init($file)
{
    $pinyin = file($file);
    if (empty($pinyin)) {
        throw new Exception("load pinyin table error.");
    }
    foreach ($pinyin as $k => $item)
    {
        $item = explode("\t", $item);
        $item[0] = trim($item[0]);
        $item[1] = (int)trim($item[1]);
        $pinyin[$k] = $item;
    }
    $pinyin[] = array('', -10248); //最后一个拼音的妈是 -10247
    return $pinyin;
}

/**
* 查找一个字符串中，中文字符部分的拼音
*
* @param array $pingyin
* @param string $str       字符串
* @param string $in_encode 字符串的编码
* @return array
*/
function pingyin_get($pingyin, $str, $in_encode = 'gb2312')
{
    if (strtolower($in_encode) != 'gb2312') {
       $str = iconv($in_encode, 'gb2312', $str);
       if (!$str) {
           throw new Exception('invalid input string.');
       }
    }
    $pinyin_arr = array();
    $len = strlen($str);
    for ($i = 0; $i < $len; $i++)
    {
        if ($i == $len -1) break;
        if (($code = pinyin_getcode_($str[$i], $str[$i + 1])) != false) {
            $i++;
            if (($py = pinyin_find_($pingyin, $code)) !== false) {
                $pinyin_arr[substr($str, $i - 1 , 2)] = $py;
            }
        }
    }
    return $pinyin_arr;
}

/**
* 内部函数，通过拼音码查找汉字
*
* @param array $pingyin
* @param int $code
* @return string/false
*/
function pinyin_find_($pingyin, $code)
{
    $start = 0;
    $count = count($pingyin) - 1;
    $end = $count;
    if ($code < $pingyin[0][1] || $code >= $pingyin[$end][1]) { //no found.
        return false;
    }
    while ($start <= $end)
    {
        $mid = (int)($start + ($end - $start)/2);
        if ($mid == $count) { //正常情况下，应该是永远都不会执行到这里，但是为了逻辑上清晰点，还是决定写上
            return $pingyin[$mid - 1][0];
        } else if ($code >= $pingyin[$mid][1] && $code < $pingyin[$mid + 1][1]) {
            return $pingyin[$mid][0];
        } else if ($code >= $pingyin[$mid + 1][1]) {
           $start = $mid + 1;
        } else {
            $end = $mid - 1;
        }
    }
    return false;
}

/**
* 内部函数，通过汉字的第一个字节和第二个字节，得到查找的code
*
* @param char $ch1
* @param char $ch2
* @return int
*/
function pinyin_getcode_($ch1, $ch2)
{
    $num1 = ord($ch1);
    $num2 = ord($ch2);
    if ($num1 > 159 && $num1 < 248) {
        return $num1 * 256 + $num2 - 65536;
    }
    return false;
}

/**
* 基本配置信息
*/
define("CURRENT_PATH", dirname(__FILE__));
$pingin_file = CURRENT_PATH . "/gb-pinyin.table";

$pinyin = pinyin_init($pingin_file);
$py = pingyin_get($pinyin, "中国银行", 'utf-8');
echo iconv('gb2312', 'utf-8', print_r($py, true));
echo implode("'", $py);
?>

拼音表如下：

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->a -20319
ai -20317
an -20304
ang -20295
ao -20292
ba -20283
bai -20265
ban -20257
bang -20242
bao -20230
bei -20051
ben -20036
beng -20032
bi -20026
bian -20002
biao -19990
bie -19986
bin -19982
bing -19976
bo -19805
bu -19784
ca -19775
cai -19774
can -19763
cang -19756
cao -19751
ce -19746
ceng -19741
cha -19739
chai -19728
chan -19725
chang -19715
chao -19540
che -19531
chen -19525
cheng -19515
chi -19500
chong -19484
chou -19479
chu -19467
chuai -19289
chuan -19288
chuang -19281
chui -19275
chun -19270
chuo -19263
ci -19261
cong -19249
cou -19243
cu -19242
cuan -19238
cui -19235
cun -19227
cuo -19224
da -19218
dai -19212
dan -19038
dang -19023
dao -19018
de -19006
deng -19003
di -18996
dian -18977
diao -18961
die -18952
ding -18783
diu -18774
dong -18773
dou -18763
du -18756
duan -18741
dui -18735
dun -18731
duo -18722
e -18710
en -18697
er -18696
fa -18526
fan -18518
fang -18501
fei -18490
fen -18478
feng -18463
fo -18448
fou -18447
fu -18446
ga -18239
gai -18237
gan -18231
gang -18220
gao -18211
ge -18201
gei -18184
gen -18183
geng -18181
gong -18012
gou -17997
gu -17988
gua -17970
guai -17964
guan -17961
guang -17950
gui -17947
gun -17931
guo -17928
ha -17922
hai -17759
han -17752
hang -17733
hao -17730
he -17721
hei -17703
hen -17701
heng -17697
hong -17692
hou -17683
hu -17676
hua -17496
huai -17487
huan -17482
huang -17468
hui -17454
hun -17433
huo -17427
ji -17417
jia -17202
jian -17185
jiang -16983
jiao -16970
jie -16942
jin -16915
jing -16733
jiong -16708
jiu -16706
ju -16689
juan -16664
jue -16657
jun -16647
ka -16474
kai -16470
kan -16465
kang -16459
kao -16452
ke -16448
ken -16433
keng -16429
kong -16427
kou -16423
ku -16419
kua -16412
kuai -16407
kuan -16403
kuang -16401
kui -16393
kun -16220
kuo -16216
la -16212
lai -16205
lan -16202
lang -16187
lao -16180
le -16171
lei -16169
leng -16158
li -16155
lia -15959
lian -15958
liang -15944
liao -15933
lie -15920
lin -15915
ling -15903
liu -15889
long -15878
lou -15707
lu -15701
lv -15681
luan -15667
lue -15661
lun -15659
luo -15652
ma -15640
mai -15631
man -15625
mang -15454
mao -15448
me -15436
mei -15435
men -15419
meng -15416
mi -15408
mian -15394
miao -15385
mie -15377
min -15375
ming -15369
miu -15363
mo -15362
mou -15183
mu -15180
na -15165
nai -15158
nan -15153
nang -15150
nao -15149
ne -15144
nei -15143
nen -15141
neng -15140
ni -15139
nian -15128
niang -15121
niao -15119
nie -15117
nin -15110
ning -15109
niu -14941
nong -14937
nu -14933
nv -14930
nuan -14929
nue -14928
nuo -14926
o -14922
ou -14921
pa -14914
pai -14908
pan -14902
pang -14894
pao -14889
pei -14882
pen -14873
peng -14871
pi -14857
pian -14678
piao -14674
pie -14670
pin -14668
ping -14663
po -14654
pu -14645
qi -14630
qia -14594
qian -14429
qiang -14407
qiao -14399
qie -14384
qin -14379
qing -14368
qiong -14355
qiu -14353
qu -14345
quan -14170
que -14159
qun -14151
ran -14149
rang -14145
rao -14140
re -14137
ren -14135
reng -14125
ri -14123
rong -14122
rou -14112
ru -14109
ruan -14099
rui -14097
run -14094
ruo -14092
sa -14090
sai -14087
san -14083
sang -13917
sao -13914
se -13910
sen -13907
seng -13906
sha -13905
shai -13896
shan -13894
shang -13878
shao -13870
she -13859
shen -13847
sheng -13831
shi -13658
shou -13611
shu -13601
shua -13406
shuai -13404
shuan -13400
shuang -13398
shui -13395
shun -13391
shuo -13387
si -13383
song -13367
sou -13359
su -13356
suan -13343
sui -13340
sun -13329
suo -13326
ta -13318
tai -13147
tan -13138
tang -13120
tao -13107
te -13096
teng -13095
ti -13091
tian -13076
tiao -13068
tie -13063
ting -13060
tong -12888
tou -12875
tu -12871
tuan -12860
tui -12858
tun -12852
tuo -12849
wa -12838
wai -12831
wan -12829
wang -12812
wei -12802
wen -12607
weng -12597
wo -12594
wu -12585
xi -12556
xia -12359
xian -12346
xiang -12320
xiao -12300
xie -12120
xin -12099
xing -12089
xiong -12074
xiu -12067
xu -12058
xuan -12039
xue -11867
xun -11861
ya -11847
yan -11831
yang -11798
yao -11781
ye -11604
yi -11589
yin -11536
ying -11358
yo -11340
yong -11339
you -11324
yu -11303
yuan -11097
yue -11077
yun -11067
za -11055
zai -11052
zan -11045
zang -11041
zao -11038
ze -11024
zei -11020
zen -11019
zeng -11018
zha -11014
zhai -10838
zhan -10832
zhang -10815
zhao -10800
zhe -10790
zhen -10780
zheng -10764
zhi -10587
zhong -10544
zhou -10533
zhu -10519
zhua -10331
zhuai -10329
zhuan -10328
zhuang -10322
zhui -10315
zhun -10309
zhuo -10307
zi -10296
zong -10281
zou -10274
zu -10270
zuan -10262
zui -10260
zun -10256
zuo -10254

本文链接

多态的内幕--(C++, C)语言两个版本

2011-01-20T06:01:00Z

本文通过分析C++编译器生成的汇编代码，分析多态的机制。并实现了一个C语言版本。

在编译性语言里面，多态真的是一个伟大的发明。它可以现在写好代码，编译好，并且可以调用未来的代码。这多少有了点动态的感觉。

很多人，也在脚本语言里面抱怨，为什么不提供多态的功能啊。脚本语言里面，一个函数参数，可以传递任何类型，甚至可以通过函数名的字符串调用函数，

这样多态的作用就小了很多。对于面向对象来说，最重要的两个概念莫过于继承和多态。继承可以减少代码重复，多态可以减少大量的条件判断，if else switch

如果在代码中太多，你的程序应该不怎么面向对象。

废话不说了，先给一个用于分析的程序：

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->#include <iostream>
using namespace std;

class Base
{
public:
    virtual void vfun1() {cout << " Base::vfun1()" <<endl;}
    virtual void vfun2() {cout << " Base::vfun2()" <<endl;}
    virtual void vfun3() {cout << " Base::vfun3()" <<endl;}
};

class Concrete:public Base
{
public:
    void vfun1() {cout << " Concrete::vfun1()" <<endl;}
    void vfun2() {cout << " Concrete::vfun2()" <<endl;}
};

void override_demo2(Base &obj)
{
    obj.vfun1();
    obj.vfun2();
    obj.vfun3();
}

typedef long point_t;  //32 位系统和 64 位系统上都表示标准指针的长度，但是可能不兼容16位系统，在编译的时候修改一下
typedef void (*func)();

inline void *  getvfptr(void *p, int offset)
{
    point_t *q = (point_t *)*(point_t *)p;
    // cout << q[0] << endl
    //      << q[1] << endl
    //      << q[2] << endl;
    return (void *)(q[offset]);
}

void override_demo(Base &obj)
{
    func f;
    f = (func)getvfptr(&obj, 0);
    f();
    f = (func)getvfptr(&obj, 1);
    f();
    f = (func)getvfptr(&obj, 2);
    f();
}

int main()
{
    Base base_obj;
    Concrete concrete_obj;
    cout << "override_demo:" << endl;
    override_demo(base_obj);
    override_demo(concrete_obj);
    cout << "override_demo2:" << endl;
    override_demo2(base_obj);
    override_demo2(concrete_obj);
}

这基本上是一个最简单的多态的演示了。我们先来看看 override_demo 这个函数。这个函数没有使用系统使用的多态功能，但是也实现了多态。

通过仔细分析可以发现，这个代码的原理是取出 Base 类的地址，如果，Base 定义了虚函数，那么会在Base的头部自动插入一个指针，指向虚表数组。

函数调用是通过函数的地址，编译器会在Base类里面插入这个虚表，里面填上按照顺序填上虚函数的地址，在子类中，会复制一份Base的虚表数组，

如果函数被重新定义，那么替换这个虚表中的函数地址，否则就用Base 类里面的地址，在调用虚函数的地方，把obj.vfunc1() 改成调用虚表中的第一个函数。

这样，即时子类指针转换成了父类指针，但是子类地址指针指向的虚表还是子类的，所以，会调用子类虚表中的第一个函数。

上面的解释太抽象，可以看看汇编的代码：

这是 override_demo2 的汇编代码，很能说明问题：

void override_demo2(Base &obj)
{
00411950 push        ebp
00411951 mov         ebp,esp
00411953 sub         esp,0C0h
00411959 push        ebx
0041195A push        esi
0041195B push        edi
0041195C lea         edi,[ebp-0C0h]
00411962 mov         ecx,30h
00411967 mov         eax,0CCCCCCCCh
0041196C rep stos    dword ptr es:[edi]
    obj.fun1();
0041196E mov         eax,dword ptr [obj] //取出obj的地址,就是getvfptr 中p的值
00411971 mov         edx,dword ptr [eax] //取出obj第一个元素的值，也就是 getvfptr 中的 *(ponit_t *)p , 取出指针所指向的地址
00411973 mov         esi,esp
00411975 mov         ecx,dword ptr [obj]
00411978 mov         eax,dword ptr [edx] //取出obj第一个元素的指针，指向的第一个元素，也就是 getvfptr 中的 q[0]
0041197A call        eax   //调用函数
0041197C cmp         esi,esp
0041197E call        @ILT+470(__RTC_CheckEsp) (4111DBh)
    obj.fun2();
00411983 mov         eax,dword ptr [obj]
00411986 mov         edx,dword ptr [eax]
00411988 mov         esi,esp
0041198A mov         ecx,dword ptr [obj]
0041198D mov         eax,dword ptr [edx+4] //第二个函数
00411990 call        eax
00411992 cmp         esi,esp
00411994 call        @ILT+470(__RTC_CheckEsp) (4111DBh)
    obj.fun3();
00411999 mov         eax,dword ptr [obj]
0041199C mov         edx,dword ptr [eax]
0041199E mov         esi,esp
004119A0 mov         ecx,dword ptr [obj]
004119A3 mov         eax,dword ptr [edx+8] //第三个函数
004119A6 call        eax
004119A8 cmp         esi,esp
004119AA call        @ILT+470(__RTC_CheckEsp) (4111DBh)
}

这样看来，调用虚函数的代码并不是很高，但是可以发现，虚函数是不可能内联的，因为，调用它必须通过地址。而且，在之类中必须声明为 virtual，

否则，这个函数不会放入虚表中，也就不能产生多态了。

依照这个思路，你可以改造成一个C语言的多态的方法。比如你定义一个基结构，它是一个函数指针列表，然后，定义几个子结构，子结构是和基结构一样排序

的函数指针列表。下面是一个例子：

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->#include <stdio.h>
#include <stdlib.h>

typedef void func();
struct Base
{
    func *vfun1;
    func *vfun2;
    func *vfun3;
};

struct Child
{
    func *vfun1;
    func *vfun2;
    func *vfun3;
    char *hello;
};

void base_vfunc1()
{
    printf(" base_vfunc1\n");
}

void base_vfunc2()
{
    printf(" base_vfunc2\n");
}

void base_vfunc3()
{
    printf(" base_vfunc3\n");
}

struct Base* init_base()
{
    static struct Base base_vtable;
    base_vtable.vfun1 = base_vfunc1;
    base_vtable.vfun2 = base_vfunc2;
    base_vtable.vfun3 = base_vfunc3;
    return &base_vtable;
}

void child_vfunc3()
{
    printf(" child_vfunc3\n");
}
struct Child * init_child()
{
    struct Child *child;
    struct Base  *base_vtable;
    child = malloc(sizeof(struct Child));
    base_vtable = init_base();
    child->vfun1 = base_vtable->vfun1;
    child->vfun2 = base_vtable->vfun2;
    child->vfun3 = child_vfunc3;
    child->hello = "hello world";
    return child;
}

free_child(struct Child *ch)
{
    if (ch) free(ch);
    ch = NULL;
}

void override_demo(void *p)
{
    struct Base *base;
    base = (struct Base *)p;
    base->vfun1();
    base->vfun2();
    base->vfun3();
}

int main()
{
    struct Child *ch  = init_child();
    struct Base *base = init_base();
    printf("base\n");
    override_demo(base);
    printf("child\n");
    override_demo(ch);
    printf(ch->hello);
    free_child(ch);
}

这样，你写一个函数，可以调用不同的代码了。

当然，可能没有面向对象这样直观了。

本文链接

博客园_混沌的世界

基数排序的一个变形应用

如何学习Yii

如何在apache启动的时候不输入ssl的密码

字符串之全文索引

2011 october calendar wallpapers

深入PHP内核（1） 引用

IP快速查找数据库

用PHP dom 处理xml,增加或者修改节点

汉字转拼音问题

多态的内幕--(C++, C)语言两个版本

深入PHP内核（1）引用