Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

ABI e PImpl: nascondere l’implementazione senza promettere una compatibilità binaria completa

PImpl sposta i dati di una classe in un oggetto di implementazione nascosto. Riduce le dipendenze dagli header e aiuta a preservare il layout della classe pubblica, ma da solo non garantisce la compatibilità ABI. I meccanismi chiave sono un tipo annidato incompleto e un distruttore definito fuori dalla classe.

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

Sintassi

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

Un’ABI (Application Binary Interface) è l’insieme di regole che consente ai componenti compilati di interagire e comprende layout degli oggetti, nomi dei simboli e convenzioni di chiamata. PImpl (pointer to implementation) nasconde i dati dietro un puntatore a un oggetto separato. Modificare i campi di Impl non aggiunge campi a Widget, aiutando a preservare un confine binario e a ridurre le dipendenze dagli header. Questo, tuttavia, non è una garanzia di compatibilità portabile tra compilatori, librerie standard o impostazioni di compilazione.

All’interno di Widget, struct Impl; dichiara un tipo annidato incompleto. Un header può contenere std::unique_ptr<Impl> senza definire Impl, ma il suo deleter predefinito richiede un tipo completo quando l’oggetto viene eliminato. Dichiara quindi ~Widget(); nell’header e definisci Widget::~Widget() = default; dopo la definizione di Impl nel file di implementazione: il distruttore è così definito fuori dalla classe. Anche il costruttore è collocato dove il tipo è completo.

extern "C" specifica il linkage del linguaggio C per i nomi applicabili di funzioni e variabili e per i tipi di funzione; non nasconde i dati né conferisce a una classe un layout compatibile con C. Non sostituisce PImpl e non è un interruttore universale per la compatibilità ABI. Un’interfaccia destinata al C richiede anche tipi di parametri adeguati, regole di proprietà e gestione degli errori; le eccezioni C++ non dovrebbero oltrepassare tale confine.

L’esempio riunisce le sezioni di header, implementazione e client in un unico file. In una libreria, separale affinché i client non vedano Impl. La copia è disabilitata esplicitamente e la classe non offre operazioni di spostamento (move). Se aggiungi operazioni di spostamento, definiscile fuori dalla classe, dopo la definizione di Impl, e specifica come si possono usare gli oggetti da cui si è effettuato lo spostamento. I costi comprendono un’allocazione e un’indirezione aggiuntiva. L’esempio usa l’opzione C++23; il comportamento in esecuzione in produzione non è attestato. Le regole provengono da una bozza di lavoro in evoluzione, non da un’edizione C++23 congelata.

Esempi

#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';
}

Risultato

42

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti