[Übersetzung] [Entwicklung und Einbettung von PHP-Erweiterungen] Kapitel 10

Objekte von PHP4

Es war einmal, in sehr frühen Versionen unterstützte PHP keine objektorientierte Programmiersyntax. Die Zend-Engine (ZE1) wurde in PHP4 eingeführt und es erschienen mehrere neue Funktionen. einschließlich Objektdatentypen.

Entwicklung von PHP-Objekttypen

Die erste Unterstützung für objektorientierte Programmierung (OOP) implementierte nur die Semantik von Objektassoziationen mit einem PHP-Kernel-Entwickler. Mit anderen Worten: „ PHP4-Objekte binden einfach ein Array und einige Methoden zusammen. Es ist das PHP-Objekt, das Sie jetzt studieren möchten.

Die zweite Hauptversion der Zend-Engine (ZE2) ist. In PHP5 wurden einige neue Funktionen eingeführt In der OOP-Implementierung von PHP können Eigenschaften und Methoden beispielsweise Zugriffsmodifikatoren verwenden, um ihre Sichtbarkeit außerhalb Ihrer Klassendefinition zu kennzeichnen, und Überladung von Funktionen kann verwendet werden, um interne Sprachkonstrukte zu definieren. Für benutzerdefinierte Verhaltensweisen können Schnittstellen verwendet werden, um die API-Standardisierung zwischen zu implementieren Wenn Sie Kapitel 11 „php5-Objekte“ studieren, werden Sie diese Funktionen durch die Implementierung dieser Funktionen in die Klassendefinition von PHP5 etablieren.

Implementierungsklassen

Bevor wir in die Welt von OOP eintreten, müssen wir mit Leichtigkeit reisen. Bitte kehren Sie daher zu Kapitel 5 „Ihre erste Erweiterung“ zurück. „Das gerade eingebaute Grundgerüst.

Um unabhängig von Ihrer ursprünglichen Übung zu sein , können Sie diese Version „sample2“ nennen. Legen Sie die folgenden drei Dateien in ext/sample2 Ihres PHP-Quellcodeverzeichnisses ab:

config.m4

PHP_ARG_ENABLE(sample2,  
  [Whether to enable the "sample2" extension],  
  [  enable-sample2       Enable "sample2" extension support])  
  
if test $PHP_SAMPLE2 != "no"; then  
  PHP_SUBST(SAMPLE2_SHARED_LIBADD)  
  PHP_NEW_EXTENSION(sample2, sample2.c, $ext_shared)  
fi

Nach dem Login kopieren

php_saple2.h

#ifndef PHP_SAMPLE2_H  
/* Prevent double inclusion */  
#define PHP_SAMPLE2_H  
  
/* Define Extension Properties */  
#define PHP_SAMPLE2_EXTNAME    "sample2"  
#define PHP_SAMPLE2_EXTVER    "1.0"  
  
/* Import configure options 
   when building outside of 
   the PHP source tree */  
#ifdef HAVE_CONFIG_H  
#include "config.h"  
#endif  
  
/* Include PHP Standard Header */  
#include "php.h"  
  
/* Define the entry point symbol 
 * Zend will use when loading this module 
 */  
extern zend_module_entry sample2_module_entry;  
#define phpext_sample2_ptr &sample2_module_entry  
  
#endif /* PHP_SAMPLE2_H */

Nach dem Login kopieren

sample2.c

#include "php_sample2.h"  
  
static function_entry php_sample2_functions[] = {  
    { NULL, NULL, NULL }  
};  
  
PHP_MINIT_FUNCTION(sample2)  
{  
    return SUCCESS;  
}  
  
zend_module_entry sample2_module_entry = {  
#if ZEND_MODULE_API_NO >= 20010901  
    STANDARD_MODULE_HEADER,  
#endif  
    PHP_SAMPLE2_EXTNAME,  
    php_sample2_functions,  
    PHP_MINIT(sample2),  
    NULL, /* MSHUTDOWN */  
    NULL, /* RINIT */  
    NULL, /* RSHUTDOWN */  
    NULL, /* MINFO */  
#if ZEND_MODULE_API_NO >= 20010901  
    PHP_SAMPLE2_EXTVER,  
#endif  
    STANDARD_MODULE_PROPERTIES  
};  
  
