分类目录归档：PHP

PHP源码，PHP扩展，PHP程序

PHP源码阅读笔记一:explode和implode函数

PHP源码阅读笔记一
一、explode和implode函数
array explode ( string separator, string string [, int limit] )
此函数返回由字符串组成的数组，每个元素都是 string 的一个子串，它们被字符串 separator 作为边界点分割出来。如果设置了 limit 参数，则返回的数组包含最多 limit 个元素，而最后那个元素将包含 string 的剩余部分。

此函数的时间复杂度应该是O(strlen(separator) * strlen(string))
其实现过程基本上是遍历字符串string,将它与separator比较，如果相同，则写入hash表，并将string的指针移到新的位置（即每一个separator的右边）；

另外，对于limit小于0的情况有特殊处理
本函数实现主要是依赖于php_memnstr函数，在php.h文件中我们可以看到它的定义，
#define php_memnstr zend_memnstr
其真正的函数是zend_memnstr，在Zend/zend_operators.h文件的217行，可以看到它的定义，其实现主要是一个while循环和两个C语言的函数memchr和memcmp

string implode ( string glue, array pieces )
此函数返回一个以glue字符串连接的pieces数组的各元素的字符串。
此函数可以是以一个数组为参数，可以是以一个数组和一个字符串为参数，并且字符串和数组的顺序可以改变，这些在程序中都有针对每种情况的特殊处理，如下代码：

              if (argc == 1) {
                            if (Z_TYPE_PP(arg1) != IS_ARRAY) {                            //              只有一个参数并且还不是数组
                                          php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument must be an array");
                                          return;
                            }
 
                            MAKE_STD_ZVAL(delim);
#define _IMPL_EMPTY ""
                            ZVAL_STRINGL(delim, _IMPL_EMPTY, sizeof(_IMPL_EMPTY) - 1, 0);
 
                            SEPARATE_ZVAL(arg1);
                            arr = *arg1;
              } else {              //              两个参数
                            if (Z_TYPE_PP(arg1) == IS_ARRAY) {              //              如果每一个参数是数组
                                          arr = *arg1;
                                          convert_to_string_ex(arg2);
                                          delim = *arg2;
                            } else if (Z_TYPE_PP(arg2) == IS_ARRAY) {              //              如果第二个参数是数组
                                          arr = *arg2;
                                          convert_to_string_ex(arg1);
                                          delim = *arg1;
                            } else {
                                          php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid arguments passed");
                                          return;
                            }
              }

最后数组都会赋值给arr，分隔字符串赋值给delim，没有的置为””

就是一个遍历数组，并连接字符串的过程，只是这个过程中使用了smart_str相关函数（更多相关请移步），针对不同的类型作了不同的连接操作（如果是数字还需要将数字转化成字符串，这些在smart_str中都有相关函数处理）

PHP中strtr函数一些奇怪行为的解释

前些日子，一哥们给我发了篇文章给我看，说是strtr函数有一些奇怪的行为，其地址如下：http://tech.cuit.edu.cn/forum/thread-1867-1-1.html

查看PHP的源码，得到如下解释：

【奇怪行为一】
先来看看这个php字符串替换函数 strtr()的两种状态
strtr(string,from,to)
或者strtr(string,array)
首先针对strtr函数第一种方式
我们看看下面的举例:

1	echo strtr("I Love you","Lo","lO");

得到的结果是
I lOve yOu

这个结果提醒我们
1.strtr它是区分大小写的

【源码分析一】
strtr函数的最终实现函数是string.c文件的2670行的php_strtr函数，其源码如下：

PHPAPI char *php_strtr(char *str, int len, char *str_from, char *str_to, int trlen)
{
int i;
unsigned char xlat[256];
 
 
if ((trlen < 1) || (len < 1)) {
return str;
}
 
 
for (i = 0; i < 256; xlat[i] = i, i++);
 
 
for (i = 0; i < trlen; i++) {
xlat[(unsigned char) str_from[i]] = str_to[i];
}
 
 
for (i = 0; i < len; i++) {
str[i] = xlat[(unsigned char) str[i]];
}
 
 
return str;
}

整个函数是对于256个字符进行hash替换，这256个字符中当然包括大小写字母啦

【奇怪行为二】
2.strtr的替换是很特殊的，你注意看后面那个yOu，中间的O被替换的，这显然不是我们的本意

【源码分析二】
道理同上，它是对每个字符进行对应替换，是以字符为单位，所以替换的是字符，而不是字符串

【奇怪行为三】
再举一个特殊例子，说明这个php sttr函数的怪异

1	echo strtr("I Love you","Love","");

结果是

I Love you

什么也不会改变，所以strtr需要注意的是:不能被替换为空，也就是末位那个参数不能是空字符串，当然空格是可以的。

【源码分析三】
在string.c文件的2833行，我们可以看到其调用程序如下：

php_strtr(Z_STRVAL_P(return_value),
 Z_STRLEN_P(return_value),
 Z_STRVAL_PP(from),
 Z_STRVAL_PP(to),
 MIN(Z_STRLEN_PP(from), 
 Z_STRLEN_PP(to)));

MIN(Z_STRLEN_PP(from), Z_STRLEN_PP(to))是取from和to两个字符串的长度中最小的，如三所示的情况，其结果为0，从php_strtr函数中我们可以看到

1
2
3

if ((trlen < 1) || (len < 1)) {
return str;
}

当长度小于1时返回原来的字符串。所以。。。。

【奇怪行为四】
再次举例strtr函数的另一种情况

1 2	echo strtr("I Loves you","Love","lOvEA");

结果是

I lOvEs yOu

注意看第三个参数的A，在结果中并没有出现
【源码分析三】
其理由与二类似，MIN(Z_STRLEN_PP(from), Z_STRLEN_PP(to))是取from和to两个字符串的长度中最小的

static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *hash)
{
zval **entry;
char  *string_key;
uint   string_key_len;
zval **trans;
zval   ctmp;
ulong num_key;
int minlen = 128*1024;
int maxlen = 0, pos, len, found;
char *key;
HashPosition hpos;
smart_str result = {0};
HashTable tmp_hash;
zend_hash_init(&tmp_hash, zend_hash_num_elements(hash), NULL, NULL, 0);
zend_hash_internal_pointer_reset_ex(hash, &hpos);
while (zend_hash_get_current_data_ex(hash, (void **)&entry, &hpos) == SUCCESS) {
switch (zend_hash_get_current_key_ex(hash, &string_key, &string_key_len, &num_key, 0, &hpos)) {
case HASH_KEY_IS_STRING:
len = string_key_len-1;
if (len < 1) {
zend_hash_destroy(&tmp_hash);
RETURN_FALSE;
}
zend_hash_add(&tmp_hash, string_key, string_key_len, entry, sizeof(zval*), NULL);
if (len > maxlen) {
maxlen = len;
}
if (len < minlen) {
minlen = len;
}
break; 
case HASH_KEY_IS_LONG:
Z_TYPE(ctmp) = IS_LONG;
Z_LVAL(ctmp) = num_key;
convert_to_string(&ctmp);
len = Z_STRLEN(ctmp);
zend_hash_add(&tmp_hash, Z_STRVAL(ctmp), len+1, entry, sizeof(zval*), NULL);
zval_dtor(&ctmp);
 
 
if (len > maxlen) {
maxlen = len;
}
if (len < minlen) {
minlen = len;
}
break;
}
zend_hash_move_forward_ex(hash, &hpos);
}
 
 
key = emalloc(maxlen+1);
pos = 0;
 
 
while (pos < slen) {
if ((pos + maxlen) > slen) {
maxlen = slen - pos;
}
 
 
found = 0;
memcpy(key, str+pos, maxlen);
 
 
for (len = maxlen; len >= minlen; len--) {
key[len] = 0;
if (zend_hash_find(&tmp_hash, key, len+1, (void**)&trans) == SUCCESS) {
char *tval;
int tlen;
zval tmp;
 
 
if (Z_TYPE_PP(trans) != IS_STRING) {
tmp = **trans;
zval_copy_ctor(&tmp);
convert_to_string(&tmp);
tval = Z_STRVAL(tmp);
tlen = Z_STRLEN(tmp);
} else {
tval = Z_STRVAL_PP(trans);
tlen = Z_STRLEN_PP(trans);
}
 
 
smart_str_appendl(&result, tval, tlen);
pos += len;
found = 1;
 
 
if (Z_TYPE_PP(trans) != IS_STRING) {
zval_dtor(&tmp);
}
break;
} 
}
 
 
if (! found) {
smart_str_appendc(&result, str[pos++]);
}
}
 
 
efree(key);
zend_hash_destroy(&tmp_hash);
smart_str_0(&result);
RETVAL_STRINGL(result.c, result.len, 0);
}

