工具类库系列(一)-StringTool

好久没写了，最近闲了下来，把这段时间的代码整理整理，将常用的代码按功能整理成一些静态库，便于以后复用

今天是第一个库：libtool，其实就是一些工具类的集合

第一个工具类：StringTool

std::string已经很强大了，但是在实际项目中，还是会遇到一些需求，需要用string提供的接口组装一些字符串相关的功能，整理如下

（PS，本系列所有代码，均不同程度的需要boost库支持，本人使用的是boost1.55.0）

1：将一个字符串的首字母大写

这个功能很简单的，就是如果第一个字符'a' - 'z' 则换成 ‘A' - 'Z'

2：去除字符串中的所有制表符：空格，'\t'，'\r'，'\n'

这里就是遍历字符串，将相应的字符过滤掉

主要用于读文件之后的初步处理

3：将字符串中所有的字符串A替换成字符串B

这里用到string的find，查找字符串A的位置

仅遍历一遍，已处理过的部分不再处理，即如果字符串“1222”，需要将 “12”替换成“1”，则结果是“122”，不是“1”

该函数目前大部分情况还是用在文件路径中的windows下的"\\"替换成windows/linux兼容的“/”

补充增加 正则表达式替换：

这里用到了一个boost库提供的功能：boost::regex正则表达式regex_replace

4：将字符串按指定分隔符进行分割，分隔符可以是一个字符串

同上，分割后的结果存成一个std::vector返回

5：判断字符串是否是一个合法的数字：int，uint，float

这里用到了一个boost库提供的功能：boost::regex正则表达式regex_match

6：判断字符串是否是合法的Utf8编码

也是遍历，按Utf8的编码规则校验

7：Unicode和Utf8互转

这里仅处理了UCS-2，也是按Utf8的编码规则去压缩/解压缩

8：单宽字节互转

为了windows和linux的兼容，这里用的是mbstowcs/wcstombs

9：Gbk和Utf8互转

有了7和8，这个就是上两项功能的组合 Gbk <-> Unicode <-> Utf8

2017/1/9 修正Utf8ToGbk/GbkToUtf8分别在windows/linux下不同的locale设置

2017/12/6 修正Utf8ToUnicode中下标越界的bug

2017/12/6 增加字符串转时间戳的功能

最后上代码

StringTool.h

#ifndef __StringTool_h__
#define __StringTool_h__

#include <string>
#include <vector>

namespace common{
	namespace tool{

		class StringTool
		{
		public:
			// 字符串首字母大写
			static std::string UpperCaseFirstChar(const std::string& str);
			static std::string LowerCaseFirstChar(const std::string& str);

			// 字符串全字母大/小写
			static std::string UpperCase(const std::string& str);
			static std::string LowerCase(const std::string& str);

			// 去除字符串str中的所有制表符：' '，'\t'，'\r'，'\n'
			static std::string TrimAll(const std::string& str);

			// 将字符串str中所有的字符串src替换成字符串des
			static std::string ReplaceAll(const std::string& str, const std::string& src, const std::string& des);
			// 将字符串str中所有符合src格式（正则表达式）的字符串替换成字符串des
			static std::string ReplaceReg(const std::string& str, const std::string& src, const std::string& des);

			// 对字符串按指定分隔符进行分割，返回分割后的内容列表
			static bool SplitStr2List(const std::string& str, const std::string& split, std::vector<std::string>& values);
			static bool SplitStr2List(const std::string& str, const std::string& split, std::vector<unsigned int>& values);
			static bool SplitStr2List(const std::string& str, const std::string& split, std::vector<int>& values);
			static bool SplitStr2List(const std::string& str, const std::string& split, std::vector<float>& values);