#ifdef COMPILE_DL_SAMPLE2  
ZEND_GET_MODULE(sample2)  
#endif

Nach dem Login kopieren

Jetzt können Sie, genau wie in Kapitel 5, phpize, ./configure, make ausführen, um Ihr sample2.so-Erweiterungsmodul zu erstellen

Machen Sie an Ihrer vorherigen config.w32 die gleichen Änderungen wie an der hier angegebenen config.m4. Funktioniert auch einwandfrei.

Klasseneintrag definieren

Definieren Sie im Benutzerbereich eine Klasse wie folgt:

<?php  
class Sample2_FirstClass {  
}  
?>

Nach dem Login kopieren

Wie Sie zweifellos erraten werden, ist es in der Erweiterung immer noch etwas schwierig, es zu implementieren. Zuerst müssen Sie einen zend_class_entry-Zeiger in Ihrer Quellcodedatei definieren, genau wie Sie in der Datei int le_sample_descriptor definiert haben vorheriges Kapitel:

zend_class_entry *php_sample2_firstclass_entry;

Nach dem Login kopieren

Jetzt können Sie es in MINIT tun. Die Klasse wird initialisiert und in der Funktion registriert

PHP_MINIT_FUNCTION(sample2)  
{  
    zend_class_entry ce; /* 临时变量 */  
  
    /* 注册类 */  
    INIT_CLASS_ENTRY(ce, "Sample2_FirstClass", NULL);  
    php_sample2_firstclass_entry =  
            zend_register_internal_class(&ce TSRMLS_CC);  
  
    return SUCCESS;  
}

Nach dem Login kopieren

Diese Erweiterung erstellen, testen get_declared_classes(), und Sie werden sehen, dass Sample2_FirstClass jetzt im Benutzerbereich verfügbar ist.

Definieren Sie die Implementierung der Methode

In diesem Moment implementieren Sie natürlich nur eine stdClass ist verfügbar. Aber eigentlich möchten Sie, dass Ihre Klasse etwas tut.

Um diesen Zweck zu erreichen, müssen Sie zu einem anderen in Kapitel 5 gelernten Wissenspunkt zurückkehren. Ersetzen Sie den an INIT_CLASS_ENTRY() übergebenen NULL-Parameter durch php_sample2_firstclass_functions. und definieren Sie diese Struktur direkt über der MINIT-Funktion wie folgt:

static function_entry php_sample2_firstclass_functions[] = {  
    { NULL, NULL, NULL }  
};

Nach dem Login kopieren

Kommt Ihnen das natürlich bekannt vor? sehr ähnlich:

PHP_NAMED_FE(method1, PHP_FN(Sample2_FirstClass_method1), NULL)

Nach dem Login kopieren

Natürlich können Sie auch PHP_FE(method1, NULL) verwenden. Aber erinnern Sie sich an Kapitel 5: Der Name der Funktionsimplementierung, die dadurch gefunden werden soll, ist möglicherweise zif_method1 Konflikt mit anderen method1()-Implementierungen. Aus Gründen der Namespace-Sicherheit der Funktion verwenden wir den Klassennamen als Präfix des Methodennamens.

PHP_FALIAS(method1, Sample2_FirstClass_method1, NULL) ist Auch möglich; aber es ist etwas unintuitiv. Wenn Sie in Zukunft auf den Code zurückblicken, fragen Sie sich vielleicht: „Warum wurde PHP_FE() nicht verwendet?“ Zur Klassendefinition ist es an der Zeit, einige Methoden zu definieren. Erstellen Sie die folgende Funktion über der Struktur php_sample2_firstclass_functions:

Fügen Sie dementsprechend einen PHP_NAMED_FE()-Eintrag zu seiner Funktionsliste hinzu:

PHP_FUNCTION(Sample2_FirstClass_countProps)  
{  
    RETURN_LONG(zend_hash_num_elements(Z_OBJPROP_P(getThis())));  
}