PHP源码中HashTable的简单示例

PHP源码中HashTable的简单示例前些日子看了那篇对hasttable的介绍，于是也想自己运行一下，可是对于源码的调试不是太在行。所以想了个办法：自己把PHP源码中的一些简单操作提取出来，自己运行一下，查看输出或调试。于是花费了三天的空闲时间把一些相关的东西提取出来，主要是Zend目录下的zend_alloc.c,zend_alloc.h,zend_hash.c,zend_hash.h四个文件。将与PHP相关的内存分配去掉，默认使用系统自带的内存分配方式。另外：一些注释是http://www.phppan.com/2009/12/zend-hashtable/中所引用文章中的相关信息。作者地址：http://www.phpinternals.com 下面的代码是一个可以运行的C程序，它初始化一个容量为50的hashtable（实际上分配了64个），然后将30到68，写入hash table，并将这个hash table 打印出来。相信这会给一些想学习源码的童鞋一些帮助。源代码如下：

<!-- 
#include <stdio.h-->
#include 
#include 
typedef unsigned long ulong;
typedef unsigned int uint;
typedef unsigned char zend_bool;
typedef unsigned int size_t;
typedef void (*dtor_func_t)(void *pDest);
typedef ulong (*hash_func_t)(char *arKey, uint nKeyLength);
#define SUCCESS 0
#define FAILURE -1	 /* this MUST stay a negative number, or it may affect functions! */
 
#define HASH_UPDATE (1&lt;&lt;0)
#define HASH_ADD	 (1&lt;&lt;1)
#define HASH_NEXT_INSERT	(1&lt;&lt;2)
 
#define HASH_DEL_KEY 0
 
#define perealloc_recoverable(ptr, size, persistent) (__zend_realloc((ptr), (size)))
#define pefree_rel(ptr, persistent)	(free(ptr))	//	此处省略了使用PHP的内存分配函数
#define pemalloc_rel(size, persistent) (__zend_malloc(size))
#define perealloc_rel(ptr, size, persistent) (__zend_realloc((ptr), (size)))
#define pemalloc(size, persistent) (__zend_malloc(size))
#define pefree(ptr, persistent)  (free(ptr))
 
inline static void * __zend_malloc(size_t len) {
    void *tmp = malloc(len);
    if (tmp) {
        return tmp;
    }  
    fprintf(stderr, "Out of memory\n");
    exit(1);
}
 
 
inline static void * __zend_realloc(void *p, size_t len) {
    p = realloc(p, len);
    if (p) {
        return p;
    }  
    fprintf(stderr, "Out of memory\n");
    exit(1);
}
 
 
typedef struct bucket {
    ulong h;       /* Used for numeric indexing */
    uint nKeyLength;     /* key 长度 */
    void *pData;      /* 指向Bucket中保存的数据的指针 */
    void *pDataPtr;     /* 指针数据 */
    struct bucket *pListNext;   /* 指向HashTable桶列中下一个元素 */
    struct bucket *pListLast;    /* 指向HashTable桶列中前一个元素 */
    struct bucket *pNext;    /* 指向具有同一个hash值的桶列的后一个元素 */
    struct bucket *pLast;    /* 指向具有同一个hash值的桶列的前一个元素 */
    char arKey[1];      /* 必须是最后一个成员，key名称*/
} Bucket;
 
 
typedef struct _hashtable {
    uint nTableSize;
/*指定了HashTable的大小，同时它限定了HashTable中能保存Bucket的最大数量
此 数越大，系统为HashTable分配的内存就越多。为了提高计算效率，
系统自动会将nTableSize调整到最小一个不小于nTableSize的2 的整数次方*/
    uint nTableMask;	/*nTableMask的值永远是nTableSize – 1，引入这个字段的主要目的是为了提高计算效率*/
    uint nNumOfElements;	/*记录HashTable当前保存的数据元素的个数*/
    ulong nNextFreeElement;	/*记录HashTable中下一个可用于插入数据元素的arBuckets的索引*/
    Bucket *pInternalPointer;	/* Used for element traversal */
    Bucket *pListHead;	/*Bucket双向链表的第一个元素*/
    Bucket *pListTail;	/*Bucket双向链表的最后一元素*/
    Bucket **arBuckets;	/*存储Bucket双向链表*/
    dtor_func_t pDestructor;	/*函数指针，在HashTable的增加、修改、删除Bucket时自动调用，用于处理相关数据的清理工作*/
    zend_bool persistent;	/*指出了Bucket内存分配的方式。如果persisient为TRUE，则使用操作系统本身的内存分配函数为Bucket分配内存，否则使用PHP的内存分配函数。*/
    unsigned char nApplyCount;	/*nApplyCount与bApplyProtection结合提供了一个防止在遍历HashTable时进入递归循环时的一种机制*/
    zend_bool bApplyProtection;
} HashTable;
 
 
 
typedef struct _zend_hash_key {
    char *arKey;
    uint nKeyLength;
    ulong h;
} zend_hash_key;
 
typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht, void *source_data, zend_hash_key *hash_key, void *pParam);
 
 
#define CONNECT_TO_BUCKET_DLLIST(element, list_head)	 \
(element)-&gt;pNext = (list_head);	 \
(element)-&gt;pLast = NULL;	 \
if ((element)-&gt;pNext) {	 \
    (element)-&gt;pNext-&gt;pLast = (element);	 \
}
 
#define CONNECT_TO_GLOBAL_DLLIST(element, ht)	 \
(element)-&gt;pListLast = (ht)-&gt;pListTail;	 \
(ht)-&gt;pListTail = (element);	 \
(element)-&gt;pListNext = NULL;	 \
if ((element)-&gt;pListLast != NULL) {	 \
    (element)-&gt;pListLast-&gt;pListNext = (element);	 \
}	 \
if (!(ht)-&gt;pListHead) {	 \
    (ht)-&gt;pListHead = (element);	 \
}	 \
if ((ht)-&gt;pInternalPointer == NULL) {	 \
    (ht)-&gt;pInternalPointer = (element);	 \
}
 
#define ZEND_HASH_IF_FULL_DO_RESIZE(ht)	 \
if ((ht)-&gt;nNumOfElements &gt; (ht)-&gt;nTableSize) {	\
    zend_hash_do_resize(ht);	 \
}
 
int zend_hash_rehash(HashTable *ht) {
    Bucket *p;
    uint nIndex;
 
 
    memset(ht-&gt;arBuckets, 0, ht-&gt;nTableSize * sizeof(Bucket *));
    p = ht-&gt;pListHead;
    while (p != NULL) {
        nIndex = p-&gt;h &amp; ht-&gt;nTableMask;
        CONNECT_TO_BUCKET_DLLIST(p, ht-&gt;arBuckets[nIndex]);
        ht-&gt;arBuckets[nIndex] = p;
        p = p-&gt;pListNext;
    }
    return SUCCESS;
}
 
static int zend_hash_do_resize(HashTable *ht) {
    Bucket **t;
 
    if ((ht-&gt;nTableSize &lt;&lt; 1) &gt; 0) {	/* Let's double the table size */
        t = (Bucket **) perealloc_recoverable(ht-&gt;arBuckets, (ht-&gt;nTableSize &lt;&lt; 1) * sizeof(Bucket *), ht-&gt;persistent);
        if (t) {
            ht-&gt;arBuckets = t;
            ht-&gt;nTableSize = (ht-&gt;nTableSize &lt;&lt; 1);
            ht-&gt;nTableMask = ht-&gt;nTableSize - 1;
            zend_hash_rehash(ht);
            return SUCCESS;
        }
        return FAILURE;
    }
    return SUCCESS;
}
 
 
 
 
#define UPDATE_DATA(ht, p, pData, nDataSize)	 \
if (nDataSize == sizeof(void*)) {	 \
if ((p)-&gt;pData != &amp;(p)-&gt;pDataPtr) {	 \
pefree_rel((p)-&gt;pData, (ht)-&gt;persistent);	 \
}	 \
memcpy(&amp;(p)-&gt;pDataPtr, pData, sizeof(void *));	 \
(p)-&gt;pData = &amp;(p)-&gt;pDataPtr;	 \
} else {	 \
    if ((p)-&gt;pData == &amp;(p)-&gt;pDataPtr) {	 \
        (p)-&gt;pData = (void *) pemalloc_rel(nDataSize, (ht)-&gt;persistent);	 \
        (p)-&gt;pDataPtr=NULL;	 \
    } else {	 \
        (p)-&gt;pData = (void *) perealloc_rel((p)-&gt;pData, nDataSize, (ht)-&gt;persistent);	\
/* (p)-&gt;pDataPtr is already NULL so no need to initialize it */	 \
    }	 \
    memcpy((p)-&gt;pData, pData, nDataSize);	 \
}
 
