Question

我尝试编写一个单例类，这样一个类只需要从它派生并自动单例：

基类：

 template <class T>
 class Singleton
 {
 private:
     static T* instance;
 public:

     static T* getInstance(void)
     {
         if(!instance)
             instance = new T;
         return instance;
     }

     static void release(void)
     {
         if(instance)
         {
             delete instance;
             instance = NULL;
         }
     }
 };

 template <class T>
 T* Singleton<T>::instance = NULL;

我的派生类：

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

class MySingleton : public Singleton<MySingleton>
{
public:
    void helloWorld(void)
    {
        printf("Hello, World!\n");
    }
};

主：

int main(int argc, const char * argv[])
{
    MySingleton* s = MySingleton::getInstance();
    s->helloWorld();
    return 0;
}

这很有效，但它不是一个真正的单例，因为我仍然可以使用它的默认构造函数构造MySingleton。当然，我可以将MySingleton的ctors私有化并宣布Singleton为朋友，但是我有什么方法可以在基类中做到这一点，所以只是派生而不是声明任何ctors就足以构成一个类单身？

Answer 1

由于基类模板必须构造单例对象，因此需要访问具体类的构造函数。因此，该构造函数应该是public或基类必须是具体类的朋友。具体类中的公共Ctor可供所有人访问，因此您无法在编译时禁止其使用。但是，您可以确保在运行时仅调用一次：

template <class T>
class Singleton
{
  /* ... */
  static bool instantiating;
protected:
  Singleton()
  {
    if (!instantiating) //not called in instance() function
      throw std::runtime_error("Don't call me!");
  }

public:
  static T* getInstance()
  {
    intantiating = true;
    instace = new T();
    instantiating = false;
  }
};

template <class T>
bool Singleton<T>::instantiating = false;

注意： - 我在这里使用的instantiating变量不是线程安全的 - instantiating的真/假设置不是例外安全的（new或T::T()可能会抛出） - 将指针用作实例变量是不安全的，容易产生memleaks。考虑使用shared_ptr或参考（Meyers singleton）

基类如何禁用派生类的构造函数

1 个答案: