phpstruct
① php中字符串怎么又可以当作数组了
一句话解释就是“PHP中下标符号可应用于数组，对象和字符串”
② php怎么查看一个变量的占用内存
我们在前面的php高效写法提到，尽量不要复制变量，特别是数组。一般来说，PHP数组的内存利用率只有 1/10, 也就是说，一个在C语言里面100M 内存的数组，在PHP里面就要1G。下面我们可以粗略的估算PHP数组占用内存的大小,首先我们测试1000个元素的整数占用的内存：
[php] view plain print?
<?php
echo memory_get_usage() , '<br>';
$start = memory_get_usage();
$a = Array();
for ($i=0; $i<1000; $i++) {
$a[$i] = $i + $i;
}
$mid = memory_get_usage();
echo memory_get_usage() , '<br>';
for ($i=1000; $i<2000; $i++) {
$a[$i] = $i + $i;
}
$end = memory_get_usage();
echo memory_get_usage() , '<br>';
echo 'argv:', ($mid - $start)/1000 ,'bytes' , '<br>';
echo 'argv:',($end - $mid)/1000 ,'bytes' , '<br>';
输出是:
353352
437848
522024
argv:84.416bytes
argv:84.176bytes
大概了解1000
个元素的整数数组需要占用 82k 内存，平均每个元素占用 84 个字节。而纯 C 中整体只需要 4k(一个整型占用4byte * 1000
)。memory_get_usage() 返回的结果并不是全是被数组占用了，还要包括一些 PHP
运行本身分配的一些结构，可能用内置函数生成的数组更接近真实的空间:
[php] view plain print?
<?php
$start = memory_get_usage();
$a = array_fill(0, 10000, 1);
$mid = memory_get_usage(); //10k elements array;
echo 'argv:', ($mid - $start )/10000,'byte' , '<br>';
$b = array_fill(0, 10000, 1);
$end = memory_get_usage(); //10k elements array;
echo 'argv:', ($end - $mid)/10000 ,'byte' , '<br>';
得到:
argv:54.5792byte
argv:54.5784byte
从这个结果来看似乎一个数组元素大约占用了54个字节左右。
首先看一下32位机C语言各种类型占用的字节：
[cpp] view plain print?
#include "stdafx.h"
//#include <stdio.h>
int main() {
printf("int:%d\nlong:%d\ndouble:%d\nchar*:%d\nsize_t:%d\n",
sizeof(int), sizeof(long),
sizeof(double), sizeof(char *),
sizeof(size_t));
return 0;
}
int:4
long:4
double:8
har*:4
size_t:4
在PHP中都使用long类型来代表数字，没有使用int类型
大家都明白PHP是一种弱类型的语言，它不会去区分变量的类型，没有int float char *之类的概念。
我们看看php在zend里面存储的变量，PHP中每个变量都有对应的 zval， Zval结构体定义在Zend/zend.h里面，其结构:
[cpp] view plain print?
typedef struct _zval_struct zval;
struct _zval_struct {
/* Variable information */
zvalue_value value; /* The value 1 12字节(32位机是12，64位机需要8+4+4=16) */
zend_uint refcount__gc; /* The number of references to this value (for GC) 4字节 */
zend_uchar type; /* The active type 1字节*/
zend_uchar is_ref__gc; /* Whether this value is a reference (&) 1字节*/
};
PHP使用一种UNION结构来存储变量的值,即zvalue_value 是一个union，UNION变量所占用的内存是由最大
成员数据空间决定。
[cpp] view plain print?
typedef union _zvalue_value {
long lval; /* long value */
double dval; /* double value */
struct { /* string value */
char *val;
int len;
} str;
HashTable *ht; /* hash table value */
zend_object_value obj; /*object value */
} zvalue_value;
最大成员数据空间是struct str，指针占*val用4字节，INT占用4字节，共8字节。
struct zval占用的空间为8+4+1+1 = 14字节，
其实呢，在zval中数组，字符串和对象还需要另外的存储结构，数组则是一个 HashTable:
HashTable结构体定义在Zend/zend_hash.h.
[cpp] view plain print?
typedef struct _hashtable {
uint nTableSize;//4
uint nTableMask;//4
uint nNumOfElements;//4
ulong nNextFreeElement;//4
Bucket *pInternalPointer; /* Used for element traversal 4*/
Bucket *pListHead;//4
Bucket *pListTail;//4
Bucket **arBuckets;//4
dtor_func_t pDestructor;//4
zend_bool persistent;//1
unsigned char nApplyCount;//1
zend_bool bApplyProtection;//1
#if ZEND_DEBUG
int inconsistent;//4
#endif
} HashTable;
HashTable 结构需要 39 个字节，每个数组元素存储在 Bucket 结构中:
[cpp] view plain print?
typedef struct bucket {
ulong h; /* Used for numeric indexing 4字节 */
uint nKeyLength; /* The length of the key (for string keys) 4字节 */
void *pData; /* 4字节*/
void *pDataPtr; /* 4字节*/
struct bucket *pListNext; /* PHP arrays are ordered. This gives the next element in that order4字节*/
struct bucket *pListLast; /* and this gives the previous element 4字节 */
struct bucket *pNext; /* The next element in this (doubly) linked list 4字节*/
struct bucket *pLast; /* The previous element in this (doubly) linked list 4字节*/
char arKey[1]; /* Must be last element 1字节*/
} Bucket;
Bucket
结构需要 33 个字节，键长超过四个字节的部分附加在 Bucket 后面，而元素值很可能是一个 zval 结构，另外每个数组会分配一个由
arBuckets 指向的 Bucket 指针数组， 虽然不能说每增加一个元素就需要一个指针，但是实际情况可能更糟。这么算来一个数组元素就会占用
54 个字节，与上面的估算几乎一样。
一个空数组至少会占用 14(zval) + 39(HashTable) + 33(arBuckets) = 86
个字节，作为一个变量应该在符号表中有个位置，也是一个数组元素，因此一个空数组变量需要 118
个字节来描述和存储。从空间的角度来看，小型数组平均代价较大，当然一个脚本中不会充斥数量很大的小型数组，可以以较小的空间代价来获取编程上的快捷。但如果将数组当作容器来使用就是另一番景象了，实际应用经常会遇到多维数组，而且元素居多。比如10k个元素的一维数组大概消耗540k内存，而10k
x 10 的二维数组理论上只需要 6M 左右的空间，但是按照 memory_get_usage
的结果则两倍于此，[10k,5,2]的三维数组居然消耗了23M，小型数组果然是划不来的。
③ php有结构体吗
没有，因为php是弱类型语言，如果只是为了返回不同类型的数据用数组就可以了，php的数组是非常强大的，因为是弱类型，所以可以使用任意类型的变量
④ php tp5中父类已经引入系统类，子类还需要引入吗
1.继承：C++支持多继承，C#类只能继承一个基类中的实现但可以实现多个接口。 2.数组：声明 C# 数组和声明 C++ 数组的语法不同。在 C# 中，“[]”标记出现在数组类型的后面。 3.数据类型：在C++中bool类可以与整型转换，但C#中bool 类型和其他类型（特别是 int）之间没有转换。long 类型：在 C# 中，long 数据类型为 64 位，而在 C++ 中为 32 位。 4.struct 类型：在 C# 中，类和结构在语义上不同。struct 是值类型，而 class 是引用类型。 5.switch 语句：与 C++ 中的 switch 语句不同，C# 不支持从一个 case 标签贯穿到另一个 case 标签。 6.delegate 类型：委托与 C++ 中的函数指针基本相似，但前者具有类型安全，是安全的。 7.从派生类调用重写基类成员。 base 8.使用 new 修饰符显式隐藏继承成员。 9.重写方法需要父类方法中用virtual声名，子类方法用override 关键字。 10.预处理器指令用于条件编译。C# 中不使用头文件。 C# 预处理器指令 11.异常处理：C#中引入了 finally 语句，这是C++没有的。 12.C# 运算符：C# 支持其他运算符，如 is 和 typeof。它还引入了某些逻辑运算符的不同功能。 13. static 的使用，static方法只能由类名调用，改变static变量。 14.在构造基类上替代 C++ 初始化列表的方法。 15.Main 方法和 C++ 及Java中的 main 函数的声明方式不同，Main而不能用main 16.方法参数：C# 支持 ref 和 out 参数，这两个参数取代指针通过引用传递参数。 17.在 C# 中只能在unsafe不安全模式下才使用指针。 18.在 C# 中以不同的方式执行重载运算符。 19.字符串：C# 字符串不同于 C++ 字符串。 20.foreach:C#从VB中引入了foreach关键字使得以循环访问数组和集合。 21.C# 中没有全局方法和全局变量：方法和变量必须包含在类型声明（如 class 或 struct）中。
⑤ 如何获得一个php变量储存在内存中占用的空间大小
我们在前面的php高效写法提到，尽量不要复制变量，特别是数组。一般来说，PHP数组的内存利用率只有 1/10, 也就是说，一个在C语言里面100M 内存的数组，在PHP里面就要1G。下面我们可以粗略的估算PHP数组占用内存的大小,首先我们测试1000个元素的整数占用的内存：
[php] view plain print?
<?php
echo memory_get_usage() , '<br>';
$start = memory_get_usage();
$a = Array();
for ($i=0; $i<1000; $i++) {
$a[$i] = $i + $i;
}
$mid = memory_get_usage();
echo memory_get_usage() , '<br>';
for ($i=1000; $i<2000; $i++) {
$a[$i] = $i + $i;
}
$end = memory_get_usage();
echo memory_get_usage() , '<br>';
echo 'argv:', ($mid - $start)/1000 ,'bytes' , '<br>';echo 'argv:',($end - $mid)/1000 ,'bytes' , '<br>';输出是:
353352
437848
522024
argv:84.416bytes
argv:84.176bytes
大概了解1000
个元素的整数数组需要占用 82k 内存，平均每个元素占用 84 个字节。而纯 C 中整体只需要 4k(一个整型占用4byte * 1000)。memory_get_usage() 返回的结果并不是全是被数组占用了，还要包括一些 PHP运行本身分配的一些结构，可能用内置函数生成的数组更接近真实的空间:
[php] view plain print?
<?php
$start = memory_get_usage();
$a = array_fill(0, 10000, 1);
$mid = memory_get_usage(); //10k elements array;echo 'argv:', ($mid - $start )/10000,'byte' , '<br>';$b = array_fill(0, 10000, 1);
$end = memory_get_usage(); //10k elements array;echo 'argv:', ($end - $mid)/10000 ,'byte' , '<br>';得到:
argv:54.5792byte
argv:54.5784byte
从这个结果来看似乎一个数组元素大约占用了54个字节左右。
首先看一下32位机C语言各种类型占用的字节：
[cpp] view plain print?
#include "stdafx.h"
//#include <stdio.h>
int main() {
printf("int:%d\nlong:%d\ndouble:%d\nchar*:%d\nsize_t:%d\n",sizeof(int), sizeof(long),
sizeof(double), sizeof(char *),
sizeof(size_t));
return 0;
}
int:4
long:4
double:8
har*:4
size_t:4
在PHP中都使用long类型来代表数字，没有使用int类型大家都明白PHP是一种弱类型的语言，它不会去区分变量的类型，没有int float char *之类的概念。
我们看看php在zend里面存储的变量，PHP中每个变量都有对应的 zval， Zval结构体定义在Zend/zend.h里面，其结构:
[cpp] view plain print?
typedef struct _zval_struct zval;
struct _zval_struct {
/* Variable information */
zvalue_value value; /* The value 1 12字节(32位机是12，64位机需要8+4+4=16) */zend_uint refcount__gc; /* The number of references to this value (for GC) 4字节 */zend_uchar type; /* The active type 1字节*/zend_uchar is_ref__gc; /* Whether this value is a reference (&) 1字节*/};
PHP使用一种UNION结构来存储变量的值,即zvalue_value 是一个union，UNION变量所占用的内存是由最大成员数据空间决定。
[cpp] view plain print?
typedef union _zvalue_value {
long lval; /* long value */double dval; /* double value */struct { /* string value */char *val;
int len;
} str;
HashTable *ht; /* hash table value */zend_object_value obj; /*object value */} zvalue_value;
最大成员数据空间是struct str，指针占*val用4字节，INT占用4字节，共8字节。
struct zval占用的空间为8+4+1+1 = 14字节，其实呢，在zval中数组，字符串和对象还需要另外的存储结构，数组则是一个 HashTable:
HashTable结构体定义在Zend/zend_hash.h.
[cpp] view plain print?
typedef struct _hashtable {
uint nTableSize;//4
uint nTableMask;//4
uint nNumOfElements;//4
ulong nNextFreeElement;//4
Bucket *pInternalPointer; /* Used for element traversal 4*/Bucket *pListHead;//4
Bucket *pListTail;//4
Bucket **arBuckets;//4
dtor_func_t pDestructor;//4
zend_bool persistent;//1
unsigned char nApplyCount;//1
zend_bool bApplyProtection;//1
#if ZEND_DEBUG
int inconsistent;//4
#endif
} HashTable;
HashTable 结构需要 39 个字节，每个数组元素存储在 Bucket 结构中:
[cpp] view plain print?
typedef struct bucket {
ulong h; /* Used for numeric indexing 4字节 */uint nKeyLength; /* The length of the key (for string keys) 4字节 */void *pData; /* 4字节*/
void *pDataPtr; /* 4字节*/
struct bucket *pListNext; /* PHP arrays are ordered. This gives the next element in that order4字节*/struct bucket *pListLast; /* and this gives the previous element 4字节 */struct bucket *pNext; /* The next element in this (doubly) linked list 4字节*/struct bucket *pLast; /* The previous element in this (doubly) linked list 4字节*/char arKey[1]; /* Must be last element 1字节*/} Bucket;
Bucket
结构需要 33 个字节，键长超过四个字节的部分附加在 Bucket 后面，而元素值很可能是一个 zval 结构，另外每个数组会分配一个由arBuckets 指向的 Bucket 指针数组， 虽然不能说每增加一个元素就需要一个指针，但是实际情况可能更糟。这么算来一个数组元素就会占用54 个字节，与上面的估算几乎一样。
一个空数组至少会占用 14(zval) + 39(HashTable) + 33(arBuckets) = 86个字节，作为一个变量应该在符号表中有个位置，也是一个数组元素，因此一个空数组变量需要 118个字节来描述和存储。从空间的角度来看，小型数组平均代价较大，当然一个脚本中不会充斥数量很大的小型数组，可以以较小的空间代价来获取编程上的快捷。但如果将数组当作容器来使用就是另一番景象了，实际应用经常会遇到多维数组，而且元素居多。比如10k个元素的一维数组大概消耗540k内存，而10kx 10 的二维数组理论上只需要 6M 左右的空间，但是按照 memory_get_usage的结果则两倍于此，[10k,5,2]的三维数组居然消耗了23M，小型数组果然是划不来的。
⑥ 乔大姐，知道如何用PHP生成结构体吗
执行phpize生成编译文件，phpize在PHP安装目录的bin目录下
/usr/local/php5/bin/phpize
运行时，可能会报错：Cannot find autoconf. Please check your autoconf installation and
the $PHP_AUTOCONF
environment variable is set correctly and then rerun this
script.，需要安装autoconf：
yum install autoconf（RedHat或者CentOS）、apt-get install
autoconf（Ubuntu Linux）
/usr/local/php5/bin/php -v
执行这个命令时，php会去检查配置文件是否正确，如果有配置错误，这里会报错，可以根据错误信息去排查！
⑦ PHP的count(数组)和strlen(字符串)的内部实现。
翻了下PHP内核的定义，大概心中也有了答案了
count()和strlen()都是O(1)的时间复杂度
试想一下如果strlen()需要O(N)的复杂度那未免也太慢了，字符串长度起来的话服务器不是要直接挂掉吗
这两个函数都是典型的空间换时间的做法
我们可以先看看zvalue的结构：
typedefunion_zvalue_value{
longlval;/*longvalue*/
doubledval;/*doublevalue*/
struct{
char*val;
intlen;
}str;
HashTable*ht;/*hashtablevalue*/
zend_object_valueobj;
zend_ast*ast;
}zvalue_value;这里用的是一个联合体，当变量类型是string类型的时候附加存储多了一个len的整型变量，显而易见需要取长度直接利用记录值就可以了，自然就是O(1)
对于count()常用的参数类型应该为数组，对于继承Countable的类暂不作讨论
数组实现方式为Hashtable，直接看看他的结构吧
typedefstruct_hashtable{
uintnTableSize;//hashBucket的大小，最小为8，以2x增长。
uintnTableMask;//nTableSize-1，索引取值的优化
uintnNumOfElements;//hashBucket中当前存在的元素个数，count()函数会直接返回此值
ulongnNextFreeElement;//下一个数字索引的位置
Bucket*pInternalPointer;//当前遍历的指针（foreach比for快的原因之一）
Bucket*pListHead;//存储数组头元素指针
Bucket*pListTail;//存储数组尾元素指针
Bucket**arBuckets;//存储hash数组
dtor_func_tpDestructor;//在删除元素时执行的回调函数，用于资源的释放
zend_boolpersistent;//指出了Bucket内存分配的方式。如果persisient为TRUE，则使用操作系统本身的内存分配函数为Bucket分配内存，否则使用PHP的内存分配函数。
unsignedcharnApplyCount;//标记当前hashBucket被递归访问的次数（防止多次递归）
zend_boolbApplyProtection;//标记当前hash桶允许不允许多次访问，不允许时，最多只能递归3次
#ifZEND_DEBUG
intinconsistent;
#endif
}HashTable;count直接获取nNumOfElements大小，所以也是O(1)
补充------------------------------------------------
count() 函数的定义在这里
/*{{{protointcount(mixedvar[,intmode])
(usuallyanarray)*/
PHP_FUNCTION(count)
{
zval*array;
zend_longmode=COUNT_NORMAL;
zend_longcnt;
zval*element;
ZEND_PARSE_PARAMETERS_START(1,2)
Z_PARAM_ZVAL(array)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(mode)
ZEND_PARSE_PARAMETERS_END();
switch(Z_TYPE_P(array)){
caseIS_NULL:
php_error_docref(NULL,E_WARNING,"");
RETURN_LONG(0);
break;
caseIS_ARRAY:
if(mode!=COUNT_RECURSIVE){
//类型为数组时调用zend内核函数zend_array_count()
cnt=zend_array_count(Z_ARRVAL_P(array));
}else{
cnt=php_count_recursive(Z_ARRVAL_P(array));
}
RETURN_LONG(cnt);
break;
caseIS_OBJECT:{
zvalretval;
/*first,wecheckifthehandlerisdefined*/
if(Z_OBJ_HT_P(array)->count_elements){
RETVAL_LONG(1);
if(SUCCESS==Z_OBJ_HT(*array)->count_elements(array,&Z_LVAL_P(return_value))){
return;
}
}
/*()method*/
if(instanceof_function(Z_OBJCE_P(array),zend_ce_countable)){
zend_call_method_with_0_params(array,NULL,NULL,"count",&retval);
if(Z_TYPE(retval)!=IS_UNDEF){
RETVAL_LONG(zval_get_long(&retval));
zval_ptr_dtor(&retval);
}
return;
}
/*IfThere'snohandleranditdoesn'*/
php_error_docref(NULL,E_WARNING,"");
RETURN_LONG(1);
break;
}
default:
php_error_docref(NULL,E_WARNING,"");
RETURN_LONG(1);
break;
}
}如果没有特别指定mode参数为 COUNT_RECURSIVE 的话（即作遍历），跳转到 zend 的数组计数函数 zend_array_count()
#definezend_hash_num_elements(ht)
(ht)->nNumOfElements
...
...
staticuint32_tzend_array_recalc_elements(HashTable*ht)
{
zval*val;
uint32_tnum=ht->nNumOfElements;
ZEND_HASH_FOREACH_VAL(ht,val){
if(Z_TYPE_P(val)==IS_INDIRECT){
if(UNEXPECTED(Z_TYPE_P(Z_INDIRECT_P(val))==IS_UNDEF)){
num--;
}
}
}ZEND_HASH_FOREACH_END();
returnnum;
}
ZEND_APIuint32_tzend_array_count(HashTable*ht)
{
uint32_tnum;
if(UNEXPECTED(ht->u.v.flags&HASH_FLAG_HAS_EMPTY_IND)){
num=zend_array_recalc_elements(ht);
if(UNEXPECTED(ht->nNumOfElements==num)){
ht->u.v.flags&=~HASH_FLAG_HAS_EMPTY_IND;
}
}elseif(UNEXPECTED(ht==&EG(symbol_table))){
num=zend_array_recalc_elements(ht);
}else{
num=zend_hash_num_elements(ht);
}
returnnum;
}
IS_REFERENCE：间接 zval 指的就是其真正的值是存储在其他地方的。注意这个IS_REFERENCE类型是不同的，间接 zval 是直接指向另外一个 zval 而不是像zend_reference结构体一样嵌入 zval。
只有当数组中有HASH_FLAG_HAS_EMPTY_IND 这个 flag 时（间接zval）才会对数组进行遍历校验，其他情况下都是直接取 数组（hash table） 里面的 nNumOfElements 的值，答案显而易见了，就是O(1)
⑧ 深入PHP中的HashTable结构详解
深入PHP中的HashTable结构详解
深入PHP中的HashTable结构详解
对php内核有一定了解的人应该都知道php的精髓就是HashTable，HashTable在php的实现中无处不在。包括php的数组、什么全局变量、局部变量的作用域等等，php的hashtable拆开来说就是四部分：
hash函数：用的是time33的散列函数，将一个字符串的key转换成一个数字
一个C数组：用来储存桶(buckets)的
两个双向的链表：第一个双向链表是数组的每个元素（桶bucket）是一个双向链表，这样做是为了解决hash冲突；第二个双向链表是数组将每一个桶(bucket)连接起来，这里要连接的也就是第一个双向链表的链表头，这样做是为了遍历整个hash表用的,鸟哥有篇blog是讲php的foreach的，这里这样设计就是给foreach用的==>《深入理解PHP之数组(遍历顺序)》
我这里不再说hashtable的struct和bucket的`struct了，因为下面的推荐链接几乎都讲了，我不觉得我能描述和说的比他们好，每个人的水平不一样，我就以我现在的技术水平来描述，所以我就只把我整理的一些东西记录一下
下面是php中hash实现的两个文件：zend_hash.c zend_hash.h。这两个文件里面实现了一堆的api，也引申出了一堆的api，下面是实现出来的api的原型
复制代码 代码如下:
ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
ZEND_API ulong zend_get_hash_value(const char *arKey, uint nKeyLength)
ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, hash_func_t pHashFunction, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProtection)
ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
ZEND_API int _zend_hash_index_update_or_next_(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
ZEND_API int zend_hash_rehash(HashTable *ht)
static int zend_hash_do_resize(HashTable *ht)
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag)
ZEND_API void zend_hash_destroy(HashTable *ht)
ZEND_API void zend_hash_clean(HashTable *ht)
static Bucket *zend_hash_apply_r(HashTable *ht, Bucket *p)
ZEND_API void zend_hash_graceful_destroy(HashTable *ht)
ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht)
ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *argument TSRMLS_DC)
ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func_args_t apply_func, int num_args, …)
ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
ZEND_API void zend_hash_(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, void *tmp, uint size)
ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC)
static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, void *source_data, Bucket *p, void *pParam, merge_checker_func_t merge_checker_func)
ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, _ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData)
ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength)
ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h)
ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)
ZEND_API int zend_hash_num_elements(const HashTable *ht)
ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr)
ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr)
ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos)
ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool plicate, HashPosition *pos)
ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)
ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos)
ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos)
ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compar, int renumber TSRMLS_DC)
ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC)
ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC)
ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)
void zend_hash_display_pListTail(const HashTable *ht)
void zend_hash_display(const HashTable *ht)
;