#define INIT_DATA(ht, p, pData, nDataSize);	 \
if (nDataSize == sizeof(void*)) {	 \
memcpy(&amp;(p)-&gt;pDataPtr, pData, sizeof(void *));	 \
(p)-&gt;pData = &amp;(p)-&gt;pDataPtr;	 \
} else {	 \
    (p)-&gt;pData = (void *) pemalloc_rel(nDataSize, (ht)-&gt;persistent);\
    if (!(p)-&gt;pData) {	 \
        pefree_rel(p, (ht)-&gt;persistent);	 \
        return FAILURE;	 \
    }	 \
    memcpy((p)-&gt;pData, pData, nDataSize);	 \
    (p)-&gt;pDataPtr=NULL;	 \
}
 
 
 
static inline ulong zend_inline_hash_func(char *arKey, uint nKeyLength) {
    register ulong hash = 5381;
 
/* variant with the hash unrolled eight times */
    for (; nKeyLength &gt;= 8; nKeyLength -= 8) {
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
        hash = ((hash &lt;&lt; 5) + hash) + *arKey++;
    }
    switch (nKeyLength) {
        case 7: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 6: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 5: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 4: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 3: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 2: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; /* fallthrough... */
        case 1: hash = ((hash &lt;&lt; 5) + hash) + *arKey++; break;
        case 0: break;
    }
    return hash;
}
ulong zend_hash_func(char *arKey, uint nKeyLength) {
    return zend_inline_hash_func(arKey, nKeyLength);
}
 
//	省略了
int zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor) {
    uint i = 3;
    Bucket **tmp;
    zend_bool persistent = 1;
 
 
    if (nSize &gt;= 0x80000000) {
/* prevent overflow */
        ht-&gt;nTableSize = 0x80000000;
    } else {
        while ((1U &lt;&lt; i) &lt; nSize) {
            i++;
        }
        ht-&gt;nTableSize = 1 &lt;&lt; i;
    }
 
    ht-&gt;nTableMask = ht-&gt;nTableSize - 1;
    ht-&gt;pDestructor = pDestructor;
    ht-&gt;arBuckets = NULL;
    ht-&gt;pListHead = NULL;
    ht-&gt;pListTail = NULL;
    ht-&gt;nNumOfElements = 0;
    ht-&gt;nNextFreeElement = 0;
    ht-&gt;pInternalPointer = NULL;
    ht-&gt;persistent = persistent;
    ht-&gt;nApplyCount = 0;
    ht-&gt;bApplyProtection = 1;
 
 
    tmp = (Bucket **) calloc(ht-&gt;nTableSize, sizeof(Bucket *));
    if (!tmp) {
        return FAILURE;
    }
    ht-&gt;arBuckets = tmp;
 
 
    return SUCCESS;
}
 
