static小结

static的引入

static 是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性。
函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题:如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。而static变量可以保持该变量的值，使得函数在下次调用时还保持上次函数退出时的值。

static内部机制

static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。

static的优势：

可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

static类成员

类的对象构建过程不会动到static变量和函数，因为它存在静态内存，程序加载进内存的时候它就存在；而对象生命周期不同。

static数据成员

static数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
static数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）,也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
static数据成员必须在类定义体的外部定义（正好一次）。不像普通数据成员，static成员不是通过类构造函数进行初始化，而是应该在定义时进行初始化。

• 在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。
• 静态数据成员可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。
• 初始化格式为 <数据类型><类名>::<静态数据成员名>=<值> 。初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆。

static成员函数

• 在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。如果静态成员函数中要引用非静态成员时，可通过对象来引用。
• 静态成员函数，不属于任何一个具体的对象，那么在类的具体对象声明之前就已经有了内存区，而非静态数据成员还没有分配内存空间，那么在静态成员函数中使用非静态成员函数，就好像没有声明一个变量却提前使用它一样。
• static成员函数没有this指针，不能被声明为const，不能被声明为虚函数。

单例模式(Singleton)

介绍

单例(Singleton)模式是保证一个类仅有一个实例，并提供一个访问它的全局访问点。
有很多地方需要这样的功能模块，如系统的日志输出，GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。
Singleton模式让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建（通过截取创建新对象的请求），并且它可以提供一个访问该实例的方法。

适用性

• 当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。
• 当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个
  扩展的实例时。

结构

singleton

实现

保证一个唯一的实例

将创建唯一实例的操作隐藏在一个类操作（即一个静态成员函数）后面，由它保证只有一个实例被创建。这个操作可以访问保存唯一实例的变量，而且它可以保证这个变量在返回值之前用这个唯一实例初始化。
在C++中，你可以用Singleton类的静态成员函数Instance来定义这个类操作。Singleton还定义一个静态成员变量_instance，它包含了一个指向它的唯一实例的指针。
Singleton类定义：

class Singleton{
    public:
    static Singleton* Instance();
    protected:
    Singleton();
    //构造函数为protected，当试图直接实例化Singleton类时，会得到编译时的错误信息
    //保证仅有一个实例可以被创建
    private:
    static Singleton* _instance;
};

Singleton* Singleton::_instance = 0;
Singleton* Singleton::Instance() {
    if(_instance == 0){
        _instance = new Singleton;
    }
    return _instance;
}

释放Singleton对象

单例类Singleton有以下特征：
它有一个指向唯一实例的静态指针_pInstance，并且是私有的；
它有一个公有的函数，可以获取这个唯一的实例，并且在需要的时候创建该实例；
它的构造函数是私有的，这样就不能从别处创建该类的实例。

我们需要一种方法，正常的删除该实例
一个妥善的方法是让这个类自己知道在合适的时候把自己删除，或者说把删除自己的操作挂在操作系统中的某个合适的点上，使其在恰当的时候被自动执行。
程序在结束的时候，系统会自动析构所有的全局变量。事实上，系统也会析构所有的类的静态成员变量，就像这些静态成员也是全局变量一样。利用这个特征，我们可以在单例类中定义一个这样的静态成员变量，而它的唯一工作就是在析构函数中删除单例类的实例。

class CSingleton  
{  
private:  
    CSingleton()  
    {  
    }  
    static CSingleton *m_pInstance;  
    class CGarbo   //它的唯一工作就是在析构函数中删除CSingleton的实例  
    {  
    public:  
        ~CGarbo()  
        {  
            if(CSingleton::m_pInstance)  
                delete CSingleton::m_pInstance;  
        }  
    };  
    static CGarbo Garbo;  //定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数  
public:  
    static CSingleton * GetInstance()  
    {  
        if(m_pInstance == NULL)  //判断是否第一次调用  
            m_pInstance = new CSingleton();  
        return m_pInstance;  
    }  
};

类CGarbo被定义为CSingleton的私有内嵌类，以防该类被在其他地方滥用。
程序运行结束时，系统会调用CSingleton的静态成员Garbo的析构函数，该析构函数会删除单例的唯一实例。

使用这种方法释放单例对象有以下特征：
在单例类内部定义专有的嵌套类；
在单例类内定义私有的专门用于释放的静态成员；
利用程序在结束时析构全局变量的特性，选择最终的释放时机；
使用单例的代码不需要任何操作，不必关心对象的释放。

创建Singleton类的子类(单件注册表方法)

使用单件注册表（registry of singleton），使得singleton类可以根据名字在一个众所周知的注册表中注册它们的单件实例。
这个注册表在字符串名字和单件之间建立映射。当Instance需要一个单件时，它参考注册表，根据名字请求单件。

class Singleton{
public:
    static void Register(const char* name, Singleton *);
    static Singleton* Instance();
protected:
    static Singleton* Lookup(const char* name);
private:
    static Singleton* _instance;
    static List<NameSingletonPair>* _registry;
};

Register以给定的名字注册Singleton实例。为保证注册简单，我们将它存储一列NameSingletonPair对象。 每个NameSingletonPair将一个名字映射到一个单件。Lookup操作根据给定单件的名字进行查找。

Singleton* Singleton::Instance(){
    if(_instance == 0){
        const char* singletonName = getenv("SINGLETON");
        //environment supplies this at startup
        _instance = Lookup(singletonName);
        //Lookup returns 0 if there‘s no such singleton
    }   
    return _instance;
}

Singleton类可以在构造函数中来注册自己。

MySingleton::MySingleton() {
    Sinleton::Register("MySingleton",this);
}

由此，Singleton类不再负责创建单件。它的主要职责是使得供选择的单件对象在系统中可以被访问。

【编程拾遗】C++的static成员函数与单例模式