Pimpl (Pointer to Implementation)

原理

Pimpl 是一种将类的实现细节从头文件中分离出来的技术，通过在类中保留一个指向实现类的指针，将所有私有成员和实现细节隐藏在源文件（.cpp）中。

核心思想：

Widget类 (公开接口，.h文件)
    │
    └──> WidgetImpl类 (具体实现，.cpp文件中定义)
         (通过一个指针关联)

优点

降低编译依赖 - 修改实现细节不需要重新编译依赖该类的其他文件
隐藏实现细节 - 头文件中不暴露私有成员，增强封装性
减少头文件包含 - 实现中用到的头文件不需要暴露给使用者
加快编译速度 - 减少了头文件的传递性包含
二进制兼容性 - 库的ABI更稳定，方便升级

示例代码

不使用 Pimpl（传统方式）

Widget.h

#ifndef WIDGET_H
#define WIDGET_H

#include <string>
#include <vector>
#include <map>  // 即使外部不需要，也必须包含

class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
    
private:
    std::string m_name;           // 修改这些成员
    std::vector<int> m_data;      // 都需要重新编译
    std::map<std::string, int> m_cache;  // 所有依赖此头文件的代码
    int m_secretValue;
};

#endif

问题： 如果修改任何私有成员（比如把 vector 改成 list），所有包含这个头文件的.cpp文件都要重新编译！

使用 Pimpl 方式

Widget.h （对外公开的头文件，极简）

#ifndef WIDGET_H
#define WIDGET_H

#include <memory>  // 只需要这一个标准库

class Widget {
public:
    Widget();
    ~Widget();  // 必须在.cpp中定义（原因见下方说明）
    
    // 支持拷贝（可选）
    Widget(const Widget& other);
    Widget& operator=(const Widget& other);
    
    // 支持移动
    Widget(Widget&& other) noexcept;
    Widget& operator=(Widget&& other) noexcept;
    
    void doSomething();
    int getValue() const;

private:
    class Impl;  // 只做前向声明，不暴露具体实现
    std::unique_ptr<Impl> Pimpl;  // 指向实现的指针
};

#endif

Widget.cpp （实现细节完全隐藏在这里）

#include "Widget.h"
#include <string>
#include <vector>
#include <map>
#include <iostream>

// 具体实现类，完全隐藏，外部不可见
class Widget::Impl {
public:
    std::string m_name = "default";
    std::vector<int> m_data;
    std::map<std::string, int> m_cache;
    int m_secretValue = 42;
    
    void doSomethingImpl() {
        m_data.push_back(m_secretValue);
        std::cout << "Doing something with " << m_name << std::endl;
    }
};

// 构造函数：创建实现对象
Widget::Widget() : Pimpl(std::make_unique<Impl>()) {
}

// 析构函数：必须在这里定义！
// 因为此时Impl的完整定义可见，unique_ptr才能正确析构
Widget::~Widget() = default;

// 拷贝构造：深拷贝实现对象
Widget::Widget(const Widget& other) 
    : Pimpl(std::make_unique<Impl>(*other.Pimpl)) {
}

// 拷贝赋值
Widget& Widget::operator=(const Widget& other) {
    if (this != &other) {
        Pimpl = std::make_unique<Impl>(*other.Pimpl);
    }
    return *this;
}

// 移动构造（默认即可，但也需要在.cpp中定义）
Widget::Widget(Widget&& other) noexcept = default;

// 移动赋值
Widget& Widget::operator=(Widget&& other) noexcept = default;

// 转发调用到实现类
void Widget::doSomething() {
    Pimpl->doSomethingImpl();
}

int Widget::getValue() const {
    return Pimpl->m_secretValue;
}

main.cpp （使用者只需要包含极简的头文件）

#include "Widget.h"
#include <iostream>

int main() {
    Widget w;
    w.doSomething();
    std::cout << "Value: " << w.getValue() << std::endl;
    
    Widget w2 = w;  // 拷贝构造，Impl也被深拷贝
    w2.doSomething();
    
    return 0;
}

关键点说明

1. 为什么析构函数必须在.cpp中定义？

// 错误示范：如果这样写在头文件中
class Widget {
    ~Widget() = default;  // 编译错误！
    std::unique_ptr<Impl> Pimpl;  // Impl只是前向声明，此时是不完整类型
};

unique_ptr 的析构函数需要知道 Impl 的完整定义（调用 delete），而在头文件中 Impl 只是前向声明，所以必须在.cpp文件（此时Impl已完整定义）中定义析构函数。

2. 编译依赖对比图

不使用Pimpl：
Widget.h (包含 <vector> <map> 等) 
    ↑ 被包含
main.cpp, other1.cpp, other2.cpp...
    
修改Widget内部实现 → Widget.h改变 → 所有.cpp都要重新编译


使用Pimpl：
Widget.h (只包含 <memory>)
    ↑ 被包含
main.cpp, other1.cpp, other2.cpp...

Widget.cpp (包含具体实现头文件)
    
修改Widget内部实现 → 只需重新编译Widget.cpp！

3. 性能权衡

方面	传统方式	Pimpl方式
编译速度	慢（依赖多）	快（依赖少）
运行时性能	快（直接访问）	稍慢（多一次指针跳转+堆分配）
二进制大小	-	略大（额外的堆分配）
封装性	弱	强

实际应用场景

Pimpl 特别适合：

大型项目：减少编译时间是刚需
库开发：保持ABI稳定，方便升级不破坏兼容性
减少头文件污染：避免向用户暴露第三方库的头文件依赖

著名案例：Qt框架大量使用Pimpl（称为 d-pointer），几乎每个Qt类背后都有一个私有实现类。

C/C++ PIMPL