Développement d'extension PHP avec PHP-CPP: code orienté objet

Cet article poursuit l'exploration de la construction d'extensions de PHP à l'aide de PHP-CPP, en se concentrant sur les fonctionnalités orientées objet. Nous allons créer une classe de nombres Complex pour illustrer les capacités de la bibliothèque.

Pour commencer, nous adapterons le modèle de projet PHP-CPP. Renommer yourtextension.ini à complex.ini et mettre à jour son contenu vers extension=complex.so. Modifiez le Makefile comme suit:

<code class="language-makefile">NAME                =   complex
INI_DIR             =   /etc/php5/cli/conf.d</code>

Ensuite, nous définirons la classe Complex dans main.cpp.

Concepts clés:

• PHP-CPP simplifie le développement d'extension PHP orienté objet en utilisant la syntaxe C familière.
• La classe Complex présente les constructeurs / destructeurs de style C et PHP pour l'intégration transparente.
• Des méthodes comme mod() et add() démontrent l'enregistrement des méthodes, permettant aux scripts PHP d'utiliser directement les fonctionnalités de la classe C.
• PHP "Méthodes magiques" (par exemple, __toString()) Améliorez l'interaction avec les objets dans les scripts PHP.
• L'article fournit un guide complet pour configurer, compiler et tester les extensions PHP.

CONTRUMORS / DESTRUCTEURS PHP:

C utilise des constructeurs (fonctions avec le nom de classe, pas de type de retour) et destructeurs (nom de classe préfixé avec ~, pas de type de retour, pas de paramètres). PHP utilise __construct() et __destruct(). PHP-CPP prend en charge les deux:

<code class="language-cpp">class Complex : public Php::Base {
private:
    double r = 0, i = 0;

public:
    Complex() {}
    virtual ~Complex() {}

    Php::Value getReal() { return r; }
    Php::Value getImage() { return i; }

    void __construct(Php::Parameters &params) {
        if (params.size() == 2) {
            r = params[0];
            i = params[1];
        } else {
            r = 0;
            i = 0;
        }
    }
    // ... other methods ...
};</code>

Points importants:

1. Toutes les classes doivent hériter de Php::Base.
2. Les constructeurs de style C et PHP sont implémentés.
3. getReal() et getImage() donner accès aux membres privés.
4. Le constructeur PHP gère l'initialisation.

mod() Méthode:

Cette méthode calcule le module d'un nombre complexe:

<code class="language-cpp">Php::Value mod() const {
    return (double)sqrt(r * r + i * i);
}</code>

N'oubliez pas d'inclure <cmath></cmath> pour sqrt(). PHP-CPP prend en charge les signatures de fonction des membres spécifiques (voir l'article pour plus de détails).

add() Méthode:

Ajout de deux nombres complexes:

<code class="language-cpp">Php::Value add(Php::Parameters &params) {
    Php::Value t = params[0];
    Complex *a = (Complex *)t.implementation();

    r += (double)a->getReal();
    i += (double)a->getImage();

    return this;
}</code>

t.implementation() est crucial pour couler un Php::Value à son objet C sous-jacent.

__toString() Méthode:

pour la sortie conviviale:

<code class="language-cpp">Php::Value __toString() {
    std::ostringstream os;
    os << r;
    if (i >= 0) os << "+";
    os << i << "i";
    return os.str();
}</code>

Inclure <sstream></sstream> pour la manipulation des cordes.

Enregistrement de la fonction:

Enregistrer la classe et ses méthodes:

<code class="language-cpp">extern "C" {
    PHPCPP_EXPORT void *get_module() {
        static Php::Extension myExtension("complex", "1.0");
        Php::Class<complex> complex("Complex");
        complex.method("mod", &Complex::mod, {});
        complex.method("__construct", &Complex::__construct);
        complex.method("add", &Complex::add, {Php::ByVal("op", "Complex", false, true)});
        myExtension.add(std::move(complex));
        return myExtension;
    }
}</complex></code>

Compilation, installation et test:

Compiler et installer en utilisant make && sudo make install. Tester avec le code PHP (voir l'article d'origine pour les exemples).

Encapsulation de l'espace de noms:

Envelopper la classe dans un espace de noms (trComplex dans cet exemple) nécessite des modifications minimales (voir l'article d'origine pour plus de détails). La clé consiste à ajuster l'espace de noms dans la fonction get_module() et à utiliser le nom entièrement qualifié dans le code PHP.

Conclusion:

PHP-CPP offre une approche rationalisée pour créer des extensions de PHP. Bien que les améliorations de la documentation soient suggérées, sa facilité d'utilisation et ses fonctionnalités en font un outil précieux. L'article fournit un guide complet, couvrant les aspects essentiels du développement d'extension PHP orienté objet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!