C++ 单例类实现问题

代码1中声明了一个静态指针aSingletonClass*instance_uu和一个静态函数void deleteInstance（void）

我没有使用静态指针和静态函数就实现了代码2（我认为没有它也可以实现Singleton，但我不确定！！！）

请告诉我这种改变是否会有危险，在这种情况下，我的程序可能会崩溃

代码1：

class aSingletonClass
{
public:

  static aSingletonClass *getInstance( void )
  {

    if(!instance_)
      instance_ = new aSingletonClass;
    return instance_;
  }

  static void deleteInstance()
  {
    if(instance_)
      delete instance_;
    instance_ = NULL; //important as this can create dead reference problems
  }

private:

  static aSingletonClass *instance_;

  aSingletonClass() {};

  ~aSingletonClass() {};
};

int main()
{
  aSingletonClass *someVar = NULL;

  someVar = aSingletonClass::getInstance();

  aSingletonClass::deleteInstance();

  return 0;
}

代码2：

class A
{
    int x;
    A(int a)
    { x=a;  }

    ~A()
    { }

public:
     static A* start()
     {
       A* ptr1 = new A(3);
       return (ptr1);
     }


     void end()
     {
       delete this;
     }
};

int main()
{
  A* ptr=A::start();

  ptr->end();
}

---

代码2将不是单例。在start（）函数中，返回指向新对象的指针。但是，在end（）函数中，删除此对象。因此，它将不起作用。

您的第二个版本不是单例，因为您没有静态的

a*

指针，只要在调用start（）时返回一个新指针，因此以下内容在您的代码中是有效的：

int main()
{
    A* ptr = A::start();
    A* ptr2 = A::start();
    A* ptr3 = A::start();
    // etc
    ptr->end();
    ptr2->end();
    ptr3->end();
    return 0;
}; // eo main

---

您的代码应该如下所示：

class A    {
  public:
    static A *getInstance( void )
    {
       if(!instance_)
          instance_ = new A();
       return instance_;
    }
    static void deleteInstance()
    {
        if(instance_)
           delete instance_;
        instance_ = NULL; //important as this can create dead reference problems
    }
    static A* start()
    {
        A* ptr1 = A::getInstance();
        ptr1 -> started = true; // check here if A had been started already !!!!
        return (ptr1);
    }

    static void end()
    {
        A* ptr1 = A::getInstance();
        ptr1 -> started = false; // check here if A had ever been started !!!!
        //A::deleteInstance();      // may be it will be useful here
    }
  private:
    bool started = false;
    static A *instance_;
    A() {};
    ~A() {};
};

int main()
{
  A *someVar = NULL;
  someVar = aSingletonClass::getInstance();
  A::deleteInstance();

  return 0;
}

---

啊。这不是单身的好方法

我会做如下的事情

class A
{
private:
  A() {}

public:

  static A& instance()
  {
    static A _inst;
    return _inst;
  }

};

使用

A& inst = A::instance()

将始终返回单个实例

---

编辑：这种方法有几个优点-您不必担心清理，但它是延迟加载（或初始化）的，并且您可以使用引用！见鬼，你甚至可以有一个恒定的单身（为什么，我相信你可以想出一些用法！；）

真是一团糟。。。我重构了一些问题，但呃……您的第二个实现不是单例。我建议您在web上搜索有关该模式的更多信息，了解其局限性和（大量）实现。如果您真的觉得需要单例，至少要确保它不可复制（boost:：noncopyable，或者将复制构造函数和赋值运算符声明设为私有且未定义）Hi Nim，这段代码怎么样..我从你的答案中得到了这个想法（任何差异或影响？？？），但是这里有一个问题，假设有另一个请求a&inst2=a:：instance（）…在这种情况下，我将获得应该被限制的引用。！！inst和inst2现在同时处理同一个对象，这可能会导致错误。根据我的理解，只有当一个删除实例时，另一个才应该获得引用。单例的全部要点是，单个实例可以在许多地方访问。我不明白你第二点的意思（或者你第一点的要求）。如果您对单例具有多线程访问权限，则必须确保锁定任何相关方法。如果您需要在下一次访问之前删除上一个实例，我认为这不是您需要的单例模式！你真的需要重新审视你的设计！