一些编码格式的字符串转换

最新推荐文章于 2022-05-19 13:14:05 发布
最新推荐文章于 2022-05-19 13:14:05 发布
阅读量443 收藏
点赞数
分类专栏： C++基础 vs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010177010/article/details/53324455
版权 
string CStringHelper::Unicode2UTF8(const wstring& strUnicode)
{
	int length = ::WideCharToMultiByte(CP_UTF8, 0, strUnicode.c_str(), -1, NULL, 0, NULL, NULL);
	if (length <= 0) return "";

	char* pText = new char[length + 1];
	memset((void*)pText, 0, sizeof(char) * (length + 1));
	::WideCharToMultiByte(CP_UTF8, 0, strUnicode.c_str(), -1, pText, length, NULL, NULL);

	string strText(pText);
	delete[] pText;
	return strText;
}

wstring CStringHelper::UTF82Unicode(const string& strUTF8)
{
	// multi char to wide char
	int length = ::MultiByteToWideChar(CP_UTF8, 0, strUTF8.c_str(), -1, NULL, 0);
	if (length <= 0) return L"";

	wchar_t* pwText = new wchar_t[length + 1];
	memset((void*)pwText, 0, sizeof(wchar_t) * (length + 1));
	::MultiByteToWideChar(CP_UTF8, 0, strUTF8.c_str(), -1, pwText, length);

	wstring strText(pwText);
	delete[] pwText;
	return strText;
}

string CStringHelper::GBKToUTF8(const string& strGBK)  
{
    int length = ::MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, NULL, 0);
	if (length <= 0) return "";

    wchar_t* pText1 = new wchar_t[length];
    ::MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, pText1, length);
    length = WideCharToMultiByte(CP_UTF8, 0, pText1, -1, NULL, 0, NULL, NULL);
    if (length <= 0)
	{
		delete [] pText1;
		return "";
	}

	char* pText2 = new char[length];
    ::WideCharToMultiByte(CP_UTF8, 0, pText1, -1, pText2, length, NULL, NULL);

    string strText(pText2);
    delete[] pText1;
    delete[] pText2;
    return strText;
}

string CStringHelper::UTF8ToGBK(const string& strUTF8)  
{  
    int length = MultiByteToWideChar(CP_UTF8, 0, strUTF8.c_str(), -1, NULL, 0);
	if (length <= 0) return "";

    unsigned short* pwText = new unsigned short[length + 1];  
    memset(pwText, 0, length * 2 + 2);  
    MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)strUTF8.c_str(), -1, (LPWSTR)pwText, length);  

    length = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)pwText, -1, NULL, 0, NULL, NULL);
	if (length <= 0) 
	{
		delete [] pwText;
		return "";
	}

    char* pText = new char[length + 1];  
    memset(pText, 0, length + 1);  
    WideCharToMultiByte(CP_ACP,0, (LPWSTR)pwText, -1, pText, length, NULL, NULL); 

    string strText(pText);
    delete[]pText;
    delete[]pwText;
    return strText;
}

string CStringHelper::Unicode2ACSII(const wstring& strUnicode)
{
    if (strUnicode.empty()) return "";

    int length = ::WideCharToMultiByte(CP_ACP, 0, strUnicode.c_str(), -1, NULL, 0, NULL, NULL);
	if (length <= 0) return "";

    char* pText = new char[length + 1];
    ::WideCharToMultiByte(CP_ACP, 0, strUnicode.c_str(), -1, pText, length, NULL, NULL);
    
	string strText(pText);
    delete[] pText;
    return strText;
}

wstring CStringHelper::ASCII2Unicode(const string& strASCII)
{
    int length = MultiByteToWideChar(CP_ACP, 0, strASCII.c_str(), -1,	NULL, 0);
	if (length <= 0) return L"";

	wchar_t* pText = new wchar_t[length + 1];
	memset((void*)pText, 0, sizeof(wchar_t) * (length + 1));
    ::MultiByteToWideChar(CP_ACP, 0, strASCII.c_str(), -1, pText, length);

	wstring strText(pText);
	delete[] pText;
	return strText;
}

int CStringHelper::SplitString(const string& strSrc, const string& strSplit, vector<string>& vecResult, bool bRemoveEmpty/* = false*/)
{
    try
    {
        int pos = strSrc.find(strSplit, 0);
        if (pos == -1)
        {
            // 如果strSrc没有分隔符，直接返回该字符串
			if (strSrc.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(strSrc);
				}
			}
			else
			{
				vecResult.push_back(strSrc);
			}

            return vecResult.size();
        }

        int startPos = 0;
        int splitN = pos;
        string lineText;

        while (pos > -1)
        {
            lineText = strSrc.substr(startPos, splitN);
            startPos = pos + strSplit.length();
            pos = strSrc.find(strSplit, startPos);
            splitN = pos - startPos;
			if (lineText.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(lineText);
				}
			}
			else
			{
				vecResult.push_back(lineText);
			}
        }

        splitN = strSrc.length() - startPos;
        if (splitN > 0)                                       //添加分割线最后一个字符
        {
            lineText = strSrc.substr(startPos, splitN);
			if (lineText.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(lineText);
				}
			}
			else
			{
				vecResult.push_back(lineText);
			}
        }
    }
    catch(exception e)
    {
        return 0;
    }

    return vecResult.size();
}

int CStringHelper::SplitString(const wstring& strSrc, const wstring& strSplit, vector<wstring>& vecResult, bool bRemoveEmpty/* = false*/)
{
    try
    {
        int pos = strSrc.find(strSplit, 0);
        if (pos == -1)
        {
            // 如果strSrc没有分隔符，直接返回该字符串
			if (strSrc.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(strSrc);
				}
			}
			else
			{
				vecResult.push_back(strSrc);
			}

            return 0;
        }

        int startPos = 0;
        int splitN = pos;
        wstring lineText;

        while (pos > -1)
        {
            lineText = strSrc.substr(startPos, splitN);
            startPos = pos + strSplit.length();
            pos = strSrc.find(strSplit, startPos);
            splitN = pos - startPos;
            Trim(lineText);
			if (lineText.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(lineText);
				}
			}
			else
			{
				vecResult.push_back(lineText);
			}
        }

        splitN = strSrc.length() - startPos;
        if (splitN > 0)                                       //添加分割线最后一个字符
        {
            lineText = strSrc.substr(startPos, splitN);
            Trim(lineText);
			if (lineText.empty())
			{
				if (!bRemoveEmpty)
				{
					vecResult.push_back(lineText);
				}
			}
			else
			{
				vecResult.push_back(lineText);
			}
        }
    }
    catch(exception e)
    {
        return 0;
    }

    return vecResult.size();
}

int CStringHelper::sSplit(char* str, const char* delim, char* vec[], size_t vecLen, int dontSaveEmptyFields, int ignoreLeading)
{
    unsigned char isDelim[256];
    unsigned char charType;
    int vecCount = 0;

    if (!str)
    {
        return(-1);
    }

    /* Build is_delim array */
    memset(isDelim, '\0', sizeof(isDelim));

    if (!delim)
    {
        delim = " \t";  /* default field separators */
    }

    while (*delim)
    {
        isDelim[(unsigned)(unsigned char)*delim++] = 1;   /* separator  */
    }

    isDelim[(unsigned)(unsigned char)'\0'] = 2;   /* terminator */
    isDelim[(unsigned)(unsigned char)'\n'] = 2;   /* terminator */


    /* Parse string */
    if (ignoreLeading)
    {
        /* skip leading separators */
        while (isDelim[(unsigned)(unsigned char)*str] == 1)
        {
            str++;
        }
    }

    /* first pointer is the beginning of string */
    /* Check if we want to save this field */
    if ((!dontSaveEmptyFields)
        || (isDelim[(unsigned)(unsigned char)*str] == 0))
    {
        /*
        * We want empty fields, or the first character in this
        * field is not a delimiter or the end of string.
        * So save it.
        */
        if (vecCount >= vecLen)
        {
            return(-1); /* overflow */
        }
        vec[vecCount++] = (char *) str;
    }

    while ((charType = isDelim[(unsigned)(unsigned char)*str]) != 2)
    {
        if (charType == 1)
        {
            /* the char is a separator */

            /* null terminate the substring */
            *str++ = '\0';

            /* Check if we want to save this field */
            if ((!dontSaveEmptyFields) || (isDelim[(unsigned)(unsigned char)*str] == 0))
            {
                /*
                * We want empty fields, or the first character in this
                * field is not a delimiter or the end of string.
                * So save it.
                */
                if (vecCount >= vecLen)
                {
                    return(-1); /* overflow */
                }
                vec[vecCount++] = (char *) str;
            }
        }
        else
        {
            str++;
        }
    }
    *str = '\0';     /* null terminate the substring */

#ifdef SSPLIT_VERBOSE
    {
        int i;
        printf("dump %d strings\n", vecCount);
        for (i = 0; i < vecCount; i++)
        {
            printf("%d '%s'\n", i, vec[i]);
        }
    }
#endif /* def SSPLIT_VERBOSE */

    return(vecCount);
}

