单例模式

单例模式的意图是保证一个类只有一个实例，并提供一个访问它的全局访问点.


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

设计步骤：
1. 在“CSingleton”类中定义一个static的私有属性。
2. 在类中定义static公共访问器函数。
3. 在访问器功能中执行“延迟初始化”（首次创建时使用）。
4. 将类的构造函数定义为protected或private。
5. 使用时只能通过访问器函数来操作CSingleton。

示例：Singleton （VS2010，win32模式）

Singleton.h文件

#pragma once
class CSingleton
{
public:
	~CSingleton(void);
	// 2. 在类中定义static公共访问器函数。
	static CSingleton* _initInstance(int _val = 0);

	void inValue(int _val);
	void outValue();

protected:
	// 3. 在访问器功能中执行“延迟初始化”（首次创建时使用）。
	CSingleton(int _val = 0);

private:
	// 1. 在“CSingleton”类中定义一个static的私有属性。
	static CSingleton* m_instance;
	int m_value;
};

Singleton.cpp文件

#include <iostream>
#include "Singleton.h"


CSingleton* CSingleton::m_instance = 0;

CSingleton::CSingleton(int _val)
{
	m_value = _val;
}

CSingleton::~CSingleton(void)
{
}

CSingleton* CSingleton::_initInstance(int _val)
{
	if (m_instance == 0)
		m_instance = new CSingleton(_val);
	return m_instance;
}

void CSingleton::inValue(int _val)
{
	m_value = _val;
}

void CSingleton::outValue()
{
	std::cout << m_value << std::endl;
}

main.cpp文件

#include <iostream>

using namespace std;

/*
	单例模式的意图是保证一个类只有一个实例，并提供一个访问它的全局访问点.
	适用场景：
	1.当类只有一个实例而且客户可以从一个众所周知的访问点访问它时；
	2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。
	
	设计步骤：
	1. 在“CSingleton”类中定义一个static的私有属性。
	2. 在类中定义static公共访问器函数。
	3. 在访问器功能中执行“延迟初始化”（首次创建时使用）。
	4. 将类的构造函数定义为protected或private。
	5. 使用时只能通过访问器函数来操作CSingleton。
*/
#include "Singleton.h"

CSingleton* singleton;

int main()
{
	// 5. 使用时只能通过访问器函数来操作CSingleton。
	CSingleton* s1 = singleton->_initInstance(100);
	s1->outValue();

	CSingleton* s2 = singleton->_initInstance(222);
	s2->outValue();

	system("pause");
	return 0;
}

包含一个子类的情况示例：WithSonClass(未细分，直接上main.cpp)

main.cpp文件

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

// 基类
class Number
{
public:
	// 2. Define a public static accessor func
	// 定义公共静态访问器方法
	static Number *instance(); 
	static void setType(string t)
	{
		type = t;
		delete inst;
		inst = 0;
	}
	virtual void setValue(int in)
	{
		value = in;
	}
	virtual int getValue()
	{
		return value;
	}
protected:
	int value;
	// 4. Define all ctors to be protected
	// 定义所有要保护的构造函数
	Number()
	{
		cout << "我是基类: ";
	} 
	// 1. Define a private static attribute
	// 定义一个私有静态属性
private:
	static string type;
	static Number *inst; 
};

// 全局实例
string Number::type = "decimal";
Number *Number::inst = 0;

// 子类(个人理解：继承单例的子类是对单例基类的一种功能扩充)
class Octal: public Number
{
	// 6. Inheritance can be supported
	// 继承可以支持
public:
	friend class Number;
	void setValue(int in)
	{
		char buf[10];
		sprintf(buf, "%o", in);// 以8进制写入buf
		sscanf(buf, "%d", &value);
	}
protected:
	// 4
	Octal(){
		cout << "我是子类：";
	}
};

Number *Number::instance()
{
	if (!inst)
		// 3. Do "lazy initialization" in the accessor function
		// 在访问器函数中执行“延迟初始化”
		if (type == "octal")
			inst = new Octal();
		else
			inst = new Number();
	return inst;
}

int main()
{
	// Number  myInstance; - error: cannot access protected constructor
	// 5. Clients may only use the accessor function to manipulate the Singleton
	// 客户端可能只使用访问器函数来操纵Singleton
	Number::instance()->setValue(42);
	cout << "value is " << Number::instance()->getValue() << endl;
	Number::setType("octal");
	Number::instance()->setValue(64);
	cout << "value is " << Number::instance()->getValue() << endl;

	system("pause");
	return 0;
}

*个人理解：继承单例的子类是对单例基类的一种功能扩充。

示例代码参考自：https://sourcemaking.com/design_patterns/object_pool