不同类型字符及字符串的转换

在C++中经常需要在不同类型字符串之间进行转换，常见的转换如下：

1. const char* 与 char* 之间转换

1） const char*转换成 char*


const char* pSrc = "test";
// 方式1：强转
char* pDest_1 = (char*)pSrc;
//方式2：调用API，会malloc新的内存，No Recommend
char* pDest_2 = _strdup(pSrc);

2）char*可以直接隐式转换成const char*
const 不可以直接转换成非常量，但是非常量可以直接转换成const类型

char* p1;
const char* p2 = p1; //直接隐式转成const 类型

2. char 与 wchar_t 之间转换

1）char 转换成 wchar_t

wchar_t* CharToWchar(const char* charSrc)
{
    size_t newsize = strlen(charSrc) + 1; //strlen不计算C-Style字串结尾的空字符
    wchar_t* wcString = new wchar_t[newsize];
    size_t convertedChars = 0;
    mbstowcs_s(&convertedChars, wcString, newsize, charSrc, _TRUNCATE);
    
    // 用于接受返回的 wchar_t* 指针需要在使用结束后，释放在此处所分配的内存，否则会造成内存泄漏
    return wcString;
}

2）wchar_t 转换成 char
因为 wchSrc 为2字节，其表示的范围大于char类型，所以如果wchSrc中存在char无法表示的字符，转换将会失败。

char* WcharToChar(const wchar_t* wchSrc)
{
    size_t origSize = wcslen(wchSrc) + 1;
    size_t convertedChars = 0;

    const size_t newSize = origSize * 2;
    char* retStr = new char[newSize];
    wcstombs_s(&convertedChars, retStr, newSize, wchSrc, _TRUNCATE);
    //使用完后，需要将返回的指针所指的数组进行释放
    return retStr;
}

const wchar_t* pWchSrc = L"Test, Just a= helloyi";
char* pDest = WcharToChar(pWchSrc);
delete[] pDest;  //释放转换过程中申请的内存

3. char 与 unsigned char 之间的转换

1). char ====> unsigned char

char* p2;
unsigned char* p3 = (unsigned char*)p2; //方式1
unsigned char* p4 = reinterpret_cast<unsigned char*>(p2); //方式2

2). unsigned char ====> char

unsigned char* p3;
char* p5 = (char*)p3;
char* p6 = reinterpret_cast<char*>(p3);

4. std::string 转换成 const char* 或 char*

1). std::string ====> const char*

std::string str;
// c_str()函数返回一个指向C字符串的常量指针（const char*）
const char *pDest = str.c_str();

2). std::string ====> char*

std::string str("test");
char* pChar = new char[str.size() + 1];
std::copy(str.begin(), str.end(), pChar);
// C-Style字符串要在末尾添加空截止符
pChar[str.size()] = '\0';

delete[] pChar;

5. const char* 或 char* 转换成 string

const char* pStr1="Test";
char pStr2[]="Test";

//将 pStr1, pStr2 转换成C++标准库的 std::string类型
std::string str1(pStr1);
std::string str2(pStr2);
std::string str3 = pStr1;

6. string 与 wstring 之间的转换

1). string ====> wstring

// 字符串转换成宽字符串
bool StringToWString(const string& strSrc, wstring& strDest)
{
    int nSize = MultiByteToWideChar(CP_ACP, 0, strSrc.c_str(), (int)strSrc.length(), 0, 0);
    if (nSize <= 0)
        return false;

    wchar_t* pwszDst = new wchar_t[nSize + 1];
    int iRet = MultiByteToWideChar(CP_ACP, 0, strSrc.c_str(), (int)strSrc.length(), pwszDst, nSize);
    pwszDst[nSize] = 0;
    strDest.clear();
    strDest.assign(pwszDst);
    delete[] pwszDst;

    return true;
}

2). wstring ====> string

// 宽字符串转换成字符串
bool WStringToString(const wstring& strSrc, string& strDest)
{
    int nLen = WideCharToMultiByte(CP_ACP, 0, strSrc.c_str(), -1, NULL, 0, NULL, NULL);
    if (nLen <= 0)
        return false;

    char* pszDst = new char[nLen];
    int iRet = WideCharToMultiByte(CP_ACP, 0, strSrc.c_str(), -1, pszDst, nLen, NULL, NULL);
    pszDst[nLen - 1] = 0;
    strDest.clear();
    strDest.assign(pszDst);

    delete[] pszDst;

    return true;
}

7. int 与 wstring 之间的转换

#include <string>

std::wstring ws = L"456";
int i = std::stoi(ws);                  // wstring ====> int
std::wstring ws2 = std::to_wstring(i);  // int ====> wstring