#include <algorithm>
#include <windows.h>
#include <assert.h>
#include <string>
#include <sstream>
#include <vector>
using namespace std;
//T类型转std::string，前提T是必须标准C++类型或者重载了转换符
// 【注意】浮点类型只能精确到.00001
template <class T>
inline std::string T2String(const T& source)
{
std::stringstream ss;
ss << source;
return ss.str();
}
// 特例化std::string转std::string
template <>
inline std::string T2String<std::string>(const std::string& source)
{
return source;
}
//T类型转std::string，前提T是必须标准C++类型或者重载了转换符
// 【注意】浮点类型只能精确到.00001
template <class T>
inline T String2T(const std::string& str)
{
//assert(!str.empty());
// 对str为空，数据转换做默认初始化。
if (str.empty())
{
T value = T();
return value;
}
T value;
std::stringstream ss(str);
ss >> value;
return value;
}
// 特例化std::string转std::string
template <>
inline std::string String2T<std::string>(const std::string& str)
{
return str;
}
// std::string转c风格std::string
template <size_t N>
inline errno_t String2CStr(char(&szArray)[N], const char* pStr)
{
assert(pStr != NULL); // 不能为NULL
memset(szArray, 0, N);
return memcpy_s(szArray, N, pStr, strlen(pStr));
}
/** @fn
* @brief std::string转c风格std::string
* @param (IN)
* @return
*/
template <size_t N>
inline errno_t String2CStr(char(&szArray)[N], const std::string& str)
{
memset(szArray, 0, N);
return memcpy_s(szArray, N, str.c_str(), str.length());
}
/** @fn
* @brief 字节流转std::string
* @param (IN) const unsigned char (&szArray)[N] 输入参数无终止符
* @return
*/
template <size_t N>
inline std::string Bytes2String(const unsigned char(&szArray)[N])
{
char szDuplicate[N + 1] = { 0 };
memcpy(szDuplicate, szArray, N);
return szDuplicate;
}
/** @fn
* @brief std::string转字节流
* @param (IN) unsigned char (&szArray)[N] 输出参数无终止符
* @return
*/
template <size_t N>
inline void String2Bytes(unsigned char(&szArray)[N], const char* pStr)
{
assert(pStr != NULL); // 不能为NULL
memset(szArray, 0, N);
memcpy_s((char*)szArray, N, pStr, strlen(pStr));
}
template <size_t N>
inline bool BytesCmp(unsigned char(&szArray)[N], const char* pStr)
{
assert(pStr != NULL); // 不能为NULL
return strncmp((char*)szArray, pStr, N) == 0;
}
/** @fn
* @brief std::string转字节流
* @param (IN) unsigned char (&szArray)[N] 输出参数无终止符
* @return
*/
template <size_t N>
inline void String2Bytes(unsigned char(&szArray)[N], const std::string& str)
{
memset(szArray, 0, N);
memcpy_s((char*)szArray, N, str.c_str(), str.length());
}
/** @fn
* @brief std::string转字节流，此函数对超长部分采取截断策略，更加安全
* @param (IN) unsigned char (&szArray)[N] 输出参数无终止符
* @return
*/
template <size_t N>
inline void String2BytesEx(unsigned char(&szArray)[N], const std::string& str)
{
//memset(szArray, 0, N);
strncpy((char *)(&szArray[0]), str.c_str(), N);
}
template <size_t N>
inline void String2BytesEx(char(&szArray)[N], const std::string& str)
{
//memset(szArray, 0, N);
strncpy(szArray, str.c_str(), N);
}
// 切割字符串
// 将 "1,2,3,4,5"这种类型的字符串转换为{ 1, 2, 3, 4, 5 }此类型数组
template <typename T>
void String2Array(std::vector<T>& vsValues, const std::string& strArray, char cSplit = ',')
{
vsValues.clear();
size_t uPreIndex = 0;
size_t uIndex = 0;
size_t uLen = 0;
while ((uIndex = strArray.find_first_of(cSplit, uPreIndex)) != std::string::npos)
{
if ((uLen = uIndex - uPreIndex) != 0)
{
vsValues.push_back(String2T<T>(strArray.substr(uPreIndex, uLen)));
}
uPreIndex = uIndex + 1;
}
if (uPreIndex < strArray.size())
{
vsValues.push_back(String2T<T>(strArray.substr(uPreIndex).c_str()));
}
}
// 将{ 1, 2, 3, 4, 5 }此类型数组转换为 "1,2,3,4,5"这种类型的字符串
template <typename T>
void Array2String(std::string& strArray, const std::vector<T>& vsValues, char cSplit = ',')
{
strArray.clear();
strArray.reserve(vsValues.size() * 3); // 有些数字可能是两位数的
if (vsValues.empty())
{
return;
}
for (typename std::vector<T>::const_iterator it = vsValues.begin();;)
{
strArray += T2String(*it);
if (++it != vsValues.end())
{
strArray += cSplit;
}
else
{
break;
}
}
}
enum class STR_TYPE
{
ACP = 0, // default to ANSI code page
OEMCP = 1, // default to OEM code page
MACCP = 2, // default to MAC code page
THREAD_ACP = 3, // current thread's ANSI code page
SYMBOL = 42, // SYMBOL translations
UTF7 = 65000, // UTF-7 translation
UTF8 = 65001, // UTF-8 translation
};
string StringReplace(const char* pSource, const string& strTarget, const string& strEscape)
{
assert(!strTarget.empty());
assert(!strEscape.empty());
string strSqlString = pSource;
int iOffset = strEscape.size() - strTarget.size() + 1;
int iEscapeNum = strTarget.size();
for (size_t upos = 0; string::npos != (upos = strSqlString.find(strTarget, upos)); upos += iOffset)
{
strSqlString.replace(upos, iEscapeNum, strEscape);
}
return strSqlString;
}
string StringReplace(const string& strSource, const string& strTarget, const string& strEscape)
{
return StringReplace(strSource.c_str(), strTarget, strEscape);
}
string StringReplace(const string& strSource, size_t uMaxLenth, const string& strTarget, const string& strEscape)
{
if (strSource.size() <= uMaxLenth) // 256字节
{
return StringUtil::StringReplace(strSource.c_str(), strTarget, strEscape);
}
else
{
string strTemp = strSource;
strTemp.resize(uMaxLenth);
return StringUtil::StringReplace(strTemp.c_str(), strTarget, strEscape);
}
}
// std::string 转大写
string UpperCase(const string &str)
{
string strTmp = str;
//lint -e(1025)
transform(strTmp.begin(), strTmp.end(), strTmp.begin(), toupper);
return strTmp;
}
// std::string 转小写
string LowerCase(const string& str)
{
string strTmp = str;
//lint -e(1025)
transform(strTmp.begin(), strTmp.end(), strTmp.begin(), tolower);
return strTmp;
}
// local std::string转UTF-8
// 转码失败返回local_string的值
string Local2UTF8(const string &local_string)
{
// 如果输入为空，直接返回
if (local_string.empty())
{
return local_string;
}
int wlen = MultiByteToWideChar(CP_ACP, 0, local_string.c_str(), -1, NULL, 0);
if (wlen == 0)
{
return local_string;
}
wchar_t* wstr = new wchar_t[wlen + 1];
memset(wstr, 0, wlen + 1);
if (MultiByteToWideChar(CP_ACP, 0, local_string.c_str(), -1, wstr, wlen) == 0)
{
delete[] wstr;
wstr = NULL;
return local_string;
}
int len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
if (len == 0)
{
delete[] wstr;
wstr = NULL;
return local_string;
}
char* str = new char[len + 1];
memset(str, 0, len + 1);
string utf8str;
if (WideCharToMultiByte(CP_UTF8, 0, wstr, wlen, str, len, NULL, NULL) == 0)
{
utf8str = local_string;
}
else
{
utf8str = str;
}
delete[] wstr;
wstr = NULL;
delete[] str;
str = NULL;
return utf8str;
}
// UTF-8转local std::string
// 转码失败返回utf8_string的值
string UTF82Local(const string &utf8_string)
{
// 如果输入为空，直接返回
if (utf8_string.empty())
{
return utf8_string;
}
int len = MultiByteToWideChar(CP_UTF8, 0, utf8_string.c_str(), -1, NULL, 0);
if (len == 0)
{
return utf8_string;
}
wchar_t* wstr = new wchar_t[len + 1];
memset(wstr, 0, len + 1);
if (MultiByteToWideChar(CP_UTF8, 0, utf8_string.c_str(), -1, wstr, len) == 0)
{
delete[] wstr;
wstr = NULL;
return utf8_string;
}
len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
if (len == 0)
{
delete[] wstr;
wstr = NULL;
return utf8_string;
}
char* str = new char[len + 1];
memset(str, 0, len + 1);
string local_str;
if (WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL) == 0)
{
local_str = utf8_string;
}
else
{
local_str = str;
}
delete[] wstr;
wstr = NULL;
delete[] str;
str = NULL;
return local_str;
}
/** @fn
* @brief 替换字符串中的特定字符
* @param <IN> string & strPendingString 待处理的字符串
* @param <IN> const string & strFindString 要去查找的字符串
* @param <IN> const string & strReplaceString 替换的字符串
* @return bool true 替换成功，false 失败
*/
bool ReplaceAll(string& strPendingString, const string& strFindString, const string& strReplaceString)
{
if (strPendingString.empty() || strFindString.empty() || strReplaceString.empty())
{
return false;
}
if (strFindString == strReplaceString)
{
return false;
}
while (true)
{
string::size_type pos(0);
if ((pos = strPendingString.find(strFindString)) != string::npos)
{
strPendingString.replace(pos, strFindString.length(), strReplaceString);
}
else
{
break;
}
}
return true;
}
// 是否保护非法字符(\ / : * ? " < > |)
// 返回true表示包含 false表示不包含
bool ContainsIllegalCharacters(const std::string &str)
{
// 需要过滤的字符
const vector<std::string> vs_filter_char = { "\\", "/", ":", "*", "?", "\"", "<", ">", "|" };
for (auto &it : vs_filter_char)
{
string::size_type pos(0);
if ((pos = str.find(it)) != string::npos)
{
return true;
}
}
return false;
}
//安全的字符串格式化方法，防止字符截断和溢出问题
std::string str_fmt(const char * _Format, ...)
{
std::string _str;
va_list marker = NULL;
va_start(marker, _Format);
size_t num_of_chars = _vscprintf(_Format, marker);
_str.resize(num_of_chars);
vsprintf_s((char *)_str.c_str(), num_of_chars + 1, _Format, marker);
va_end(marker);
return _str;
}
//获取字符串中字符长度（非字节长度）
int str_len(const std::string& str, STR_TYPE type)
{
return MultiByteToWideChar(static_cast<int>(type), NULL, str.c_str(),
str.length(), NULL, NULL);
}
}
//实现split功能
vector<string> split(const string& str, const string& delim)
{
vector<string> res;
if("" == str) return res;
//先将要切割的字符串从string类型转换为char*类型
char * strs = new char[str.length() + 1] ; //不要忘了
strcpy(strs, str.c_str());
char * d = new char[delim.length() + 1];
strcpy(d, delim.c_str());
char *p = strtok(strs, d);
while(p) {
string s = p; //分割得到的字符串转换为string类型
res.push_back(s); //存入结果数组
p = strtok(NULL, d);
}
return res;
}
//示例
string str1 = "M135buffer.buffer,|M135data.data1,4.22424|M135data.data6,-0.0714111|M135data.data7,-0.53833|M135data.data11,145.569|M135data.data16,5.0354|M135data.data17,-112.906|M135data.data21,4.34509|M135data.data22,-0.115356|M135data.data23,0|M135data.data24,-14|M135data.data25,49521|M135data.data_lng,0|M135data.data26,-14|M135data.data27,49521|M135data.data_lati,0";
string str2 = "|This is a test!\n";
string str = str1+str2;
printf(str.c_str());
vector<string> AllStr = split(str,"|");
for (int i=0; i<AllStr.size();i++)
{
vector<string> tempStr = split(AllStr[i],",");
if(tempStr.size()>=2)
{
printf("Name:%s Value:%s\n",tempStr[0].c_str(),tempStr[1].c_str());
}
}
}
扫一扫
1910
评论
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
查看更多评论
添加红包
