PHP7和PHP5的对象有哪些区别呢？

发布时间：2023-01-31 11:00 所属栏目：121 来源：互联网

导读：关于PHP7和PHP5的对象有哪些差异呢？的知识有一些人不是很理解，对此小编给大家总结了相关内容，具有一定的参考借鉴价值，而且易于学习与理解，希望能对大家有所帮助，有这个方面学习需要的朋友就继续往下看吧。一、 class 介绍 PHP 中的 class、interface

　　关于“PHP7和PHP5的对象有哪些差异呢？”的知识有一些人不是很理解，对此小编给大家总结了相关内容，具有一定的参考借鉴价值，而且易于学习与理解，希望能对大家有所帮助，有这个方面学习需要的朋友就继续往下看吧。

　　一、 class 介绍

　　 PHP 中的 class、interface、trait 在底层均以 zend_class_entry 结构体实现

　　struct _zend_class_entry {
　　 char type;
　　 const char *name;
　　 zend_uint name_length;
　　 struct _zend_class_entry *parent;
　　 int refcount;
　　 zend_uint ce_flags;

　　 HashTable function_table;
　　 HashTable properties_info;
　　 zval **default_properties_table;
　　 zval **default_static_members_table;
　　 zval **static_members_table;
　　 HashTable constants_table;
　　 int default_properties_count;
　　 int default_static_members_count;

　　 union _zend_function *constructor;
　　 union _zend_function *destructor;
　　 union _zend_function *clone;
　　 union _zend_function *__get;
　　 union _zend_function *__set;
　　 union _zend_function *__unset;
　　 union _zend_function *__isset;
　　 union _zend_function *__call;
　　 union _zend_function *__callstatic;
　　 union _zend_function *__tostring;
　　 union _zend_function *serialize_func;
　　 union _zend_function *unserialize_func;

　　 zend_class_iterator_funcs iterator_funcs;

　　 /* handlers */
　　 zend_object_value (*create_object)(zend_class_entry *class_type TSRMLS_DC);
　　 zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
　　 int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type TSRMLS_DC); /* a class implements this interface */
　　 union _zend_function *(*get_static_method)(zend_class_entry *ce, char* method, int method_len TSRMLS_DC);

　　 /* serializer callbacks */
　　 int (*serialize)(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
　　 int (*unserialize)(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);

　　 zend_class_entry **interfaces;
　　 zend_uint num_interfaces;
　　
　　 zend_class_entry **traits;
　　 zend_uint num_traits;
　　 zend_trait_alias **trait_aliases;
　　 zend_trait_precedence **trait_precedences;

　　 union {
　　 struct {
　　 const char *filename;
　　 zend_uint line_start;
　　 zend_uint line_end;
　　 const char *doc_comment;
　　 zend_uint doc_comment_len;
　　 } user;
　　 struct {
　　 const struct _zend_function_entry *builtin_functions;
　　 struct _zend_module_entry *module;
　　 } internal;
　　 } info;
　　};
　　 zend_class_entry 结构体中包含大量的指针以及 hashtable，这就导致结构体本身会占用不小的内存空间。另外，结构体中的指针还需要单独分配相应的内存空间，这又会消耗一部分内存空间。

　　⒈ 开发者自定义的 class 与 PHP 内部定义的 class 的比较

　　所谓开发者自定义的 class 即使用 PHP 语言定义的 class，而 PHP 内部定义的 class 是指 PHP 源代码中定义的 class 或 PHP 扩展中定义的 class。二者最本质的区别在于生命周期不同：

　　以 php-fpm 为例，当请求到来时，PHP 会解析开发者定义的 class 并为其分配相应的内存空间。其后在处理请求的过程中，PHP 会对这些 class 进行相应的调用，最后在处理完请求之后销毁这些 class，释放之前为其分配的内存空间。

　　为了节约内存空间，不要在代码中定义一些实际并不使用的 class。可以使用 autoload 来屏蔽这些实际并不使用的 class，因为 autoload 只有在一个 class 被用到时才加载和解析，但这样就会把 class 的解析和加载过程由代码的编译阶段延后到代码的执行阶段，影响性能

　　另外需要注意的是，即使开启了 OPCache 扩展，开发者自定义的 class 还是会随着请求的到来而解析和加载，随着请求的完成而销毁，OPCache 只是提高了这两个阶段的速度

