字符编码转换

已于 2024-01-18 15:56:13 修改
阅读量1.2k 收藏 24
点赞数 21
分类专栏： C++ 编码 STL 文章标签： c++ stl
于 2024-01-03 21:50:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SNAKEpc12138/article/details/135373142
版权
C++ 同时被 3 个专栏收录
54 篇文章 3 订阅
订阅专栏
编码
7 篇文章 0 订阅
订阅专栏
STL
5 篇文章 1 订阅
订阅专栏

宽窄字符和字符编码的关系

多字节(窄)字符：在C/C++中，char是一种数据类型，规定sizeof(char)=1，即一个char占用一个字节，1Byte=8bit。并没有规定一个char就要与ASCII对应，不过，通常情况下char值与ASCII编码对应。

宽字符：标准并没有规定wchar_t占多少位，标准只是要求一个wchar_t可以表示任何系统所能认识的字符，在win32 中，wchar_t为16位；Linux中是32位。

wchar_t同样没有规定编码，一个wchar_t可以不同的编码表示，不过鉴于UTF16正好是两个字节，且为通用编码方式，所以通常情况下将wchar_t与uinicode编码对应。在 win32中，wchar_t的编码是UCS-2BE（utf16BE）；而Linux中是UTF-32BE（等价于UCS-4BE）。

如果想明确声明使用两个字节大小的类型存储UTF-16编码字符，可使用C++提供的另一个宽字符类型char16_t。

char16_t和wchar_t是两种表示宽字符的数据类型，其在不同的编译器和平台下可能有不同的实现和用途。

char16_t: 是C++11引入的数据类型，用于表示16位宽字符，常用于存储UTF-16编码字符。在大多数平台上，它是确切的16位宽字符类型，每个字符占用2个字节。这种数据类型适用于处理Unicode字符，并且可以使用u""前缀来定义UTF-16编码的字符串字面量。

wchar_t: 是用于表示宽字符的数据类型，其宽度在不同的平台和编译器下可能不同。在Windows平台和Visual C++编译器中，wchar_t通常表示16位宽字符，用于存储UTF-16编码的字符。而在其他平台（Linux）和编译器中，wchar_t通常表示32位宽字符，用于存储UTF-32编码的字符。wchar_t一般用于处理宽字符数据，如文件路径、系统命令等。

所以，char16_t和wchar_t的区别主要在于它们的宽度和使用的场景。char16_t固定为16位，主要用于存储UTF-16编码字符；而wchar_t的宽度可能是16位或32位，用于不同平台和编译器下的宽字符处理。

在使用这两个数据类型时，需要注意平台和编译器的不同实现，以及与其他代码/库的兼容性，在Windows系统下，char16_t和wchar_t都占两个字节（16位）大小。但是，为了避免混淆和错误，建议在代码中明确指定所使用的字符编码和数据类型，以确保程序在不同环境中的正确性。

因此后续会使用char16_t存储UTF-16编码的内容

UTF-16BE、UTF-16LE、UTF-16 三者之间的区别。
用两个字节表示必然存在字节序的问题，即大端小端的问题，因此UTF-16后缀就是大小端的意思了。

UTF-16BE，其后缀是 BE 即 big-endian，大端的意思。大端就是将高位的字节放在低地址表示。
UTF-16LE，其后缀是 LE 即 little-endian，小端的意思。小端就是将高位的字节放在高地址表示。
UTF-16，没有指定后缀，即不知道其是大小端，所以其开始的两个字节表示该字节数组是大端还是小端。即FE FF表示大端，FF FE表示小端。

宽窄字符的转换

首先介绍下如何声明各种编码字符串常量：

char ch_ansi[] = "ABC这是一个测试文本123";  //取决于系统默认编码，简体系统为GBK，繁体系统为BIG5
char ch_utf8[] = u8"ABC这是一个测试文本123";  //明确这是一个UTF-8编码的字符串常量
char16_t ch16_utf16[] = u"ABC这是一个测试文本123";    //明确这是一个UTF-16编码的字符串常量，且存储在16位的宽字符数组中
wchar_t wch_utf16[] = L"ABC这是一个测试文本123";      //声明了一个宽字符编码的字符串常量，具体宽度可能是16位（UTF-16，Windows）或32位（UTF-32，Linux）

u"“前缀和L”"前缀是用于定义字符串字面量的前缀，在C++中有不同的含义和用途。

u"“前缀：u”"前缀表示引号内的字符串是以UTF-16编码的宽字符字符串。它用于定义UTF-16字符串字面量，其中每个字符通常占用2个字节。这种前缀主要用于支持Unicode字符集，并且适用于处理宽字符数据。例如，u"你好"定义了一个UTF-16编码的字符串字面量。

L"“前缀：L”“前缀表示引号内的字符串是以宽字符编码的字符串。它的宽度可能是平台和编译器相关的，可能是16位（UTF-16）或32位（UTF-32）。L”"前缀的主要目的是用于处理宽字符数据，例如文件路径、系统命令等。例如，L"Hello"定义了一个宽字符编码的字符串字面量。

总结来说，u"“前缀表示UTF-16编码的宽字符字符串，L”"前缀表示宽字符编码的字符串。它们的使用取决于编译器和平台的实现，并且在处理宽字符数据时起到重要的作用。

注意：不能使用char16_t接收L"“前缀声明的字符串常量，同样不能使用char16_t存储u”"前缀声明的字符串常量：
1

回到正题，对于宽窄字符的转换，这里有两种转换方式：

一种是保持原有字符编码不变，仅进行宽窄字符类型的转换。

另一种是即进行宽窄字符类型的转换，也进行字符编码的转换。

保持原编码转换：只转换类型，不转换编码

char*、char16_t*、wchar* 、UTF-16 等存储的都是二进制数据，不涉及字符编码，因此是能够在不改变字符编码的情况下进行相互转换的。

char* 转 char16_t*

示例：

    char ch_ansi[] = "ABC这是一个测试文本123";

    //char* 转 char16_t*
    size_t srcLen = strlen(ch_ansi);
    size_t wideLen = srcLen / 2;
    char16_t* wideStr = new char16_t[wideLen + 1];

    for (int i = 0; i < wideLen; i++)
    {
        reinterpret_cast<char*>(&wideStr[i])[0] = ch_ansi[i * 2];
        reinterpret_cast<char*>(&wideStr[i])[1] = ch_ansi[i * 2 + 1];
    }

    wideStr[wideLen] = u'\0';

    QString qsLocal = QString::fromLocal8Bit((char*)wideStr);
    QString qsUTF16 = QString::fromUtf16(wideStr);
    delete[]wideStr;

解码结果：
2

在这段代码中，reinterpret_cast<char*>(&wideString[i])将wchar_t类型的指针&wideString[i]转换为char类型的指针。这样做是为了访问wchar_t类型的指针所指向的内存，并按字节存储到char类型的指针中。

然后，[0]表示通过char类型的指针获取指针所指向的第一个字节的值。因为UTF-16编码的字符由两个字节组成，所以通过reinterpret_cast<char>(&wideString[i])[0]可以获取到UTF-16字符的第一个字节。

在循环中，我们将每个UTF-16编码的字符拆分为两个字节，并分别存储到char*数组中。拆分过程中，使用[0]和[1]分别获取两个字节的值，并存储到对应的位置上。

为什么使用reinterpret_cast而不是static_cast或dynamic_cast

在上述代码中，使用reinterpret_cast而不是static_cast或dynamic_cast是因为需要进行指针类型之间的转换，而不是从一个类层次结构中进行类型转换。