int CStringHelper::sSplitOnce(const string &str, const string &delim, vector<string> &vecResult)
{
	if (str.empty() || delim.empty())
	{
		return 0;
	}
	vecResult.clear();

	if (str.size() && str.find(delim.c_str()))
	{
		string strFirst = str.substr(0, str.find_first_of(delim));
		string strLast = str.substr(str.find_first_of(delim) + 1, str.length() - str.find_first_of(delim) - 1);
		vecResult.push_back(strFirst);
		vecResult.push_back(strLast);
	}
	else
	{
		vecResult.push_back(str);
	}
	return vecResult.size();
}

static unsigned int UTF8Decode(char* s, unsigned int* pi)
{
	unsigned int c;
	int i = *pi;
	/* one digit utf-8 */
	if ((s[i] & 128) == 0) 
	{
		c = (unsigned int)s[i];
		i += 1;
	}
	else if ((s[i] & 224) == 192) 
	{ 
		/* 110xxxxx & 111xxxxx == 110xxxxx */
		c = (((unsigned int)s[i] & 31) << 6) + 
			((unsigned int)s[i+1] & 63);
		i += 2;
	}
	else if ((s[i] & 240)== 224 )
	{ 
		/* 1110xxxx & 1111xxxx == 1110xxxx */
		c = (((unsigned int)s[i] & 15) << 12 ) +
			(((unsigned int)s[i+1] & 63) << 6 ) +
			((unsigned int)s[i+2] & 63);
		i += 3;
	} 
	else if ((s[i] & 248) == 240 )
	{ 
		/* 11110xxx & 11111xxx == 11110xxx */
		c = (((unsigned int)s[i] & 7) << 18) +
			(((unsigned int)s[i+1] & 63) << 12) +
			(((unsigned int)s[i+2] & 63) << 6) +
			((unsigned int)s[i+3] & 63);
		i+= 4;
	}
	else if ((s[i] & 252) == 248 )
	{ 
		/* 111110xx & 111111xx == 111110xx */
		c = (((unsigned int)s[i] & 3) << 24) +
			(((unsigned int)s[i+1] & 63) << 18) +
			(((unsigned int)s[i+2] & 63) << 12) +
			(((unsigned int)s[i+3] & 63) << 6) +
			((unsigned int)s[i+4] & 63);
		i += 5;
	}
	else if ((s[i] & 254) == 252 )
	{ 
		/* 1111110x & 1111111x == 1111110x */
		c = (((unsigned int)s[i] & 1) << 30) +
			(((unsigned int)s[i+1] & 63) << 24) +
			(((unsigned int)s[i+2] & 63) << 18) +
			(((unsigned int)s[i+3] & 63) << 12) +
			(((unsigned int)s[i+4] & 63) << 6) +
			((unsigned int)s[i+5] & 63);
		i += 6;
	} 
	else 
	{
		c = '?';
		i++;
	}

	*pi = i;

	return c;
}

/**
 ** URL加密原理：遍历URL字符串，对每个字符，按照以下规则进行加密。
 ** 1.如果当前字符是数字，不加密；
 ** 2.如果当前字符是空格，则用"+"代替；
 ** 3.如果是字符，按照下面的规则加密：将1个字符加密成3个字符。
 **   a.第1个字符为："%"，表示加密标志；
 **   b.第2个字符为一个16进制的字符：hex[ch / 16]，取倍数；
 **   c.第3个字符为一个16进制的字符：hex[ch % 16]，取余数；
 **/