　　PHP 内部定义的 class 则不同。仍然以 php-fpm 为例，当一个 php-fpm 进程启动时，PHP 会为这些 class 一次性永久分配内存空间，直到此 php-fpm 进程消亡（为避免内存泄漏，php-fpm 会在处理完一定数量的请求之后销毁然后重启）
　　if (EG(full_tables_cleanup)) {
　　 zend_hash_reverse_apply(EG(function_table), (apply_func_t) clean_non_persistent_function_full TSRMLS_CC);
　　 zend_hash_reverse_apply(EG(class_table), (apply_func_t) clean_non_persistent_class_full TSRMLS_CC);
　　} else {
　　 zend_hash_reverse_apply(EG(function_table), (apply_func_t) clean_non_persistent_function TSRMLS_CC);
　　 zend_hash_reverse_apply(EG(class_table), (apply_func_t) clean_non_persistent_class TSRMLS_CC);
　　}

　　static int clean_non_persistent_class(zend_class_entry **ce TSRMLS_DC)
　　{
　　 return ((*ce)->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
　　}
　　由以上代码可以看出，在请求结束时，PHP 内部定义的 class 并不会被销毁。另外，由于 PHP 扩展中定义的 class 也属于 PHP 内部定义的 class 的范畴，所以，从节省内存空间的角度出发，不要开启一些自己并不使用的扩展。因为，如果扩展一旦开启，扩展中定义的 class 就会在 php-fpm 进程启动时被解析和加载。

　　很多时候，为了处理方便，我们会通过继承 \Exception 来自定义 exception。但由于 zend_class_entry 结构体非常庞大，这就导致在提高便利的同时耗费了大量的内存

　　⒉ class 绑定
　　 class 绑定指的是 class 数据的准备过程

　　对于 PHP 内部定义的 class，绑定过程在 class 注册时就已经完成。此过程发生在 PHP 脚本运行之前，并且在整个 php-fpm 进程的生命周期中只发生一次。

　　对于既没有继承 parent class，也没有实现 interface，也没有使用 trait 的 class，绑定过程发生在 PHP 代码的编辑阶段，并且不会消耗太多资源。此种 class 的绑定通常只需要将 class 注册到 class_table 中，并检查 class 是否包含了抽象方法但没有被申明为 abstract 类型。

　　void zend_do_early_binding(TSRMLS_D) /* {{{ */
　　{
　　 zend_op *opline = &CG(active_op_array)->opcodes[CG(active_op_array)->last-1];
　　 HashTable *table;

　　 while (opline->opcode == ZEND_TICKS && opline > CG(active_op_array)->opcodes) {
　　 opline--;
　　 }

　　 switch (opline->opcode) {
　　 case ZEND_DECLARE_FUNCTION:
　　 if (do_bind_function(CG(active_op_array), opline, CG(function_table), 1) == FAILURE) {
　　 return;
　　 }
　　 table = CG(function_table);
　　 break;
　　 case ZEND_DECLARE_CLASS:
　　 if (do_bind_class(CG(active_op_array), opline, CG(class_table), 1 TSRMLS_CC) == NULL) {
　　 return;
　　 }
　　 table = CG(class_table);
　　 break;
　　 case ZEND_DECLARE_INHERITED_CLASS:
　　 {
　　 /*... ...*/
　　 }
　　 case ZEND_VERIFY_ABSTRACT_CLASS:
　　 case ZEND_ADD_INTERFACE:
　　 case ZEND_ADD_TRAIT:
　　 case ZEND_BIND_TRAITS:
　　 /* We currently don't early-bind classes that implement interfaces */
　　 /* Classes with traits are handled exactly the same, no early-bind here */
　　 return;
　　 default:
　　 zend_error(E_COMPILE_ERROR, "Invalid binding type");
　　 return;
　　 }

　　/*... ...*/
　　}

　　void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC)
　　{
　　 zend_abstract_info ai;

　　 if ((ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) && !(ce->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
　　 memset(&ai, 0, sizeof(ai));

　　 zend_hash_apply_with_argument(&ce->function_table, (apply_func_arg_t) zend_verify_abstract_class_function, &ai TSRMLS_CC);

　　 if (ai.cnt) {
　　 zend_error(E_ERROR, "Class %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
　　 ce->name, ai.cnt,
　　 ai.cnt > 1 ? "s" : "",
　　 DISPLAY_ABSTRACT_FN(0),
　　 DISPLAY_ABSTRACT_FN(1),
　　 DISPLAY_ABSTRACT_FN(2)
　　 );
　　 }
　　 }
　　}
　　对于实现了 interface 的 class 的绑定过程非常复杂，大致流程如下：

　　检查 interface 是否已经实现
　　检查实现该 interface 的确实是一个 class，而不是 interface 自身（class、interface、trait 的底层数据结构都是 zend_class_entry）
　　复制常量，并检查可能存在的冲突
　　复制方法，并检查可能存在的冲突，除此之外还需要检查访问控制
　　将 interface 加入到 zend_class_entry 的 **interfaces 中
　　需要注意的是，所谓的复制只是将常量、属性、方法的引用计数加 1

　　ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC)
　　{
　　 /* ... ... */
　　
　　 } else {
　　 if (ce->num_interfaces >= current_iface_num) { /* resize the vector if needed */
　　 if (ce->type == ZEND_INTERNAL_CLASS) {
　　 /*对于内部定义的 class，使用 realloc 分配内存，所分配的内存在进程的生命周期中永久有效*/
　　 ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
　　 } else {
　　 /*对于开发者定义的 class，使用 erealloc 分配内存，所分配的内存只在请求的生命周期中有效*/
　　 ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
　　 }
　　 }
　　 ce->interfaces[ce->num_interfaces++] = iface; /* Add the interface to the class */

　　 /* Copy every constants from the interface constants table to the current class constants table */
　　 zend_hash_merge_ex(&ce->constants_table, &iface->constants_table, (copy_ctor_func_t) zval_add_ref, sizeof(zval *), (merge_checker_func_t) do_inherit_constant_check, iface);
　　 /* Copy every methods from the interface methods table to the current class methods table */
　　 zend_hash_merge_ex(&ce->function_table, &iface->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);

　　 do_implement_interface(ce, iface TSRMLS_CC);
　　 zend_do_inherit_interfaces(ce, iface TSRMLS_CC);
　　 }
　　}
　　对于常量的复制，zval_add_ref 用于将常量的引用计数加1；而对于方法的复制，do_inherit_method 除了将相应方法的引用计数加 1 之外，还将方法中定义的静态变量的引用计数加 1。

