C/C++字符串总结

一、概念

ANSI：单字节字符，占1个字节，最多能表示256个符号。
DBCS(Double-Byte Character Set):每个字符占1到2个字节。
Unicode：每个字符占2个字节。
UTF-8：将一些字符编码为1个字节，一些字符编码为2个字节，一些字符编码为3个字节，一些字符编码为4个字节，1个字节–美国字符，2个字节–欧洲和中东地区，3个字节–东亚地区，4个字节–代理对(Surrogate Pair)。
UTF-32:将每个字符都编码为4个字节，不是一种高效的编码格式，将字符串保存到文件或者传到网络时，很少用这个格式，这种编码格式一般在应用程序内部使用。

C语言用char来表示一个8位ANSI字符，用wchar_t表示一个16位的Unicode字符。
strlen返回一个ANSI字符串的长度，wcslen返回一个Unicode字符串的长度。

char表示一个ANSI字符。
wchar_t表示一个Unicode字符。
std::string表示一个ANSI字符串。
std::wstring表示一个Unicode字符串。

“winnt.h”
typedef char CHAR;

typedef CHAR *PCHAR, *LPCH, *PCH;
typedef __nullterminated CHAR *NPSTR, *LPSTR, *PSTR;
typedef __nullnullterminated CHAR *PZZSTR;
typedef __possibly_notnullterminated CHAR *PNZCH;

typedef CONST CHAR *LPCCH, *PCCH;
typedef __nullterminated CONST CHAR *LPCSTR, *PCSTR;
typedef __nullnullterminated CONST CHAR *PCZZSTR;
typedef __possibly_notnullterminated CONST CHAR *PCNZCH;

typedef __nullterminated PSTR *PZPSTR;
typedef __nullterminated CONST PSTR *PCZPSTR;

typedef __nullterminated PCSTR *PZPCSTR;
注：__nullterminated表示一个以’\0’结尾的字符串，__nullnullterminated表示一个以两个’\0’结尾的字符串，__possibly_notnullterminated表示一个不以’\0’结尾的字符串。

typedef WCHAR *PWCHAR, *LPWCH, *PWCH;
typedef CONST WCHAR *LPCWCH, *PCWCH;

typedef WCHAR TCHAR, *PTCHAR;
typedef WCHAR TBYTE, *PTBYTE;

typedef __nullterminated WCHAR *NWPSTR, *LPWSTR, *PWSTR;
typedef __nullterminated PWSTR *PZPWSTR;
typedef __nullterminated CONST PWSTR *PCZPWSTR;
typedef __nullterminated WCHAR UNALIGNED *LPUWSTR, *PUWSTR;
typedef __nullterminated CONST WCHAR *LPCWSTR, *PCWSTR;
typedef __nullterminated PCWSTR *PZPCWSTR;
typedef __nullterminated CONST WCHAR UNALIGNED *LPCUWSTR, *PCUWSTR;

typedef __nullnullterminated WCHAR *PZZWSTR;
typedef __nullnullterminated CONST WCHAR *PCZZWSTR;
typedef __nullnullterminated WCHAR UNALIGNED *PUZZWSTR;
typedef __nullnullterminated CONST WCHAR UNALIGNED *PCUZZWSTR;

typedef __possibly_notnullterminated WCHAR *PNZWCH;
typedef __possibly_notnullterminated CONST WCHAR *PCNZWCH;
typedef __possibly_notnullterminated WCHAR UNALIGNED *PUNZWCH;
typedef __possibly_notnullterminated CONST WCHAR UNALIGNED *PCUNZWCH;

typedef LPWCH LPTCH, PTCH;
typedef LPCWCH LPCTCH, PCTCH;
typedef LPWSTR PTSTR, LPTSTR;
typedef LPCWSTR PCTSTR, LPCTSTR;
typedef LPUWSTR PUTSTR, LPUTSTR;
typedef LPCUWSTR PCUTSTR, LPCUTSTR;
typedef LPWSTR LP;
typedef PZZWSTR PZZTSTR;
typedef PCZZWSTR PCZZTSTR;
typedef PUZZWSTR PUZZTSTR;
typedef PCUZZWSTR PCUZZTSTR;
typedef PNZWCH PNZTCH;
typedef PCNZWCH PCNZTCH;
typedef PUNZWCH PUNZTCH;
typedef PCUNZWCH PCUNZTCH;

根据类型定义，直接给出常见的字符串类型所对应的具体类型

LPSTR – char*

LPWSTR – wchar_t*

LPTSTR – char* 或 wchar_t*

LPCSTR – const char*

LPCWSTR – const wchar_t*

LPCTSTR – const wchar_t* 或 const char*

typedef unsigned char byte;
typedef unsigned char BYTE;
typedef BYTE near *PBYTE;
typedef BYTE far *LPBYTE;
注：BYTE和byte就代表一个字节。

COM中的字符串
BSTR是COM/OLE中定义的标准字符串数据类型。
对于C++，定义在”wtypes.h”中。
typedef wchar_t WCHAR;
typedef WCHAR OLECHAR;
typedef OLECHAR __RPC_FAR *BSTR;
BSTR是一个有长度前缀和NULL结束符的OLECHAR数组。
BSTR的前4个字节是一个表示字符串长度的前缀，长度域的值不包含结束符。
由于是Unicode串，所以字符串是字节数的一半。
BSTR的前四个字节表示长度，而OLECHAR数组的前四个字节表示前两个字符，因此，BSTR和OLECHAR的转换是一个问题。
COM提供了两个BSTR分配用的API：SysAllocString()和SysReallocString()，函数返回的指针指向BSTR的第一个字符，而不是BSTR在内存的第一个字节。