string CStringHelper::UrlEncode(const string& strSrc)
{
	static char hex[] = "0123456789ABCDEF";
	string dst;

	const size_t srcLen = strSrc.size();
	for (size_t i = 0; i < srcLen; i++)
	{
		unsigned char ch = strSrc[i];
		if (isalnum(ch))				// Don't encode number or character.
		{
			dst += ch;
		}
		else
		{
			if (' ' == ch)				// ' ' encode to '+'.
			{
				dst += '+';
			}
			else						// Encode others from one character to three.
			{
				dst += '%';				// Set the encode flag.
				dst += hex[ch / 16];	// Multiple	 - 倍数
				dst += hex[ch % 16];	// Remainder - 余数
			}
		}
	}

	return dst;
}

/**
 ** URL解密原理：
 ** 1.如果当前字符为数字，不需要解密；
 ** 2.如果当前字符为"+"，则用空格" "代替；
 ** 3.如果当前字符为"%"，而且后两个字符均为16进制数字，则需要按照下面的规则解密：
 **   a.将后两个16进制字符转换成10进制数字(c1-48：字符转换成数字)；
 **   b.这两个数字分别代表倍数和余数，然后转换为原来的数字：c1*16+c3；
 **/
string CStringHelper::UrlDecode(const string& strSrc)
{
	string strDst;
	size_t srclen = strSrc.size();
	for (size_t i = 0; i < srclen; i++)
	{
		if (strSrc[i] == '%')	// Find the encode flag.
		{
            // isxdigit：是否为16进制数字
			if(isxdigit(strSrc[i + 1]) && isxdigit(strSrc[i + 2])) // Hexadecimal number.
			{
                // 16进制转换为10进制
				char c1 = strSrc[++i];
				char c2 = strSrc[++i];
				// 0 ANSI Code: 48;
				// The counts from 58 to 65: 7;
				// The counts from 65 to 97: 32;
				c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
				c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
				strDst += (unsigned char)(c1 * 16 + c2);			// Multiple * 16 + Remainder.
			}
		}
		else
		{
			if (strSrc[i] == '+')
			{
				strDst += ' ';
			}
			else
			{
				strDst += strSrc[i];
			}
		}
	}

	string strDstUrl;
	unsigned int len = strDst.size();
	for (unsigned int pos = 0; pos < len;)
	{
		unsigned int nvalue = UTF8Decode((char*)strDst.c_str(), &pos);
		strDstUrl += (unsigned char)nvalue;
	}

	return strDstUrl;
}

wstring CStringHelper::UrlDecodeEx(const string &strSrc)
{
    string strDst;
    wstring strDstUrl;

    size_t srclen = strSrc.size();
    for (size_t i = 0; i < srclen; i++)
    {
        if (strSrc[i] == '%')
        {
            if(isxdigit(strSrc[i + 1]) && isxdigit(strSrc[i + 2]))
            {
                char c1 = strSrc[++i];
                char c2 = strSrc[++i];
                c1 = c1 - 48 - ((c1 >= 'A') ? 7 : 0) - ((c1 >= 'a') ? 32 : 0);
                c2 = c2 - 48 - ((c2 >= 'A') ? 7 : 0) - ((c2 >= 'a') ? 32 : 0);
                strDst += (unsigned char)(c1 * 16 + c2);
            }
        }
        else
        {
            if (strSrc[i] == '+')
            {
                strDst += ' ';
            }
            else
            {
                strDst += strSrc[i];
            }
        }
    }

    unsigned int len = strDst.size();
    for(unsigned int pos = 0; pos < len;)
    {
        unsigned int nvalue = UTF8Decode((char *)strDst.c_str(), &pos);
        strDstUrl += (unsigned wchar_t)nvalue;
    }

    return strDstUrl;
}

wstring CStringHelper::GetSubString(const wstring& strSrc, const wstring& strPattern)
{
    wstring strSub;
    try
    {
        if (strSrc.empty())
        {
            return L"";
        }

        const int pos = strSrc.find(strPattern);
        if (wstring::npos == pos)
        {
            return strSrc;
        }

        strSub = strSrc.substr(0, pos);
    }
    catch(exception e)
    {
        return L"";
    }

    return strSub;
}

bool CStringHelper::LTrim(wstring& wstr,wchar_t sp)
{
	if(!wstr.empty())
	{
		wchar_t* tmp_head = new wchar_t[wstr.length() + 1];
		memcpy(tmp_head,wstr.c_str(),wstr.length() * sizeof(wchar_t));
		tmp_head[wstr.length()] = '\0';


		wchar_t *p, *q, *r;

		p = tmp_head + wstr.length();

	   /*
		* find end of leading whitespace
		*/
	   q = r = tmp_head;
	   while (*q && (*q == sp))
	   {
		  q++;
	   }

	   /*
		* if there was any, move the rest forwards
		*/
	   if (q != tmp_head)
	   {
		  while (q <= p )
		  {
			 *r++ = *q++;
		  }
	   }
	   wstr.clear();
	   wstr = tmp_head;

	   delete tmp_head;
	}

   return true;
}

bool CStringHelper::RTrim(wstring& wstr,wchar_t sp)
{
	if(!wstr.empty())
	{
		wchar_t* tmp_head = new wchar_t[wstr.length() + 1];
		memcpy(tmp_head,wstr.c_str(),wstr.length() * sizeof(wchar_t));
		tmp_head[wstr.length()] = '\0';
		/*
		* strip trailing whitespace
		*/
	   wchar_t* p = tmp_head + wstr.length();
	   while (p > tmp_head && *(p-1) == sp)
	   {
		  p--;
	   }
	   *p = '\0';

	   wstr.clear();
	   wstr = tmp_head;

	   delete tmp_head;
	}


	return true;
}

bool CStringHelper::Trim(wstring& wstr,wchar_t sp)
{
	if(!wstr.empty())
	{
		wchar_t* tmp_head = new wchar_t[wstr.length() + 1];
		memcpy(tmp_head,wstr.c_str(),wstr.length() * sizeof(wchar_t));
		tmp_head[wstr.length()] = '\0';


		wchar_t *p, *q, *r;

	   /*
		* strip trailing whitespace
		*/
	   p = tmp_head + wstr.length();
	   while (p > tmp_head && *(p-1) == sp)
	   {
		  p--;
	   }
	   *p = '\0';

	   /*
		* find end of leading whitespace
		*/
	   q = r = tmp_head;
	   while (*q && (*q == sp))
	   {
		  q++;
	   }

	   /*
		* if there was any, move the rest forwards
		*/
	   if (q != tmp_head)
	   {
		  while (q <= p)
		  {
			 *r++ = *q++;
		  }
		}

	   wstr.clear();
	   wstr = tmp_head;

	   delete tmp_head;
	}

   return true;
}

#define CONVERT_BUF_SIZE    20
string CStringHelper::Int2Str(int val)
{
    char szStr[CONVERT_BUF_SIZE] = {0};
	_itoa(val, szStr, 10);

	return string(szStr);
}

wstring CStringHelper::Int2WStr(int val)
{
    return ASCII2Unicode(Int2Str(val));
}

string CStringHelper::Long2Str(long val)
{
	char szStr[CONVERT_BUF_SIZE] = {0};
	_ltoa(val, szStr, 10);

	return string(szStr);
}

wstring CStringHelper::Long2WStr(long val)
{
    return ASCII2Unicode(Long2Str(val));
}

void CStringHelper::Replace(wstring &strInput, const wstring &strSrc, const wstring &strDst)
{
    if (strInput.empty())
    {
        return;
    }

	wstring::size_type pos = 0;
	wstring::size_type srclen = strSrc.size();         
	wstring::size_type dstlen = strDst.size();       
	while((pos = strInput.find(strSrc, pos)) != wstring::npos)
	{ 
		strInput.replace(pos, srclen, strDst);                 
		pos += dstlen;         
	}
}

bool CStringHelper::BeginWith(wstring strSrc, const wstring str)
{
    if (strSrc.empty())
    {
        return false;
    }

	wstring::size_type pos = wstring::npos;

	if((pos = strSrc.find(str)) == 0)
	{ 
		return true;       
	}

	return false;
}

bool CStringHelper::EndWith(wstring strSrc, const wstring str)
{
    if (strSrc.empty())
    {
        return false;
    }

	wstring::size_type pos = strSrc.rfind(str);

	if( pos == (strSrc.length() - str.length()))
	{ 
		return true;       
	}

	return false;
}

