Question

我正在刷新我的C ++知识，我选择实现单例作为起点。我只是不想实现经典的私有构造函数＆amp; 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方法的经典方式的优缺点。

缺点：

实际上并没有用新的
继承可能会造成混乱以维护单例功能（可以将其转换为功能吗？）

Answer 1

首先，此实施的专业是什么？

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

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

e.g：

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。：关闭记录，我第一次实施＆＃34; singleton＆＃34;是这样的在向大学解释代码半小时之后，突然他问：＆＃34;它是一个单身人士，你想要达到什么目标？＆＃34;我不得不承认，当时我不知道，单身是什么。

使用运算符重载（new / delete）实现Singleton的优点/缺点

1 个答案: