Erste Schritte mit der PHP-Erweiterungsentwicklung über PHP-CPP

In Ihren Geschäften mit PHP können Sie selbst eine PHP -Erweiterung selbst schreiben. Es gibt mehrere Gründe, warum ich mir vorstellen kann, dass ich mich dazu motiviert:

• Die PHP -Funktionalität für eine ganz bestimmte Verwendung (Mathematik, Statistik, geometrische usw.) erweitern.
• eine höhere Leistung und Effizienz im Vergleich zu einer reinen PHP -Implementierung
• , um die Schnelligkeit zu nutzen,

Verwenden Sie mehr Pro-Php-Semantik wie Zephir.
Verwenden Sie mehr Pro-C/C-Semantik wie PHP-CPP, die in diesem Artikel behandelt wird.

PHP-CPP ist eine Bibliothek zur Entwicklung von PHP-Erweiterungen, mit der C-Entwickler PHP-Erweiterungen schreiben können, ohne dass die Komplexität der direkten Arbeit direkt mit der Zend-API arbeitet. Es ist in C 11 geschrieben und bietet eine Sammlung gut dokumentierter und benutzerfreundlicher Klassen.
PHP-CPP entwickelt sich rasant und es wird empfohlen, Git für die neuesten Updates zu klonen, um das Repository zu klonen. Es unterstützt Einzel-Thread-PHP-Installationen und erfordert ein Upgrade auf den G-Compiler auf Version 4.8.x oder höher für die Kompatibilität.
PHP-CPP bietet ein Skeleton-Erweiterungsprojekt, das eine Main.cpp-Datei, eine Datei zum Kompilieren der Erweiterung und eine .ini-Datei für das Laden der Erweiterung enthält. Das Skelettprojekt kann an individuelle Bedürfnisse angepasst und mit dem Befehl "make && sudo make make install" zusammengestellt und installiert werden.
PHP-CPP unterstützt vier Arten von Funktionssignaturen, die von PHP aufgerufen werden sollen, und ermöglicht die Übergabe von Parametern in einem Array-Formular. Es ermöglicht auch Funktionenxport/Registrierung, Spezifikation der Funktionsparametertypen und die Erstellung von objektorientierten Erweiterungen.

Hinweis: Die PHP-CPP-Dokumentation zur Installation besagt, dass sie vorerst „nur Einzel-Thread-PHP-Installationen unterstützt“, da „die Zend-Engine intern ein sehr seltsames System verwendet, um die Gewindesicherheit zu gewährleisten“. Zukünftige Veröffentlichungen können Multi-Thread-PHP-Installationen unterstützen, aber denken wir vorerst im Auge und halten uns an seine aktuelle Einschränkung. Zum Glück sollte „Single-Threaded-PHP-Installationen“ für die meisten PHP-Installationen der Fall der Fall sein.

PHP-CPP ist in C 11 geschrieben. Somit unterstützt die in meinem Ubuntu 12.04 LTS installierte ältere Version G nicht. Wir müssen unseren G -Compiler oben auf Version 4.8.x upgraden. Es gibt einen Artikel, in dem die Schritte zum Aufrüsten beschrieben werden. Bitte befolgen Sie die dort aufgeführten Anweisungen.

Außerdem verwendet die PHP-CPP-Kompilierung die Php.h-Header-Datei. Diese Datei fehlt normalerweise in einem Ubuntu-Box, es sei denn, Php-Dev wurde installiert. Wir können PHP5 -verwandte Entwicklungsdateien installieren, indem wir diesen Befehl ausgeben:

<span>sudo apt-get install php5-dev</span>

Nach dem Aktualisieren von G und der Installation der erforderlichen Header-Dateien können wir den folgenden Befehl zum Kompilieren und Installieren der PHP-CPP-Bibliotheksdatei (libPHPCPP.SO) ausstellen:

<span>make && sudo make install</span>