reinterpret_cast是最强大的类型转换操作符，可以在指针类型之间进行任意的转换。它不进行任何运行时的类型检查，而是仅仅对二进制数据进行重新解释。

而static_cast用于在静态类型转换中，包括基本类型的转换，指针或引用之间的上下转换以及类之间的上下转换。但它不能用于没有直接或间接转换关系的类型之间的转换，也不能用于指针类型的底层二进制表示的转换。

同样，dynamic_cast主要用于在具有多态关系的类之间进行类型转换，而不是用于指针类型的底层二进制表示的转换。

在这种情况下，我们需要将wchar_t类型的指针转换为char类型的指针，以进行字节级别的内存操作。由于这两种指针类型之间没有直接的转换关系，也没有多态关系，因此使用reinterpret_cast是最合适的选择。*

直接使用强制类型转换也可以，但不推荐：

    char16_t* pCh16 = (char16_t*)ch_ansi;
    QString qsLocal_2 = QString::fromLocal8Bit((char*)pCh16);
    QString qsUTF16_2 = QString::fromUtf16(pCh16);

解码结果：

3

这段代码直接将wideString数组指针的类型直接转换为char*类型，而不是对数组中的每个元素进行单独的字节拆分和转换，这会使pCH16按照宽字符的内存布局来处理数据。

char* 转 wchar_t*

示例：

    //char* 转 wchar_t*
    char ch_ansi[] = "ABC这是一个测试文本123";
    size_t srcLen = strlen(ch_ansi);
    size_t wideLen = srcLen / 2;
    wchar_t* wideStr = new wchar_t[wideLen + 1];
    for (int i = 0; i < wideLen; i++)
    {
        reinterpret_cast<char*>(&wideStr[i])[0] = ch_ansi[i * 2];
        reinterpret_cast<char*>(&wideStr[i])[1] = ch_ansi[i * 2 + 1];
    }
    wideStr[wideLen] = L'\0';
    QString qsLocal = QString::fromLocal8Bit((char*)wideStr);
    QString qsUTF16 = QString::fromWCharArray(wideStr);
    delete[]wideStr;

解码结果：
4

char16_t* 转 char*

示例：

    //char16_t* 转 char*，已测试可行
    char16_t ch16_utf16[] = u"SOP这是一个宽字符测试文本456"; // UTF-16编码的字符串

    // 计算UTF-16编码字符串的长度
    int length = std::char_traits<char16_t>::length(ch16_utf16);

    // 计算转换后的char*所需的长度 (每个UTF-16字符需要2个字节)
    int charArrayLength = length * 2;

    // 创建用于存储转换后的char*的缓冲区
    char* charArray = new char[charArrayLength + 1]; // 需要添加额外的终止空字符

    // 将UTF-16编码的字符串转换为char*
    for (int i = 0; i < length; i++) 
    {
        charArray[i * 2] = reinterpret_cast<char*>(&ch16_utf16[i])[0]; // 高位字节
        charArray[i * 2 + 1] = reinterpret_cast<char*>(&ch16_utf16[i])[1]; // 低位字节
    }
    charArray[charArrayLength] = '\0'; // 添加终止空字符

    QString qsLocal = QString::fromLocal8Bit(charArray);
    QString qsUtf16 = QString::fromWCharArray((wchar_t*)charArray);
    QString qsUtf16_2 = QString::fromUtf16((char16_t*)charArray);
    // 释放分配的内存
    delete[] charArray;

解码结果：
5

char16_t* 转 wchar_t*

示例：

//char16_t* 转 wchar_t*
char16_t ch16_utf16[] = u"SOP这是一个宽字符测试文本456";
std::wstring result;
for (int i = 0; ch16_utf16[i] != u'\0'; ++i)
{
    result.push_back(static_cast<wchar_t>(ch16_utf16[i]));
}

const wchar_t* wch_utf16 = result.c_str();

将UTF-16编码的char16_t数组转换为wchar_t时，相当于将UTF-16编码直接存储在wchar_t中，因为它们的大小和编码方式相匹配。所以可以理解为使用wchar_t*存储UTF-16编码的内容。

解码结果：
6

但在Linux系统上，将UTF-16编码的char16_t数组转换为wchar_t后，并不能直接理解为使用wchar_t存储UTF-16编码的内容。
在Linux系统上，wchar_t的大小通常是4个字节，与UTF-32编码中每个字符的大小相匹配。而UTF-16编码中每个字符的大小是2个字节。
如果您将UTF-16编码的char16_t数组直接转换为wchar_t*，会导致字符编码不匹配。因为在Linux系统上，wchar_t*所表示的是UTF-32编码的内容，而不是UTF-16编码的内容。

wchar_t* 转 char*

示例：

    //wchar_t* 转 char*，已测试可行
    wchar_t wideString[] = L"SOP这是一个宽字符测试文本456"; // UTF-16编码的wchar_t数组

    // 获取宽字符数组的长度
    int length = wcslen(wideString);

    // 创建存储UTF-16编码字符的char数组
    char* narrowString = new char[length * 2 + 1]; // 每个UTF-16字符由两个字节组成

    // 将UTF-16编码的wchar_t*数组转换为char*数组
    for (int i = 0; i < length; i++) {
        narrowString[i * 2] = reinterpret_cast<char*>(&wideString[i])[0];
        narrowString[i * 2 + 1] = reinterpret_cast<char*>(&wideString[i])[1];
    }
    narrowString[length * 2] = '\0'; // 添加字符串结束符

    QString qsWArr = QString::fromWCharArray((wchar_t*)narrowString);
    QString qsUtf16 = QString::fromUtf16((char16_t*)narrowString);

    // 释放内存
    delete[] narrowString;

解码结果：
7

wchar_t* 转 char16_t*

在Windows系统上, 将UTF-16编码的wchar_t数组转换为char16_t后，可以理解为使用char16_t存储UTF-16编码的内容。

    //wchar_t* 转 char16_t*
    wchar_t wch_utf16[] = L"SOP这是一个宽字符测试文本456"; // UTF-16编码的宽字符数组

    // 计算宽字符数组的长度
    int wideLength = wcslen(wch_utf16);

    // 计算转换后的char16_t*所需的长度 (每个宽字符字符需要2个字节)
    int charArrayLength = wideLength;

    // 创建用于存储转换后的char16_t*的缓冲区
    char16_t* char16Array = new char16_t[charArrayLength + 1]; // 需要添加额外的终止空字符

    // 将宽字符数组转换为char16_t*
    for (int i = 0; i < wideLength; i++) {
        char16Array[i] = static_cast<char16_t>(wch_utf16[i]);
    }
    char16Array[charArrayLength] = u'\0';

    QString qsWArr = QString::fromWCharArray((wchar_t*)char16Array);
    QString qsUTF16 = QString::fromUtf16(char16Array);tf16(char16Array);

    // 释放分配的内存
    delete[] char16Array;

解码结果：
8

同样在Linux系统上，将wchar_t数组转换为char16_t时，不能直接理解为使用char16_t存储UTF-32编码的内容。这是因为wchar_t和char16_t是不同的数据类型，它们在内存中使用的字节数不同。

小结

本质上，所有字符类型容器存储的都是二进制数据，这些二进制的编码可以是任何字符编码，至于怎么解析这些二进制数据，其值代表什么字符，怎么显示给你看的，就是解码的过程了。

只要清楚源数据的字符编码，无论使用何种容器存储，只能能使用相应的编码方式解码，就一定不会有乱码问题。

当然，通常情况下都会使用以char类型为基础的容器存储ANSI以及UTF-8编码的内容，用以char16_t、wchar_t为基础的容器存储UTF-16、UTF-32的内容，如下：
20

字符编码转换：既转换类型，也转换编码

宽字符转多字节字符

WideCharToMultiByte

WideCharToMultiByte是Windows API中的一个函数，用于将宽字符字符串（UTF-16或UCS-2编码）转换为多字节字符字符串（例如ASCII或UTF-8编码）。它通常在需要支持多种字符编码的Windows应用程序中使用。

原型如下：

#include <Windows.h>
int WideCharToMultiByte(
    UINT CodePage,              // 字符编码标识符
    DWORD dwFlags,              // 标志位
    LPCWCH lpWideCharStr,       // 宽字符字符串地址
    int cchWideChar,            // 宽字符字符串长度
    LPSTR lpMultiByteStr,       // 多字节字符字符串地址
    int cbMultiByte,            // 多字节字符字符串长度
    LPCCH lpDefaultChar,        // 默认字符
    LPBOOL lpUsedDefaultChar    // 指向布尔值的指针，用于指示是否使用了默认字符
    );

注意：WideCharToMultiByte的CodePage参数用于指定目标字符编码。它表示将要转换成的多字节字符的编码方式。即这个参数的值决定了将宽字符转换为多字节字符时所使用的字符集。

#include <Windows.h>
#include <string>

// 宽字符转多字节字符
std::string WideCharToMultiByteWithAcp(const wchar_t* wideStr, UINT codePage)
{
    int bufferSize = WideCharToMultiByte(codePage, 0, wideStr, -1, nullptr, 0, nullptr, nullptr);
    if (bufferSize == 0)
    {
        // 转换失败
        return "";
    }

    std::string multiStr(bufferSize, '\0');
    if (WideCharToMultiByte(codePage, 0, wideStr, -1, &multiStr[0], bufferSize, nullptr, nullptr) == 0)
    {
        // 转换失败
        return "";
    }

    return multiStr;
}

codePage参数是用来指定字符编码的参数，其中不同的值代表不同的字符编码。以下是一些常用的codePage值及其对应的字符编码：

CP_ACP（常用）：系统默认的 Windows ANSI 代码页。简体-GBK，繁体-BIG5

CP_MACCP：当前系统 Macintosh 代码页。

CP_OEMCP：当前系统 OEM 代码页。

CP_SYMBOL：Windows 2000： 符号代码页 (42) 。

CP_THREAD_ACP：Windows 2000： 当前线程的 Windows ANSI 代码页。

CP_UTF7：UTF-7。 仅当受 7 位传输机制强制使用此值。 最好使用 UTF-8。 设置此值后， 必须将 lpDefaultChar 和 lpUsedDefaultChar 设置为 NULL。

CP_UTF8（常用）：UTF-8。 设置此值后， 必须将 lpDefaultChar 和 lpUsedDefaultChar 设置为 NULL。

测试示例：

char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

//接口测试
// 测试环境：Windows系统，CodePage: 936 简体中文 - GB2312//WideCharToMultiByte & MultiByteToWideChar

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 UTF-8编码的多字节
std::string sUtf8_fromWCH = WideCharToMultiByteWithAcp(wch_utf16, CP_UTF8); 

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sGB2312_fromWCH = WideCharToMultiByteWithAcp(wch_utf16, CP_ACP);

//UTF-16编码的宽字符 转 UTF-8编码的多字节
std::string sUTF8_fromCh16 = WideCharToMultiByteWithAcp((wchar_t*)ch16_utf16, CP_UTF8);

//UTF-16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sGB2312_fromCh16 = WideCharToMultiByteWithAcp((wchar_t*)ch16_utf16, CP_ACP);

测试结果：
9

优点：

可指定转换时的编码

缺点：

Windows接口，不能跨平台

W2A

W2A宏是特定于Windows平台的，依赖于MFC库。

W2A定义如下：

//atlconv.h
#define W2A(lpw) (\
    ((_lpw = lpw) == NULL) ? NULL : (\
        (_convert = (static_cast<int>(wcslen(_lpw))+1), \
        (_convert>INT_MAX/2) ? NULL : \
        ATLW2AHELPER((LPSTR) alloca(_convert*sizeof(WCHAR)), _lpw, _convert*sizeof(WCHAR), _acp))))


#define ATLW2AHELPER AtlW2AHelper


_Ret_maybenull_z_ _Post_writable_byte_size_(nChars) inline LPSTR WINAPI AtlW2AHelper(
    _Out_writes_opt_z_(nChars) LPSTR lpa,
    _In_opt_z_ LPCWSTR lpw,
    _In_ int nChars) throw()
{
    return AtlW2AHelper(lpa, lpw, nChars, CP_ACP);
}


ATLPREFAST_SUPPRESS(6054)
_Ret_maybenull_z_ _Post_writable_byte_size_(nChars) inline LPSTR WINAPI AtlW2AHelper(
    _Out_writes_opt_z_(nChars) LPSTR lpa,
    _In_opt_z_ LPCWSTR lpw,
    _In_ int nChars,
    _In_ UINT acp) throw()
{
    ATLASSERT(lpw != NULL);
    ATLASSERT(lpa != NULL);
    if (lpa == NULL || lpw == NULL)
        return NULL;
    // verify that no illegal character present
    // since lpa was allocated based on the size of lpw
    // don't worry about the number of chars
    *lpa = '\0';
    int ret = WideCharToMultiByte(acp, 0, lpw, -1, lpa, nChars, NULL, NULL);
    if(ret == 0)
    {
        ATLASSERT(FALSE);
        return NULL;
    }
    return lpa;
}
ATLPREFAST_UNSUPPRESS()

可以看到W2A宏也是使用Windows接口WideCharToMultiByte进行宽字符到多字节字符的转换，因此使用W2A时，还需要包含Windows.h头文件:

#include <Windows.h>

需要注意的是，使用W2A宏进行字符串转换时，会使用系统默认的字符编码（CP_ACP）进行转换。如果需要使用其他字符编码进行转换，可以使用上面用WideCharToMultiByte实现的转换函数并指定相应的字符编码。

这里使用alloca在在W2A宏函数所在的作用域内的栈上分配内存，无需再手动释放内存！

自定义转换接口如下：

std::string WToA(const wchar_t* wideStr)
{
    USES_CONVERSION;
    return std::string(W2A(wideStr));
}

测试示例：

//W2A & A2W : 默认使用系统默认编码转换，不支持指定转换编码
char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_fromWCH = WToA(wch_utf16);

//UTF-16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_fromCH16 = WToA((wchar_t*)ch16_utf16);

测试结果：
10

不能指定编码，且不能跨平台，直接拉黑。

wcstombs

wcstombs 是一个 C/C++ 标准库函数，用于将宽字符字符串（wchar_t 类型）转换为多字节字符串（char 类型）。

函数原型：

size_t wcstombs(char* dest, const wchar_t* src, size_t destSize);
//dest：指向目标多字节字符串的指针，用于存储转换后的结果。
//src：指向源宽字符字符串的指针，要进行转换的字符串。
//destSize：目标多字节字符串的最大长度，包括终止符 \0。
//返回值：
//如果转换成功，则返回转换后的多字节字符数（不包括终止符 \0）。
//如果目标多字节字符串的空间不足以存储转换后的结果或发生了无效的宽字符，则返回 SIZE_MAX 并设置 errno 为 EILSEQ。

注意事项：

  • wcstombs 函数将宽字符字符串按照当前的本地编码进行转换。因此，转换结果可能因系统区域设置而异，对于非 ASCII 字符，可能需要使用 Unicode 或其他编码来转换。
  • 目标多字节字符串应该具备足够的空间，以确保转换后的结果不会溢出。
  • 如果 dest 参数为 NULL，则 wcstombs 函数会计算转换后的结果长度，但不进行实际转换。可以通过检查返回值来获取所需的缓冲区大小。

可使用std::setlocale获取、设置当前程序的本地化（locale）环境。

std::setlocale函数用于设置程序的本地化环境，以便程序能够正确处理与语言、字符集、日期时间格式等相关的操作。根据指定的本地化环境，不同的函数和库可能在字符转换、字符串比较、日期时间格式化等方面表现出不同的行为。

关于std::setlocale的使用，详见：std::setlocale详解

这里列举下常规的使用示例：

    //std::setlocale
    //获取本地化环境
    char* pCurLocale = std::setlocale(LC_ALL, nullptr);

    //仅传入可选值，设置失败返回NULL
    //当前系统环境（Chinese (Simplified)_China.936），使用GB2312编码
    char* pZh_CN_936 = std::setlocale(LC_ALL, ".936");
    //当前系统环境（Chinese (Simplified)_China.936），使用BIG5编码
    char* pZh_CN_950 = std::setlocale(LC_ALL, ".950");
    //当前系统环境（Chinese (Simplified)_China.936），UTF-8编码
    char* pZh_CN_65001 = std::setlocale(LC_ALL, ".65001");

    //恢复系统本地默认设置
    char* pDefault = std::setlocale(LC_ALL, "");

结果：
11

自定义转换接口（带编码参数）如下：

// 将宽字符字符串转换为多字节字符串
std::string MyWidget::WcsToMbs(const wchar_t* wideStr, const char* encoding)
{
	// 获取当前的locale设置
	std::locale prevLocale = std::locale::global(std::locale(""));

	// 尝试设置并使用给定的locale
	try
	{
		std::locale::global(std::locale(encoding));

		// 先用wcstombs计算需要多少长度的缓冲区
		size_t bufferSize = std::wcstombs(nullptr, wideStr, 0);
		if (bufferSize == static_cast<size_t>(-1))
		{
			throw std::runtime_error("WcsToMbs: conversion failed at calculation phase");
		}

		// 创建所需长度的缓冲区
		std::vector<char> multiByteStrBuffer(bufferSize + 1);   // bufferSize + 1，以便放置'\0'

		// 然后再调用wcstombs进行转换
		size_t numBytesConverted = std::wcstombs(multiByteStrBuffer.data(), wideStr, bufferSize + 1);

		// 检查转换是否成功
		if (numBytesConverted == static_cast<size_t>(-1)) {
			throw std::runtime_error("WcsToMbs: conversion failed at conversion phase");
		}

		// 可以安全地创建字符串，因为我们知道在缓冲区中已经有一个'\0'
		std::string result(multiByteStrBuffer.data());

		// 操作成功完成，恢复原始的本地化设置
		std::locale::global(prevLocale);

		return result;
	}
	catch (...)
	{
		// 如果发生异常，恢复原有的locale设置并重新抛出该异常
		std::locale::global(prevLocale);
		throw;
	}
}

**注意：**MbsToWcs的encoding参数用于指定目标字符编码。它表示将要转换成的多字节字符的编码方式。即这个参数的值决定了将宽字符转换为多字节字符时所使用的字符集。同前面的WideCharToMultiByte。

测试示例：

try
{
	char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
	wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

	//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
	std::string sANSI_fromWCH = WcsToMbs(wch_utf16, "");

	//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 UTF-8编码的多字节
	std::string sUTF8_fromWCH = WcsToMbs(wch_utf16, ".65001");

	//UTF-16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
	std::string sANSI_fromCh16 = WcsToMbs((wchar_t*)ch16_utf16, "");

	//UTF-16编码的宽字符 转 UTF-8编码的多字节
	std::string sUTF8_fromCh16 = WcsToMbs((wchar_t*)ch16_utf16, ".65001");
}
catch(...)
{
	//转换失败
}

测试结果：
12
优点：C/C++ 标准库接口实现，可跨平台，且能指定编码转换

std::wstring_convert

std::wstring_convert 是 C++ 标准库中的一个类模板，它提供了多字节字符串和宽字符字符串之间的转换功能。它是在 C++11 标准中引入的，定义在 <locale> 头文件中。

std::wstring_convert 类模板主要用于将多字节字符串（std::string）和宽字符字符串（std::wstring）之间进行转换。它提供了一种方便的方法来处理不同编码之间的字符串转换，而无需直接使用底层的 C 标准库函数。

下面是 std::wstring_convert 类模板的基本语法：

template <class Codecvt, class Elem = wchar_t, class Wide_alloc = std::allocator<Elem>, class Byte_alloc = std::allocator<char>>
class wstring_convert;

std::wstring_convert 模板有四个参数：

  • Codecvt：指定编码转换器的类型。这是一个实现了 std::codecvt 接口的类型，用于执行不同编码之间的转换。通常可以使用 std::codecvt_utf8, std::codecvt_utf16, std::codecvt_utf8_utf16 等标准实现的编码转换器。
  • Elem：目标字符类型，默认为 wchar_t，表示宽字符。
  • Wide_alloc：宽字符字符串的分配器类型，默认为 std::allocator<Elem>。
  • Byte_alloc：多字节字符串的分配器类型，默认为 std::allocator<char>。

std::wstring_convert 类模板提供了以下成员函数：

  1. wstring_convert(Codecvt* pcvt): 构造函数，使用指定的编码转换器 pcvt 创建一个 std::wstring_convert 对象。
  2. ~wstring_convert(): 析构函数，释放 std::wstring_convert 对象的资源。
  3. std::string to_bytes(const std::wstring& str): 将宽字符字符串 str 转换为多字节字符串，并返回转换后的结果。
  4. std::wstring from_bytes(const std::string& str): 将多字节字符串 str 转换为宽字符字符串，并返回转换后的结果。

std::wstring_convert 模板的 Codecvt 参数指定了编码转换器的类型，它是一个实现了 std::codecvt 接口的类型。下面是一些常见的可用的 Codecvt 参数值：

  1. std::codecvt_utf8<wchar_t>：用于将 UTF-8 编码的多字节字符串转换为宽字符字符串。
  2. std::codecvt_utf16<wchar_t>：用于将 UTF-16 编码的多字节字符串转换为宽字符字符串。
  3. std::codecvt_utf8_utf16<wchar_t>：用于在 UTF-8 编码和 UTF-16 编码之间进行转换。
  4. std::codecvt_byname<wchar_t, char, std::mbstate_t>：使用特定名称的编码转换器。
  5. std::codecvt<char16_t, char, std::mbstate_t>：用于将 UTF-16 编码的多字节字符串转换为 char16_t 类型的宽字符字符串。
  6. std::codecvt<char32_t, char, std::mbstate_t>：用于将 UTF-32 编码的多字节字符串转换为 char32_t 类型的宽字符字符串。

注意，具体可用的 Codecvt 参数值取决于你的编译器和标准库的实现，以及系统所支持的编码类型。

另外需注意，如果你使用的编译器和标准库不支持特定的编码转换器，你可以自定义实现 std::codecvt 接口的子类，并将其作为 Codecvt 参数传递给 std::wstring_convert 模板实例化。这样可以根据您的需要支持其他编码转换（例ANSI编码）。

