使用运算符重载(新建/删除)实现单例的优缺点

Question

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

所以这是鲁布·戈德堡的方式，

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. 困惑的是，对象实际上并没有用新的
2. 继承是可能的，这将造成混乱来维护单例功能（这可以变成一个功能吗？

Answer 1

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

只是我不想实现经典的私有构造函数[...]

为什么不呢？为什么不遵循最不令人惊讶的规则并使用迈耶斯单身人士？

例如：

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;
};

PS：不公开，我第一次实现"单例"是这样的。在向一所大学解释了半个小时的代码后，他突然问道："你想实现的是单身吗？我不得不承认，当时我不知道什么是单身人士。