C++ 单例实现 : pimpl idiom for singletons, 优点和缺点

Question

在 C++ 中实现单例时，我看到两种存储实现数据的方法:

(A) 将所有实现数据放在私有(private)部分并像往常一样实现类
(B) “单例的 pimpl 习语”:通过将实现数据放置到“Impl”结构中来隐藏实现数据，该结构可以在实现文件中定义。私有(private)部分仅包含对实现结构的引用。

这是一个概念代码，用于阐明我所说的 (A) 和 (B) 实现选项的含义:

(A) 单例类成员.hpp :

// a lot of includes required by private section
#include "HelperClass1.hpp"
#include "HelperClass2.hpp"
// some includes required by public section
// ...
class SingletonClassMembers {
public:
    static SingletonClassMembers& getInstance();
    // public methods
private:
   SingletonClassMembers ();
   ~SingletonClassMembers();
   SingletonClassMembers (const SingletonClassMembers&); //not implemented
   SingletonClassMembers& operator=(const SingletonClassMembers&); //not implemented
   HelperClass1 mMember1;
   HelperClass2 mMember2; //and so on

(A) SingletonClassMembers.cpp :

#include "SingletonClassMembers.hpp"
SingletonClassMembers& getInstance() { 
    static SingletonClassMembers sImpl; 
    return sImpl; 
}

(B) SingletonHiddenImpl.hpp :

// some includes required by public section
// ...
class SingletonHiddenImpl {
public:
    static SingletonHiddenImpl& getInstance();
    // public methods
private:
   SingletonHiddenImpl ();
   ~SingletonHiddenImpl ();
   SingletonHiddenImpl (const SingletonHiddenImpl&); //not implemented
   SingletonHiddenImpl& operator=(const SingletonHiddenImpl&); //not implemented
   struct Impl;
   Impl& mImpl;
};

(B) SingletonHiddenImpl.cpp :

#include "SingletonHiddenImpl.hpp"
#include "HelperClass1.hpp"
#include "HelperClass2.hpp"<p></p>

<p>struct SingletonHiddenImpl::Impl {
    HelperClass1 member1;
    HelperClass2 member2;
};
static inline SingletonHiddenImpl::Impl& getImpl () {
    static Impl sImpl;
    return sImpl;
}
SingletonHiddenImpl::SingletonHiddenImpl ()
: mImpl (getImpl())
{
}
</p>

因此，使用 (B) 方法，您可以更好地隐藏实现细节，并且(与普通类的 pimpl 习惯用法不同)没有性能损失。我无法想象 (A) 方法更合适的条件

问题是，将实现数据存储为类成员(A)有什么好处？

谢谢

Answer 1

使用案例 A 有以下好处:

1. 您减少类 SingletonClassMembers 和 SingletonHiddenImpl 之间的依赖性。
2. 如果您尝试通过依赖注入(inject)避免对 (1) 的限制，则无需在类 SingletonClassMembers 中创建配置器模式
3. 这种情况很弱，但无论如何:维护单个类很简单
4. 在多线程环境中，您需要同时支持两种类同步机制，而在单类中，只需要单锁。