Nach dem Login kopieren

static function_entry php_sample2_firstclass_functions[] = {  
    PHP_NAMED_FE(countprops,  
            PHP_FN(Sample2_FirstClass_countProps), NULL)  
    { NULL, NULL, NULL }  
};

Nach dem Login kopieren

Beachten Sie, dass die hier im Benutzerbereich angezeigten Funktionsnamen alle in Kleinbuchstaben geschrieben sind. Um sicherzustellen, dass bei Methoden- und Funktionsnamen die Groß- und Kleinschreibung nicht berücksichtigt wird, müssen interne Funktionen alle Namen in Kleinbuchstaben angeben >

Das einzige neue Element hier ist getThis(), das in allen PHP-Versionen als Makro geparst wird. Die Erweiterung ist im Wesentlichen die gleiche wie $this in User-Space-Objektmethoden Die Objektinstanz, z. B. die Methode wird statisch aufgerufen, getThis() gibt NULL zurück.

Objekt Die Datenrückgabesemantik der Methode ist dieselbe wie die der Prozedurfunktion, und die Parameterannahme und arg_info sind die gleichen Dinge.

Konstruktor

PHP_FUNCTION(Sample2_FirstClass_sayHello)  
{  
    char *name;  
    int name_len;  
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s",  
                        &name, &name_len) == FAILURE) {  
        RETURN_NULL();  
    }  
    php_printf("Hello");  
    PHPWRITE(name, name_len);  
    php_printf("!\nYou called an object method!\n");  
    RETURN_TRUE;  
}

Nach dem Login kopieren

Ihr Klassenkonstruktor kann derselbe sein wie bei anderen gewöhnlichen Klassenmethoden. Die Benennung folgt auch denselben Regeln. Das Besondere ist, dass Sie die benennen müssen Konstruktor mit dem Klassennamen. Die anderen beiden magischen ZE1-Methoden __sleep() und __wakeup() können ebenfalls auf diese Weise implementiert werden.

Vererbung

In PHP4 ist die Vererbung zwischen internen Objekten unvollkommen und wird am besten vermieden. Wenn Sie wirklich andere Objekte erben müssen, müssen Sie den folgenden ZE1-Code kopieren:

Definieren Sie eine solche Funktion, Sie können sie unter zend_register_internal_class in MINIT aufrufen:

void php_sample2_inherit_from_class(zend_class_entry *ce,  
                        zend_class_entry *parent_ce) {  
    zend_hash_merge(&ce->function_table,  
            &parent_ce->function_table, (void (*)(void *))function_add_ref,  
            NULL, sizeof(zval*), 0);  
    ce->parent = parent_ce;  
    if (!ce->handle_property_get) {  
        ce->handle_property_get =  
                parent_ce->handle_property_get;  
    }  
    if (!ce->handle_property_set) {  
        ce->handle_property_set =  
                parent_ce->handle_property_set;  
    }  
    if (!ce->handle_function_call) {  
        ce->handle_function_call =  
                parent_ce->handle_function_call;  
    }  
    if (!zend_hash_exists(&ce->function_table,  
                ce->name, ce->name_length + 1)) {  
        zend_function *fe;  
        if (zend_hash_find(&parent_ce->function_table,  
                parent_ce->name, parent_ce->name_length + 1,  
                (void**)fe) == SUCCESS) {  
            zend_hash_update(&ce->function_table,  
                ce->name, ce->name_length + 1,  
                fe, sizeof(zend_function), NULL);  
            function_add_ref(fe);  
        }  
    }  
}

Nach dem Login kopieren

Obwohl die Vererbung auf diese Weise funktionieren kann, sollte die Vererbung in ZE1 vermieden werden, da sie nicht für die Vererbung interner Objekte ausgelegt ist. Für die meisten OOP-Praktiken in PHP sind ZE2 und sein überarbeitetes Objektmodell robust und alle OOP-. Es wird empfohlen, verwandte Aufgaben direkt damit zu bearbeiten.

