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.