【面试练习题】单例模式

饿汉式，基本版

#include <iostream>

using namespace std;
class Single {
private:
	Single() {} // 构造函数私有
	Single(const Single &) {}; // 拷贝构造函数私有
	Single& operator=(const Single&) {}; // 赋值操作符私有，不允许复制操作
	static Single _obj; // 一个属于类的对象
	static int a; // 该对象的其他数据
	
public:
	virtual ~Single() {}
	static Single get_obj(){
		return _obj;
	}
	static int get_data() {
		return a;
	}
	static void set_data(int a2) {
		a = a2;
	}
};
Single Single::_obj;// 类static成员变量必须在类外初始化，否则会出现连接错误，可能是RAII
int Single::a = 1;// 为什么静态成员不能再类内初始化：因为静态成员属于整个类，而不属于某个对象，如果在类内初始化，会导致每个对象都包含该静态成员，这是矛盾的。

int main()
{
	Single::get_obj().set_data(12);
	cout << Single::get_obj().get_data() << endl;
	return 0;
}

或者：

#include <iostream>

using namespace std;
class Single {
private:
	Single() {} // 构造函数私有
	Single(const Single &) {}; // 拷贝构造函数私有
	Single& operator=(const Single&) {}; // 赋值操作符私有，不允许复制操作
	static Single* _obj; // 指向属于类的对象
	static int *a;// 该对象的其他数据
	
public:
	virtual ~Single() {}
	static Single* get_obj(){
		return _obj;
	}
	static int get_data() {
		return *a;
	}
	static void set_data(int a2) {
		*a = a2;
	}
};

Single* Single::_obj = new Single;
int* Single::a = new int(0);

int main()
{
	Single::get_obj()->set_data(12);
	cout << Single::get_obj()->get_data() << endl;
	return 0;
}

加入了模板的饿汉式：

#include <iostream>

using namespace std;

template<typename T>
class Single {
private:
	Single() {} // 构造函数私有
	Single(const Single &) {}; // 拷贝构造函数私有
	Single& operator=(const Single&) {}; // 赋值操作符私有，不允许赋值操作
	static Single<T>* _obj; // 指向属于类的对象
	static T* a;// 该对象的其他数据
	
public:
	virtual ~Single() {}
	static Single<T>* get_obj(){
		return _obj;
	}
	static T get_data() {
		return *a;
	}
	static void set_data(T a2) {
		*a = a2;
	}
};

template<typename T>
Single<T>* Single<T>::_obj = new Single<T>;

template<typename T>
T* Single<T>::a = new T;

int main()
{
	Single<int>::get_obj()->set_data(12);
	cout << Single<int>::get_obj()->get_data() << endl;
	return 0;
}

精简版：

#include <iostream>

using namespace std;

template<typename T>
class Single {
private:
	Single() {} // 构造函数私有
	Single(const Single &) {}; // 拷贝构造函数私有
	Single& operator=(const Single&) {}; // 赋值操作符私有，不允许赋值操作
	static T* a;// 该对象的其他数据

public:
	virtual ~Single() {}
	static T* get_obj() {
		return a;
	}
};

template<typename T>
T* Single<T>::a = new T;

int main()
{
	*(Single<int>::get_obj()) = 12;
	cout << *(Single<int>::get_obj()) << endl;
	return 0;
}

懒汉模式：

#include <iostream>
#include <mutex>

using namespace std;

template<typename T>
class Single {
private:
	Single() {} // 构造函数私有
	Single(const Single &) {}; // 拷贝构造函数私有
	Single& operator=(const Single&) {}; // 赋值操作符私有，不允许赋值操作
	static T* _point;
	static mutex _mutex;
public:
	virtual ~Single() {}
	static T* get_obj(){
		if (_point == NULL) {
			_mutex.lock();
				if (_point == NULL) {
					_point = new T;
				}
			_mutex.unlock();
		}
		return _point;
	}
};


template<typename T>
T* Single<T>::_point = new T;

template<typename T>
mutex Single<T>::_mutex;


int main()
{
	*(Single<int>::get_obj()) = 12;
	cout << *(Single<int>::get_obj()) << endl;
	return 0;
}