wstring CStringHelper::StringCreateEscapes(const wstring& strSrc)
{
	wstring result;
	wstring::const_iterator b = strSrc.begin();
	wstring::const_iterator e = strSrc.end();
	while (b != e)
	{
		if (*b == 0x20 || *b == 0x21 || (*b >= 0x23 && *b <= 0x2E) ||
			(*b >= 0x30 && *b <= 0x5B) || (*b >= 0x5D && *b <= 0xFF))
			result += *b;
		else if (*b == L'\b') result += L'\\', result += L'b';
		else if (*b == L'\f') result += L'\\', result += L'f';
		else if (*b == L'\n') result += L'\\', result += L'n';
		else if (*b == L'\r') result += L'\\', result += L'r';
		else if (*b == L'/') result += L'\\', result += L'/';
		else if (*b == L'"')  result += L'\\', result += L'"';
		else if (*b == L'\\') result += L'\\', result += L'\\';
		else
		{
			const wchar_t *hexdigits = L"0123456789ABCDEF";
			typedef make_unsigned<wchar_t>::type UCh;
			unsigned long u = (std::min)(static_cast<unsigned long>(
				static_cast<UCh>(*b)),
				0xFFFFul);
			int d1 = u / 4096; u -= d1 * 4096;
			int d2 = u / 256; u -= d2 * 256;
			int d3 = u / 16; u -= d3 * 16;
			int d4 = u;
			result += L'\\'; result += L'u';
			result += hexdigits[d1]; result += hexdigits[d2];
			result += hexdigits[d3]; result += hexdigits[d4];
		}
		++b;
	}
	return result;
}

string CStringHelper::StringCreateEscapes(const string& strSrc)
{
	string result;
	string::const_iterator b = strSrc.begin();
	string::const_iterator e = strSrc.end();
	while (b != e)
	{
		if (*b == 0x20 || *b == 0x21 || (*b >= 0x23 && *b <= 0x2E) ||
			(*b >= 0x30 && *b <= 0x5B) || (*b >= 0x5D && *b <= 0xFF))
			result += *b;
		else if (*b == '\b') result += '\\', result += 'b';
		else if (*b == '\f') result += '\\', result += 'f';
		else if (*b == '\n') result += '\\', result += 'n';
		else if (*b == '\r') result += '\\', result += 'r';
		else if (*b == '/') result += '\\', result += '/';
		else if (*b == '"')  result += '\\', result += '"';
		else if (*b == '\\') result += '\\', result += '\\';
		else
		{
			const char *hexdigits = "0123456789ABCDEF";
			typedef make_unsigned<char>::type UCh;
			unsigned long u = (std::min)(static_cast<unsigned long>(
				static_cast<UCh>(*b)),
				0xFFFFul);
			int d1 = u / 4096; u -= d1 * 4096;
			int d2 = u / 256; u -= d2 * 256;
			int d3 = u / 16; u -= d3 * 16;
			int d4 = u;
			result += '\\'; result += 'u';
			result += hexdigits[d1]; result += hexdigits[d2];
			result += hexdigits[d3]; result += hexdigits[d4];
		}
		++b;
	}
	return result;
}

wstring CStringHelper::Lower2Capital(const wstring& lower)
{
	return _wcsupr(const_cast<wchar_t*>(lower.c_str()));
}

wstring CStringHelper::Capital2Lower(const wstring& capital)
{
	return _wcslwr(const_cast<wchar_t*>(capital.c_str()));
}

wstring CStringHelper::GenerateRandStr(const int len/* = 32*/)
{
    wstring strRet(L"", len);

    static bool bTmp = true;
    if (bTmp)
    {
        // 种子只需设置一次
        srand(GetTickCount()); 
        bTmp = false;
    }

    for (int i = 0; i < len; i++)
    {
        strRet.at(i) = rand() % 26 + 'a';
    }

    return strRet;
}

// 生成随机字符串的源数据
wchar_t srcStrArr[] = L"0123456789abcdefghijklmnopqrstuvwxyz";

wstring CStringHelper::GenerateRandStrEx(const int len/* = 32*/)
{
    wstring strRet(L"", len);

    static bool bTmp = true;
    if (bTmp)
    {
        // 种子只需设置一次
        srand(GetTickCount()); 
        bTmp = false;
    }

    for (int i = 0; i < len; i++)
    {
        strRet.at(i) = srcStrArr[rand() % 36]; // 36 = 10 + 26
    }

    return strRet;
}

string CStringHelper::DecryptString(const string& strSrc, const string& strKey /* = L"" */)
{
	string strS = strSrc;
	string strK = strKey;

	string strValue = CRyptLib::Decode(strS, strK);

	return strValue;
}