			// 判断字符串是否是一个合法的无符号数
			static bool IsUInt(const std::string& str);
			// 判断字符串是否是一个合法的数字
			static bool IsInt(const std::string& str);
			// 判断字符串是否是一个合法的浮点数
			static bool IsFloat(const std::string& str);
			// 判断字符串是否是一个符合“YYYY-MM-DD hh-mm-ss”格式的时间
			static bool IsDateTime(const std::string& str);
			// 判断字符串是否是一个符合“hh-mm(-ss)”格式的时间
			static bool IsTime(const std::string& str);
			// 判断字符串是否是一个符合“int-int”格式的区间范围
			static bool IsRang(const std::string& str);

			// 将符合“YYYY-MM-DD hh-mm-ss”格式的字符串转换成距离1970-1-1 00:00:00经过的秒数
			static bool String2DateTime(const std::string& str, time_t& datetime);
			// 将符合“hh-mm-ss”格式的字符串转换成距离当天00:00:00经过的秒数
			static bool String2Time(const std::string& str, time_t& time);
			// 将符合“int-int”格式的区间转换成区间的起始值 和 终止值
			static bool String2Rang(const std::string& str, int (&rang)[2]);

			// 返回一个字符串是否是合法的utf8编码
			static bool IsUtf8(const std::string& str);

			// Gbk和Utf8互转，返回转换后的字符串
			static std::string GbkToUtf8(const std::string& gbk);
			static std::string Utf8ToGbk(const std::string& utf8);

			// Unicode和Utf8互转，返回转换后的字符串
			static void UnicodeToUtf8(std::string& utf8, const std::wstring& unicode);
			static void Utf8ToUnicode(std::wstring& unicode, const std::string& utf8);

			// 单宽字节互转
#ifdef UNICODE
			static std::wstring MbStrToWcStr(const std::string& mbs, const wchar_t* language);
			static std::string WcStrToMbStr(const std::wstring& wcs, const wchar_t* language);
#else
			static std::wstring MbStrToWcStr(const std::string& mbs, const char* language);
			static std::string WcStrToMbStr(const std::wstring& wcs, const char* language);
#endif

		private:
			// Unicode和Utf8互转，获取转换后的字符数
			static size_t UnicodeToUtf8Length(const std::wstring& unicode);
			static size_t Utf8ToUnicodeLength(const std::string& utf8);
		};

	}
}

#endif

StringTool.cpp

#include "StringTool.h"

#include <string>
#include <vector>

#include <regex>

using namespace common::tool;

using namespace std;

string StringTool::UpperCaseFirstChar(const string& str)
{
	string temp = str;

	if (temp.length() > 0)
	{
		if ('a' <= temp[0] && temp[0] <= 'z')
		{
			temp[0] = temp[0] - ('a' - 'A');
		}
	}

	return temp;
}

string StringTool::LowerCaseFirstChar(const string& str)
{
	string temp = str;

	if (temp.length() > 0)
	{
		if ('A' <= temp[0] && temp[0] <= 'Z')
		{
			temp[0] = temp[0] + ('a' - 'A');
		}
	}

	return temp;
}

string StringTool::UpperCase(const string& str)
{
	string temp = str;

	for (unsigned int i = 0; i < temp.length(); i++)
	{
		if ('a' <= temp[i] && temp[i] <= 'z')
		{
			temp[i] = temp[i] - ('a' - 'A');
		}
	}

	return temp;
}

string StringTool::LowerCase(const string& str)
{
	string temp = str;

	for (unsigned int i = 0; i < temp.length(); i++)
	{
		if ('A' <= temp[i] && temp[i] <= 'Z')
		{
			temp[i] = temp[i] + ('a' - 'A');
		}
	}

	return temp;
}

string StringTool::TrimAll(const string& str)
{
	string temp;
	temp.reserve(str.size());

	for (size_t i = 0; i < str.length(); i++)
	{
		if (str[i] != ' ' &&
			str[i] != '\t' &&
			str[i] != '\r' &&
			str[i] != '\n')
		{
			temp += str[i];
		}
	}

	return temp;
}