int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag) {
    ulong h;
    uint nIndex;
    Bucket *p;
 
 
    if (nKeyLength &lt;= 0) {
        return FAILURE;
    }
 
    h = zend_inline_hash_func(arKey, nKeyLength);
    nIndex = h &amp; ht-&gt;nTableMask;
 
    p = ht-&gt;arBuckets[nIndex];
 
    while (p != NULL) {
        if ((p-&gt;h == h) &amp;&amp; (p-&gt;nKeyLength == nKeyLength)) {
            if (!memcmp(p-&gt;arKey, arKey, nKeyLength)) {
                if (flag &amp; HASH_ADD) {
                    return FAILURE;
                }
 
                if (ht-&gt;pDestructor) {
                    ht-&gt;pDestructor(p-&gt;pData);
                }
                UPDATE_DATA(ht, p, pData, nDataSize);
                if (pDest) {
                *pDest = p-&gt;pData;
            }
            return SUCCESS;
        }
    }
    p = p-&gt;pNext;
}
 
p = (Bucket *) pemalloc(sizeof(Bucket) - 1 + nKeyLength, ht-&gt;persistent);
if (!p) {
    return FAILURE;
}
memcpy(p-&gt;arKey, arKey, nKeyLength);
p-&gt;nKeyLength = nKeyLength;
INIT_DATA(ht, p, pData, nDataSize);
p-&gt;h = h;
CONNECT_TO_BUCKET_DLLIST(p, ht-&gt;arBuckets[nIndex]);
if (pDest) {
*pDest = p-&gt;pData;
}
 
 
CONNECT_TO_GLOBAL_DLLIST(p, ht);
ht-&gt;arBuckets[nIndex] = p;
 
 
ht-&gt;nNumOfElements++;
ZEND_HASH_IF_FULL_DO_RESIZE(ht);	 /* If the Hash table is full, resize it */
return SUCCESS;
}
 
void zend_hash_destroy(HashTable *ht) {
    Bucket *p, *q;
 
 
    p = ht-&gt;pListHead;
    while (p != NULL) {
        q = p;
        p = p-&gt;pListNext;
        if (ht-&gt;pDestructor) {
            ht-&gt;pDestructor(q-&gt;pData);
        }
        if (q-&gt;pData != &amp;q-&gt;pDataPtr) {
            pefree(q-&gt;pData, ht-&gt;persistent);
        }
        pefree(q, ht-&gt;persistent);
    }
    pefree(ht-&gt;arBuckets, ht-&gt;persistent);
 
}
 
 
 
int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) {
    ulong h;
    uint nIndex;
    Bucket *p;
 
 
    h = zend_inline_hash_func(arKey, nKeyLength);
    nIndex = h &amp; ht-&gt;nTableMask;
 
    p = ht-&gt;arBuckets[nIndex];
    while (p != NULL) {
        if ((p-&gt;h == h) &amp;&amp; (p-&gt;nKeyLength == nKeyLength)) {
            if (!memcmp(p-&gt;arKey, arKey, nKeyLength)) {
            *pData = p-&gt;pData;
            return SUCCESS;
        }
    }
    p = p-&gt;pNext;
}
return FAILURE;
}
 
 
void zend_hash_display(HashTable *ht) {
    Bucket *p;
    uint i;
    int flag  = 0 ;
 
    for (i = 0; i &lt; ht-&gt;nTableSize; i++) {
        p = ht-&gt;arBuckets[i];
        flag = 0;
        while (p != NULL) {
            printf("(%d %s &lt;==&gt; 0x%lX %d)   ", i, p-&gt;arKey, p-&gt;h, p-&gt;pNext);
            p = p-&gt;pNext;
            flag = 1;
        }
        if (flag == 1) {
            printf("\n");
        }
 
    }
 
    p = ht-&gt;pListTail;
    while (p != NULL) {
        printf("%s &lt;==&gt; 0x%lX\n", p-&gt;arKey, p-&gt;h);
        p = p-&gt;pListLast;
    }
}
int main() {
    int i;
    char ch[20];
    HashTable ht;
    zend_hash_init(&amp;ht, 50, NULL, NULL);
    for (i = 30; i &lt; 68; i++) {
        sprintf(ch, "%d", i);
        ch[strlen(ch) + 1] = '\0';
        zend_hash_add_or_update(&amp;ht, ch, strlen(ch) + 1, NULL, 0, NULL, 0);
    }
 
    zend_hash_display(&amp;ht);
    zend_hash_destroy(&amp;ht);
    return 0;
}
?&gt;

潘锦的空间

SaaS SaaS架构团队管理技术管理技术架构 PHP 内核扩展项目管理

分类目录归档：PHP

PHP源码阅读笔记一:explode和implode函数

PHP中strtr函数一些奇怪行为的解释

PHP源码中HashTable的简单示例