　　static void do_inherit_method(zend_function *function)
　　{
　　 function_add_ref(function);
　　}

　　ZEND_API void function_add_ref(zend_function *function)
　　{
　　 if (function->type == ZEND_USER_FUNCTION) {
　　 zend_op_array *op_array = &function->op_array;

　　 (*op_array->refcount)++;
　　 if (op_array->static_variables) {
　　 HashTable *static_variables = op_array->static_variables;
　　 zval *tmp_zval;

　　 ALLOC_HASHTABLE(op_array->static_variables);
　　 zend_hash_init(op_array->static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
　　 zend_hash_copy(op_array->static_variables, static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *));
　　 }
　　 op_array->run_time_cache = NULL;
　　 }
　　}
　　对于实现了 interface 的 class 的绑定，由于要进行多次的循环遍历以及检查，通常非常消耗 CPU 资源，但却节省了内存空间。

　　现阶段，PHP 将 interface 的绑定推迟到了代码执行阶段进行，以为这每次请求都会进行这些操作

　　对于 class 继承的绑定，过程与 interface 的绑定类似，但更为复杂。另外有一个值得注意的地方，如果 class 在绑定时已经解析到了父类，则绑定发生在代码编译阶段；否则发生在代码执行阶段。

　　// A 在 B 之前申明，B 的绑定发生在编译阶段
　　class A { }
　　class B extends A { }

　　// A 在 B 之后申明，绑定 B 时编译器无法知道 A 情况，此时 B 的绑定只能延后到代码执行时
　　class B extends A { }
　　class A { }

　　// 这种情况会报错：Class B doesn't exist
　　// 在代码执行阶段绑定 C，需要解析 B，但此时 B 有继承了 A，而 A 此时还是未知状态
　　class C extends B { }
　　class B extends A { }
　　class A { }
　　如果使用 autoload，并且采用一个 class 对应一个文件的模式，则所有 class 的绑定都只会发生在代码执行阶段

　　二、PHP 5 中的 object

　　⒈ object 中的方法
　
　方法与函数的底层数据结构均为 zend_function。PHP 编译器在编译时将方法编译并添加到 zend_class_entry 的 function_table 属性中。所以，在 PHP 代码运行时，方法已经编译完成，PHP 要做的只是通过指针找到方法并执行。

　　typedef union _zend_function {
　　 zend_uchar type;

　　 struct {
　　 zend_uchar type;
　　 const char *function_name;
　　 zend_class_entry *scope;
　　 zend_uint fn_flags;
　　 union _zend_function *prototype;
　　 zend_uint num_args;
　　 zend_uint required_num_args;
　　 zend_arg_info *arg_info;
　　 } common;

　　 zend_op_array op_array;
　　 zend_internal_function internal_function;
　　} zend_function;
　　当 object 尝试调用方法时，首先会在其对应的 class 的 function_table 中查找该方法，同时还会检查方法的访问控制。如果方法不存在或方法的访问控制不符合要求，object 会尝试调用莫属方法 __call。

　　static inline union _zend_function *zend_get_user_call_function(zend_class_entry *ce, const char *method_name, int method_len)
　　{
　　 zend_internal_function *call_user_call = emalloc(sizeof(zend_internal_function));
　　 call_user_call->type = ZEND_INTERNAL_FUNCTION;
　　 call_user_call->module = (ce->type == ZEND_INTERNAL_CLASS) ? ce->info.internal.module : NULL;
　　 call_user_call->handler = zend_std_call_user_call;
　　 call_user_call->arg_info = NULL;
　　 call_user_call->num_args = 0;
　　 call_user_call->scope = ce;
　　 call_user_call->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
　　 call_user_call->function_name = estrndup(method_name, method_len);

　　 return (union _zend_function *)call_user_call;
　　}

　　static union _zend_function *zend_std_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
　　{
　　 zend_function *fbc;
　　 zval *object = *object_ptr;
　　 zend_object *zobj = Z_OBJ_P(object);
　　 ulong hash_value;
　　 char *lc_method_name;
　　 ALLOCA_FLAG(use_heap)

　　 if (EXPECTED(key != NULL)) {
　　 lc_method_name = Z_STRVAL(key->constant);
　　 hash_value = key->hash_value;
　　 } else {
　　 lc_method_name = do_alloca(method_len+1, use_heap);
　　 /* Create a zend_copy_str_tolower(dest, src, src_length); */
　　 zend_str_tolower_copy(lc_method_name, method_name, method_len);
　　 hash_value = zend_hash_func(lc_method_name, method_len+1);
　　 }

　　 if (UNEXPECTED(zend_hash_quick_find(&zobj->ce->function_table, lc_method_name, method_len+1, hash_value, (void **)&fbc) == FAILURE)) {
　　 if (UNEXPECTED(!key)) {
　　 free_alloca(lc_method_name, use_heap);
　　 }
　　 if (zobj->ce->__call) {
　　 return zend_get_user_call_function(zobj->ce, method_name, method_len);
　　 } else {
　　 return NULL;
　　 }
　　 }

　　 /* Check access level */
　　 if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
　　 zend_function *updated_fbc;

　　 /* Ensure that if we're calling a private function, we're allowed to do so.
　　 * If we're not and __call() handler exists, invoke it, otherwise error out.
　　 */
　　 updated_fbc = zend_check_private_int(fbc, Z_OBJ_HANDLER_P(object, get_class_entry)(object TSRMLS_CC), lc_method_name, method_len, hash_value TSRMLS_CC);
　　 if (EXPECTED(updated_fbc != NULL)) {
　　 fbc = updated_fbc;
　　 } else {
　　 if (zobj->ce->__call) {
　　 fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
　　 } else {
　　 zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
　　 }
　　 }
　　 } else {
　　 /* Ensure that we haven't overridden a private function and end up calling
　　 * the overriding public function...
　　 */
　　 if (EG(scope) &&
　　     is_derived_class(fbc->common.scope, EG(scope)) &&
　　     fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
　　 zend_function *priv_fbc;

　　 if (zend_hash_quick_find(&EG(scope)->function_table, lc_method_name, method_len+1, hash_value, (void **) &priv_fbc)==SUCCESS
　　 && priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
　　 && priv_fbc->common.scope == EG(scope)) {
　　 fbc = priv_fbc;
　　 }
　　 }
　　 if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
　　 /* Ensure that if we're calling a protected function, we're allowed to do so.
　　 * If we're not and __call() handler exists, invoke it, otherwise error out.
　　 */
　　 if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) {
　　 if (zobj->ce->__call) {
　　 fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
　　 } else {
　　 zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
　　 }
　　 }
　　 }
　　 }

　　 if (UNEXPECTED(!key)) {
　　 free_alloca(lc_method_name, use_heap);
　　 }
　　 return fbc;
　　}
　　这里需要指出的是：

