C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性。在C++11标准下，《Effective C++》提出了一种更优雅的单例模式实现，使用函数内的 local static 对象。这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers’ Singleton。C++0x之后该实现是线程安全的，C++0x之前仍需加锁。

// version 1.2

class Singleton
private:
	Singleton() { };
	~Singleton() { };
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&);
public:
	static Singleton& getInstance() 
		static Singleton instance;
		return instance;
补充：C++中static对象的初始化
 
non-local static对象（函数外）
 
C++规定，non-local static 对象的初始化发生在main函数执行之前，也即main函数之前的单线程启动阶段，所以不存在线程安全问题。但C++没有规定多个non-local static 对象的初始化顺序，尤其是来自多个编译单元的non-local static对象，他们的初始化顺序是随机的。
 
local static 对象（函数内）
 
对于local static 对象，其初始化发生在控制流第一次执行到该对象的初始化语句时。多个线程的控制流可能同时到达其初始化语句。
 
在C++11之前，在多线程环境下local static对象的初始化并不是线程安全的。具体表现就是：如果一个线程正在执行local static对象的初始化语句但还没有完成初始化，此时若其它线程也执行到该语句，那么这个线程会认为自己是第一次执行该语句并进入该local static对象的构造函数中。这会造成这个local static对象的重复构造，进而产生内存泄露问题。所以，local static对象在多线程环境下的重复构造问题是需要解决的。
 
而C++11则在语言规范中解决了这个问题。C++11规定，在一个线程开始local static 对象的初始化后到完成初始化前，其他线程执行到这个local static对象的初始化语句就会等待，直到该local static 对象初始化完成。
 
C++ 单例模式
单例模式-析构函数的深入理解
 
在一般的操作系统中，上述基于c++11的 local static懒汉式单例模式都是work的，但是最近，遇到了在某个特殊的操作系统（QNX）中上述单例模式不work的情况，现象是每次getinstance返回的静态对象地址不相同，即便我编译时已经支持了c++11，也是不能工作。
 
无奈，采用了实现比较复杂一点的懒汉式单例实现方法，也是参考上文的例子：
 
 
为了保证线程安全，采用了双重加锁策略（DCL, double-checked locking pattern）
 
 
加入DCL后，其实还是有问题的，关于memory model。在某些内存模型中（虽然不常见）或者是由于编译器的优化以及运行时优化等等原因，使得instance虽然已经不是nullptr但是其所指对象还没有完成构造，这种情况下，另一个线程如果调用getInstance()就有可能使用到一个不完全初始化的对象。换句话说，就是代码中第2行：if(instance == NULL)和第六行instance = new Singleton();没有正确的同步，在某种情况下会出现new返回了地址赋值给instance变量而Singleton此时还没有构造完全，当另一个线程随后运行到第2行时将不会进入if从而返回了不完全的实例对象给用户使用，造成了严重的错误。在C++11没有出来的时候，只能靠插入两个memory barrier（内存屏障）来解决这个错误，但是C++11引进了memory model，提供了Atomic实现内存的同步访问，即不同线程总是获取对象修改前或修改后的值，无法在对象修改期间获得该对象。 利用atomic去实现这部分，需要后续深入学习、理解
 
 
为了去除内存泄漏的风险，使用了嵌套类作为析构类，嵌套类析构时，会释放此前getInstance中new出的内存
 
 
值得注意的几点：
 
c++静态变量（const整数类型除外）一定要在类外进行定义和初始化（类内的只是声明，非初始化，不会分配内存）
单例模式的析构函数中不要释放（delete）单例对象，而是应该定义一个静态的嵌套类对象去析构单例对象。因为delete对象时，先要调用对象的析构函数，这会造成在析构函数中去调用析构函数的递归死循环，最后耗尽栈空间
单例的析构函数最好是私有的，否则别人可能会delete你的instance
GetInstance()肯定是static的，因为它不属于某个对象，最关键的是你也不能构造出类对象去调用它，所以必须是static的
由于GetInstance是static的，所以它内部用到的锁，也得是static的，不能属于类对象才行。
                    C++11规定了local static在多线程条件下的初始化行为，要求编译器保证了内部静态变量的线程安全性。在C++11标准下，《Effective C++》提出了一种更优雅的单例模式实现，使用函数内的 local static 对象。这样，只有当第一次访问getInstance()方法时才创建实例。这种方法也被称为Meyers’ Singleton。C++0x之后该实现是线程安全的，C++0x...
	　　前段时间在网上看到了个的面试题，大概意思是如何在不使用锁和C++11的情况下，用C++实现线程安全的Singleton。
	　　看到这个题目后，第一个想法是用Scott Meyer在《Effective C++》中提到的，在static成员函数中构造local static变量的方法来实现，但是经过一番查找、思考，才明白这种实现在某些情况下是有问题的。本文主要将从基本的单线程中的Singleton开始，慢慢讲述多线程与Singleton的那些事。
	　　在单线程下，下面这个是常见的写法：
	template<typename>
	class Singleton
				
