Question

在代码1中声明了一个静态指针aSingletonClass * instance_和一个静态函数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();
}

Answer 1

您的第二个版本不是单例，因为您没有静态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

Answer 2

唉。做单身人士不是一个好方法！

我会做以下事情......

class A
{
private:
  A() {}

public:

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

};

使用，

A& inst = A::instance()

将始终返回单个实例！

编辑：这种方法有几个优点 - 你不必担心清理，但它是懒惰加载（或初始化），你使用引用！哎呀，你甚至可以有一个不变的单身人士（为什么，我相信你能想到一些用途！;）

Answer 3

代码2不是单身人士。在start（）函数中，返回指向新A对象的指针。但是，在end（）函数中，您删除此对象。所以，它不会起作用。

Answer 4

您的代码应该是这样的：

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

单例类实现问题

4 个答案: