Question

为什么不选择这个设计：

// A.hpp
class A
{
public:
    void do_something();
};

// A.cpp
#include "A.hpp"
#include <vector>

std::vector<int> impl_database_for_do_something;

static void impl_helper_for_do_something(const std::vector<int>& database){}

void A::do_something(){ impl_helper_for_do_something(impl_database_for_do_something); }

而不是这一个：

// A.hpp
#include <vector>
class A
{
public:
    void do_something();

private:
    std::vector<int> database_for_do_something_;
    void helper_for_do_something(const std::vector<int>& database){}
};

我可以隐藏实现细节并使用源文件中定义的变量和静态函数加速编译吗？如果没有，这个设计有什么问题（除了继承）？

Answer 1

在第一种情况下，整个程序只有一个impl_database_for_do_something实例。你想要每个A实例的一个实例。所以代码在任何意义上都不等同。

Answer 2

如果你按照你的建议使用全局向量存储状态，你将以某种方式确保A类的不同实例使用向量的不同部分（除了这样做的明显困难之外，考虑如果这样做有多困难，不同的线程使用A）的不同实例。如果A是单身，这种设计非常有意义。

Answer 3

您的第一个设计为 A的所有个实例提供了一个向量;后者有一个 per 实例。阅读实例变量与类变量。

Answer 4

这根本不是PIMPL：指向IMPLementation的指针。

你可以这样做：

// A.hpp
#include <boost/shared_ptr.hpp>

class A
{
public:
  A();
  void foo();

private:
  struct Impl;
  boost::shared_ptr<Impl> _impl;
};

// A.cpp
#include <vector>
#include "A.hpp"

struct A::Impl {
  std::vector<int> _data;
};

A::A(): _impl(new std::vector<int>()) {}

void A::foo() {
  _impl->_data.push_back(3);
}

警告：此代码不处理正确的复制/分配行为，而是留给读者练习。

一种更简单的pimpl形式

4 个答案: