pimpl 与匿名命名空间兼容吗？

Question

我正在尝试使用 pimpl 模式并在匿名命名空间中定义实现类。这在 C++ 中可能吗？我的失败尝试如下所述。

是否可以在不将实现移动到具有名称（或全局名称）的名称空间中的情况下解决此问题？

class MyCalculatorImplementation;

class MyCalculator
{
public:
    MyCalculator();
    int CalculateStuff(int);

private:
    MyCalculatorImplementation* pimpl;
};

namespace // If i omit the namespace, everything is OK
{
    class MyCalculatorImplementation
    {
    public:
        int Calculate(int input)
        {
            // Insert some complicated calculation here
        }

    private:
        int state[100];
    };
}

// error C2872: 'MyCalculatorImplementation' : ambiguous symbol
MyCalculator::MyCalculator(): pimpl(new MyCalculatorImplementation)
{
}

int MyCalculator::CalculateStuff(int x)
{
    return pimpl->Calculate(x);
}

Answer 1

不，在使用指针类型之前至少必须声明该类型，并且将匿名名称空间放入标头中实际上不起作用。但你为什么要这么做呢？如果你真的想隐藏实现类，请将其设为私有内部类，即

// .hpp
struct Foo {
    Foo();
    // ...
private:
    struct FooImpl;
    boost::scoped_ptr<FooImpl> pimpl;
};

// .cpp
struct Foo::FooImpl {
    FooImpl();
    // ...
};

Foo::Foo() : pimpl(new FooImpl) { }

Answer 2

是的。有一个解决方法可以解决这个问题。将头文件中的指针声明为 void*，然后在实现文件中使用重新解释转换。

注意：这是否是一个理想的解决方法完全是另一个问题。正如人们常说的，我将把它作为练习留给读者。

请参阅下面的示例实现：

class MyCalculator 
{
public:
    MyCalculator();
    int CalculateStuff(int);

private:
    void* pimpl;
};

namespace // If i omit the namespace, everything is OK
{
    class MyCalculatorImplementation
    {
    public:
        int Calculate(int input)
        {
            // Insert some complicated calculation here
        }

    private:
        int state[100];
    };
}

MyCalculator::MyCalculator(): pimpl(new MyCalculatorImplementation)
{
}

MyCalaculator::~MyCalaculator() 
{
    // don't forget to cast back for destruction!
    delete reinterpret_cast<MyCalculatorImplementation*>(pimpl);
}

int MyCalculator::CalculateStuff(int x)
{
    return reinterpret_cast<MyCalculatorImplementation*>(pimpl)->Calculate(x);
}

Answer 3

不，你不能那样做。您必须前向声明 Pimpl 类：

class MyCalculatorImplementation;

并声明该类。如果您随后将定义放入未命名的命名空间中，则会创建另一个类 （匿名命名空间）::MyCalculatorImplementation，它与 ::MyCalculatorImplementation 无关。

如果这是任何其他命名空间 NS，您可以修改前向声明以包含该命名空间：

namespace NS {
    class MyCalculatorImplementation;
}

但是未命名的命名空间，就像它一样神奇，当该标头包含在其中时，将解析为其他内容其他翻译单元（每当您将该标头包含到另一个翻译单元中时，您都会声明一个新类）。

但这里不需要使用匿名名称空间：类声明可能是公共的，但位于实现文件中的定义仅对实现文件中的代码可见。

Answer 4

如果您确实希望在头文件中使用前向声明的类名，并在模块文件中的匿名命名空间中实现，那么请将声明的类设为接口：

// header
class MyCalculatorInterface;

class MyCalculator{
   ...
   MyCalculatorInterface* pimpl;
};



//module
class MyCalculatorInterface{
public:
    virtual int Calculate(int) = 0;
};

int MyCalculator::CalculateStuff(int x)
{
    return pimpl->Calculate(x);
}

namespace {
    class MyCalculatorImplementation: public MyCalculatorInterface {
        ...
    };
}

// Only the ctor needs to know about MyCalculatorImplementation
// in order to make a new one.
MyCalculator::MyCalculator(): pimpl(new MyCalculatorImplementation)
{
}

Answer 5

markshiz 和 quamrana 为以下解决方案提供了灵感。

类实现，旨在在全局头文件中声明，并充当代码库中任何 pimpl 应用程序的 void*。它不在匿名/未命名的命名空间中，但由于它只有析构函数，因此命名空间污染仍然在可接受的范围内。

MyCalculatorImplementation 类 派生自Implementation 类。由于 pimpl 被声明为 std::unique_ptr，因此无需在任何头文件中提及 MyCalculatorImplementation。因此，现在 MyCalculatorImplementation 可以在匿名/未命名命名空间中实现。

好处是 MyCalculatorImplementation 中的所有成员定义都位于匿名/未命名命名空间中。您必须付出的代价是必须将 Implementation 转换为 MyCalculatorImplementation。为此，提供了转换函数toImpl()。
我怀疑是否使用 dynamic_cast 还是 static_cast 进行转换。我猜 dynamic_cast 是典型的规定解决方案；但 static_cast 也可以在这里工作，并且性能可能会更高一些。

#include <memory>

class Implementation
{
public:
  virtual ~Implementation() = 0;
};
inline Implementation::~Implementation() = default;

class MyCalculator
{
public:
  MyCalculator();
  int CalculateStuff(int);

private:
  std::unique_ptr<Implementation> pimpl;
};

namespace // Anonymous
{
class MyCalculatorImplementation
  : public Implementation
{
public:
  int Calculate(int input)
  {
    // Insert some complicated calculation here
  }

private:
  int state[100];
};

MyCalculatorImplementation& toImpl(Implementation& impl)
{
  return dynamic_cast<MyCalculatorImplementation&>(impl);
}
}

// no error C2872 anymore
MyCalculator::MyCalculator() : pimpl(std::make_unique<MyCalculatorImplementation>() )
{
}

int MyCalculator::CalculateStuff(int x)
{
  return toImpl(*pimpl).Calculate(x);
}