Die Zusammenstellung wird ziemlich schnell sein. Nach der Installation wird die Datei libPHPCPP.SO in/usr/lib und alle PHP-CPP-Header-Dateien in/usr/include und/usr/include/phpcpp kopiert.

main.cpp: Die Haupt -CPP -Datei mit einer Get_Module -Funktion (wird später ausführlicher besprochen)
Makefile: Die Beispiel -Datei machen Sie die Erweiterung
• zum Kompilieren

Makefile

Wenn Sie mit *Nix -Entwicklung vertraut sind, sind Sie mit diesem Makefile vertraut. Es müssen einige geringfügige Änderungen vorgenommen werden, um diese Datei an unsere Anforderungen anzupassen:
• ändere name = yourextesion zu einem sinnvolleren wie name = skeletton.

Dies sind alle Änderungen, die ich vorgenommen habe. Der Rest des Makefile kann so aufbewahrt werden, wie er ist.

yourextesion.ini

<span>sudo apt-get install php5-dev</span>

main.cpp

In dem von PHP-CPP bereitgestellten leeren Projekt enthält diese Datei nur eine Funktion: get_module (), das unten auszugteil ist:

<span>make && sudo make install</span>

ändern wir vorerst diese Zeile so, dass sie mit dem Erweiterungsnamen übereinstimmen, den wir erstellen möchten:

<span>extension=skeleton.so</span>

get_module () wird von PHP aufgerufen, wenn letztere versucht, eine erforderliche Bibliothek zu laden. Es wird als Einstiegspunkt für eine LIB angesehen. Es wird unter Verwendung des externen "C" -Modifikators deklariert, um die Funktion von Get_Module () der PHP LIB -Anforderung zu erfüllen. Es verwendet auch ein Makro -PHPCPP_EXPORT, das sicherstellt

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

<span>make && sudo make install</span>

<span>cp -f skeleton.so /usr/lib/php5/20121212
</span><span>cp -f skeleton.ini /etc/php5/cli/conf.d</span>

<span><span>#include <phpcpp.h></span>
</span><span><span>#include <iostream></span>
</span>
<span>void helloWorld (Php::Parameters &params)
</span><span>{
</span>    std<span>::string name=params[0];
</span>    std<span>::cout<<"Hello "<<name<<"!"<<std::endl;
</span>
<span>}
</span>
<span>extern "C" {
</span>
    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>static Php::Extension extension("skeleton", "1.0");
</span>        extension<span>.add("helloWorld", helloWorld);
</span>
        <span>return extension;
</span>    <span>}
</span><span>}</span>

Funktionsparameter durch Referenz

Als nächstes werden wir eine andere Funktion sehen, die die Parameter durch Referenz, eine SWAP () -Funktion, übergibt. In dieser Funktion werden wir auch versuchen, die Anzahl der Parameter und deren Typ anzugeben.

In main.cpp fügen wir noch einen weiteren Funktionswap () hinzu:

<span>sudo apt-get install php5-dev</span>

und exportieren Sie die Funktion auch, indem Sie die Anzahl der Parameter und deren Typ angeben:

<span>make && sudo make install</span>

wir sagen ausdrücklich, dass:

• Es wird zwei Parameter (a und b);
geben
• Sie sollten mit Referenz übergeben werden (anstelle von Wert);
• Sie sollten vom Typ numerisch sein.

Lassen Sie uns die aktualisierte Erweiterung erneut kompilieren und installieren und einige Code -Snippets schreiben, um zu sehen, wie diese neuen Funktionen funktionieren:

<span>extension=skeleton.so</span>

Swap ($ A) fällt aus. Dies wird erwartet und unerwartet. Der erwartete Teil ist, dass wir zwei Parameter benötigen und nur einer gegeben ist. Aber sollte dieser Fehler nicht von PHP erfasst werden, wenn Sie den Funktionswechsel aufrufen und uns so etwas wie nicht genug Parameter veranlassen?

Der erste Anruf (Swap ($ A, $ b)) zeigt das erwartete Ergebnis: 20 | 10. Die Funktion tauscht die beiden übergebenen Zahlen aus.

