C++单例模式（简单懒汉式）

根据类内静态成员的特点：
静态成员变量的生命周期是整个程序，作用域是在类内
静态成员变量属于类，不属于对象，是所有对象共享
静态成员需要在类内生命，类外初始化
静态成员变量可以用类访问，也可以用对象访问

class M
{
public:
	static int val;
};
//初始化静态成员变量
int M::val = 10;
void test()
{
	M a;//实例化一个对象a
	cout << a.val << endl;//输出结果为10
	cout << M::val << endl;//输出结果为10
	M b;//实例化一个对象b
	cout << b.val << endl;//输出结果为10
	M::val = 20;//改变静态成员变量的值  改变b.val 或者a.val的值，结果都是一样的
	cout << b.val << endl;//输出结果为20
	cout << a.val << endl;//输出结果为20
}

单例模式（根据静态成员的特性）
一个类只能实例化一个对象
懒汉式：（只有被调用时才会实例化）

class Marker
{
//1.将构造函数和拷贝构造私有化
private:
	Marker() { count = 0; }
	//拷贝构造会产生一个新对象，所以要私有化
	Marker(const Marker&m){}
public:
	//3.静态成员函数访问静态成员变量
	static Marker*GetMarker()
	{
		return pMarker;
	}
	//例子，每调用此函数，变量count会自增一
	void func(string str)
	{
		count++;
		cout << str << endl;
	}
	//获取count当前值
	int GetCount()
	{
		return count;
	}
private:
	//2.类内静态成员指针
	static Marker*pMarker;
	int count;
};
//4.new一个对象 ,Marker::作用域可以让编译器当在类内初始化
Marker*Marker::pMarker = new Marker;
void test()
{
	//Marker m;//err不能直接定义一个对象，只能用类指针接类内静态函数
	Marker* m = Marker::GetMarker();
	//调用func()函数，count++;
	m->func("类m:1");
	cout << m->GetCount() << endl;//输出结果为：1
	m->func("类m:2");
	cout << m->GetCount() << endl;//输出结果为：2
	//用另一个类指针接静态函数
	Marker* m1 = Marker::GetMarker();
	m1->func("类m1:1");
	cout << m1->GetCount() << endl;//输出结果为：3
	//可以直接使用类内静态函数
	Marker::GetMarker()->func("调用静态函数");
	cout << Marker::GetMarker()->GetCount() << endl;//输出结果为：4
	cout << m1->GetCount() << endl;//输出结果为：4

}