单键模式

从单例模式实现的角度考虑：

 1、总是避免第三方调用拷贝构造函数以及赋值操作符

 2、总是避免第三方调用构造函数

 3、尽量避免第三方调用析构函数

 4、总是需要一个静态方法用于全局访问

.h文件：

#pragma once
/*****************************
* @filename:    Singleton.h
* @author:      kzf
* @version:     1.0
* @date:        2011/11/14 
* @describe:    单键模式 保证唯一的实例
如果你整个程序是单线程的，那么标准模式或Meyers单例模式是你最佳选择
* @modification:无
*****************************/


//标准模式
class CSingleton1
{
private:
    //构造函数及析构函数私有化
    CSingleton1();
    virtual ~CSingleton1();

private:
    //防止拷贝构造 以及 赋值 操作
    CSingleton1(const CSingleton1 &ob);
    CSingleton1& operator=(const CSingleton1 &ob);
private:
    static CSingleton1* m_pInstance;

public:
    static CSingleton1* GetInstance();
    static void ReleaseInstance();
    void Print();
};

/**
标准模式的优缺点：
优点：
    属于“懒汉”单例模式，第一次调用GetInstance才分配内存，不调用则不分配内存
缺点：
    1）GetInstance中每次需要判断是否=NULL
    2）由于指针动态分配，必须手动调用ReleaseInstance释放
    3）多线程不安全，有可能实例化多个内存对象
**/



//Meyers单例模式
class CSingleton2
{
private:
    //构造函数及析构函数私有化
    CSingleton2();
    virtual ~CSingleton2();

private:
    //防止拷贝构造 以及 赋值 操作
    CSingleton2(const CSingleton2 &ob);
    CSingleton2& operator=(const CSingleton2 &ob);
private:
    int m_nTestNum;
public:
    static CSingleton2& GetInstance();
    void Print();
};
/**
Meyers单例模式的优缺点：
优点：
    1）属于“懒汉”单例模式，第一次调用GetInstance才实例化
    2）GetInstance中不需要判断是否=NULL，效率提高
    3）使用对象不是指针分配内存，不会内存泄漏
    4）多线程下能确保实例化一个内存对象
缺点：
    1）多线程下未真正意义上同步。
    这是因为C++中构造函数并不是线程安全的。
    C++中的构造函数简单来说分两步：
    第一步：内存分配
    第二步：初始化成员变量

    结论：Meyers方式虽然能确保在多线程中产生唯一的实例，但是不能确保成员变量的值是否正确.
**/


/**
从单例模式实现的角度考虑：
1、总是避免第三方调用拷贝构造函数以及赋值操作符
2、总是避免第三方调用构造函数
3、尽量避免第三方调用析构函数
4、总是需要一个静态方法用于全局访问

**/

.cpp文件：

#include "StdAfx.h"
#include "Singleton.h"


//----------------------标准模式----------------------------
CSingleton1* CSingleton1::m_pInstance = NULL;

CSingleton1::CSingleton1(void)
{
    printf("Construct begin
");
    //假设各种变量的初始化操作，花费近1s时间 用Sleep进行模拟
    Sleep(1000); 
    printf("Construct end
");
}

CSingleton1::~CSingleton1(void)
{
    printf("Destruct
");
}

CSingleton1::CSingleton1(const CSingleton1 &ob)
{
    //
}

CSingleton1& CSingleton1::operator =(const CSingleton1 &ob)
{
    if (&ob != this)
    {
    }
    return *this;
}

CSingleton1* CSingleton1::GetInstance()
{
    if (NULL == m_pInstance)
    {
        m_pInstance = new CSingleton1;
    }

    return m_pInstance;
}

void CSingleton1::ReleaseInstance()
{
    if (NULL != m_pInstance)
    {
        delete m_pInstance;
        m_pInstance = NULL;
    }
}

void CSingleton1::Print()
{
    printf("print out CSingleton1
");
}


//----------------------Meyers单例模式----------------------------

CSingleton2::CSingleton2(void)
{
    m_nTestNum = 0;
    printf("Construct begin,testnum=%d
", m_nTestNum);
    //假设各种变量的初始化操作，花费近1s时间 用Sleep进行模拟
    Sleep(1000); 

    m_nTestNum = 100;
    printf("Construct end,testnum=%d
", m_nTestNum);
}

CSingleton2::~CSingleton2(void)
{
    printf("Destruct
");
}

CSingleton2::CSingleton2(const CSingleton2 &ob)
{
    //
}

CSingleton2& CSingleton2::operator =(const CSingleton2 &ob)
{
    if (&ob != this)
    {
    }
    return *this;
}

CSingleton2& CSingleton2::GetInstance()
{
    //使用局部静态变量方式，从而使之延迟到调用时实例化
    static CSingleton2 gInstance;

    return gInstance;
}

void CSingleton2::Print()
{
    printf("print out CSingleton2 testnum=%d
", m_nTestNum);
}