std::wstring_convert 并不能直接使用 ANSI 编码进行转换。std::wstring_convert 模板的 Codecvt 参数是一个实现了 std::codecvt 接口的类型，但是标准库并没有提供直接支持 ANSI 编码的 std::codecvt 实现。

ANSI 编码是一个与操作系统和环境相关的编码方式，不同的操作系统和环境可能使用不同的 ANSI 编码。在 C++ 标准库中，提供了与 ANSI 编码相关的 std::codecvt 实现的特定名称，例如 std::codecvt_byname，它允许使用特定名称的编码来进行转换。但是，具体可用的编码名称取决于操作系统和环境的支持。

如果需要使用 ANSI 编码进行字符串转换，可以考虑以下几种方法：

  1. 使用底层的 C 语言标准库函数，例如 mbstowcs 和 wcstombs，来手动进行 ANSI 编码和宽字符字符串之间的转换。

  2. 使用第三方库，例如 iconv，它可以提供更灵活和全面的字符串编码转换功能。

  3. 根据具体需求，可以自己实现一个符合 ANSI 编码转换要求的 std::codecvt 子类。

自定义转换接口：

std::string ws_convert_to_s(const std::wstring& wideStr)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        return converter.to_bytes(wideStr);
    }
    catch (...)
    {
        return "";
    }
}

该方式不能指定ANSI编码进行转换，若想指定需自定义std::codecvt子类，较为麻烦。

但对于Unicode字符集中的编码转换较为方便。

测试示例：

//std::wstring_convert
char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
//不支持转 ANSI(当前系统是GB2312)编码的多字节

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 UTF-8编码的多字节
std::string sANSI_fromWCH = ws_convert_to_s(wch_utf16);

//UTF-16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
//不支持转 ANSI(当前系统是GB2312)编码的多字节

//UTF-16编码的宽字符 转 UTF-8编码的多字节
std::string sANSI_fromCh16 = ws_convert_to_s((wchar_t*)ch16_utf16);

测试结果：
13

借助QString转换

QString内部封装了各种编码的转换接口，如果在Qt开发环境下，也可借助QString进行编码转换。

自定义转换接口：

enum class EncodingFormat : int
{
	ANSI = 0,          // 默认
	UTF8,          // UTF-8
	UTF16_LE,      // UTF-16 LE
	UTF16_BE,      // UTF-16 BE
					//后面可按需补充
};


std::string ws_to_s_with_qs(const std::wstring& wideStr, const EncodingFormat& toEncode)
{
	QString qsTo = QString::fromStdWString(wideStr);
	if (toEncode == EncodingFormat::UTF8)
	{
		return qsTo.toUtf8();
	}
	else if (toEncode == EncodingFormat::ANSI)
	{
		return qsTo.toLocal8Bit();
	}
	else
	{
		//默认转UTF-8
		return qsTo.toUtf8();
	}
}

测试示例：

//ws_to_s_with_qs
char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_from_WCH = ws_to_s_with_qs(wch_utf16, EncodingFormat::ANSI);

//宽字符编码（Windows系统上是UTF-16) 的宽字符 转 UTF-8编码的多字节
std::string sUtf8_from_WCH = ws_to_s_with_qs(wch_utf16, EncodingFormat::UTF8);

//UTF-16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_from_CH16 = ws_to_s_with_qs((wchar_t*)ch16_utf16, EncodingFormat::ANSI);

//UTF-16编码的宽字符 转 UTF-8编码的多字节
std::string sUtf_from_CH16 = ws_to_s_with_qs((wchar_t*)ch16_utf16, EncodingFormat::UTF8);

测试结果：
20
缺点：无法指定具体的ANSI编码。如无法指定具体的GB2312、BIG5等编码。

借助QTextCodec转换

与QString比较，QTextCodec的fromUnicode(const QString& str) 和 toUnicode(const QByteArray& input)支持从ANSI编码转换到Unicode，也可以从Unicode转换到ANSI。

自定义转换接口：

std::string ws_to_s_with_qtextcodec(const std::wstring& wideStr, const char* toEncodeName)
{
	QTextCodec* codec = QTextCodec::codecForName(toEncodeName);
	return codec->fromUnicode(wideStr);
}

toEncodeName常见值：GB2312、GBK、GB18030、BIG5、UTF-8

支持的所有值详见：

https://doc.qt.io/qt-6/qtextcodec.html#details

测试示例：

//ws_to_s_with_qtextcodec
char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

//宽字符编码（Windows系统上是UTF - 16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_from_WCH = ws_to_s_with_qtextcodec(wch_utf16, "GB2312");

//宽字符编码（Windows系统上是UTF - 16) 的宽字符 转 UTF - 8编码的多字节
std::string sUtf8_from_WCH = ws_to_s_with_qtextcodec(wch_utf16, "UTF-8");

//UTF - 16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
std::string sAnsi_from_CH16 = ws_to_s_with_qtextcodec((wchar_t*)ch16_utf16, "GB2312");

//UTF - 16编码的宽字符 转 UTF - 8编码的多字节
std::string sUtf_from_CH16 = ws_to_s_with_qtextcodec((wchar_t*)ch16_utf16, "UTF-8");

测试结果：
21

借助iconv三方库转换

iconv三方库地址：
https://github.com/winlibs/libiconv/tree/master/MSVC16

下载后选择对应MSVC版本重新编译生成即可：
22

例：我使用VS2019重新生成MSVC16目录中的动态库项目，重新生成的文件如下：
23
24
25

将输出目录下的.h、.lib、.dll放到自己项目中即可，不知道操作可参考：
动态链接库(三)–动态链接库的使用_动态链接库怎么调用-CSDN博客

自定义接口：

std::string WideToMultiByte_With_Iconv(const wchar_t* input, const char* fromEncoding, const char* toEncoding)
{
	iconv_t conv = iconv_open(toEncoding, fromEncoding);

	if (conv == (iconv_t)-1)
	{
		throw std::invalid_argument("Invalid 'to' or 'from' encoding parameter");
	}

	size_t inputBytesLeft = wcslen(input) * sizeof(wchar_t);
	size_t outputBytesLeft = inputBytesLeft * 2; // For handling multi-byte characters
	char* output = new char[outputBytesLeft + 1]; // +1 for null termination
	char* outputPtr = output;

	if (iconv(conv, (char**)&input, &inputBytesLeft, &outputPtr, &outputBytesLeft) == (size_t)-1)
	{
		delete[] output;
		iconv_close(conv);
		throw std::runtime_error("Conversion failed");
	}

	*outputPtr = '\0';  // Null terminate the string
	std::string outputStr(output);
	delete[] output;
	iconv_close(conv);

	return outputStr;
}

测试示例：

//WideToMultiByte_With_Iconv
char16_t ch16_utf16[] = u"这是一个UTF-16编码的测试文本";
wchar_t wch_utf16[] = L"在Windows系统上，这是一个UTF-16编码的测试文本";

try
{
	//宽字符编码（Windows系统上是UTF - 16) 的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
	std::string sAnsi_from_WCH = WideToMultiByte_With_Iconv(wch_utf16, "UTF-16LE", "GB2312");

	//宽字符编码（Windows系统上是UTF - 16) 的宽字符 转 UTF - 8编码的多字节
	std::string sUtf8_from_WCH = WideToMultiByte_With_Iconv(wch_utf16, "UTF-16LE", "UTF-8");

	//UTF - 16编码的宽字符 转 ANSI(当前系统是GB2312)编码的多字节
	std::string sAnsi_from_CH16 = WideToMultiByte_With_Iconv((wchar_t*)ch16_utf16, "UTF-16LE", "GB2312");

	//UTF - 16编码的宽字符 转 UTF - 8编码的多字节
	std::string sUtf_from_CH16 = WideToMultiByte_With_Iconv((wchar_t*)ch16_utf16, "UTF-16LE", "UTF-8");
}
catch (...)
{
	//转换失败
}

测试结果：
26

多字节字符转宽字符

MultiByteToWideChar

MultiByteToWideChar是Windows API中的一个函数，用于将多字节字符字符串（例如ASCII或UTF-8编码）转换为宽字符字符串（UTF-16或UCS-2编码）。它与WideCharToMultiByte相反，可以在Windows应用程序中进行字符编码的转换。该函数可以根据指定的代码页来处理字符转换，同时还可以处理不可转换的字符。

原型如下：

#include <Windows.h>
int MultiByteToWideChar(
    UINT CodePage,              // 字符编码标识符
    DWORD dwFlags,              // 标志位
    LPCCH lpMultiByteStr,       // 多字节字符字符串地址
    int cbMultiByte,            // 多字节字符字符串长度
    LPWSTR lpWideCharStr,       // 宽字符字符串地址
    int cchWideChar             // 宽字符字符串长度
    );

注意：MultiByteToWideChar函数中的CodePage参数是指定源字符编码的参数。它表示将要转换的多字节字符的编码方式。参数nCodePage指定了输入多字节字符的代码页，用于将多字节字符转换为宽字符（UTF-16或UCS-2编码）。即这个参数的值决定了多字节字符转换为宽字符时所使用的字符集。

#include <Windows.h>
#include <string>

// 多字节字符转宽字符
std::wstring MultiByteToWideCharWithAcp(const char* multiStr, UINT codePage)
{
    int bufferSize = MultiByteToWideChar(codePage, 0, multiStr, -1, nullptr, 0);
    if (bufferSize == 0)
    {
        // 转换失败
        return L"";
    }

    std::wstring wideStr(bufferSize, L'\0');
    if (MultiByteToWideChar(codePage, 0, multiStr, -1, &wideStr[0], bufferSize) == 0)
    {
        // 转换失败
        return L"";
    }

    return wideStr;
}

测试示例：

char ch_ansi[] = "这是一个ANSI编码的测试文本";
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_fromANSI = MultiByteToWideCharWithAcp(ch_ansi, CP_ACP);

//ANSI(当前系统是GB2312)编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_fromANSI.c_str();

//UTF-8编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_fromUTF8 = MultiByteToWideCharWithAcp(ch_utf8, CP_UTF8);

//UTF-8编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_fromUTF8.c_str();

测试结果：
14

优点：

可指定转换时的编码

缺点：

Windows接口，不能跨平台

A2W

同理，A2W宏是特定于Windows平台的，依赖于MFC库。

A2W定义如下：

//atlconv.h
#define A2W(lpa) (\
    ((_lpa = lpa) == NULL) ? NULL : (\
        _convert = (static_cast<int>(strlen(_lpa))+1),\
        (INT_MAX/2<_convert)? NULL :  \
        ATLA2WHELPER((LPWSTR) alloca(_convert*sizeof(WCHAR)), _lpa, _convert, _acp)))

#define ATLA2WHELPER AtlA2WHelper

_Ret_maybenull_z_ _Post_writable_byte_size_(nChars) inline LPWSTR WINAPI AtlA2WHelper(
    _Out_writes_opt_z_(nChars) LPWSTR lpw,
    _In_opt_z_ LPCSTR lpa,
    _In_ int nChars) throw()
{
    return AtlA2WHelper(lpw, lpa, nChars, CP_ACP);
}

ATLPREFAST_SUPPRESS(6054)
_Ret_maybenull_z_ _Post_writable_byte_size_(nChars) inline LPWSTR WINAPI AtlA2WHelper(
    _Out_writes_opt_z_(nChars) LPWSTR lpw,
    _In_opt_z_ LPCSTR lpa,
    _In_ int nChars,
    _In_ UINT acp) throw()
{
    ATLASSERT(lpa != NULL);
    ATLASSERT(lpw != NULL);
    if (lpw == NULL || lpa == NULL)
        return NULL;
    // verify that no illegal character present
    // since lpw was allocated based on the size of lpa
    // don't worry about the number of chars
    *lpw = '\0';
    int ret = MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);
    if(ret == 0)
    {
        ATLASSERT(FALSE);
        return NULL;
    }
    return lpw;
}
ATLPREFAST_UNSUPPRESS()

注意：

使用A2W同样需要包含Windows.h

#include <Windows.h>

转换时也是使用系统默认的字符编码（CP_ACP）进行转换。

这里使用alloca在在A2W宏函数所在的作用域内的栈上分配内存，无需再手动释放内存！

自定义转换接口如下：

std::wstring AToW(const char* multiStr)
{
    USES_CONVERSION;
    return std::wstring(A2W(multiStr));
}

测试示例：

char ch_ansi[] = "这是一个ANSI编码的测试文本";

//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_fromANSI = AToW(ch_ansi);

//ANSI(当前系统是GB2312)编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromAnsi = (const char16_t*)wsWide_fromANSI.c_str();

测试结果：

15

因默认使用系统默认编码进行转码，传入UTF-8编码内容时转码会乱码：

//传入UTF-8编码内容转码 会 乱码
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";
std::wstring wsWide_fromUTF8 = AToW(ch_utf8);

测试结果：
16

mbstowcs

mbstowcs 是一个 C/C++ 标准库函数，用于将多字节字符串（char 类型）转换为宽字符字符串（wchar_t 类型）。

函数原型：

size_t mbstowcs(wchar_t* dest, const char* src, size_t destSize);
dest：指向目标宽字符字符串的指针，用于存储转换后的结果。
src：指向源多字节字符串的指针，要进行转换的字符串。
//destSize：目标宽字符字符串的最大长度，以宽字符的单位进行计数。
//返回值：
//如果转换成功，则返回转换后的宽字符数（不包括终止符 \0）。
//如果目标宽字符字符串的空间不足以存储转换后的结果或发生了无效的多字节字符，则返回 SIZE_MAX 并设置 errno 为 EILSEQ。

注意事项：

  • mbstowcs 函数将多字节字符串按照当前的本地化设置进行转换。因此，转换结果可能因系统区域设置而异，对于非 ASCII 字符，可能需要使用 Unicode 或其他宽字符编码来转换。
  • 目标宽字符字符串应该具备足够的空间，以确保转换后的结果不会溢出。
  • 如果 dest 参数为 NULL，则 mbstowcs 函数会计算转换后的结果长度，但不进行实际转换。可以通过检查返回值来获取所需的缓冲区大小。

自定义转换接口（带编码参数）如下：

// 将多字节字符串转换为宽字符字符串
std::wstring MyWidget::MbsToWcs(const char* multiByteStr, const char* encoding)
{
	// 设置转换编码
	std::locale prevLocale = std::locale::global(std::locale(""));

	try
	{
		std::locale::global(std::locale(encoding));

		// 先用mbstowcs计算需要多少长度的缓冲区
		size_t bufferSize = std::mbstowcs(nullptr, multiByteStr, 0);
		if (bufferSize == static_cast<size_t>(-1))
		{
			throw std::runtime_error("MbsToWcs: conversion failed at calculation phase");
		}

		// 创建所需长度的缓冲区
		std::vector<wchar_t> wideStrBuffer(bufferSize + 1);   // bufferSize + 1，以便放置'\0'

		// 然后调用mbstowcs进行实际的转换
		size_t numCharsConverted = std::mbstowcs(wideStrBuffer.data(), multiByteStr, bufferSize + 1);

		// 检查转换是否成功
		if (numCharsConverted == static_cast<size_t>(-1))
		{
			throw std::runtime_error("MbsToWcs: conversion failed at conversation phase");
		}

		std::wstring result(wideStrBuffer.data());

		// 操作成功完成，恢复原始的本地化设置
		std::locale::global(prevLocale);

		return result;
	}
	catch (...)
	{
		// 如果发生异常，恢复原始的本地化设置，并重新抛出异常
		std::locale::global(prevLocale);
		throw;
	}
}

注意：MbsToWcs函数中的encoding参数是指定源字符编码的参数。它表示将要转换的多字节字符的编码方式。参数nCodePage指定了输入多字节字符的代码页，用于将多字节字符转换为宽字符（UTF-16或UCS-2编码）。即这个参数的值决定了多字节字符转换为宽字符时所使用的字符集。同MultiByteToWideChar。

测试示例：

    char ch_ansi[] = "这是一个ANSI编码的测试文本";
    char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

	try
	{
		//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
    	std::wstring wsWide_fromANSI = MbsToWcs(ch_ansi, "");

    	//ANSI(当前系统是GB2312)编码的多字节 转 UTF-16编码的宽字符
    	const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_fromANSI.c_str();

    	//UTF-8编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
    	std::wstring wsWide_fromUTF8 = MbsToWcs(ch_utf8, ".65001");

    	//UTF-8编码的多字节 转 UTF-16编码的宽字符
    	const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_fromUTF8.c_str();
	}
	catch(...)
	{
		//转换失败
	}

测试结果：
17

若指定编码和原数据编码不一致时，会导致转码失败:

//若指定编码和原数据编码不一致时，会导致转码失败
//原数据是ANSI(当前系统是GB2312)编码，却指定UTF-8编码
std::wstring wsTmp = MbsToWcs(ch_ansi, ".65001");

//原数据是UTF-8编码，却指定ANSI(当前系统是GB2312)编码
std::wstring wsTmp2 = MbsToWcs(ch_utf8, "");

结果：
18

因使用C/C++标准库接口，相较前两种转换，会更通用。

std::wstring_convert

相关介绍同上。

自定义转换接口：

std::wstring s_convert_to_ws(const std::string& multiStr)
{
    try
    {
        std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
        return converter.from_bytes(multiStr);
    }
    catch (...)
    {
        return L"";
    }

}

测试示例：

char ch_ansi[] = "这是一个ANSI编码的测试文本";
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_fromANSI = s_convert_to_ws(ch_ansi);

//ANSI(当前系统是GB2312)编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_fromANSI.c_str();

//UTF-8编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_fromUTF8 = s_convert_to_ws(ch_utf8);

//UTF-8编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_fromUTF8.c_str();

测试结果：

19

借助QString转换

自定义接口：

enum class EncodingFormat : int
{
	ANSI = 0,          // 默认
	UTF8,          // UTF-8
	UTF16_LE,      // UTF-16 LE
	UTF16_BE,      // UTF-16 BE
					//后面可按需补充
};

std::wstring s_to_ws_with_qs(const std::string& multiStr, const EncodingFormat& fromEncode)
{
	QString qsFrom;
	if (fromEncode == EncodingFormat::UTF8)
	{
		qsFrom = QString::fromUtf8(multiStr.c_str());
	}
	else if (fromEncode == EncodingFormat::ANSI)
	{
		qsFrom = QString::fromLocal8Bit(multiStr.c_str());
	}
	else
	{
		//默认为UTF-8
		qsFrom = QString::fromUtf8(multiStr.c_str());
	}
	return qsFrom.toStdWString();
}

测试示例：

//s_to_ws_with_qs
char ch_ansi[] = "这是一个ANSI编码的测试文本";
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_from_ANSI = s_to_ws_with_qs(ch_ansi, EncodingFormat::ANSI);

//ANSI(当前系统是GB2312)编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_from_ANSI.c_str();

//UTF-8编码的多字节 转 宽字符编码（Windows系统上是UTF-16) 的宽字符
std::wstring wsWide_from_UTF8 = s_to_ws_with_qs(ch_utf8, EncodingFormat::UTF8);

//UTF-8编码的多字节 转 UTF-16编码的宽字符
const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_from_UTF8.c_str();

测试结果：
27

缺点：无法指定具体的ANSI编码。如无法指定具体的GB2312、BIG5等编码。

借助QTextCodec转换

自定义接口：

std::wstring MyWidget::s_to_ws_with_qtextcodec(const std::string& multiStr, const char* fromEncodeName)
{
	QTextCodec* codec = QTextCodec::codecForName(fromEncodeName);
	QString qsUnicode = codec->toUnicode(multiStr.c_str());
	return qsUnicode.toStdWString();
}

测试示例：

//s_to_ws_with_qtextcodec
char ch_ansi[] = "这是一个ANSI编码的测试文本";
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF - 16) 的宽字符
std::wstring wsWide_from_ANSI = s_to_ws_with_qtextcodec(ch_ansi, "GB2312");

//ANSI(当前系统是GB2312)编码的多字节 转 UTF - 16编码的宽字符
const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_from_ANSI.c_str();

//UTF - 8编码的多字节 转 宽字符编码（Windows系统上是UTF - 16) 的宽字符
std::wstring wsWide_from_UTF8 = s_to_ws_with_qtextcodec(ch_utf8, "UTF-8");

//UTF - 8编码的多字节 转 UTF - 16编码的宽字符
const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_from_UTF8.c_str();

测试结果：
28

借助iconv三方库转换

自定义转换接口：

std::wstring MultiByteToWide_With_Iconv(const char* input, const char* fromEncoding, const char* toEncoding)
{
	iconv_t conv = iconv_open(toEncoding, fromEncoding);

	if (conv == (iconv_t)-1)
	{
		throw std::invalid_argument("Invalid 'to' or 'from' encoding parameter");
	}

	size_t inputBytesLeft = strlen(input);
	size_t outputBytesLeft = (inputBytesLeft * sizeof(wchar_t)) + sizeof(wchar_t); // +sizeof(wchar_t) for null termination
	wchar_t* output = new wchar_t[outputBytesLeft / sizeof(wchar_t)];
	wchar_t* outputPtr = output;

	if (iconv(conv, (char**)&input, &inputBytesLeft, (char**)&outputPtr, &outputBytesLeft) == (size_t)-1)
	{
		delete[] output;
		iconv_close(conv);
		throw std::runtime_error("Conversion failed");
	}

	*outputPtr = L'\0'; // Null terminate the wstring
	std::wstring outputStr(output);
	delete[] output;
	iconv_close(conv);

	return outputStr;
}

测试示例：

//MultiByteToWide_With_Iconv
char ch_ansi[] = "这是一个ANSI编码的测试文本";
char ch_utf8[] = u8"这是一个UTF-8编码的测试文本";

try
{
	//ANSI(当前系统是GB2312)编码的多字节 转 宽字符编码（Windows系统上是UTF - 16) 的宽字符
	std::wstring wsWide_from_ANSI = MultiByteToWide_With_Iconv(ch_ansi, "GB2312", "UTF-16LE");

	//ANSI(当前系统是GB2312)编码的多字节 转 UTF - 16编码的宽字符
	const char16_t* pCh16_fromANSI = (const char16_t*)wsWide_from_ANSI.c_str();

	//UTF - 8编码的多字节 转 宽字符编码（Windows系统上是UTF - 16) 的宽字符
	std::wstring wsWide_from_UTF8 = MultiByteToWide_With_Iconv(ch_utf8, "UTF-8", "UTF-16LE");

	//UTF - 8编码的多字节 转 UTF - 16编码的宽字符
	const char16_t* pCh16_fromUTF8 = (const char16_t*)wsWide_from_UTF8.c_str();
}
catch (...)
{
	//转换失败
}

测试结果：
29
注意：

iconv() 是一个非常低级别的转换函数，尽可能使用更高级别的、更易于使用的函数（上面自定义接口）更为安全和易于维护。

总结

本文详细介绍了宽窄字符和字符编码之间的关系，同时归纳了两种宽窄字符转换的情况：
一种是保持原有字符编码不变，仅进行宽窄字符类型的转换。
另一种是即进行宽窄字符类型的转换，也进行字符编码的转换。

并给出了对应的测试示例及测试结果。

SNAKEpc12138
关注
  • 21
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串编码转换
wxd090108的博客
11-17 748
//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...
Q701696 MFC在UNICODE环境下，如何读取UNICODE编码形式的TXT文件？
10-05
MFC在UNICODE环境下，如何读取UNICODE编码形式的TXT文件？ 详细请见 https://ask.csdn.net/questions/701696
字符编码及转换
chen_jianjian的专栏
02-13 5805
字符编码（Character encoding）也称字集码，是把字符集中的字符，编码为指定集合中的某一对象（例如：比特模式、自然数序列、8位组或者电脉冲），以便文本在计算机中存储或者通信网络的传递。常见的例子是将拉丁字母表编码成摩斯电码和ASCII，比如ASCII编码是将字母、数字和其它符号进行编号，并用7比特的二进制来表示这个整数。
常见编码格式&编码格式转换详解
信仰的博客
10-29 5608
编码格式详解一.常见的几种编码格式1.ASIIC2.GB23123.GBK4.Unicode5.UTF8二.GBK和UTF8的相互转换附录 一.常见的几种编码格式 1.ASIIC 最早的计算机使用的编码方式，使用一个字节表示一个字符； 特点 用0-127(7位)表示一个字符 2.GB2312 计算机流入中国后，因为ASIIC只使用一个字节表示字符，而汉字有好几千个，1个字节无法满足表示所有汉字的需求。 特点 ①用双字节表示一个汉字，单字节表示一个英文字符(保持和ASIIC一致) ②一个小于127的字符的意义
C语言实现UCS2、UTF8与GBK2312编码转换
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
12-22 2347
在软件开发中，字符编码是一个非常重要的概念。不同的编码方式用于在不同的系统和应用中表示文本数据。UCS2、UTF8和GBK2312是三种常见的字符编码方式。为了实现不同编码间的转换，我们可以使用C语言进行编程，利用已有的库或者手动实现转换算法。
小知识·编码格式和转换方法
m0_64560763的博客
02-08 1671
如何实现编码之间互相转换
shell实现字符编码转换工具分享
09-15
本文主要介绍了一个使用shell脚本实现的字符编码转换工具，它支持在UTF-8和GBK之间进行转换。对于需要处理多语言文本或者在不同编码格式之间切换的开发者来说，这个工具非常实用。 首先，我们来看一下这个脚本的...
易语言字符编码转换
07-23
易语言字符编码转换源码,字符编码转换
字符编码转换器
11-14
字符编码转换器。支持GB2312、UNICODE、UTF-8、BIG5、以及GB1803编码的相互转换！
字符编码转换器.rar
09-26
方便快捷的编码转换工具，可以在各种编码之间进行转换，一直在用
Linux下各种字符编码进行转码
hfwyydy的博客
11-29 435
支持各种编码相互转换 具体 iconv --list 可以查看 支持的转码格式。
编码转换问题 （Unicode utf-8 的爱恨情仇
weixin_63681863的博客
07-08 1916
Unicode的引入解决了这个问题，它包含了超过130,000个字符的编码范围，涵盖了世界上大多数的语言、符号和表情。2. 将代码点转换为所需的编码格式：根据您的需求，可以将Unicode代码点转换为不同的编码格式，如UTF-8、UTF-16或UTF-32。1. 获取Unicode字符的代码点：Unicode字符由一个唯一的代码点表示，可以使用十六进制或十进制表示。这样，你就可以通过解码原始的URL编码字符串并解析其中的JSON数据，得到一个包含"类型"键和"喜剧"值的字典对象。在这个特定的例子中，
Unicode(UTF16)、UTF8、ansi编码格式字符串之间相互转换
萧戈的专栏
12-21 1万+
C++标准模板库只能实现宽字符和utf8编码格式字符串之间的转换，而且这个功能在c++11引入，在C++17中废弃，所以不建议使用，如果需要跨平台，建议使用 ICU（International Components for Unicode）库。C++ 标准库没有直接提供 ANSI 和 UTF-8 之间的转换功能，但你可以使用第三方库，例如 ICU（International Components for Unicode），或者在 Windows 平台上使用特定的 API 进行转换。
Unicode与UTF-8互转(C语言实现)
热门推荐
tge7618291的专栏
05-24 11万+
>                 Tags: encoding,c 1. 基础 1.1 ASCII码 我们知道, 在计算机内部, 所有的信息最终都表示为一个二进制的字符串. 每一个二进制 位(bit)有0和1两种状态, 因此八个二进制位就可以组合出 256种状态, 这被称为一个字 节(byte). 也就是说, 一个字节一共可以用来表示256种不同的状态, 每一个状态对应一
常见编码及转换
qq_43609240的博客
06-08 2054
1、BCD码 （1）压缩BCD：4位二进制数表示一个十进制数，例如： 0001 0010 --> 12 0001 0011 --> 13 （2）BCD：8位二进制数表示一个十进制数，高四位为0； 0000 0001 0000 0010 --> 12 0000 0001 0000 0011 --> 13 一般地，压缩BCD码比较常用，可以节约存储空间。 2、Hex
字符串的编码格式转换
Myueye的博客
08-18 4708
主要的思路就是先将字符串正常化,然后就可以按照指定编码进行编码解码。开发工具是STS,默认的编码格式是UTF-8。本次主要是UTF-8和GBK之间的相互转换。
java 字符编码转换
荷逸的博客
02-27 4741
字符编码是将字符转换为二进制数字的过程，用于计算机的输入、输出和存储。在Java中，字符编码是使用Java编程语言中的Unicode字符集进行处理的。Unicode字符集是一个标准的字符集，它为世界上的每个字符分配了一个唯一的编号，包括拉丁字母、汉字、日语假名等等。
常用五种编码方式总结（ASCII，Unicode，UTF-8，GB123，Base64）
LCW991207的博客
09-05 6508
ASCII（American Standard Code for Information Interchange，美国信息交换标准代码）是一种常见的字符编码系统，定义了128个数字编码，包括字母、数字、标点符号和控制字符等。每个字符用一个7位的二进制数表示。ASCII码表中的字符从0到127，其中0到31为控制字符（如回车、换行等），32到127为可显示字符（如大写字母、小写字母、数字和标点符号）。当我们要将字符转换为对应的ASCII码时，可以使用编程语言提供的函数或方法来实现。
python处理excel的字符编码转换为utf-8
09-03
Python处理Excel的字符编码转换为UTF-8相对简单。首先，要使用Python的pandas库来读取和处理Excel文件。然后，我们可以使用以下代码将Excel文件中的字符编码转换为UTF-8： ```python import pandas as pd # 读取...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值