c++小心得之1： 静态成员变量、静态成员函数和单例模式

今天在看单例模式时，看到了有静态成员变量和静态成员函数的使用，发现不太熟悉，特意去熟悉了下，现贴些自己的心得；

拿单例模式代码来说明；

            静态数据成员是类的成员，而不是对象的成员，所有该类对象都共用该数据成员，可以实现同类对象之间进行数据共享。

            静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。

　　1、静态数据成员在定义或声明时前面加关键字static。

               eg:     static  CSingleton *p;

　　2、静态变量的初始化f方式:

　　　　<数据类型><类名>::<静态数据成员名>=<值>  

               eg:                   CSingleton*   CSingleton::p = NULL;

　　初始化在类外实现，不能在头文件中，前面不加static，需要使用作用域运算符来标明它所属类；

       3、类外引用静态数据成员时，采用如下格式：

　　　         <类名>::<静态成员名>   

静态数据成员优点： 因为它是所有对象所公有的，可以节省内存，可以提高时间效率。

静态成员函数：

      1. 静态成员函数可以通过类名直接访问；

      2.静态成员函数可以通过对象访问

      3. 静态成员函数只能直接访问静态成员变量（函数），不能直接访问普通成员变量（函数）；

      4.静态成员函数不属于任何对象，故静态成员函数没有this指针；

静态成员和静态成员函数可以用来统计生成的类对象数量，没创建任何对象数量就是0；

 

在单例模式中，将构造函数设为private， 无法通过new创建对象；

好在类的静态成员函数不需要创建对象即可运行，而静态成员函数又属于类的一部分，这样就可以调用构造函数构造对象了，并且通过对静态成员变量的判断，确保了该类只能通过静态成员函数生成唯一的一个对象，这就是单例模式的原理。

单例模式构建要素：

1.私有的构造函数；

2. 静态的自身类引用；

3. 提供静态的外部接口；

单例模式应用场景：

　　（1）资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如日志文件，应用配置。

　　（2）控制资源的情况下，方便资源之间的互相通信。如线程池等。

单例模式应用实例：

1. Windows的Task Manager（任务管理器）是很典型的单例模式；

2. windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。

3. 网站的计数器，一般也是采用单例模式实现，否则难以同步。

4. 应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。

5. Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。

6. 数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。

7. 多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。

8. 操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。

9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.

单例分为懒汉式单例和饿汉式单例，如果实例是new出来的，需要注意实例的释放；

懒汉式单例： 在需要的时候，才创建对象，这是一种时间换空间的方式，如以下代码；

#include <iostream>
using namespace std;

class   CSingleton
{
private:
    CSingleton()
    {

    }
    static  CSingleton *p;
public:
    static CSingleton* getInstance()
    {
        if(p == NULL)
        {
            p = new CSingleton();
        }
        return p;
    }
};

CSingleton*  CSingleton::p = NULL;

int main(void)
{
    CSingleton* t     = CSingleton::getInstance();
    CSingleton* tt     = CSingleton::getInstance();

    cout << t << endl << tt << endl;

    return 0;
}

但在以上的懒汉模式是非线程安全的，可以在使用时加锁保证线程安全；如以下代码， 这种方法会因为频繁的加锁和解锁造成资源浪费。

#include <iostream>
#include <pthread.h>

using namespace std;

class CSingleton
{
private:
    CSingleton()
    {
            cout << "Singleton create" << endl;
            pthread_mutex_init(&mutex, 0);
    }
    ~CSingleton()
    {
        cout << "Singleton destroy" << endl;
    }
    static pthread_mutex_t mutex;
    static CSingleton *p;
public:
    static CSingleton* getInstance()
    {
            pthread_mutex_lock(&mutex);
            if(NULL == p)
            {
                p = new CSingleton();
            }
            pthread_mutex_unlock(&mutex);
            return p;
    }
};

pthread_mutex_t CSingleton::mutex;
CSingleton* CSingleton::p = NULL;

int main(void)
{
    CSingleton* t     = CSingleton::getInstance();
    CSingleton* tt     = CSingleton::getInstance();

    cout << t << endl << tt << endl;

    return 0;
}

 

饿汉式单例模式：即类产生的时候就创建好实例对象，这是一种空间换时间的方式；

如以下代码在静态变量初始化时就已经创建实例对象了，一直到程序结束才释放。即对象的生存周期和程序一样长；

饿汉式在类中就已经创建了对象，因此是线程安全的；

 

#include <iostream>
using namespace std;

class CSingleton
{
private:
    CSingleton()
    {

    }
    static CSingleton *p;

   // static CSingleton p;
public:
    static CSingleton* getInstance()
    {
            return p;

           //return &p
    }
};

CSingleton* CSingleton::p = new CSingleton();

int main(void)
{
    CSingleton* t     = CSingleton::getInstance();
    CSingleton* tt     = CSingleton::getInstance();

    cout << t << endl << tt << endl;

    return 0;
}

但这样会存在一个问题 ， 静态函数中new了一个新实例对象， 那就同样需要有静态的释放函数，手动detele实例；

如果忘了delete，就会内存泄露，

        1.可以将静态指针改为静态变量，即将以上代码相应代码替换为注释掉的代码，并注释掉p指针的初始化。

        2. 可以加个内部类，和一个内部类的静态变量，在静态变量释放时，同时delete实例，如以下代码所示：

#include <iostream>
using namespace std;

class CSingleton
{
private:
    CSingleton()
    {
            cout << "Singleton create" << endl;
    }
    ~CSingleton()
    {
        cout << "Singleton destroy" << endl;
    }
    static CSingleton *p;
public:
    static CSingleton* getInstance()
    {
            return p;
    }

private:
    class CRelease
    {
    public:
            CRelease(){}
            ~CRelease() {

                if(NULL != p)
                {
                        delete p;
                        p = NULL;
                }
            }
    };
    static CRelease m_release;
};

CSingleton* CSingleton::p = new CSingleton();
//CSingleton CSingleton::p;
CSingleton::CRelease CSingleton::m_release;

int main(void)
{
    CSingleton* t     = CSingleton::getInstance();
    CSingleton* tt     = CSingleton::getInstance();

    cout << t << endl << tt << endl;

    return 0;
}