单例模式几乎是最常用的设计模式，简单易懂，使用起来效果显著，在此也不对单例模式做剖析，不了解的可以自行查阅资料。
项目中多次使用单例模式后发现每次都是重复的构建单例类，于是做了一个单例模式的模板。
//单例模板
//delete 与 default 来自于 c++ 11
template <typename T>
class Singleton {
    //使用默认构造和析构函数
    Singleton() = default;
    ~Singleton() = default;
				
2011年12月8日，ISO正式发布了新的C语言的新标准C11，之前被称为C1X，官方名称为ISO/IEC 9899:2011。
新的标准提高了对C++的兼容性，并增加了一些新的特性。这些新特性包括：
    对齐处理(Alignment)的标准化(包括_Alignas标志符，alignof运算符, aligned_alloc函数以及<stdalign.h>头文件。
    _Noreturn 函数标记，类似于 gcc 的 __attribute__((noreturn))。
    _Generic 关键字。
    多线程(Multithreading)支持，包括：_Thread_local存储类型标识符，<threads.h>头文件，里面包含了线程的创建和管理函数。
    增强的Unicode的支持。基于C Unicode技术报告ISO/IEC TR 19769:2004，增强了对Unicode的支持。包括为UTF-16/UTF-32编码增加了char16_t和char32_t数据类型，提供了包含unicode字符串转换函数的头文件<uchar.h>.
    删除了 gets() 函数，使用一个新的更安全的函数gets_s()替代。
    增加了边界检查函数接口，定义了新的安全的函数，例如 fopen_s()，strcat_s() 等等。
    增加了更多浮点处理宏。
    匿名结构体/联合体支持。这个在gcc早已存在，C11将其引入标准。
    静态断言(Static assertions)，_Static_assert()，在解释 #if 和 #error 之后被处理。
    新的 fopen() 模式，(“…x”)。类似 POSIX 中的 O_CREAT|O_EXCL，在文件锁中比较常用。
    新增 quick_exit() 函数作为第三种终止程序的方式。当 exit()失败时可以做最少的清理工作。
    _Atomic类型修饰符和<stdatomic.h>头文件。
	　　在前几天接触到了协程的概念，觉得很有趣。因为我可以使用一个线程来实现一个类似多线程的程序，如果使用协程来替代线程，可以省去很多原子操作和内存栅栏的麻烦，大大减少与线程同步相关的系统调用。因为我只有一个线程，而且协程之间的切换是可以由函数自己决定的。
	　　我有见过几种协程的实现，因为没有 C/C++ 的原生支持，所以多数的库使用了汇编代码，还有些库利用了 C 语言的 setjmp 和 longjmp 但是要求函数里面使用 static local 的变量来保存协程内部的数据。我讨厌写汇编和使用 static local 变量，所以想出了一种稍微优雅一点又有点奇技淫巧的实现方法。 这
				
1,pop3.zip
CPop3Connection - an MFC Class to encapsulate the POP3 protocol(15KB)<END><br>2,ipenum.zip
IPEnum - an MFC class and console app to allow IP address enumeration(11KB)<END><br>3,smtp....
				
单例模式是保证一个类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
本文提供两种方式实现单例模板类：1、使用私有静态指针变量  2、使用局部静态变量， 具体如下：
1、私有静态指针变量
struct Uncloneable
protected:
	Uncloneable() {}
	~Uncloneable(){}
private:
	Uncloneable(const...
				
static关键字
之前在C的面经总结中有对static进行详细介绍，就不多介绍了，今天我们重点来介绍C++中static用法。
在类中，普通的成员方法在调用的时候编译器会自动添加一个this形参变量
普通成员方法的特点：
1、属于类的作用域
2、调用该方法时需要依赖一个对象
3、可以任意访问类的私有成员变量
在成员变量前面加上static后，这个成员变量就是静态的成员变量
静态的成员变量在类内只是一个声明
一定要在类外进行定义和初始化
（重点）静态成员变量不属于对象，而是属于类级别
在成员方法前面加上st
				
大名鼎鼎的Scott Meyer在《Effective C++》中提出了一种简洁的singleton写法：
在C++11之前的标准中并没有规定local static变量的内存模型。于是乎它就是不是线程安全的了。但是在C++11却是线程安全的，这是因为新的C++标准规定了当一个线程正在初始化一个变量的时候，其他线程必须得等到该初始化完成以后才能访问它。
封装之后的测试代码如下：
#include <iostream>
using namespace std;
class Singleto
    static Singleton* getInstance() {
        if (m_instance == nullptr) {
            std::lock_guard<std::mutex> lock(m_mutex);
            if (m_instance == nullptr) {
                m_instance = new Singleton();
        return m_instance;
private:
    Singleton() {}
    static Singleton* m_instance;
    static std::mutex m_mutex;
Singleton* Singleton::m_instance = nullptr;
std::mutex Singleton::m_mutex;
在 getInstance() 函数中，首先判断实例是否已经存在。如果存在，直接返回实例指针。如果不存在，则加锁，再次判断实例是否存在。如果不存在，则创建实例并返回实例指针。加锁保证了多个线程同时调用 getInstance() 函数时只有一个线程可以创建实例，从而保证了线程安全性。