INIT_CLASS_ENTRY(ce, "Sample2_FirstClass", NULL);  
/* 假定php_saple2_ancestor是一个已经注册的zend_class_entry */  
php_sample2_firstclass_entry =  
        zend_register_internal_class(&ce TSRMLS_CC);  
php_sample2_inherit_from_class(php_sample2_firstclass_entry  
                            ,php_sample2_ancestor);

Nach dem Login kopieren

Arbeiten mit Beispielen

和其它用户空间变量一样, 对象存储在zval *容器中. 在ZE1中, zval *包含了一个HashTable *用于保存属性, 以及一个zend_class_entry *指针, 指向类的定义. 在ZE2中, 这些值被一个句柄表替代, 增加了一个数值的对象ID, 它和资源ID的用法类似.

很幸运, ZE1和ZE2的这些差异被第2章"变量的里里外外"中介绍的Z_*()族宏隐藏了, 因此在你的扩展中不需要关心这些. 下表10.1列出了两个ZE1的宏, 与非OOP的相关宏一致, 它们也有对应的_P和_PP版本, 用来处理一级或两级间访.

[Übersetzung] [Entwicklung und Einbettung von PHP-Erweiterungen] Kapitel 10 – Objekte von PHP4

创建实例

大部分时间, 你的扩展都不需要自己创建实例. 而是用户空间调用new关键字创建实例并调用你的类构造器.

但你还是有可能需要创建实例, 比如在工厂方法中, ZEND_API中的object_init_ex(zval *val, zend_class_entry *ce)函数可以用于将对象实例初始化到变量中.

要注意, object_init_ex()函数并不会调用构造器. 当在内部函数中实例化对象时, 构造器必须手动调用. 下面的过程函数重演了new关键字的功能逻辑:

PHP_FUNCTION(sample2_new)  
{  
    int argc = ZEND_NUM_ARGS();  
    zval ***argv = safe_emalloc(sizeof(zval**), argc, 0);  
    zend_class_entry *ce;  
    if (argc == 0 ||  
        zend_get_parameters_array_ex(argc, argv) == FAILURE) {  
        efree(argv);  
        WRONG_PARAM_COUNT;  
    }  
    /* 第一个参数是类名 */  
    SEPARATE_ZVAL(argv[0]);  
    convert_to_string(*argv[0]);  
    /* 类名存储为小写 */  
    php_strtolower(Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]));  
    if (zend_hash_find(EG(class_table),  
            Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]) + 1,  
            (void**)&ce) == FAILURE) {  
        php_error_docref(NULL TSRMLS_CC, E_WARNING,  
            "Class %s does not exist.",  
            Z_STRVAL_PP(argv[0]));  
        zval_ptr_dtor(argv[0]);  
        efree(argv);  
        RETURN_FALSE;  
    }  
    object_init_ex(return_value, ce);  
    /* 如果有构造器则调用, 额外的参数将传递给构造器 */  
    if (zend_hash_exists(&ce->function_table,  
            Z_STRVAL_PP(argv[0]),Z_STRLEN_PP(argv[0]) + 1)) {  
        /* 对象有构造器 */  
        zval *ctor, *dummy = NULL;  
  
        /* 构造器名字是类名 */  
        MAKE_STD_ZVAL(ctor);  
        array_init(ctor);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
        if (call_user_function_ex(&ce->function_table,  
                NULL, ctor,  
                &dummy, /* 不关心返回值 */  
                argc - 1, argv + 1, /* 参数 */  
                0, NULL TSRMLS_CC) == FAILURE) {  
            php_error_docref(NULL TSRMLS_CC, E_WARNING,  
                 "Unable to call constructor");  
        }  
        if (dummy) {  
            zval_ptr_dtor(&dummy);  
        }  
        zval_ptr_dtor(&ctor);  
    }  
    zval_ptr_dtor(argv[0]);  
    efree(argv);  
}

Nach dem Login kopieren

不要忘了在php_sample2_functions中增加一个引用. 它是你的扩展的过程函数列表, 而不是类方法的列表. 为了使用php_strtolower()函数, 还需要增加#include "ext/standard/php_string.h".