Der zweite Anruf ist irgendwie unerwartet: Wir haben PHP mitgeteilt, dass wir zwei Zahlen austauschen sollen! Aber es ignoriert nur die Tatsache, dass der zweite Parameter eine Zeichenfolge ist und trotzdem der Austausch!

In gewisser Weise wird es immer noch erwartet. PHP unterscheidet einen Zahlentyp und einen String -Typ nicht wirklich. Dieses Verhalten entspricht dem PHP -Standard. Aufgrund dieses Verhaltens haben wir auch nicht C -Typen für die in der Funktion (TEMP) verwendete temporäre Variable nicht verwenden, aber php ::wert als variabler Typ verwendet.

Der dritte Anruf funktioniert. Der erste var_dump zeigt das DateTime -Objekt an und der zweite zeigt die Ganzzahl an. Dies ist irgendwie sehr unerwartet (zumindest für mich). Schließlich unterscheidet sich ein Objekt ganz anders als eine Zahl/eine Zeichenfolge. Nachdem dieses "Swap" -Verhalten in PHP auch machbar ist, passt es in die Kuriositäten von PHP.

Bedeutet dies, dass die Spezifikation "Typ" keine Auswirkungen hat? Nicht wirklich. Um dies weiter auszuarbeiten, erstellen wir eine dritte Funktion:

<span><span>#include <phpcpp.h></span>
</span>
<span>/**
</span><span> *  tell the compiler that the get_module is a pure C function
</span><span> */
</span><span>extern "C" {
</span>
    <span>/**
</span><span>     *  Function that is called by PHP right after the PHP process
</span><span>     *  has started, and that returns an address of an internal PHP
</span><span>     *  strucure with all the details and features of your extension
</span><span>     *
</span><span>     *  @return void*   a pointer to an address that is understood by PHP
</span><span>     */
</span>    PHPCPP_EXPORT <span>void *get_module() 
</span>    <span>{
</span>        <span>// static(!) Php::Extension object that should stay in memory
</span>        <span>// for the entire duration of the process (that's why it's static)
</span>        <span>static Php::Extension extension("yourextension", "1.0");
</span>
        <span>// @todo    add your own functions, classes, namespaces to the extension
</span>
        <span>// return the extension
</span>        <span>return extension;
</span>    <span>}
</span><span>}  </span>

Und wir registrieren diese Funktion wie folgt:

<span>static Php::Extension extension("skeleton", "1.0"); // To be humble, we can change the version number to 0.0.1</span>

Der Testcode ist wie folgt:

<span>make && sudo make install</span>

Der erste Aufruf von SwapObject () funktioniert, wie wir am richtigen Klassentyp (SampleClass) bestanden haben. Der zweite wird fehlschlagen und zeigt „PHP Catchable Fatal ERROR: Argument 1 an SwapObject () übergeben muss eine Instanz der Stichprobenklasse, Instanz einer anderen Klasse, die ...“.

Das obige Codesegment veranschaulicht einen wichtigen Aspekt bei der Typeinschränkung: Die Erklärung der Skalartypen wird nicht wirklich implementiert. PHP und damit PHP-CPP erzwingen nur die Erklärung vom Typ Objekt. Auch die Anzahl der Parameter wird auf der PHP -Seite nicht wirklich erzwungen.

Schlussfolgerung

In diesem Artikel haben wir die Schritte zur Vorbereitung von PHP-CPP für unsere PHP-Umgebung veranschaulicht. Wir haben auch einige grundlegende Schritte besprochen, um eine PHP-Erweiterung mit PHP-CPP (und C-Semantik) zu erstellen.

Wir haben die Erweiterungsprojektdateien, Funktionssignaturen, Funktionsexport/Registrierung und die Funktionsparametertypen abgedeckt.

In unserem nächsten Artikel werden wir einige wichtige Funktionen in PHP-CPP weiter ausarbeiten und einen realen Anwendungsfall bereitstellen, der die Verwendung von C-Klasse- und Namespace-Implementierungen unter Verwendung von PHP-CPP zeigt.

häufig gestellte Fragen (FAQs) zur Entwicklung der PHP -Erweiterung

Was ist PHP-CPP und wie unterscheidet es sich von PHP?

PHP-CPP ist eine Bibliothek zur Entwicklung von PHP-Erweiterungen. Es bietet eine Sammlung gut dokumentierter und benutzerfreundlicher Klassen, sodass C-Entwickler PHP-Erweiterungen schreiben können, ohne die Komplexität der direkten Arbeit mit der Zend-API zu schreiben. Im Gegensatz zu PHP, bei dem es sich um eine interpretierte Sprache handelt, können Sie mit PHP-CPP Code in C, eine kompilierte Sprache, schreiben. Dies kann zu Leistungsverbesserungen führen, da kompilierter Code im Allgemeinen schneller als interpretierter Code ausgeführt wird.

Wie installiere ich PHP-CPP auf meinem System? Muss das PHP-CPP-Repository aus GitHub klonen. Navigieren Sie nach dem Klonen zum Verzeichnis und führen Sie den Befehl "make" aus. Sobald der Build -Vorgang abgeschlossen ist, installieren Sie die Bibliothek mit dem Befehl "Installation erstellen". Denken Sie daran, Sie müssen Root-Berechtigungen haben, um die Bibliothek zu installieren. Zunächst müssen Sie ein Verzeichnis für Ihre Erweiterung erstellen und dazu navigieren. Erstellen Sie dann eine "Makefile" und eine C -Quelldatei für Ihre Erweiterung. Das „Makefile“ enthält Anweisungen zum Erstellen Ihrer Erweiterung, während die C -Quelldatei den tatsächlichen Code für Ihre Erweiterung enthält. Nachdem Sie Ihren Code geschrieben haben, können Sie Ihre Erweiterung mit dem Befehl 'make' erstellen.

Wie kann ich meine PHP -Erweiterung debuggen? Ich habe mich mit einer kompilierten Sprache um. Sie können jedoch Tools wie GDB (GNU -Debugger) verwenden, um Ihre Erweiterung zu debuggen. Mit GDB können Sie Breakpoints festlegen, Ihren Code durchlaufen und Variablen inspizieren. Dies kann sehr hilfreich sein, wenn Sie versuchen, Fehler aufzuspüren.

Wie kann ich mit Ausnahmen in PHP-CPP umgehen? Diese Ausnahmen können dann in Ihrem PHP -Code gefangen und behandelt werden, genau wie jede andere PHP -Ausnahme.

Kann ich PHP-CPP verwenden, um objektorientierte Erweiterungen zu erstellen? Sie können Klassen in Ihrem C -Code definieren, und diese Klassen können dann in Ihrem PHP -Code verwendet werden. Auf diese Weise können Sie sauberen, modularen Code schreiben, der leicht zu warten ist.

Wie kann ich PHP-Funktionen aus meinem C-Code aufrufen? Sie können PHP -Funktionen aus Ihrem C -Code aufrufen. Auf diese Weise können Sie die Leistung der integrierten Funktionen von PHP in Ihrer Erweiterung nutzen.

Kann ich PHP-CPP verwenden, um Erweiterungen zu erstellen, die mit Datenbanken interagieren? CPP zum Erstellen von Erweiterungen, die mit Datenbanken interagieren. Sie müssen jedoch eine C-Datenbankbibliothek verwenden, da PHP-CPP keine integrierte Datenbankfunktionalität bereitstellt.

Wie kann ich meine PHP-Erweiterung verteilen? Wenn Sie Ihre PHP -Erweiterung erstellt haben, können Sie sie verteilen, indem Sie sie als PECL -Paket verpacken. PECL ist ein Repository für PHP -Erweiterungen und bietet eine Standardmethode zum Verteilen und Installieren von Erweiterungen.

Das obige ist der detaillierte Inhalt vonErste Schritte mit der PHP-Erweiterungsentwicklung über PHP-CPP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!