Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

ABI et PImpl : masquer l’implémentation sans promettre une compatibilité binaire complète

PImpl déplace les données d’une classe dans un objet d’implémentation masqué. Il réduit les dépendances aux en-têtes et aide à préserver la disposition de la classe publique, mais ne garantit pas à lui seul la compatibilité ABI. Les mécanismes clés sont un type imbriqué incomplet et un destructeur défini hors de la classe.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

class Widget { struct Impl; std::unique_ptr<Impl> impl_; public: Widget(); ~Widget(); }; // Define Impl, constructor, and destructor in the implementation file.

Une ABI (Application Binary Interface) désigne l’ensemble des règles qui permettent aux composants compilés d’interagir, notamment la disposition des objets, le nommage des symboles et les conventions d’appel. PImpl (pointer to implementation) masque les données derrière un pointeur vers un objet séparé. Modifier les champs de Impl n’ajoute pas de champs à Widget, ce qui aide à préserver une frontière binaire et à réduire les dépendances aux en-têtes. Cela ne constitue toutefois pas une garantie de compatibilité portable entre compilateurs, bibliothèques standard ou paramètres de compilation.

Dans Widget, struct Impl; déclare un type imbriqué incomplet. Un en-tête peut contenir std::unique_ptr<Impl> sans définir Impl, mais son destructeur par défaut exige un type complet au moment de supprimer l’objet. Déclare donc ~Widget(); dans l’en-tête et définis Widget::~Widget() = default; après la définition de Impl dans le fichier d’implémentation : le destructeur est ainsi défini hors de la classe. Le constructeur est lui aussi placé là où le type est complet.

extern "C" spécifie une liaison de langage C pour les noms de fonctions et de variables concernés ainsi que pour les types de fonctions ; il ne masque pas les données et ne donne pas à une classe une disposition compatible avec C. Ce n’est ni un substitut à PImpl ni un commutateur universel de compatibilité ABI. Une interface destinée au C nécessite aussi des types de paramètres adaptés, des règles de propriété et une gestion des erreurs appropriée ; les exceptions C++ ne devraient pas franchir cette frontière.

L’exemple réunit les parties en-tête, implémentation et client dans un seul fichier. Dans une bibliothèque, sépare-les afin que les clients ne voient pas Impl. La copie est explicitement désactivée et le déplacement n’est pas fourni. Si tu ajoutes des opérations de déplacement, définis-les hors de la classe après Impl et précise comment les objets déplacés peuvent être utilisés. Les coûts comprennent une allocation et une indirection supplémentaire. L’exemple utilise l’option C++23 ; le comportement à l’exécution en production n’est pas attesté. Les règles proviennent d’un projet de norme en évolution, et non d’une édition C++23 figée.

Exemples

#include <iostream>
#include <memory>

// Public header section
class Widget {
public:
    Widget();
    ~Widget();
    Widget(const Widget&) = delete;
    Widget& operator=(const Widget&) = delete;
    int value() const;
private:
    struct Impl;
    std::unique_ptr<Impl> impl_;
};

// Implementation section
struct Widget::Impl {
    int value = 42;
};

Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
int Widget::value() const { return impl_->value; }

int main() {
    Widget widget;
    std::cout << widget.value() << '\n';
}

Résultat

42

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources