c++程序的编码与字符集的转换

benojan • 2023-02-08 19:36 • 790 次点击 • c/c++

一、程序相关的编码

程序源文件编码

程序源文件编码是指保存程序源文件内容所使用的编码方案，该编码方案可在保存文件的时候自定义。

通常在简体中文windows环境下，各种编辑器（包括visual studio）新建文件缺省编码都是GB18030。

所以不特别指定的话，在windows环境下，c++源文件的编码通常为GB18030（GB18030兼容GBK）；
在linux环境下，默认的为UTF-8编码。
c++程序内码

源程序编译后，c++中的字符串常量变成一串字节存放在可执行文件中，内码指的是在可执行文件中，字符串以什么编码进行存放。

这里的字符串常量指的是窄字符(char)而不是宽字符(wchar_t)。
宽字符通常都是以Unicode（VC使用UTF-16BE，gcc使用UTF-32BE）存放。

通常简体中文版的VC使用内码为GB18030，而gcc使用内码缺省为UTF-8，但可以通过-fexec-charset参数进行修改。
（可以通过在程序中打印字符串中每个字节的16进制形式来判断程序使用的内码）。
运行环境编码

运行环境编码指的是，执行程序时，操作系统或终端所使用的编码。程序中输出的字符最终要转换为运行环境编码才能显示，否则就会出现乱码。

常用的简体中文版的windows环境编码是GB18030，linux下最常用的环境编码是UTF-8。
三种编码之间的关系

程序源文件【源文件编码】 → （编译器编译） → 目标文件【程序内码】 → （运行后输出信息） → 输出【运行环境编码】

二、已知的问题

windows下，wchar_t的c++程序内码，VC默认使用UTF-16BE，所以wchar_t可能不支持生僻字。可以使用utf-8格式的char字符。

linux下，wchar_t的c++程序内码，默认使用UTF-32BE，所以生僻字应该没有这样的问题。

c++新标准里新增的char32_t，在windows下并未完全实现可用。标准输入输出流无法使用。

三、指定编译编码

功能	g++编译器	vs编译器
指定c++程序内码	`-fexec-charset=GBK`	`#pragma execution_character_set("utf-8")`
指定源文件编码	`-finput-charset=UTF-8`
指定c++程序宽字符(wchar_t)内码	`-fwide-exec-charset=UTF-16`
指定运行环境utf-8编码	`system("chcp 65001");`

四、C++中的字符类型

字符类型	字符文本	字符串类型	字符串文本	编码	范围
char	'a'	string	"abc"	`GBK` 或 `UTF-8`	Windows 默认 `GBK` Linux 默认 `UTF-8`
wchar_t	L'a'	wstring	L"abc"	`UTF-16BE` 或 `UTF-32BE`	Windows 默认 `UTF-16BE` Linux 默认 `UTF-32BE`
char8_t	u8'a'	u8string	u8"abc"	`UTF-8`	`UTF-8`
char16_t	u'a'	u16string	u"abc"	`UTF-16`	`BMP平面字符` （即代码点 U+0000 到 U+FFFF 范围内的字符）
char32_t	U'a'	u32string	U"abc"	`UTF-32`	`UTF-32`

（char8_t 是 C++20 中的新增功能，需要 /std:c++20 或 /std:c++latest 编译器选项）

五、字符集转换

Windows平台

MFC程序中，如果从文件读入Utf-8字符集的字符在CString中，可以使用MultiByteToWideChar函数，转成Unicode字符集。
反之，Unicode字符集的CString，可以使用WideCharToMultiByte函数，转成GBK字符集或utf-8字符集的char[]或string。

void Utf8ToUnicode(CString& str)
{
    // str是用CStdioFile类的ReadString()读取的Utf-8格式的文件，存入CString中

    if (str.GetLength() == 0)
    {
        return;
    }

    PSTR szBuf = new CHAR[str.GetLength() + 1]; // 注意“+1”，char[]字符数组要求结束符，而CString中没有'\0'

    memset(szBuf, '\0', str.GetLength() + 1);

    // 将 WCHAR 转换成 CHAR
    for (int i = 0; i < str.GetLength(); ++i)
    {
        szBuf[i] = (CHAR)str.GetAt(i); // 逐字节读取CString中的数据，存入char[]中
    }

    // 根据保存着utf8的char[]，计算需要的宽字符字节数
    INT nLen = MultiByteToWideChar(CP_UTF8, 0, szBuf, -1, NULL, 0);

    LPWSTR ptch = new WCHAR[nLen];

    // utf8 => unicode
    MultiByteToWideChar(CP_UTF8, 0, szBuf, -1, ptch, nLen);

    // 将转换后的unicode交给str
    str = ptch;

    // 回收空间
    if (NULL != ptch)
        delete[] ptch;
    ptch = NULL;

    if (NULL != szBuf)
        delete[] szBuf;
    szBuf = NULL;
}

LPSTR UnicodeToUtf8(CString& str, INT& nCount)
{
    // CP_ACP 是 GBK，CP_UTF 是 Utf-8
    nCount = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL); // 获得需要的宽字符字节数
    LPSTR pChar = new CHAR[nCount];

    WideCharToMultiByte(CP_UTF8, 0, str, -1, pChar, nCount, NULL, NULL); // utf8 => unicode

    return pChar;
}

wstring是Unicode字符集，可以使用WideCharToMultiByte转换成gbk字符集的string或utf-8字符集的string。

#include <iostream>
#include <windows.h>

int main()
{
    std::wstring pwszUnicode = L"你好𣍐";
    int iSize;
    char* pszMultiByte;

    // CP_ACP 是 GBK，CP_UTF 是 Utf-8
    iSize = WideCharToMultiByte(CP_UTF8, 0, pwszUnicode.c_str(), -1, NULL, 0, NULL, NULL);

    pszMultiByte = new char[iSize + 1];
    WideCharToMultiByte(CP_UTF8, 0, pwszUnicode.c_str(), -1, pszMultiByte, iSize, NULL, NULL);

    std::string pszUtf8(pszMultiByte);
    system("chcp 65001");
    std::cout << pszUtf8 << std::endl;

    delete[] pszMultiByte;
    pszMultiByte = NULL;

    return 0;
}

Linux平台

Linux平台下可以使用 iconv() 函数

// https://www.cnblogs.com/huojing/articles/16291647.html
太复杂，略...

通用方式

使用 wstring_convert 转换（注意：c++17已弃用<codecvt>）

#include <iostream>
#include <locale>
#include <codecvt>

// vs编译器需要这一行
#pragma execution_character_set("utf-8")

std::string u32string_to_string(const std::u32string& str)
{
    // 虽然在linux平台下此处使用codecvt_utf8_utf16和codecvt_utf8都能正常转换，但是还是不建议用codecvt_utf8_utf16
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
    return converter.to_bytes(str);
}

std::u32string string_to_u32string(const std::string& str)
{
    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
    return converter.from_bytes(str);
}

std::string u16string_to_string(const std::u16string& str)
{
    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> converter;
    return converter.to_bytes(str);
}

std::string wstring_to_string(const std::wstring& str)
{
    // 虽然在linux平台下此处使用codecvt_utf8_utf16和codecvt_utf8都能正常转换，但是还是不建议用codecvt_utf8_utf16
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    return converter.to_bytes(str);
}

std::wstring string_to_wstring(const std::string& str)
{
    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
    return converter.from_bytes(str);
}

int main()
{
    // windows平台需要这一行
    system("chcp 65001");

    std::u32string u32str = U"中國人𣍐";
    std::cout << u32string_to_string(u32str) << std::endl;

    std::string str = "中國人𣍐";
    std::cout << u32string_to_string(string_to_u32string(str)) << std::endl;

    std::u16string u16str = u"中國人𣍐";
    std::cout << u16string_to_string(u16str) << std::endl;

    std::wstring wstr = L"中國人𣍐";
    std::cout << wstring_to_string(wstr) << std::endl;

    std::string str2 = "中國人𣍐";
    std::cout << wstring_to_string(string_to_wstring(str2)) << std::endl;
}

注意：

codecvt_utf8_utf16 在 UTF-8 和 UTF-16 之间转换。
codecvt_utf8 只转换为 UCS-2/4。

关于两者之间的区别，chatGPT的回答是：

std::codecvt_utf8和std::codecvt_utf8_utf16都是C++ STL库中用于文本编码转换的类，但它们之间有一些细微的区别。

std::codecvt_utf8是用于将UTF-8编码的字符串转换为本地宽字符集编码的类。它提供了从UTF-8到本地宽字符集编码和从本地宽字符集编码到UTF-8的转换方法。因此，当你想要使用UTF-8编码来存储或传输字符串时，可以使用std::codecvt_utf8来将其转换为本地编码。
std::codecvt_utf8_utf16是用于在UTF-8和UTF-16编码之间进行转换的类。它提供了从UTF-8到UTF-16和从UTF-16到UTF-8的转换方法。因此，当你需要在UTF-8和UTF-16编码之间进行转换时，可以使用std::codecvt_utf8_utf16。
虽然它们都可以用于对UTF-8编码进行转换，但它们之间的主要区别在于它们所涵盖的编码范围不同。std::codecvt_utf8_utf16可以处理所有Unicode字符，包括增补平面字符（Supplementary Planes）；而std::codecvt_utf8只能处理基本多文种平面（BMP）中的字符，无法处理增补平面字符。

使用boost的conv来进行字符集转换

#include <boost/locale/encoding.hpp>

std::string UTF8toGBK(const std::string& str)
{
    return boost::locale::conv::between(str, "GBK", "UTF-8");
}

std::string GBKtoUTF8(const std::string& str)
{
    return boost::locale::conv::between(str, "UTF-8", "GBK");
}

std::wstring GBKtoUNICODE(const std::string& str)
{
    return boost::locale::conv::to_utf<wchar_t>(str, "GBK");
}

std::string UNICODEtoGBK(std::wstring wstr)
{
    return boost::locale::conv::from_utf(wstr, "GBK");
}

std::string UNICODEtoUTF8(const std::wstring& wstr)
{
    return boost::locale::conv::from_utf(wstr, "UTF-8");
}

std::wstring UTF8toUNICODE(const std::string& str)
{
    return boost::locale::conv::utf_to_utf<wchar_t>(str);
}

结合 c++20 的新类型：
u8string、u16string、u32string
char8_t、char16_t、char32_t

头文件

#include <string>

// UTF8与UTF16互相转换
u8string conv_utf16_to_utf8(u16string s);
u16string conv_utf8_to_utf16(u8string s);

// UTF16与UTF32互相转换
u32string conv_utf16_to_utf32(u16string s);
u16string conv_utf32_to_utf16(u32string s);

// UTF8与UTF32互相转换
u8string conv_utf8_to_utf32(u32string s);
u32string conv_utf32_to_utf8(u8string s);

// 同类型不同类型名强制转换

// 如果明确知道string内容为UTF8字符集，使用该函数将其强制转换为u8string
u8string cast_u8string(string s);
string cast_string(u8string s);

// 如果明确知道wstring内容为UTF16字符集，使用该函数将其强制转换为wstring
u16string cast_u16string(wstring s);
wstring cast_wstring(u16string s);

函数定义

#include <string>
#include <boost/locale.hpp>

u8string conv_utf16_to_utf8(u16string s)
{
    return boost::locale::conv::utf_to_utf<char8_t>(s.c_str());
}

u16string conv_utf8_to_utf16(u8string s)
{
    return boost::locale::conv::utf_to_utf<char16_t>(s.c_str());
}

u32string conv_utf16_to_utf32(u16string s)
{
    return boost::locale::conv::utf_to_utf<char32_t>(s.c_str());
}

u16string conv_utf32_to_utf16(u32string s)
{
    return boost::locale::conv::utf_to_utf<char16_t>(s.c_str());
}

u8string conv_utf8_to_utf32(u32string s)
{
    return boost::locale::conv::utf_to_utf<char8_t>(s.c_str());
}

u32string conv_utf32_to_utf8(u8string s)
{
    return boost::locale::conv::utf_to_utf<char32_t>(s.c_str());
}

u8string cast_u8string(string s)
{
    return u8string((char8_t*)s.data(), s.size());
}

string cast_string(u8string s)
{
    return string((char*)s.data(), s.size());
}

u16string cast_u16string(wstring s)
{
    return u16string((char16_t*)s.data(), s.size());
}

wstring cast_wstring(u16string s)
{
    return wstring((wchar_t*)s.data(), s.size());
}

u32string 输出到 utf-8 文件中

std::u32string str{ U"中國娃娃𣍐快活" };
std::locale loc(std::locale(), new std::codecvt_utf8<char32_t>);
std::basic_ofstream<char32_t> ofs("test.txt");
ofs.imbue(loc);

std::cout << "Writing to file (UTF-8)... ";
ofs << str;
std::cout << "done!\n";

六、相关链接

https://blog.csdn.net/whl0071/article/details/125677678 [c++程序编码]⭐
https://blog.csdn.net/qq981091829/article/details/114121785 [UTF16及GB18030编码介绍]
http://blog.csdn.net/haiross/article/details/45074355 [C++中的locale设置（即系统区域设置）]
http://blog.csdn.net/wallaceli1981/article/details/6116738 [C++ 标准库的 locale 类用法]
https://gcc.gnu.org/onlinedocs/libstdc++/manual/localization.html [libstd c++ localization章节]

c++ boost 编码转换字符集 UTF-8 Unicode GBK •