判断字符串通用函数模板

static bool bIsHex(const string & sStr);

#pragma once
#include <string>
#include <vector>
using namespace std;
class CUtilFun
{
public:
	// 整形日期转换为字符串日期
	static string sIntDate2StrDate(time_t tTime, bool bAccurateToDay = false);

	// 字符串日期转换为整形日期
	static time_t tStrDate2IntDate(const string & sTime, bool bAccurateToDay = false);

	// 整形日期转换为字符串日期
	static string sIntDate2StrDateExt(time_t tTime);

	// 字符串日期转换为整形日期
	static time_t tStrDate2IntDateExt(const string & sTime);

	// Byte型数据转换为字符串
	static string sByte2String(const unsigned char * bsData, int iDataLen);

	// 判断字符串是否为数字
	static bool bIsDigit(const string & sStr);

	// 判断字符串是否是16进制字符串
	static bool bIsHex(const string & sStr);

	// 获取探头内部型号要素
	static bool bGetProberComponent(vector<string> &seqComponent, const string &sProberInnerCode, const char cncSeperator= '_');
};

#include <cstring> 
#include <time.h>
#include <stdlib.h>
#include "UtilFun.h"


// 整形日期转换为字符串日期
string CUtilFun::sIntDate2StrDate(time_t tTime, bool bAccurateToDay)
{
	char sDateBuf[128];
	memset(sDateBuf, 128, 0);
#ifdef _WIN32
	tm  tmLocalTime;
	localtime_s(&tmLocalTime, &tTime);
	if (bAccurateToDay)
	{
		strftime(sDateBuf, 64, "%Y-%m-%d", &tmLocalTime);
	}
	else
	{
		strftime(sDateBuf, 64, "%Y-%m-%d %H:%M:%S", &tmLocalTime);
	}
	
#else
	tm *pLocalTime = localtime(&tTime);
	if (bAccurateToDay)
	{
		strftime(sDateBuf, 64, "%Y-%m-%d", pLocalTime);
	}
	else
	{
		strftime(sDateBuf, 64, "%Y-%m-%d %H:%M:%S", pLocalTime);
	}
	
#endif
	return string(sDateBuf);
}

// 字符串日期转换为整形日期
time_t CUtilFun::tStrDate2IntDate(const string & sTime, bool bAccurateToDay)
{
	tm tmDate;
	int iYear;
	int iMonth;
	int iDay;
	int iHour;
	int iMinute;
	int iSecond;
#ifdef _WIN32
	if (bAccurateToDay)
	{
		sscanf_s(sTime.c_str(), "%d-%d-%d", &iYear, &iMonth, &iDay);
		iHour = 0;
		iMinute = 0;
		iSecond = 0;
	}
	else
	{
		sscanf_s(sTime.c_str(), "%d-%d-%d %d:%d:%d", &iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond);
	}
	
#else
	if (bAccurateToDay)
	{
		sscanf(sTime.c_str(), "%d-%d-%d", &iYear, &iMonth, &iDay);
		iHour = 0;
		iMinute = 0;
		iSecond = 0;
}
	else
	{
		sscanf(sTime.c_str(), "%d-%d-%d %d:%d:%d", &iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond);
	}
#endif
	tmDate.tm_year = iYear - 1900;
	tmDate.tm_mon = iMonth - 1;
	tmDate.tm_mday = iDay;
	tmDate.tm_hour = iHour;
	tmDate.tm_min = iMinute;
	tmDate.tm_sec = iSecond;
	tmDate.tm_isdst = 0;
	return mktime(&tmDate);
}


// 整形日期转换为字符串日期
string CUtilFun::sIntDate2StrDateExt(time_t tTime)
{
	char sDateBuf[128];
	memset(sDateBuf, 128, 0);
#ifdef _WIN32
	tm  tmLocalTime;
	localtime_s(&tmLocalTime, &tTime);
	strftime(sDateBuf, 64, "%Y%m%d%H%M%S", &tmLocalTime);
#else
	tm *pLocalTime = localtime(&tTime);
	strftime(sDateBuf, 64, "%Y%m%d%H%M%S", pLocalTime);
#endif
	return string(sDateBuf);
}

// 字符串日期转换为整形日期
time_t CUtilFun::tStrDate2IntDateExt(const string & sTime)
{
	tm tmDate;
	int iYear;
	int iMonth;
	int iDay;
	int iHour;
	int iMinute;
	int iSecond;
#ifdef _WIN32
	sscanf_s(sTime.c_str(), "%4d%2d%2d%2d%2d%2d", &iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond);
#else
	sscanf(sTime.c_str(), "%4d%2d%2d%2d%2d%2d", &iYear, &iMonth, &iDay, &iHour, &iMinute, &iSecond);
#endif
	tmDate.tm_year = iYear - 1900;
	tmDate.tm_mon = iMonth - 1;
	tmDate.tm_mday = iDay;
	tmDate.tm_hour = iHour;
	tmDate.tm_min = iMinute;
	tmDate.tm_sec = iSecond;
	tmDate.tm_isdst = 0;
	return mktime(&tmDate);
}

// Byte型数据转换为字符串
string CUtilFun::sByte2String(const unsigned char * bsData, int iDataLen)
{
	string sValue;
	char sStr[3];
	memset(sStr, 0, 3);
	for (int i = 0; i < iDataLen; i++)
	{
#ifdef _WIN32
		sprintf_s(sStr, "%02x", bsData[i]);
#else
		sprintf(sStr, "%02x", bsData[i]);
#endif
		sValue += string(sStr);
	}
	return sValue;
}

// 判断字符串是否为数字
bool CUtilFun::bIsDigit(const string & sStr)
{
	string sValue = sStr;
	if (sValue.empty())
	{
		return false;
	}
	
	bool bHex = false;
	if ("0x" == sValue.substr(0, 2) || "0X" == sValue.substr(0, 2))
	{
		sValue = sValue.substr(2);
		bHex = true;
	}

	if (!bHex)
	{
		for (auto iter = sValue.begin(); iter != sValue.end(); iter++)
		{
			if (!isdigit(*iter))
			{
				return false;
			}
		}
	}
	else
	{
		for (auto iter = sValue.begin(); iter != sValue.end(); iter++)
		{
			if (!isdigit(*iter) && (*iter < 'a' || *iter > 'f') && (*iter < 'A' || *iter > 'F'))
			{
				return false;
			}
		}
	}
	return true;
}


// 判断字符串是否是16进制字符串
bool CUtilFun::bIsHex(const string & sStr)
{
	string sValue = sStr;
	if (sValue.empty())
	{
		return false;
	}

	for (auto iter = sValue.begin(); iter != sValue.end(); iter++)
	{
		if (!isdigit(*iter) && (*iter < 'a' || *iter > 'f') && (*iter < 'A' || *iter > 'F'))
		{
			return false;
		}
	}
	return true;
}


// 获取探头内部型号要素
bool CUtilFun::bGetProberComponent(vector<string> &seqComponent, const string &sProberInnerCode, const char cncSeperator)
{
	string sValue = sProberInnerCode;
	if (sValue.empty())
	{
		return false;
	}

	while (!sValue.empty())
	{
		size_t nPos = sValue.find_first_of(cncSeperator);
		if (string::npos != nPos)
		{
			seqComponent.push_back(sValue.substr(0, nPos));
			sValue = sValue.substr(nPos+1);
		}
		else
		{
			seqComponent.push_back(sValue);
			break;
		}
	}

	if (sValue.size() != 3)
	{
		return false;
	}
	else
	{
		return true;
	}
}