　　由于 PHP 对大小写不敏感，所以所有的方法名称都会被转为小写（zend_str_tolower_copy()）
　　为了避免不必要的资源消耗，PHP 5.4 开始引入了 zend_literal 结构体，即参数 key
　　typedef struct _zend_literal {
　　 zval       constant;
　　 zend_ulong hash_value;
　　 zend_uint cache_slot;
　　} zend_literal;
　　其中，constant 记录了转为小写后的字符串，hash_value 则是预先计算好的 hash。这样就避免了 object 每次调用方法都要将方法名称转为小写并计算 hash 值。

　　class Foo { public function BAR() { } }
　　$a = new Foo;
　　$b = 'bar';

　　$a->bar(); /* good */
　　$a->$b(); /* bad */
　　
在上例中，在代码编译阶段，方法 BAR 被转换成 bar 并添加到 zend_class_entry 的 function_table 中。当发生方法调用时：

　　第一种情形，在代码编译阶段，方法名称 bar 确定为字符串常量，编译器可以预先计算好其对应的 zend_literal 结构，即 key 参数。这样，代码在执行时相对会更快。

　　第二种情形，由于在编译阶段编译器对 $b 一无所知，这就需要在代码执行阶段现将方法名称转为小写，然后计算 hash 值。

　　⒉ object 中的属性

　　当对一个 class 进行实例化时，object 中的属性只是对 class 中属性的引用。这样，object 的创建操作就会相对轻量化，并且会节省一部分内存空间。

　　如果要对 object 中的属性进行修改，zend 引擎会单独创建一个 zval 结构，只对当前 object 的当前属性产生影响。

　　 class 的实例化对应的会在底层创建一个 zend_obejct 数据结构，新创建的 object 会注册到 zend_objects_store 中。zend_objects_store 是一个全局的 object 注册表，同一个对象在该注册表中只能注册一次。

　　typedef struct _zend_object {
　　 zend_class_entry *ce;
　　 HashTable *properties;
　　 zval **properties_table;
　　 HashTable *guards; /* protects from __get/__set ... recursion */
　　} zend_object;

　　typedef struct _zend_objects_store {/*本质上是一个动态 object_bucket 数组*/
　　 zend_object_store_bucket *object_buckets;
　　 zend_uint top; /*下一个可用的 handle，handle 取值从 1 开始。对应的在 *object_buckets 中的 index 为 handle - 1*/
　　 zend_uint size; /*当前分配的 *object_buckets 的最大长度*/
　　 int free_list_head; /*当 *object_bucket 中的 bucket 被销毁后，该 bucket 在 *object_buckets 中的 index 会被有序加入 free_list 链表。free_list_head 即为该链表中的第一个值*/
　　} zend_objects_store;

　　typedef struct _zend_object_store_bucket {
　　 zend_bool destructor_called;
　　 zend_bool valid; /*值为 1 表示当前 bucket 被使用，此时 store_bucket 中的 store_object 被使用；值为 0 表示当前 bucket 并没有存储有效的 object，此时 store_bucket 中的 free_list 被使用*/
　　 zend_uchar apply_count;
　　 union _store_bucket {
　　 struct _store_object {
　　 void *object;
　　 zend_objects_store_dtor_t dtor;
　　 zend_objects_free_object_storage_t free_storage;
　　 zend_objects_store_clone_t clone;
　　 const zend_object_handlers *handlers;
　　 zend_uint refcount;
　　 gc_root_buffer *buffered;
　　 } obj;
　　 struct {
　　 int next; /*第一个未被使用的 bucket 的 index 永远存储在 zend_object_store 的 free_list_head 中，所以 next 只需要记录当前 bucket 之后第一个未被使用的 bucket 的 index*/
　　 } free_list;
　　 } bucket;
　　} zend_object_store_bucket;