string StringTool::ReplaceAll(const string& str, const string& src, const string& des)
{
	string temp;
	temp.reserve(str.size());

	if (0 < src.length())
	{
		size_t pos = str.find(src);
		size_t lastpos = 0;
		while (pos != string::npos)
		{
			temp += str.substr(lastpos, pos - lastpos);
			temp += des;
			lastpos = pos + src.length();
			pos = str.find(src, lastpos);
		}
		if (lastpos != str.length())
		{
			temp += str.substr(lastpos, str.length() - lastpos);
		}
	}

	return temp;
}

string StringTool::ReplaceReg(const string& str, const string& src, const string& des)
{
	regex reg(src);
	return regex_replace(str, reg, des);
}

bool StringTool::SplitStr2List(const string& str, const string& split, vector<string>& values)
{
	size_t currPos = str.find(split);
	size_t lastPos = 0;
	while (currPos != string::npos)
	{
		values.push_back(str.substr(lastPos, currPos - lastPos));
		lastPos = currPos + split.length();
		currPos = str.find(split, lastPos);
	}
	values.push_back(str.substr(lastPos, str.length() - lastPos));

	return true;
}

bool StringTool::SplitStr2List(const string& str, const string& split, vector<unsigned int>& values)
{
	string temp = str;
	TrimAll(temp);

	size_t currPos = temp.find(split);
	size_t lastPos = 0;
	while (currPos != string::npos)
	{
		string strUInt = temp.substr(lastPos, currPos - lastPos);
		if (IsUInt(strUInt))
		{
			values.push_back(static_cast<unsigned int>(atoi(strUInt.c_str())));
		}
		else
		{
			return false;
		}
		lastPos = currPos + split.length();
		currPos = temp.find(split, lastPos);
	}
	string strUInt = temp.substr(lastPos, temp.length() - lastPos);
	if (IsUInt(strUInt))
	{
		values.push_back(static_cast<unsigned int>(atoi(strUInt.c_str())));
	}
	else
	{
		return false;
	}

	return true;
}

bool StringTool::SplitStr2List(const string& str, const string& split, vector<int>& values)
{
	string temp = str;
	TrimAll(temp);

	size_t currPos = temp.find(split);
	size_t lastPos = 0;
	while (currPos != string::npos)
	{
		string strInt = temp.substr(lastPos, currPos - lastPos);
		if (IsInt(strInt))
		{
			values.push_back(atoi(strInt.c_str()));
		}
		else
		{
			return false;
		}
		lastPos = currPos + split.length();
		currPos = temp.find(split, lastPos);
	}
	string strInt = temp.substr(lastPos, temp.length() - lastPos);
	if (IsInt(strInt))
	{
		values.push_back(atoi(strInt.c_str()));
	}
	else
	{
		return false;
	}

	return true;
}

bool StringTool::SplitStr2List(const string& str, const string& split, vector<float>& values)
{
	string temp = str;
	TrimAll(temp);

	size_t currPos = temp.find(split);
	size_t lastPos = 0;
	while (currPos != string::npos)
	{
		string strFloat = temp.substr(lastPos, currPos - lastPos);
		if (IsFloat(strFloat))
		{
			values.push_back(static_cast<float>(atof(strFloat.c_str())));
		}
		else
		{
			return false;
		}
		lastPos = currPos + split.length();
		currPos = temp.find(split, lastPos);
	}
	string strFloat = temp.substr(lastPos, temp.length() - lastPos);
	if (IsFloat(strFloat))
	{
		values.push_back(static_cast<float>(atof(strFloat.c_str())));
	}
	else
	{
		return false;
	}

	return true;
}

bool StringTool::IsUInt(const string& str)
{
	regex reg("(0)|([1-9][0-9]*)"); // 0 或者 1-9开头后面若干个0-9的数字
	return regex_match(str, reg);
}

bool StringTool::IsInt(const string& str)
{
	regex reg("(0)|([-]?[1-9][0-9]*)"); // 0 或者 正负1-9开头后面若干个0-9的数字
	return regex_match(str, reg);
}

bool StringTool::IsFloat(const string& str)
{
	regex reg(
				"("
					"0([.]0+)?" // 0 后面跟 小数点 再跟若干个0（如果有小数点，则后面的数字字符串长度必须大于0）
				")"
				"|"
				"("
					"[-]?0[.][0-9]*[1-9][0-9]*" // 正负 0 后面跟 小数点 再跟一个不为0的数字字符串
				")"
				"|"
				"("
					"[-]?([1-9][0-9]*)([.][0-9]+)?" // 正负 1-9开头后面若干个0-9的数字 后面跟 小数点 再跟数字字符串（如果有小数点，则后面的数字字符串长度必须大于0）
				")"
			);
	return regex_match(str, reg);
}

bool StringTool::IsDateTime(const string& str)
{
	regex reg(
				"[1-9][0-9]?[0-9]?[0-9]?" // 年，1-9开头，后面最多3个0-9的数字
				"[-]"
				"("
					"(0?[1-9])|(1[0-2])" // 月，01 - 09（十位的0可以没有），10 - 12
				")"
				"[-]"
				"("
					"(0?[1-9])|([1-2][0-9])|(3[0-1])" // 日，01 - 09（十位的0可以没有），10 - 29，30 - 31 
				")"
				"[ ]"
				"("
					"([0-1]?[0-9])|(2[0-3])" // 时，00 - 19（十位的0可以没有）， 20 - 23
				")"
				"[:]"
				"[0-5]?[0-9]" // 分， 00 - 59（十位的0可以没有）
				"[:]"
				"[0-5]?[0-9]" // 秒， 00 - 59（十位的0可以没有）
			);
	return regex_match(str, reg);
}

bool StringTool::IsTime(const string& str)
{
	regex reg(	
				"("
					"([0-1]?[0-9])|(2[0-3])" // 时，00 - 19（十位的0可以没有）， 20 - 23
				")"
				"[:]"
				"[0-5]?[0-9]" // 分， 00 - 59（十位的0可以没有）
				"("
					"[:]"
					"[0-5]?[0-9]" // 秒（可以没有）， 00 - 59（十位的0可以没有）
				")?"
			);
	return regex_match(str, reg);
}

bool StringTool::IsRang(const std::string& str)
{
	regex reg(
				"("
					"(0)|([-]?[1-9][0-9]*)" // 0 或者 正负1-9开头后面若干个0-9的数字
				")"
				"[-]"
				"("
					"(0)|([-]?[1-9][0-9]*)" // 0 或者 正负1-9开头后面若干个0-9的数字
				")");
	return regex_match(str, reg);
}

bool StringTool::String2DateTime(const std::string& str, time_t& datetime)
{
	tm _tm;
	int year = 1900, month = 1, day = 0, hour = 0, minute = 0, second = 0;
	int ret = sscanf(str.c_str(), "%d-%d-%d %d:%d:%d", &year, &month, &day, &hour, &minute, &second);
	if (ret != 6)
	{
		return false;
	}
	_tm.tm_year = year - 1900;
	_tm.tm_mon = month - 1;
	_tm.tm_mday = day;
	_tm.tm_hour = hour;
	_tm.tm_min = minute;
	_tm.tm_sec = second;
	_tm.tm_isdst = 0;
	datetime = mktime(&_tm);
	return true;
}

bool StringTool::String2Time(const std::string& str, time_t& time)
{
	int hour = 0, minute = 0, second = 0;
	int ret = sscanf(str.c_str(), "%d:%d:%d", &hour, &minute, &second);
	if (ret != 2 && ret != 3)
	{
		return false;
	}
	time = hour * 60 * 60 + minute * 60 + second;
	return true;
}

bool StringTool::String2Rang(const std::string& str, int(&rang)[2])
{
	int ret = sscanf(str.c_str(), "%d-%d", &(rang[0]), &(rang[1]));
	if (ret != 2)
	{
		return false;
	}
	return true;
}

bool StringTool::IsUtf8(const string& str)
{
	unsigned int nBytes = 0;
	bool bAllAscii = true;

	for (size_t i = 0; i < str.length(); i++)
	{
		unsigned char ch = str[i];

		// 判断是否ASCII编码，如果不是，说明有可能是UTF-8，ASCII一个字节用7位编码，最高位标记为0，0xxxxxxx
		if ((ch & 0x80) != 0)
		{
			bAllAscii = false;
		}

		// 如果不是ASCII码，计算字节数(校验是否符合UTF8规则)
		if (nBytes == 0)
		{
			if (ch >= 0x80)
			{
				if (ch >= 0xFC && ch <= 0xFD)
				{
					nBytes = 6;
				}
				else if (ch >= 0xF8)
				{
					nBytes = 5;
				}
				else if (ch >= 0xF0)
				{
					nBytes = 4;
				}
				else if (ch >= 0xE0)
				{
					nBytes = 3;
				}
				else if (ch >= 0xC0)
				{
					nBytes = 2;
				}
				else
				{
					return false;
				}
				nBytes--;
			}
		}
		// 多字节符的非首字节，应为10xxxxxx
		else
		{
			if ((ch & 0xC0) != 0x80)
			{
				return false;
			}
			nBytes--;
		}
	}

	if (nBytes > 0)
	{
		return false;
	}

	// 如果全部都是ASCII, 说明不是UTF-8
	if (bAllAscii)
	{
		return false;
	}

	return true;
}

string StringTool::GbkToUtf8(const string& gbk)
{
#ifdef WIN32
#ifdef UNICODE
	wstring unicode = MbStrToWcStr(gbk, L"chs");
#else // UNICODE
	wstring unicode = MbStrToWcStr(gbk, "chs");
#endif // UNICODE
#else // WIN32
#ifdef UNICODE
	wstring unicode = MbStrToWcStr(gbk, L"zh_CN.GB18030");
#else // UNICODE
	wstring unicode = MbStrToWcStr(gbk, "zh_CN.GB18030");
#endif // UNICODE
#endif // WIN32

	string utf8;
	UnicodeToUtf8(utf8, unicode);

	return utf8;
}

string StringTool::Utf8ToGbk(const string& utf8)
{
	wstring unicode;
	Utf8ToUnicode(unicode, utf8);

#ifdef WIN32
#ifdef UNICODE
	string gbk = WcStrToMbStr(unicode, L"chs");
#else // UNICODE
	string gbk = WcStrToMbStr(unicode, "chs");
#endif // UNICODE
#else // WIN32
#ifdef UNICODE
	string gbk = WcStrToMbStr(unicode, L"zh_CN.GB18030");
#else // UNICODE
	string gbk = WcStrToMbStr(unicode, "zh_CN.GB18030");
#endif // UNICODE
#endif // WIN32

	return gbk;
}

void StringTool::UnicodeToUtf8(string& utf8, const wstring& unicode)
{
	size_t mbLen = UnicodeToUtf8Length(unicode) + 1;
	if (1 < mbLen)
	{
		utf8.resize(mbLen);

		size_t utf8Pos = 0;
		size_t unicodePos = 0;

		size_t unicodeLen = unicode.length();
		while (unicodePos < unicodeLen)
		{
			unsigned short unicodeCh = unicode[unicodePos];

			// 0x0800 - 0xffff => 1110 XXXX, 10XX XXXX, 10XX XXXX
			if (0x0800 <= unicodeCh)
			{
				utf8[utf8Pos + 0] = ((unicodeCh >> 12) & 0x0F) | 0xE0;
				utf8[utf8Pos + 1] = ((unicodeCh >> 6) & 0x3F) | 0x80;
				utf8[utf8Pos + 2] = (unicodeCh & 0x3F) | 0x80;

				unicodePos += 1;
				utf8Pos += 3;
			}
			// 0x0080 - 0x07ff => 110X XXXX, 10XX XXXX
			else if (0x0080 <= unicodeCh && unicodeCh < 0x07FF)
			{
				utf8[utf8Pos + 0] = ((unicodeCh >> 6) & 0x1F) | 0xC0;
				utf8[utf8Pos + 1] = (unicodeCh & 0x3F) | 0x80;

				unicodePos += 1;
				utf8Pos += 2;
			}
			// unicodeCh < 0x0080 // 0x0000 - 0x007f => 0XXX XXXX
			else
			{
				utf8[utf8Pos + 0] = unicodeCh & 0x7F;

				unicodePos += 1;
				utf8Pos += 1;
			}
		}

		utf8[utf8Pos] = 0;
	}
}

void StringTool::Utf8ToUnicode(wstring& unicode, const string& utf8)
{
	size_t wcLen = Utf8ToUnicodeLength(utf8) + 1;
	if (1 < wcLen)
	{
		unicode.resize(wcLen);

		size_t utf8Pos = 0;
		size_t unicodePos = 0;

		size_t utf8Len = utf8.length();
		while (utf8Pos < utf8Len)
		{
			unsigned short utfCh0 = utf8[utf8Pos + 0] & 0xFF;

			// 1111 110X, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX
			// 1111 10XX, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX
			// 1111 0XXX, 10XX XXXX, 10XX XXXX, 10XX XXXX 
			if (0xF0 <= utfCh0)
			{
				break; // 需要UCS-4，未处理
			}
			// 1110 XXXX, 10XX XXXX, 10XX XXXX
			else if (0xE0 <= utfCh0 && utfCh0 < 0xF0)
			{
				unsigned short utfCh1 = utf8[utf8Pos + 1] & 0xFF;
				unsigned short utfCh2 = utf8[utf8Pos + 2] & 0xFF;
				unicode[unicodePos] = ((((utfCh0 << 4) & 0xF0) + ((utfCh1 >> 2) & 0x0F)) << 8) + (((utfCh1 << 6) & 0xC0) + (utfCh2 & 0x3F));

				utf8Pos += 3;
				unicodePos += 1;
			}
			// 110X XXXX, 10XX XXXX
			else if (0xC0 <= utfCh0 && utfCh0 < 0xE0)
			{
				unsigned short utfCh1 = utf8[utf8Pos + 1] & 0xFF;
				unicode[unicodePos] = (((utfCh0 >> 2) & 0x07) << 8) + ((utfCh0 << 6) & 0xC0 + utfCh1 & 0x3F);

				utf8Pos += 2;
				unicodePos += 1;
			}
			// 10XX XXXX 
			else if (0x80 <= utfCh0 && utfCh0 < 0xC0)
			{
				break; // 非法情况，Utf8首字节不存在该种编码
			}
			// 0XXX XXXX
			else
			{
				unicode[unicodePos] = utfCh0;

				utf8Pos += 1;
				unicodePos += 1;
			}
		}

		unicode[unicodePos] = 0;
	}
}

size_t StringTool::UnicodeToUtf8Length(const wstring& unicode)
{
	size_t chars = 0;

	size_t unicodeLen = unicode.length();
	size_t unicodePos = 0;
	while (unicodePos < unicodeLen)
	{
		unsigned short unicodeCh = unicode[unicodePos];

		// 0x0800 - 0xffff => 1110 XXXX, 10XX XXXX, 10XX XXXX
		if (0x0800 <= unicodeCh)
		{
			unicodePos += 1;
			chars += 3;
		}
		// 0x0080 - 0x07ff => 110X XXXX, 10XX XXXX
		else if (0x0080 <= unicodeCh && unicodeCh < 0x07FF)
		{
			unicodePos += 1;
			chars += 2;
		}
		// unicodeCh < 0x0080 // 0x0000 - 0x007f => 0XXX XXXX
		else
		{
			unicodePos += 1;
			chars += 1;
		}
	}

	return chars;
}

