再请问这种new出来的静态指针怎么delete(静态成员函数返回的)

例如:
class base
{
public:
  ...
  void print();
  static base* instance() { static base* ptr = new base();  
                            return ptr; }
....
};

int main()
{
   base::instance()->print();        // using this pointer
   ...
   return 1;
}

12 个解决方案

#1

进行强制类型转换！

#2

强制类型转换？？？我 ft

因为是 Singleton ，这个类在整个程序生命周期中也不会产生第二个 Instance，所以不必 delete 也不会造成内存泄露（或者说，这样的泄露可以忽略）。

#3

int main()
{
// base::instance()->print(); // using this pointer
// 必须保存指针值以便在使用完后释放分配的内存空间，所以做以下调整：
base* pb;
pb = base::instance();
pb->print();

// ...

delete pb;

// return 1; // return 1; 表示非正常的退出；正常的退出应该是 return 0;
return 0;
}

#4

还是三楼的说法和我的想法比较近.
四楼这样做在一个函数里面可以,但实际上我是在一个cpp文件里面用,这样会增加一个全局的变量,最后还是没地方删啊.如下
static base* pb = base::instance();

void func1() {   // using pb }
void func2()  {  // using  pb }
....

#5

同意楼上

#6

刚开始没注意到通过 instance 创建类的特点。经过Wolf0403(完美废人)的提醒，注意到了调用 instance 不会产生第二个实例的特点。但是不同意他说的可以忽略这样的内存泄漏的说法：new 过的内存还是要用 delete 来回收的。

由于 instance 第一次调用的时候会创建一个新的对象，但是在其后的调用中只是简单地返回原来创建的对象的地址，并不会再次创建新的对象。根据这个特点，可以在使用完这个对象之后不用变量保存对象的地址，而直接进行如下的释放内存的操作：

delete base::instance();

#7

Singleton没必要new了再delete再new再delete

#8

>> Singleton没必要new了再delete再new再delete

对于Singleton，你不可能 new 第二次，实际上你只能 new 一次。因此，象你上面说的 new -> delete -> new -> delete 是不存在的。

问题是：对于 new 的对象，一定要 delete （在不再需要的时候），否则就造成内存泄漏。这是一个基本原则吧。除非你象上面 Wolf0403(完美废人) 说的那样容忍这个内存泄漏。这是一个好的做法吗？除非你是在做简单的测试程序，我想你也不会允许你的代码中有内存泄漏这样错误的存在吧。

#9

哈哈，又见singleton，其实singleton实现成这样麻烦的方式有自找苦吃的意味

创建singleton的方式多着呢，何苦用这种方式？这样利用的是static类型数据的特殊性，因为它的初始化只会被执行一次。

我认为它的delete是必要的，因为如果这个单件类如果做了其他的行为，譬如申请硬件资源之类的，而且它的产生是来自于operator new()，编译器不会负责调用这个单件的destructor，这样的话就不仅仅是内存泄漏了，这可能造成系统的崩溃。

如果你想要释放这个类的话，写一个成员函数，然后里面放入delete this;这句就OK了

#10

template <typename T>
class Singleton
{
public:
  static T * getInst() { if (!ptr_) {ptr_ = new T(); } ++cnt_; return ptr_; }
  static void releaseInst(T * _p) { if (0 == --cnt_) {delete ptr_; }
private:
  static T * ptr_;
  static size_t cnt_;
};
这样好了？简单的 ref-count

#11

少了个花括号：（

#12

这个还是singleton吗？怎么变成容器类了？