string CStringHelper::EncryptString(const string& strSrc, const string& strKey /* = L"" */)
{
	string strS = strSrc;
	string strK = strKey;

	string strValue = CRyptLib::Encode(strS, strK);

	return strValue;
}

wstring CStringHelper::DecryptString(const wstring& strSrc, const wstring& strKey /* = L"" */)
{
	string strS = Unicode2ACSII(strSrc);
	string strK = Unicode2ACSII(strKey);

	string strValue = CRyptLib::Decode(strS, strK);

	wstring strResult = ASCII2Unicode(strValue);

	return strResult;
}

wstring CStringHelper::EncryptString(const wstring& strSrc, const wstring& strKey /* = L"" */)
{
	string strS = Unicode2ACSII(strSrc);
	string strK = Unicode2ACSII(strKey);

	string strValue = CRyptLib::Encode(strS, strK);

	wstring strResult = ASCII2Unicode(strValue);

	return strResult;
}

徐小hi
关注
专栏目录
字符串编码转换
wxd090108的博客
11-17 775
//StringConvert.h #ifndef STRINGCONVERT_H_H #define STRINGCONVERT_H_H #include "stdafx.h" #include &lt;Windows.h&gt; #include &lt;iostream&gt; using std::string; using std::wstring; wstring AsciiToU...
c++字符串编码格式转换
qq_43142808的博客
04-19 1011
# 字符转换函数介绍 函数功能：该函数映射一个unicode字符串到一个多 字节字符串。 函数原型： int WINAPI MultiByteToWideChar( _In_ UINT CodePage, _In_ DWORD dwFlags, _In_NLS_string_(cbMultiByte) LPCCH lpMultiByteStr, _In_ int cbMultiByte, _Out_writes_to_opt_(cchWideChar,return)...
字符串的编码格式转换
xwl_java的博客
09-09 656
字符串的编码格式转换 package com.xwl; import java.io.UnsupportedEncodingException; /** * web开发中，tomcat对于传输的字符串都是采用iso-8859-1编码/解码方式。 * 而客户端（浏览器端对于中文都是用gbk或utf-8中文编码/解码方式），所以传到后台都会是乱码的。 * 容器一般都是有处理的，所以中文能正常显...
js前台加密传输到后台C#解密
狮子座小小羊
09-08 6987
源码下载地址：js前台加密传输到后台c#解密 前提条件： 1、添加3个js，在代码crypto文件夹中 2、添加4个类文件，在代码App_Code\Migrated文件夹中 3、两个加密解密文件，在代码MyXml文件夹中 前台代码： Untitled Page function cmdEncrypt()
【flag】总结文件格式编码转换的方法
PJZero
11-26 4589
文章目录查看文件编码文件编码转换工具python脚本iconvnotepad++ 查看文件编码 file filename 文件编码转换工具 python脚本 ！！！TODO iconv # 查看iconv支持的编码格式 iconv -l # 格式转换命令 iconv -f GBK -t UTF-8 input_file -o output_file notepad++ 非常方便！！！ ...
关于python的实现编码转换的问题
unexpectedthing的博客
09-07 284
文章目录base64编码ascii编码URL编码unicode编码进制的转换\x标志的码 base64编码 import base64 a='flag' #编码 b=base64.b64encode((a).encode("utf-8") print(b) #解码 print(base64.b64decode((b).decode("utf-8"))) 解释一下这儿出现的问题 TypeError: a bytes-like object is required, not 'str 因为python2跟pyt
encode-utf8:使用 UTF8 编码将字符串转换为 ArrayBuffer
08-04
使用 UTF8 编码将字符串转换为 ArrayBuffer。 安装 npm install -- save encode - utf8 用法 import encodeUtf8 from 'encode-utf8' console . log ( encodeUtf8 ( 'Hello, World!' ) ) //=> ArrayBuffer { ...
java转换字符串编码格式的方法
08-27
在Java中，字符编码转换是一个常见的需求，特别是当我们处理不同的数据源和目标存储介质时，常常需要转换字符串的编码格式以保证数据的正确显示和处理。字符编码是字符集的表示形式，规定了某个文字对应的二进制数字...
JavaScript将字符串转换成字符编码列表的方法
10-24
在处理文本和字符数据时，经常需要将字符串转换为字符编码列表，以便进行各种字符串操作或数据处理。在JavaScript中，这个功能可以通过charCodeAt方法实现。 首先，charCodeAt是JavaScript中的一个内置方法，它用于...
PHP实现将base64编码字符串转换成图片示例
10-18
这个函数可以将base64编码的字符串转换回原始的二进制格式，本例中即为图片数据。 然后，需要将解码后的二进制数据保存为图片文件。在这里，可以使用PHP的文件操作函数如`fopen()`, `fwrite()`, 和`fclose()`。首先...
Java 正确的做字符串编码转换
二楼窗外的毛白杨
08-29 4049
Java 正确的做字符串编码转换 字符串的内部表示？ 字符串在java中统一用unicode表示( 即utf-16 LE) ,  对于 String s = "你好哦!"; 如果源码文件是GBK编码, 操作系统（windows）默认的环境编码为GBK，那么编译时,  JVM将 按照GBK编码将字节数组解析成字符，然后将字符转换为unicode格式的字节数组，作为内部
字符串编码方式转换
cxy20170309的博客
06-05 2830
String newstr=new String(pc.getBytes("ISO-8859-1"), "UTF-8");
任意字符编码转换
努力学习
12-16 2048
事情起因是这样的,每当打开eclipse时候,忘记设置字符编码为utf-8时候,默认编码就会是gbk.当我们导入一个项目字符编码是utf-8的时候就会变的非常尴尬,非要去单独制定每个项目对应的字符集 于是自己就想着写一个任意字符编码转换的小工具,其中遇到最大的问题就乱码问题 无法获取到自己的文件的编码格式是实现任意转码的根本原因,通过获取bom头部可以解决本分情况,但是对于没有bom头部的文本...
java 编码格式_java转换字符串编码格式的方法
weixin_39946266的博客
02-12 491
java转换字符串编码格式 (解码错误,重新解码)字符集概念：规定了某个文字对应的二进制数字存放方式(编码)和某串二进制数值代表了哪个文字(解码)的转换关系。我们在计算机屏幕上看到的是实体化的文字，而在计算机存储介质中存放的实际是二进制的比特流。乱码场景(纯属瞎掰)：1) 前台输入utf-8编码的一串汉字(string1)。 (页面编码为utf-8, 在内存中会将这串汉字以utf-8编码为对应的二...
QString字符串常用编码格式转换
qq_39612543的博客
05-19 2491
QString GBK2UTF8(const QString &str) { QTextCodec *utf8 = QTextCodec::codecForName("UTF-8"); return utf8->toUnicode(str.toUtf8()); } QString UTF82GBK(const QString &str) { QTextCodec *gbk = QTextCodec::codecForName("GB18030"); ...
字符串编码格式的转换
jun524的博客
12-02 944
主要知识点： 检查文件或目录是否存在1.file_exists ,2.is_file ,3.is_dir 读取文件1.get_contents将整个文件读取一个参数(读取内容少的时候建议使用) 2.fopen打开文件或URL (@屏蔽错误信息) 3.fclose关闭打开的文件指针 4.fgets从文件指针中读取一行（每次只能读一行） 字符串的编码格式1.ASCII 2.gb2312(EUC-CN)...
java字符串应用之字符串编码转换
热门推荐
上善若水
11-24 5万+
    无论是对程序的本地化还是国际化，都会涉及到字符编码的转换的问题。尤其在web应用中常常需要处理中文字符，这时就需要进行字符串的编码转换，将字符串编码转换为GBK或者GB2312。一、关键技术点：    1、当前流行的字符编码格式有：US-ASCII、ISO-8859-1、UTF-8、UTF-16BE、UTF-16LE、UTF-16、GBK、GB2312等，其中GBK、GB2312是专门
C++不可以返回局部变量的引用或指针
徐小小小hi的博客
03-04 1万+
返回引用事实上是返回变量的地址。 所谓的不可以返回局部变量的引用或指针，指的是不能返回局部变量的引用或地址给引用或指针。事实上还是看该地址的位置是否在该函数的栈区，若是在栈区，函数调用结束，该地址就被释放了。尽管会出现栈地址上的值没被销毁的问题，可能是该栈区还没被其他的函数堆栈掉。 1、int & fun() { int a = 10; return a; } 不可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值