PHP core-detailed explanation of classes and object-oriented code

When I first came into contact with PHP, I used a process-oriented approach to make some very simple websites for fun. Writing PHP code was Stacking, scalability and maintainability are so poor that it is extremely inconvenient to change the logic. Later I discovered that PHP supports object-oriented, and suddenly I felt that I was really young and ignorant at that time. After all, PHP is implemented in C, which is not surprising.

Foreword:

From our contact PHPStarting, the first thing we encounter are functions: array operation functions, string operation functions, file operation functions, etc. These functions are the basis for our use of PHP, and they are also the process-oriented programming that PHP has supported since its birth. Process-oriented encapsulates functions one by one and solves problems with a modular idea.

# Supports object-oriented programming starting from PHP4. However, PHP4's object-oriented support is not perfect. Starting from PHP5, PHP has introduced a new object model (Object Model) and added many new features, including access control, abstract and final classes, class methods, magic methods, interfaces, object cloning and type hints, etc. And in the recently released PHP5.3 version, namespaces, delayed static binding and additional There are two magic methods __callStatic() and __invoke().

#So, how is it implemented at the bottom of PHP and what is its structure?

one. Class structure

Quoting an example of TIPI:

class ParentClass {
}
 
interface Ifce {
        public function iMethod();
}
 
final class Tipi extends ParentClass implements Ifce {
        public static $sa = 'aaa';
        const CA = 'bbb';
 
        public function __constrct() {
        }
 
        public function iMethod() {
        }
 
        private function _access() {
        }
 
        public static function access() {
        }
}

A parent class ParentClass, an interface Ifce, and a subclass Tipi are defined here. The subclass inherits the parent class ParentClass, implements the interface Ifce, and has a static variable $sa, a class constant CA, a public method, a private method and a public static method. How are these structures implemented inside the Zend engine? How are class methods and member variables stored? Access control, how are static members marked?

First, let’s look at the internal storage structure of the class:

Taking some fields of the above structure, we analyze the performance of the PHP code at the beginning of the article in the kernel. As follows:

二。变量与成员变量

如PHP内核的存储机制（分离/改变）所介绍，

变量要么是定义在全局范围中，叫做全局变量，要么是定义在某个函数中， 叫做局部变量。

成员变量是定义在类里面，并和成员方法处于同一层次。如下一个简单的PHP代码示例，定义了一个类， 并且这个类有一个成员变量。

class Tipi { 
	public $var;
}

1.成员变量的访问：

访问这个成员变量当然是通过对象来访问。

2.成员变量的规则：

1.接口中不允许使用成员变量

2.成员变量不能拥有抽象属性

3.不能声明成员变量为final

4.不能重复声明属性

在声明类的时候初始化了类的成员变量所在的HashTable，之后如果有新的成员变量声明时，在编译时zend_do_declare_property。函数首先检查成员变量不允许的这4 条情况。

比如：.

class Tipi { 
	public final $var;
}

运行程序将报错，违反了第三条：Fatal error: Cannot declare property Tipi::$var final, the final modifier is allowed only for methods and classes in .. 这个错误由zend_do_declare_property函数抛出

三。函数与成员方法

成员方法从本质上来讲也是一种函数，所以其存储结构也和常规函数一样，存储在zend_function结构体中。

对于一个类的多个成员方法，它是以HashTable的数据结构存储了多个zend_function结构体。 和前面的成员变量一样，在类声明时成员方法也通过调用zend_initialize_class_data方法，初始化了整个方法列表所在的HashTable。 在类中我们如果要定义一个成员方法，格式如下：

class Tipi{ 
     public function t() {echo 1; }
}

除去访问控制关键字，一个成员方法和常规函数是一样的，从语法解析中调用的函数一样（都是zend_do_begin_function_declaration函数）， 但是其调用的参数有一些不同，第三个参数is_method，成员方法的赋值为1，表示它作为成员方法的属性。 在这个函数中会有一系统的编译判断，比如在接口中不能声明私有的成员方法。 看这样一段代码：

interface Ifce { 
    private function method();
}

If run directly, the program will report an error: Fatal error: Access type for interface method Ifce::method() must be omitted in This code corresponds to the code in the zend_do_begin_function_declaration function.

Four. Similarities and Differences between Method and Method Similarly, a series of logic is put into a collection for execution, but there are many differences in the use of the two. Here we discuss the implementation of the two. From an implementation point of view, the internal code of both is ultimately interpreted as op_array, and there is no difference in its execution (unless object-specific changes or methods such as $this/self are used), and the difference between the two is reflected in the two Aspects:

1. It is the implementation of definition (registration);

2. It is the implementation of the call;

Functions and methods are registered in the compiler_globals variable during the compilation phase, and both use the same kernel processing functions zend_do_begin_function_declaration() and zend_do_end_function_declaration() to complete this process. The internal contents of the two will be eventually interpreted and stored as an op_codes array, but the "mounted" location after compilation is different, as shown below:

Registration location of functions and methods in PHP

Implementation of calling method

The difference in definition location and nature determines that methods are more complex than functions. More verification work, the method call has one more OPCODE named
ZEND_INIT_METHOD_CALL

, than the function call Its function is to register the method to execute_data.fbc, and then you can use the same processing function as the function ZEND_DO_FCALL_BY_NAME

The above is the detailed content of PHP core-detailed explanation of classes and object-oriented code. For more information, please follow other related articles on the PHP Chinese website!