_bstr_t是一个封装并管理BSTR的类，通过这个类，可以方便的把C++类型转换成COM中的变量。
_bstr_t有点类似于只能指针，使用了引用计数。

CComBSTR提供了对BSTR的封装。

二、类型转换[根据目录通过索引查询]

1.std::string与std::wstring相互转换

2.char*与wchar_t*相互转换

3.char*与BSTR相互转换

4.char*与_bstr_t相互转换

5.char*与CComBSTR相互转换

6.BSTR与_bstr_t相互转换

7.BSTR与CComBSTR相互转换

8._bstr_t与CComBSTR相互转换

9.char*与std::string相互转换

10.wchar_t*与std::wstring相互转换

1

std::wstring StdstringToStdwstring(const std::string& szStr)
{
    // Get the length of buffer we'll need for the string
    const int nStdwstringLengthBytes = ::MultiByteToWideChar(CP_UTF8, 0, szStr.c_str(), -1, NULL,
        /*give us the length of buffer we'll need for the encoded string*/0);
    if (nStdwstringLengthBytes <= 0 )
    { // Record Error
        return NULL;
    }


    // And now actually perform the conversion...
    wchar_t* wszStr = new wchar_t[nStdwstringLengthBytes];
    const int nStdstringLengthBytes = ::MultiByteToWideChar(
        CP_UTF8, 0, szStr.c_str(), -1, wszStr, nStdwstringLengthBytes);


    if (nStdstringLengthBytes != nStdwstringLengthBytes)
    { // Record Error
        return NULL;
    }


    return std::wstring(wszStr);
}


std::string StdwstringToStdstring(const std::wstring& wszStr)
{
    // Get the length of buffer we'll need for the string
    const int nStdstringLengthBytes = ::WideCharToMultiByte(CP_UTF8, 0, wszStr.c_str(), -1, NULL,
        /*give us the length of buffer we'll need for the encoded string*/0, NULL, NULL);
    if (nStdstringLengthBytes <= 0)
    { // Record Error
        return NULL;
    }


    // And now actually perform the conversion...
    char* szStr = new char[nStdstringLengthBytes];
    const int nStdwstringLengthBytes = ::WideCharToMultiByte(
        CP_UTF8, 0, wszStr.c_str(), -1, szStr, nStdstringLengthBytes, NULL, NULL);
    if (nStdwstringLengthBytes != nStdstringLengthBytes)
    { // Record Error
        return NULL;
    }


    return std::string(szStr);
}

2

wchar_t* PccharToPwcchart(const char* pszStr)
{
    size_t nLen = strlen(pszStr) + 1;
    size_t nConverted = 0;


    wchar_t* pwszStr = (wchar_t*)malloc(nLen * sizeof(wchar_t));
    mbstowcs_s(&nConverted, pwszStr, nLen, pszStr, _TRUNCATE);


    return pwszStr;
}


char* PwcchartToPcchar(const wchar_t* pwszStr)
{
    size_t nLen = wcslen(pwszStr) + 1;
    size_t nConverted = 0;


    char* pszStr = (char*)malloc(nLen * sizeof(char));
    wcstombs_s(&nConverted, pszStr, nLen, pwszStr, _TRUNCATE);


    return pszStr;
}

3

BSTR PccharToBSTR(const char* pszStr)
{
    if (NULL == pszStr)
    { // Record Error
        return NULL;
    }


    BSTR bstr = _bstr_t(pszStr);


    return bstr;
}


char* BSTRToPcchar(const BSTR bstr)
{
    char* pszStr = _bstr_t(bstr);


    return pszStr;
}

4

_bstr_t PccharTobstrt(const char* pszStr)
{
    if (NULL == pszStr)
    { // Record Error
        return "";
    }


    _bstr_t bstrt(pszStr);


    return bstrt;
}


char* bstrtToPcchar(const _bstr_t bstrt)
{
    return bstrt;
}

5

CComBSTR PccharToCComBSTR(const char* pszStr)
{
    if (NULL == pszStr)
    { // Record Error
        return NULL;
    }


    CComBSTR str(pszStr);


    return str;
}


char* CComBSTRToPcchar(const CComBSTR str)
{
    return const_cast<char*>(static_cast<const char*>(str));
}

6

_bstr_t BSTRTobstrt(const BSTR bstr)
{
    _bstr_t bstrt(bstr);


    return bstrt;
}


BSTR bstrtToBSTR(const _bstr_t bstrt)
{
    return static_cast(bstrt);
}

7

CComBSTR BSTRToCComBSTR(const BSTR bstr)
{
    CComBSTR str(bstr);


    return str;
}


BSTR CComBSTRToBSTR(const CComBSTR str)
{
    return static_cast(str);
}

8

CComBSTR bstrtToCComBSTR(const _bstr_t bstr)
{
    CComBSTR str(static_cast(bstr));


    return str;
}


_bstr_t CComBSTRTobstrt(const CComBSTR str)
{
    _bstr_t bstrt(static_cast(bstr));


    return bstrt;
}

9

std::string PccharToStdstring(const char* pszStr)
{
    return pszStr;
}


char* StdstringToPcchar(const std::string szStr)
{
    return const_cast<char*>(szStr.c_str());
}

10

std::wstring PwccharToStdwstring(const wchar_t* pwszStr)
{
    return pwszStr;
}


wchar_t* StdwstringToPwcchar(const std::wstring wszStr)
{
    return const_cast<wchar_t*>(wszStr.c_str());
}