size_t StringTool::Utf8ToUnicodeLength(const string& utf8)
{
	size_t wchars = 0;

	size_t utf8Len = utf8.length();
	size_t utf8Pos = 0;
	while (utf8Pos < utf8Len)
	{
		unsigned char utf8Ch = utf8[utf8Pos];

		// 1111 110X, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX
		// 1111 10XX, 10XX XXXX, 10XX XXXX, 10XX XXXX, 10XX XXXX
		// 1111 0XXX, 10XX XXXX, 10XX XXXX, 10XX XXXX 
		if (0xF0 <= utf8Ch)
		{
			return 0; // 需要UCS-4，未处理
		}
		// 1110 XXXX, 10XX XXXX, 10XX XXXX
		else if (0xE0 <= utf8Ch && utf8Ch < 0xF0)
		{
			utf8Pos += 3;
			wchars += 1;
		}
		// 110X XXXX, 10XX XXXX
		else if (0xC0 <= utf8Ch && utf8Ch < 0xE0)
		{
			utf8Pos += 2;
			wchars += 1;
		}
		// 10XX XXXX 
		else if (0x80 <= utf8Ch && utf8Ch < 0xC0)
		{
			return 0; // 非法情况，Utf8首字节不存在该种编码
		}
		// 0XXX XXXX
		else
		{
			utf8Pos += 1;
			wchars += 1;
		}
	}

	return wchars;
}

#ifdef UNICODE
wstring StringTool::MbStrToWcStr(const string& mbs, const wchar_t* language)
#else
wstring StringTool::MbStrToWcStr(const string& mbs, const char* language)
#endif
{
	wstring wcs;

#ifdef UNICODE
	wstring curLocale = _wsetlocale(LC_ALL, NULL);
	_wsetlocale(LC_ALL, language);
#else
	string curLocale = setlocale(LC_ALL, NULL);
	setlocale(LC_ALL, language);
#endif

	int wcLen = mbstowcs(NULL, mbs.c_str(), 0) + 1;
	if (1 < wcLen)
	{
		wchar_t* wcBuf = new wchar_t[wcLen];
		if (NULL != wcBuf)
		{
			wmemset(wcBuf, 0, wcLen);
			mbstowcs(wcBuf, mbs.c_str(), wcLen);
		}

		wcs = wcBuf;

		if (NULL != wcBuf)
		{
			delete[] wcBuf;
			wcBuf = NULL;
		}
	}

#ifdef UNICODE
	_wsetlocale(LC_ALL, curLocale.c_str());
#else
	setlocale(LC_ALL, curLocale.c_str());
#endif

	return wcs;
}

#ifdef UNICODE
string StringTool::WcStrToMbStr(const wstring& wcs, const wchar_t* language)
#else
string StringTool::WcStrToMbStr(const wstring& wcs, const char* language)
#endif
{
	string mbs;

#ifdef UNICODE
	wstring curLocale = _wsetlocale(LC_ALL, NULL);
	_wsetlocale(LC_ALL, language);
#else
	string curLocale = setlocale(LC_ALL, NULL);
	setlocale(LC_ALL, language);
#endif

	int mbLen = wcstombs(NULL, wcs.c_str(), 0) + 1;
	if (1 < mbLen)
	{
		char* mbBuf = new char[mbLen];
		if (NULL != mbBuf)
		{
			memset(mbBuf, 0, mbLen);
			wcstombs(mbBuf, wcs.c_str(), mbLen);
		}

		mbs = mbBuf;

		if (NULL != mbBuf)
		{
			delete[] mbBuf;
			mbBuf = NULL;
		}
	}

#ifdef UNICODE
	_wsetlocale(LC_ALL, curLocale.c_str());
#else
	setlocale(LC_ALL, curLocale.c_str());
#endif

	return mbs;
}