c++ - 使用运算符重载(new/delete)实现单例的优点/缺点

Question

我正在复习我的 C++ 知识，我选择实现单例作为起点。只是我不想实现经典的私有(private)构造函数和 static getInstance 方法。

所以这是一个 Rube Goldberg 的方式，

class Singleton : public IDestroy {
    static Singleton* iS; // Singleton instance
    static int count; // number of undeleted objects

    int a;

    public:
    Singleton(int A = 0) {
        if (!iS) {
            a = A;
            iS = this;
        }
        count++;
    }

    void destroy() {delete this;} // way to destroy HeapOnly

    int get() {
        return a;
    }

    static void* operator new(std::size_t size);
    static void operator delete(void* ptr);
    protected:
    // Ensuring construction of HeapOnly objects
    // If object created on stack, there is no control of new operator
    ~Singleton() {
        count--;
        std::cout << "Destroyed, remaining :" << count << std::endl;
    }
};

void* Singleton::operator new(std::size_t size)
{
    if (iS)
        return iS;
    else
        return ::operator new(size);
}

void Singleton::operator delete(void* ptr)
{
    if (!count)
    {
        ::operator delete(ptr);
        iS = 0;
        std::cout << "Cleared memory" << std::endl;
    }
}

Singleton* Singleton::iS = 0;
int Singleton::count = 0;

并与 shared_ptr 一起工作:

class IDestroy
{
    public:
        virtual void destroy() = 0;
};

class HeapOnlyDestroyer {
    public:
        void operator()(IDestroy* s) {
            s->destroy();
        }
};

现在，我可以像这样使用相同的对象:

a = new Singleton(1);
..
a->destroy();

或

shared_ptr<Singleton> s(new Singleton(1), HeapOnlyDestroyer());

我想知道这种方法是否存在任何问题，以及它相对于使用 static getInstance 方法的经典方法的优缺点。

缺点:

1. 令人困惑的是实际上并没有用 new 创建对象
2. 继承可能会造成困惑以维护单例功能(这可以变成一个特性吗？)

Answer 1

首先，此实现的优点是什么？

Just I didn't want to implement the classic private constructor[...]

为什么不呢？为什么不遵循最不意外规则并使用 Meyers Singleton？

例如:

http://www.devarticles.com/c/a/Cplusplus/C-plus-plus-In-Theory-The-Singleton-Pattern-Part-I/4/

class Log {
public:
  static Log& Instance() {
    static Log theLog;
    return theLog;
}
  void Write(char const *logline);
  bool SaveTo(char const *filename);
private:
  Log();          // ctor is hidden
  Log(Log const&);      // copy ctor is hidden
  Log& operator=(Log const&);  // assign op is hidden

  static std::list<std::string> m_data;
};

P.S.:私下里，我第一次实现“单例”是这样的。给一个学院解释了半个小时的代码，突然问:“你要实现的是单例吗？”我不得不承认，当时我并不知道什么是单例。