C++11应用：单例模式

    Singleton.hpp：

#pragma once
template <typename T>
class Singleton
{
private:
	Singleton();
	virtual ~Singleton() {};
	Singleton(const Singleton&);
	Singleton& operator=(const Singleton&) {};

	static T* mInstance; 
public: 
	template <typename... Args>
	// 创建单例
	static T* Instance(Args&&... args)
	{
		if (mInstance == nullptr)
		{
			mInstance = new T(std::forward<Args>(args)...); // 完美转发
		}
		return mInstance;
	}
	// 获取单例
	static T* GetInstance()
	{
		if (mInstance == nullptr)
		{
			throw std::logic_error("instance never init...");
		}
		return mInstance;
	}
	// 释放单例
	static void DestroyInstance()
	{
		if (mInstance != nullptr)
		{
			delete mInstance;
			mInstance = nullptr;
		}
	}
};

template<typename T>
T* Singleton<T>::mInstance = nullptr; // 类的静态成员变量必须在外面进行初始化

    测试：

#include <iostream>
#include <string>  

#include "Singleton.hpp"

using namespace std;
 
struct TestA 
{
	TestA(const string&)
	{
		cout << "TestA left value." << endl;
	}
	TestA(const string&&)
	{
		cout << "TestA right value." << endl;
	}
};
struct TestB
{
	TestB(const string&)
	{
		cout << "TestB left value." << endl;
	}
	TestB(const string&&)
	{
		cout << "TestB right value." << endl;
	}
};
struct TestC
{
	TestC(int x, double y)
	{
		cout << "TestC construct." << endl;
	}
	void test() {
		cout << "TestC test." << endl;
	}
}; 

int main(int, char *[])
{     
	string str = "test...string";

	// 创建TestA类型的单例
	Singleton<TestA>::Instance(str);

	// 创建TestB类型的单例，临时变量str被move为右值，然后可以根据移动语义来避免复制
	Singleton<TestB>::Instance(std::move(str));
	
	// 创建TestC类型的单例，包含两个参数
	auto aaa = Singleton<TestC>::Instance(1, 3.14);
	aaa->test();
	Singleton<TestC>::GetInstance()->test();


	// 释放
	Singleton<TestA>::DestroyInstance();
	Singleton<TestB>::DestroyInstance();
	Singleton<TestC>::DestroyInstance();
	  
	system("pause");
	return 0;
}