　　ZEND_API zend_object_value zend_objects_new(zend_object **object, zend_class_entry *class_type TSRMLS_DC)
　　{
　　 zend_object_value retval;

　　 *object = emalloc(sizeof(zend_object));
　　 (*object)->ce = class_type;
　　 (*object)->properties = NULL;
　　 (*object)->properties_table = NULL;
　　 (*object)->guards = NULL;
　　 retval.handle = zend_objects_store_put(*object, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) zend_objects_free_object_storage, NULL TSRMLS_CC);
　　 retval.handlers = &std_object_handlers;
　　 return retval;
　　}
　　将 object 注册到 zend_objects_store 中以后，将会为 object 创建属性（对相应 class 属性的引用）

　　ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type)
　　{
　　 int i;

　　 if (class_type->default_properties_count) {
　　 object->properties_table = emalloc(sizeof(zval*) * class_type->default_properties_count);
　　 for (i = 0; i default_properties_count; i++) {
　　 object->properties_table[i] = class_type->default_properties_table[i];
　　 if (class_type->default_properties_table[i]) {
　　#if ZTS
　　 ALLOC_ZVAL( object->properties_table[i]);
　　 MAKE_COPY_ZVAL(&class_type->default_properties_table[i], object->properties_table[i]);
　　#else
　　 Z_ADDREF_P(object->properties_table[i]);
　　#endif
　　 }
　　 }
　　 object->properties = NULL;
　　 }
　　}
　　需要指出的是，在创建属性时，如果是非线程安全模式的 PHP，仅仅是增加相应属性的引用计数；但如果是线程安全模式的 PHP，则需要对属性进行深度复制，将 class 的属性全部复制到 object 中的 properties_table 中。

　　这也说明，线程安全的 PHP 比非线程安全的 PHP 运行慢，并且更耗费内存

　　每个属性在底层都对应一个 zend_property_info 结构：

　　typedef struct _zend_property_info {
　　    zend_uint flags;
　　    const char *name;
　　    int name_length;
　　    ulong h;
　　    int offset;
　　    const char *doc_comment;
　　    int doc_comment_len;
　　    zend_class_entry *ce;
　　} zend_property_info;

　　 class 中声明的每个属性，在 zend_class_entry 中的 properties_table 中都有一个zend_property_info 与之相对应。properties_table 可以帮助我们快速确定一个 object 所访问的属性是否存在：

　　如果属性不存在，并且我们尝试向 object 写入该属性：如果 class 定义了 __set 方法，则使用 __set 方法写入该属性；否则会向 object 添加一个动态属性。但无论以何种方式写入该属性，写入的属性都将添加到 object 的 properties_table 中。
　
　如果属性存在，则需要检查相应的访问控制；对于 protected 和 private 类型，则需要检查当前的作用域。
　
　在创建完 object 之后，只要我们不向 object 中写入新的属性或更新 object 对应的 class 中的属性的值，则 object 所占用的内存空间不会发生变化。

　　属性的存储/访问方式：

　　zend_class_entry->properties_info 中存储的是一个个的 zend_property_info。而属性的值实际以 zval 指针数组的方式存储在 zend_class_entry->default_properties_table 中。object 中动态添加的属性只会以 property_name => property_value 的形式存储在 zend_object->properties_table 中。而在创建 object 时，zend_class_entry->properties_table 中的值会被逐个传递给 zend_object->properties_table。
　　zend_literal->cache_slot 中存储的 int 值为 run_time_cache 中的索引 index。run_time_cache 为数组结构，index 对应的 value 为访问该属性的 object 对应的 zend_class_entry；index + 1 对应的 value 为该属性对应的 zend_property_info 。在访问属性时，如果 zend_literal->cache_slot 中的值不为空，则可以通过 zend_literal->cache_slot 快速检索得到 zend_property_info 结构；如果为空，则在检索到 zend_property_info 的信息之后会初始化 zend_literal->cache_slot。

　　属性名称的存储方式

　　private 属性："\0class_name\0property_name"

　　protected 属性："\0*\0property_name"

　　public 属性："property_name"

　　执行以下代码，看看输出结果

　　class A {
　　    private $a = 'a';
　　    protected $b = 'b';
　　    public $c = 'c';
　　}

　　class B extends A {
　　    private $a = 'aa';
　　    protected $b = 'bb';
　　    public $c = 'cc';
　　}

　　class C extends B {
　　    private $a = 'aaa';
　　    protected $b = 'bbb';
　　    public $c = 'ccc';
　　}

　　var_dump(new C());
　　zend_object 中 guards 的作用
　　guards 的作用是对 object 的重载提供递归保护。

　　class Foo {
　　    public function __set($name, $value) {
　　        $this->$name = $value;
　　    }
　　}

　　$foo = new Foo;
　　$foo->bar = 'baz';
　　var_dump($foo->bar);

　　以上代码中，当为 foo 动态设置

　　现在大家对于PHP7和PHP5的对象有哪些差异呢？的内容应该都有一定的认识了吧，希望这篇能对大家有所帮助。

（编辑：ASP站长网）