这个函数是目前你实现的最复杂的一个, 其中有几个全新的特性. 首先就是SEPARATE_ZVAL(), 实际上它的功能你已经实现过很多次, 利用zval_copy_ctor()赋值值到一个临时的结构体, 避免修改原始的内容. 不过它是一个宏版本的封装.

php_strtolower()用于将类名转换为小写, 这样做是为了达到php类名和函数名不区分大小写的目的. 这只是附录B中列出的众多PHPAPI工具函数的其中一个.

EG(class_table)是一个全局变量, 所有的zend_class_entry定义都注册到它里面. 要注意的是在ZE1(php4)中这个HashTable存储了一级间访的zend_class_entry *结构体. 而在ZE2(php5)中, 它被存储为两级间访. 这应该不会是一个问题, 因为对这个HashTable的直接访问并不常见, 但知道这一点总归是有好处的.

call_user_function_ex()是你将在第20章"高级嵌入式"中看到的ZENDAPI调用的一部分. 这里你将从zend_get_parameters_ex()接收到的zval **参数栈第一个元素拿走, 这样做就是为了原封不动的将剩余的参数传递给构造器.

译注: 原著中的代码在译者的环境(php-5.4.9)中不能运行, 需要将zend_class_entry *ce修改为二级间访. 下面给出译者测试通过的代码.

PHP_FUNCTION(sample_new)  
{  
    int                 argc    = ZEND_NUM_ARGS();  
    zval                ***argv = safe_emalloc(sizeof(zval **), argc, 0);   
    zend_class_entry    **ce;       /* 译注: 这里在译者的环境(php-5.4.9)是二级间访 */  
  
    /* 数组方式读取所有传入参数 */  
    if ( argc == 0 ||    
            zend_get_parameters_array_ex(argc, argv) == FAILURE ) {   
        efree(argv);  
        WRONG_PARAM_COUNT;  
    }     
  
    /* 隔离第一个参数(隔离为了使下面的类型转换不影响原始数据) */  
    SEPARATE_ZVAL(argv[0]);  
    /* 将第一个参数转换为字符串类型, 并转为小写(因为php的类名是不区分大小写的) */  
    convert_to_string(*argv[0]);  
    php_strtolower(Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]));  
    /* 在类的HashTable中查找提供的类是否存在, 如果存在, ce中就得到了对应的zend_class_entry * */  
    if ( zend_hash_find(EG(class_table), Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]) + 1, (void **)&ce) == FAILURE ) {   
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class %s does not exist.", Z_STRVAL_PP(argv[0]));  
        zval_ptr_dtor(argv[0]);  
        efree(argv);  
        RETURN_FALSE;  
    }     
  
    /* 将返回值初始化为查找到的类的对象 */  
    object_init_ex(return_value, *ce);  
    /* 检查类是否有构造器 */  
    if ( zend_hash_exists(&(*ce)->function_table, Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]) + 1) ) {   
        zval    *ctor, *dummy = NULL;  
  
        /* 将ctor构造为一个数组, 对应的用户空间形式为: array(argv[0], argv[0]),  
         * 实际上对应于用户空间调用类的静态方法时$funcname的参数形式: 
         * array(类名, 方法名) 
         */  
        MAKE_STD_ZVAL(ctor);  
        array_init(ctor);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
        /* 调用函数 */  
        if ( call_user_function_ex(&(*ce)->function_table, NULL, ctor, &dummy, argc - 1, argv + 1, 0, NULL TSRMLS_CC) == FAILURE ) {   
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call constructor");  
        }     
        /* 如果有返回值直接析构丢弃 */  
        if ( dummy ) {  
            zval_ptr_dtor(&dummy);  
        }  
        /* 析构掉临时使用(用来描述所调用方法名)的数组 */  
        zval_ptr_dtor(&ctor);  
    }  
    /* 析构临时隔离出来的第一个参数(类名) */  
    zval_ptr_dtor(argv[0]);  
    /* 释放实参列表空间 */  
    efree(argv);  
}

Nach dem Login kopieren

接受实例

有时你的函数或方法需要接受用户空间的对象参数. 对于这种目的, zend_parse_parameters()提供了两种格式的修饰符. 第一种是o(小写字母o), 它将验证传递的参数是否是对象, 并将它设置到传递的zval **中. 下面是这种方式的一个简单的用户空间函数示例, 它返回传入对象的类名.

PHP_FUNCTION(sample2_class_getname)  
{  
    zval *objvar;  
    zend_class_entry *objce;  
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o",  
                                &objvar) == FAILURE) {  
        RETURN_NULL();  
    }  
    objce = Z_OBJCE_P(objvar);  
    RETURN_STRINGL(objce->name, objce->name_length, 1);  
}

Nach dem Login kopieren

第二种修饰符是O(大写字母O), 它不仅允许zend_parse_parameters()验证zval *的类型, 还可以验证所传递对象的类. 要做到这一点, 就需要传递一个zval **容易以及一个zend_class_entry *用来验证, 比如下面的实现就期望传入的是Sample2_FirstClass类的实例:

PHP_FUNCTION(sample2_reload)  
{  
    zval *objvar;  
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O",  
        &objvar, php_sample2_firstclass_entry) == FAILURE) {  
        RETURN_NULL();  
    }  
    /* 调用假想的"reload"函数 */  
    RETURN_BOOL(php_sample2_fc_reload(objvar TSRMLS_CC));  
}

Nach dem Login kopieren

访问属性

你已经看到了, 类方法可以通过getThis()获取到当前对象实例. 将这个宏的结果或其它包含对象实例的zval *与Z_OBJPROP_P()宏组合, 得到的HashTable *就包含了该对象的所有属性.

对象的属性列表是一个包含zval *的HashTable *, 它只是另外一种放在特殊位置的用户空间变量列表. 和使用zend_hash_find(EG(active_symbol_table), ...)从当前作用域获取变量一样, 你也可以使用第8章"在数组和HashTable上工作"中学习的zend_hash-API去获取或设置对象的属性.

例如, 假设在变量rcvdclass这个zval *中包含的是Sample2_FirstClass的实例, 下面的代码块就可以从它的标准属性HashTable中取到属性foo.

zval **fooval;  
if (zend_hash_find(Z_OBJPROP_P(rcvdclass),  
        "foo", sizeof("foo"), (void**)&fooval) == FAILURE) {  
    /* $rcvdclass->foo doesn&#39;t exist */  
    return;  
}

Nach dem Login kopieren

要向属性表中增加元素, 则是这个过程的逆向过程, 调用zend_hash_add()去增加元素, 或者也可以将第8章介绍数组时介绍的add_assoc_*()族函数的assoc替换为property来处理对象.

下面的构造器函数为Sample2_FirstClass的实例提供了一些预先设置的默认属性:

PHP_NAMED_FUNCTION(php_sample2_fc_ctor)  
{  
    /* 为了简洁, 同时演示函数名可以是任意的, 这里实现的函数名并不是类名 */  
    zval *objvar = getThis();  
  
    if (!objvar) {  
        php_error_docref(NULL TSRMLS_CC, E_WARNING,  
                        "Constructor called statically!");  
        RETURN_FALSE;  
    }  
  
    add_property_long(objvar, "life", 42);  
    add_property_double(objvar, "pi", 3.1415926535);  
    /* 构造器的返回值会被忽略(请回顾前面构造器的例子) */  
}

Nach dem Login kopieren

现在可以通过php_sample2_firstclass_functions列表将它连接到对象的构造器:

PHP_NAMED_FE(sample2_firstclass, php_sample2_fc_ctor, NULL)

Nach dem Login kopieren

译注: 由于前面的sample_new()工厂函数在call_user_function_ex()调用构造器时使用的是静态方法的调用格式, 因此, 如果是使用这个工厂函数触发的构造器调用, getThis()就不会有期望的结果. 因此译者对例子进行了相应的修改, 读者如果在这块遇到问题可以参考译者的代码.

