单例模式学习[已迁移]

1、例子

如果单例对象是类的static成员，那么在程序结束时不会调用类的析构函数，如下：

#include <iostream>
using namespace std;
 
class A{
private:
    static A* m_ins;//声明，静态指针成员
    A(){}
public:
    static A* getIns(){
        if(m_ins==NULL){
            m_ins=new A();
        }
        return m_ins;
    }
    void test(){
      cout<<"testA\n";
    }
    ~A(){
        cout<<"~A destruction\n";
    }
};

A* A::m_ins=nullptr;//定义
int main()
{
    A* a=A::getIns();
    a->test();
    return 0;
}

输出：

testA

需要在返回前单独添加delete A; 否则是会有内存泄漏的风险的，不过上述的例子，程序结束后，操作系统会回收。

使用new创建对象，需要开发人员手动管理。如果不执行delete，对象和分配的内存将一直存在，直到程序退出后，才由操作系统回收。

将静态指针成员改为函数内的静态变量：

class A{
private:
    A(){}
public:
    static A& getIns(){//返回引用
        static A m_a;
        return m_a;
    }
    static A* getIns(){
    　　static A m_a;
       return & m_a;
    }
};

int main()
{
    A::getIns().test();
    return 0;
}

#输出：
-> % ./Demo
testA
~A destruction

如果使用如下：

    static A* getIns(){
        static A* m_a;
        if(m_a==nullptr){
            m_a = new A();
        }
        return m_a;
    }
main:
A::getIns()->test();