pimpl idiom 比总是使用 unique_ptr 作为成员变量更好吗？

Question

在我的工作场所，我们有这样的约定：几乎每个 class（除了极少数例外）都使用unique_ptr 、原始指针或引用作为成员变量来实现。

这是因为编译时间的原因：通过这种方式，您只需要在 header 文件中为 class 进行前向声明，并且只需将该文件包含在您的 cpp 中。 此外，如果您更改包含在unique_ptr中的 class 的.h 或 .cpp，则无需重新编译。

我认为这种模式至少有以下缺点：

• 它迫使您编写自己的复制构造函数和赋值运算符，如果您想保持复制的语义，您必须单独管理每个变量。
• 代码的语法变得非常繁琐，例如您将使用std::vector<std::unique_ptr<MyClass>>而不是更简单的std::vector<MyPimplClass> 。
• 指针的常量不会传播到指向的 object，除非您使用我无法使用的 std::experimental::propagate_const。

所以我想到建议使用 pImpl 习惯用法作为指针包含的类，而不是在任何地方都使用指针。 通过这种方式，我认为我们可以两全其美：

• 更快的编译时间：pimpl 减少了编译依赖
• 要编写您的复制构造函数和复制赋值运算符，您只需执行以下操作：

A::A(const A& rhs) : pImpl(std::make_unique<Impl>(*rhs.pImpl)) {}
A& A::operator=(const A& rhs) {
  *pImpl = *rhs.pImpl;
  return *this;
}

• 常量被传播到成员 object。

在这一点上，我与我的同事进行了讨论，他们认为 pImpl 并不比在任何地方使用指针更好，原因如下：

• 与使用指针相比，它减少了编译依赖性，因为如果您使用 pImpl，则在更改公共接口时必须重新编译包含 pImpl class 的类：如果您只使用指针而不是 pImpl class，则不需要即使更改 header 文件时也要重新编译。

现在我有点困惑。 我认为我们的实际约定并不比 pImpl 更好，但我无法解释为什么。

所以我有一些问题：

• 在这种情况下，pImpl 成语是一个不错的选择吗？
• 除了我提到的那些之外，我们使用的模式还有其他缺点吗？

编辑：我正在添加一些示例来阐明这两种方法。

• 以unique_ptr作为成员的方法：

// B.h
#pragma once
class B {
    int i = 42;
public:
    void print();
};

// B.cpp
#include "B.h"
#include <iostream>
void B::print() { std::cout << i << '\n'; }

// A.h
#pragma once
#include <memory>
class B;
class A {
    std::unique_ptr<B> b;
public:
    A();
    ~A();
    void printB();
};

// A.cpp
#include "A.h"
#include "B.h"
A::A() : b{ std::make_unique<B>() } {}
A::~A() = default;
void A::printB() {  b->print(); }

• 使用 pImpl 的方法：

// Bp.h
#pragma once
#include <memory>
class Bp {
    struct Impl;
    std::unique_ptr<Impl> m_pImpl;
public:
    Bp();
    ~Bp();
    void print();
};

// Bp.cpp
#include "Bp.h"
#include <iostream>
struct Bp::Impl {
    int i = 42;
};
Bp::Bp() : m_pImpl{ std::make_unique<Impl>() } {}
Bp::~Bp() = default;
void Bp::print() {  std::cout << m_pImpl->i << '\n'; }

// Ap.h
#pragma once
#include <memory>
#include "Bp.h"
class Ap {
    Bp b;
public:
    void printB();
};

// Ap.cpp
#include "Ap.h"
#include "Bp.h"
void Ap::printB() { b.print(); }

主要的：

// main.cpp
#include "Ap.h"
#include "A.h"

int main(int argc, char** argv) {
    A a{};
    a.printB();

    Ap aPimpl{};
    aPimpl.printB();
}

此外，当我说第一种方法我们不需要重新编译时，我想更加准确，这是不准确的。 的确，我们需要重新编译更少的文件：

• 如果我们改变 Bh，我们只需要重新编译 A.cpp、B.cpp。
• 如果我们改变 Bp.h 我们需要重新编译 Ap.cpp、Bp.cpp 和 main.cpp

Answer 1

过了一段时间，我对这个问题有了更广泛的理解，终于可以回答我自己的问题了。

事实证明，我所说的并不完全正确。

实际上在下面的代码中只有Bp class 是 pImpl。 如果我们把Ap也改成 pImpl 我们就得到了，如果我们改变 Bp.h 我们只需要重新编译 Ap.cpp、Bp.cpp，这与具有unique_ptr s 的相应解决方案相同。

话虽如此，我想我可以说 pImpl 的解决方案通常看起来比unique_ptr的解决方案更好（我们只需要 pImpl 正确的类。）。

出于这个原因，我们决定切换到 pImpl idiom 作为我们类的默认设置。