PHP_FUNCTION(sample_new)  
{  
    int                 argc    = ZEND_NUM_ARGS();  
    zval                ***argv = safe_emalloc(sizeof(zval **), argc, 0);   
    zend_class_entry    **ce;       /* 译注: 这里在译者的环境(php-5.4.9)是二级间访 */  
  
    /* 数组方式读取所有传入参数 */  
    if ( argc == 0 ||    
            zend_get_parameters_array_ex(argc, argv) == FAILURE ) {   
        efree(argv);  
        WRONG_PARAM_COUNT;  
    }     
  
    /* 隔离第一个参数(隔离为了使下面的类型转换不影响原始数据) */  
    SEPARATE_ZVAL(argv[0]);  
    /* 将第一个参数转换为字符串类型, 并转为小写(因为php的类名是不区分大小写的) */  
    convert_to_string(*argv[0]);  
    php_strtolower(Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]));  
    /* 在类的HashTable中查找提供的类是否存在, 如果存在, ce中就得到了对应的zend_class_entry * */  
    if ( zend_hash_find(EG(class_table), Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]) + 1, (void **)&ce) == FAILURE ) {   
        php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class %s does not exist.", Z_STRVAL_PP(argv[0]));  
        zval_ptr_dtor(argv[0]);  
        efree(argv);  
        RETURN_FALSE;  
    }     
  
    /* 将返回值初始化为查找到的类的对象 */  
    object_init_ex(return_value, *ce);  
    /* 检查类是否有构造器 */  
    if ( zend_hash_exists(&(*ce)->function_table, Z_STRVAL_PP(argv[0]), Z_STRLEN_PP(argv[0]) + 1) ) {   
#define DYNAMIC_CONSTRUCTOR  
#ifndef DYNAMIC_CONSTRUCTOR  
        zval    *ctor;  
#endif  
        zval    *dummy = NULL;  
  
#ifndef DYNAMIC_CONSTRUCTOR  
        /* 将ctor构造为一个数组, 对应的用户空间形式为: array(argv[0], argv[0]),  
         * 实际上对应于用户空间调用类的静态方法时$funcname的参数形式: 
         * array(类名, 方法名) 
         */  
        MAKE_STD_ZVAL(ctor);  
        array_init(ctor);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
        zval_add_ref(argv[0]);  
        add_next_index_zval(ctor, *argv[0]);  
#endif  
        /* 调用函数 */  
        if ( call_user_function_ex(&(*ce)->function_table,  
#ifndef DYNAMIC_CONSTRUCTOR  
                NULL, ctor,  
#else  
                &return_value, *argv[0],  
#endif  
                &dummy, argc - 1, argv + 1, 0, NULL TSRMLS_CC) == FAILURE ) {  
            php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call constructor");  
        }  
        /* 如果有返回值直接析构丢弃 */  
        if ( dummy ) {  
            zval_ptr_dtor(&dummy);  
        }  
#ifndef DYNAMIC_CONSTRUCTOR  
        /* 析构掉临时使用(用来描述所调用方法名)的数组 */  
        zval_ptr_dtor(&ctor);  
#endif  
    }  
    /* 析构临时隔离出来的第一个参数(类名) */  
    zval_ptr_dtor(argv[0]);  
    /* 释放实参列表空间 */  
    efree(argv);  
}

Nach dem Login kopieren

译注: 现在, 就可以用函数中是否定义DYNAMIC_CONSTRUCTOR这个宏来切换构造器的调用方式, 以方便读者理解.

小结

尽管ZE1/php4提供的类功能最好少用, 但是由于当前php4在产品环境下还是广泛使用的, 因此做这个兼容还是有好处的. 本章涉及的技术可以让你灵活的编写各种功能的代码, 它们现在可以编译运行, 并且未来也将继续可以工作.

下一章, 你将看到php5中真正的面向对象, 如果你想要OOP, 从中你就可以得到升级的理由, 并且, 升级后你肯定再也不愿回头.

以上就是 [翻译][php扩展开发和嵌入式]第10章-php4的对象的内容，更多相关内容请关注PHP中文网（www.php.cn）！