PImpl

来自cppreference.com
< cpp‎ | language
 
 
C++ 语言
 

“指向实现的指针”或“ pImpl ”是一种 C++ 编程技巧[1],它将类的实现细节放到分离的、以不透明指针访问的类中,以从其对象表示中移除实现细节:

// widget.h (接口)
class widget {
    // 公开成员
private:
    struct impl;  // 实现类的前置声明
    // 一种实现示例:见后述其他设计选项和权衡
    std::experimental::propagate_const< // 转发 const 的指针包装器
        std::unique_ptr<                // 唯一所有权的不透明指针
            impl>> pImpl;               // 指向前置声明的实现类
};
 
// widget.cpp (实现)
struct widget::impl {
   // 实现细节
};

此技巧用于构造拥有稳定 ABI 的 C++ 库接口,及减少编译时依赖。

目录

[编辑] 解释

因为类的私有数据成员参与其对象表示,影响大小和布局,而且因为类的私有成员函数参与重载决议(这在成员访问检查前发生),故任何对实现细节的更改要求该类的所有用户重编译。

pImpl 打破此编译依赖;更改实现不导致重编译。后续结果是,若库于其 ABI 使用 pImpl ,则库的新版本可以更改实现,并且与旧版本保持 ABI 兼容。

[编辑] 得失权衡

pImpl 技法的备选方案是

  • 内联实现:私有成员和公开成员是同一类的成员
  • 纯虚类( OOP 工厂):用户获得到轻量级或纯虚类的唯一指针,实现细节在覆写其虚成员函数的导出类中。

[编辑] 编译防火墙

简单情况下, pImpl 和工厂方法都会打破实现和类接口用户的编译时依赖。工厂方法穿件一个隐藏的虚表,故而重排、添加或溢出虚函数会打破 ABI 。 pImpl 方法没有隐藏的依赖,然而若实现类是类模板特化,则丧失编译防火墙的优势:接口的用户必须观测整个模板定义,以实例化正确的特化。此情况下常见的设计方法是以避免参数化的方式重构实现,这是《 C++ 核心方针》的另一种使用情况 T.61 勿过分参数化成员T.84 使用非模板核心实现以提供 ABI 稳定的接口

例如,下列类模板在其私有成员或 push_back 体内中不使用类型 T

template<class T>
class ptr_vector {
    void **beg, **end, **cap;
public:
    void push_back(T* p) {
        if (end == cap) reallocate(end - beg + 1);
        *end++ = p;
    }
};

从而能原态传送私有成员给实现,而且 push_back 能转发到也不于接口使用 T 的实现:

// 头文件( ptr_vector.h )
class ptr_vector_base {
    struct impl; // 不依赖 T
    std::unique_ptr<impl> pImpl;
 protected:
    void push_back_fwd(void*);
    ... // 见特殊成员函数的实现章节
};
template<class T>
class ptr_vector : private ptr_vector_base {
public:
    void push_back(T* p) { push_back_fwd(p); }
};
 
// 源文件( ptr_vector.cpp )
struct ptr_vector_base::impl {
    void **beg, **end, **cap;
    void push_back(void* p) {
        if (end == cap) reallocate(end - beg + 1);
        *end++ = p;
    }
    void reallocate(size_t sz) { ... }
};
void ptr_vector_base::push_back_fwd(void* p) { pImpl->push_back(p); }
ptr_vector_base::ptr_vector_base() : pImpl(std::make_unique<impl>()) {}

[编辑] 运行时开销

  • 访问开销: pImpl 中,每个私有成员函数都通过指针间接使用。每个私有成员对公开成员的访问通过另一个指针间接进行。两个访问都跨翻译单元边界,从而只能被链接时优化优化掉。注意 OO 工厂要求跨翻译单元的间接使用,以一同访问公开数据和实现细节,并甚至因虚派发,给予链接时优化器更少机会。
  • 空间开销: pImpl 添加一个指针到公开组分,并且若任何私有成员需要访问公开成员,则要么添加另一个指针到实现组分,要么对于每个要求它的私有成员在每次调用传递另一个指针。若支持有状态自定义分配器,则必须一同存储分配器实例。
  • 生存期管理开销: pImpl (还有 OO 工厂)将实现对象放在堆上,这在构造与析构强加了运行时开销。这可以部分地为自定义分配器所弥补,因为 pImpl (但非 OO 工厂)的大小在编译时已知。

另一方面, pImpl 类是对移动友好的;重构大类为可移动 pImpl 可以提升操作保有这些对象的容器的算法性能,虽然可移动 pImpl 拥有额外的运行时开销:任何在被移动对象上容许并需要访问私有实现的公开成员函数必须有空指针检查。

[编辑] 维护开销

pImpl 的使用要求特别设计的分配单元(唯头文件的库不能使用 pImpl ),引入额外额类,一组转发函数,且若使用分配器,则需暴露用于公开接口的分配器细节。

因为虚成员是 pImpl 的接口组分,故模拟 pImpl 意味着单独模拟接口组分。可测试的 pImpl 典型地被设计为允许通过可用接口完整覆盖测试。

[编辑] 实现

作为接口类型的对象控制实现类型对象的生存期,指向实现的指针通常是 std::unique_ptr

因为 std::unique_ptr 要求被指向类型在任何调用删除器的语境下是完整类型,析构函数和复制/移动赋值运算符必须为用户声明,并越界定义于实现文件,其中实现类型是完整的。这压制了移动构造函数,使它必须被定义或为默认。

因为在通过非 const 成员指针调用 const 成员函数时,会调用实现函数的非 const 重载,故该指针必须包装于 std::experimental::propagate_const 或等价者中。

将所有私有数据成员和所有私有非虚成员函数置于实现类中。将所有公开、受保护和虚成员留于接口类(替用的讨论见 GOTW #100 )。

若任何私有成员需要访问公开或受保护成员,则可以将指向接口的引用或指针作为参数传递给私有函数。另外,也可以将回溯引用作为实现类的一部分维持。

若有意使用非默认分配器以支持实现对象的分配,则可以工具化任何常用的具分配器模式,包含默认为 std::allocator 的分配器模板形参,及类型为 std::pmr::memory_resource* 的构造函数参数。

[编辑] 示例

以 const_propagation 演示 pImpl ,带作为参数传递的回溯引用,不具分配器,并启用不带运行时检查的移动

#include <iostream>
#include <memory>
#include <experimental/propagate_const>
 
// 接口( widget.h )
class widget {
    class impl;
    std::experimental::propagate_const<std::unique_ptr<impl>> pImpl;
 public:
    void draw() const; // 将转发到实现的公开 API
    void draw();
    bool shown() const { return true; } // 实现必须调用的公开 API
    widget(int);
    ~widget(); // 定义于实现文件,其中 impl 是完整类型
    widget(widget&&) = default;  // 注意:在被移动的对象上调用 draw() 是 UB
    widget(const widget&) = delete;
    widget& operator=(widget&&); // 定义于实现文件
    widget& operator=(const widget&) = delete;
};
 
// 实现( widget.cpp )
class widget::impl {
    int n; // 私有数据
 public:
    void draw(const widget& w) const {
        if(w.shown()) // 对成员函数的此调用要求回溯引用
            std::cout << "drawing a const widget " << n << '\n';
    }
    void draw(const widget& w) {
        if(w.shown())
            std::cout << "drawing a non-const widget " << n << '\n';
    }
    impl(int n) : n(n) {}
};
void widget::draw() const { pImpl->draw(*this); }
void widget::draw() { pImpl->draw(*this); }
widget::widget(int n) : pImpl{std::make_unique<impl>(n)} {}
widget::~widget() = default;
widget& widget::operator=(widget&&) = default;
 
// 用户( main.cpp )
int main()
{
    widget w(7);
    const widget w2(8);
    w.draw();
    w2.draw();
}

输出:

drawing a non-const widget 7
drawing a const widget 8

[编辑] 注意

[编辑] 引用

  1. GotW #100 :编译防火墙