C++实现ANSI、UTF8、Unicode字符编码互转（libiconv，WideCharToMultiByte）

文章目录

1、简介
- 1.1 ANSI
- 1.2 Unicode
- 1.3 UTF8
2、代码实现
3、iconv
- 3.1 命令行
- 3.2 C++代码实现一
- 3.3 C++代码实现二
- 3.4 C++代码实现三
结语

1、简介 1.1 ANSI

ANSI是一种字符代码，为使计算机支持更多语言，通常使用 0x00~0x7f 范围的1 个字节来表示 1 个英文字符。超出此范围的使用0x80~0xFFFF来编码，即扩展的ASCII编码。

在简体中文Windows操作系统中，ANSI 编码代表 GBK 编码；在繁体中文Windows操作系统中，ANSI编码代表Big5；在日文Windows操作系统中，ANSI 编码代表 Shift_JIS 编码。

ASCII在内的1字节字符128个，即char型的正数，汉字2字节，第一个字节是0x80以上，即char型负数第一字节，文件开头没有标志，直接是内容。直接读取，计算机会结合本地的编码（如GBK进行显示）。

ASCII相关文章汇总如下：

ASCII码对照表（255个ascii字符汇总）
ASCII码对照表（Python代码实现打印）
ASCII码对照表（emoji表情符号）

1.2 Unicode

对于英文来讲，ASCII码就足以编码所有字符，但对于中文，则必须使用两个字节来代表一个汉字，这种表示汉字的方式习惯上称为双字节。虽然双字节可以解决中英文字符混合使用的情况，但对于不同字符系统而言，就要经过字符码转换，非常麻烦，如中英、中日、日韩混合的情况。为解决这一问题，很多公司联合起来制定了一套可以适用于全世界所有国家的字符码，不管是东方文字还是西方文字，一律用两个字节来表示，这就是UNICODE。

Unicode字符集可以简写为UCS（Unicode Character Set）。
Unicode开始启用2个字节表示。衍生出USC-2LE 、USC-2BE、UTF8等。
这个就是固定的2字节表示字符，包括英文字符也是2字节。开头有特征：以0xFFEF（小端）和0xEFFF（大端）开头为标志。

Unicode编码系统可分为编码方式和实现方式两个层次。

编码方式
Unicode是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案。Unicode用数字0-0x10FFFF来映射这些字符，最多可以容纳1114112个字符，或者说有1114112个码位。码位就是可以分配给字符的数字。UTF-8、UTF-16、UTF-32都是将数字转换到程序数据的编码方案。
实现方式
在Unicode中：汉字“字”对应的数字是23383。在Unicode中，我们有很多方式将数字23383表示成程序中的数据，包括：UTF-8、UTF-16、UTF-32。UTF是“UCS Transformation Format”的缩写，可以翻译成Unicode字符集转换格式，即怎样将Unicode定义的数字转换成程序数据。
例如，“汉字”对应的数字是0x6c49和0x5b57，而编码的程序数据是：
BYTE data_utf8[] = {0xE6, 0xB1, 0x89, 0xE5, 0xAD, 0x97}; // UTF-8编码
WORD data_utf16[] = {0x6c49, 0x5b57}; // UTF-16编码
DWORD data_utf32[] = {0x6c49, 0x5b57}; // UTF-32编码

1.3 UTF8

UTF-8以字节为单位对Unicode进行编码。
UTF8是变长的编码，英文字符还有1字节，汉字和其他各国字符用2字节或者3字节。
UTF8编码的分为带BOM和不带BOM的，BOM(Byte Order Mark)就是文件开头的标志了。

带BOM的UTF-8文件是：开头三字节，EE BB EF
不带BOM的UTF-8，开头为特征，直接是内容，造成和ANSI的一样。

“汉字”的UTF-8编码需要6个字节。“汉字”的UTF-16编码需要两个WORD，大小是4个字节。“汉字”的UTF-32编码需要两个DWORD，大小是8个字节。根据字节序的不同，UTF-16可以被实现为UTF-16LE或UTF-16BE，UTF-32可以被实现为UTF-32LE或UTF-32BE。

2、代码实现

FxEncodeUtil.h：

#pragma once

#include 
#include 
#include  
#include  

class FxEncodeUtil
{
public:
	static std::string UnicodeToUTF8(const std::wstring & wstr);
	static std::wstring UTF8ToUnicode(const std::string & str);
	static std::string UnicodeToANSI(const std::wstring & wstr);
	static std::wstring ANSIToUnicode(const std::string & str);
	static std::string UTF8ToANSI(const std::string & str);
	static std::string ANSIToUTF8(const std::string & str);

	static std::wstring ANSIToUnicode2(const std::string & str);
	static std::string UnicodeToANSI2(const std::wstring & str);
	static std::wstring UTF8ToUnicode2(const std::string & str);
	static std::string UnicodeToUTF82(const std::wstring & str);
	static std::string UTF8ToANSI2(const std::string & str);
	static std::string ANSIToUTF82(const std::string & str);

};

FxEncodeUtil.cpp：

#include "FxEncodeUtil.h"
#include "gtest/gtest.h"
#include "FxUnicode.h"

#define _AMD64_
#include 

std::string FxEncodeUtil::UnicodeToUTF8(const std::wstring &wstr)
{
	std::string ret;
	try
	{
		std::wstring_convert> wcv;
		ret = wcv.to_bytes(wstr);
	}
	catch (const std::exception &e)
	{
		std::cerr << e.what() << std::endl;
	}
	return ret;
}

std::wstring FxEncodeUtil::UTF8ToUnicode(const std::string &str)
{
	std::wstring ret;
	try
	{
		std::wstring_convert> wcv;
		ret = wcv.from_bytes(str);
	}
	catch (const std::exception &e)
	{
		std::cerr << e.what() << std::endl;
	}
	return ret;
}

std::string FxEncodeUtil::UnicodeToANSI(const std::wstring &wstr)
{
	char *curLocale = setlocale(LC_ALL, NULL);
	setlocale(LC_ALL, "chs");

	std::string ret;
	std::mbstate_t state = {};
	const wchar_t *src = wstr.data();
	size_t len = std::wcsrtombs(nullptr, &src, 0, &state);
	if (static_cast(-1) != len)
	{
		std::unique_ptr buff(new char[len + 1]);
		len = std::wcsrtombs(buff.get(), &src, len, &state);
		if (static_cast(-1) != len)
		{
			ret.assign(buff.get(), len);
		}
	}

	setlocale(LC_ALL, curLocale);
	return ret;
}

std::wstring FxEncodeUtil::ANSIToUnicode(const std::string &str)
{
	char *curLocale = setlocale(LC_ALL, NULL);
	setlocale(LC_ALL, "chs");

	std::wstring ret;
	std::mbstate_t state = {};
	const char *src = str.data();
	size_t len = std::mbsrtowcs(nullptr, &src, 0, &state);
	if (static_cast(-1) != len)
	{
		std::unique_ptr buff(new wchar_t[len + 1]);
		len = std::mbsrtowcs(buff.get(), &src, len, &state);
		if (static_cast(-1) != len)
		{
			ret.assign(buff.get(), len);
		}
	}

	setlocale(LC_ALL, curLocale);
	return ret;
}

std::string FxEncodeUtil::UTF8ToANSI(const std::string &str)
{
	return UnicodeToANSI(UTF8ToUnicode(str));
}

std::string FxEncodeUtil::ANSIToUTF8(const std::string &str)
{
	return UnicodeToUTF8(ANSIToUnicode(str));
}

///
///
///

std::wstring FxEncodeUtil::ANSIToUnicode2(const std::string &str)
{
	size_t len = str.length();
	int iTextLen = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);

	wchar_t *pUnicodeText;
	pUnicodeText = new wchar_t[iTextLen + 1];
	memset(pUnicodeText, 0, (iTextLen + 1) * sizeof(wchar_t));
	::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, (LPWSTR)pUnicodeText, iTextLen);

	std::wstring ret;
	ret = (wchar_t *)pUnicodeText;
	delete pUnicodeText;
	return ret;
}

std::string FxEncodeUtil::UnicodeToANSI2(const std::wstring &str)
{
	char *pAnsiText;
	int iTextLen = WideCharToMultiByte(CP_ACP, 0, str.c_str(), -1, NULL, 0, NULL, NULL);

	pAnsiText = new char[iTextLen + 1];
	memset((void *)pAnsiText, 0, sizeof(char) * (iTextLen + 1));
	::WideCharToMultiByte(CP_ACP, 0, str.c_str(), -1, pAnsiText, iTextLen, NULL, NULL);

	std::string ret;
	ret = pAnsiText;
	delete[] pAnsiText;
	return ret;
}

std::wstring FxEncodeUtil::UTF8ToUnicode2(const std::string &str)
{
	size_t len = str.length();
	int iTextLen = ::MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);

	wchar_t *pUnicode;
	pUnicode = new wchar_t[iTextLen + 1];
	memset(pUnicode, 0, (iTextLen + 1) * sizeof(wchar_t));
	::MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, (LPWSTR)pUnicode, iTextLen);

	std::wstring ret;
	ret = (wchar_t *)pUnicode;
	delete[] pUnicode;
	return ret;
}

std::string FxEncodeUtil::UnicodeToUTF82(const std::wstring &str)
{
	char *pUtf8Text;
	int iTextLen = WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, NULL, 0, NULL, NULL);

	pUtf8Text = new char[iTextLen + 1];
	memset((void *)pUtf8Text, 0, sizeof(char) * (iTextLen + 1));
	::WideCharToMultiByte(CP_UTF8, 0, str.c_str(), -1, pUtf8Text, iTextLen, NULL, NULL);

	std::string strText;
	strText = pUtf8Text;
	delete[] pUtf8Text;
	return strText;
}

std::string FxEncodeUtil::UTF8ToANSI2(const std::string &str)
{
	return UnicodeToANSI2(UTF8ToUnicode2(str));
}

std::string FxEncodeUtil::ANSIToUTF82(const std::string &str)
{
	return UnicodeToUTF82(ANSIToUnicode2(str));
}

///
///
///

TEST(FxEncodeUtilTest, StringComparison)
{
	

	char strZhong[] = {-28, -72, -83, 0}; //中

	ASSERT_STREQ(strZhong, FxEncodeUtil::ANSIToUTF8("中").c_str());
	ASSERT_STREQ(strZhong, FxEncodeUtil::ANSIToUTF82("中").c_str());

	EXPECT_EQ(FxEncodeUtil::ANSIToUTF82("中国"), FxEncodeUtil::ANSIToUTF82("中国"));
	EXPECT_EQ(FxEncodeUtil::ANSIToUTF82("你好世界，2022"), FxEncodeUtil::ANSIToUTF82("你好世界，2022"));
}

3、iconv

http://gnuwin32.sourceforge.net/packages/libiconv.htm

iconv是linux下的编码转换的工具，它提供命令行的使用和函数接口支持。

3.1 命令行

-f, --from-code=名称 原始文本编码
-t, --to-code=名称 输出编码
-l, --list 列举所有已知的字符集
-c 从输出中忽略无效的字符
-o, --output=FILE 输出文件
-s, --silent 关闭警告
--verbose 打印进度信息

iconv -f encoding -t encoding inputfile
iconv -f utf-8 -t unicode utf8file.txt> unicodefile.txt
iconv -f utf-8 -t gb2312 /server_test/reports/t1.txt > /server_test/reports/t2.txt
iconv -f utf8 -t gb18030 -oresult.xls result_tmp.xls
iconv -f utf8 -t gb18030 result_tmp.xls> result.xls
iconv -f utf8 -t gb2312 result_tmp.xls> result.xls
iconv -f latin1 -t ascii//TRANSLIT file
iconv -f UTF-8 -t ascii//TRANSLIT file
iconv -f "ISO_8859-1" -t "GBK" ./test
cmake -G "Visual Studio 15 2017 Win64" ..

https://www.gnu.org/software/libiconv/

3.2 C++代码实现一

/
	const char *encFrom = "GBK";

	
	 //const char *encTo = "UNICODE//TRANSLIT";
	 //const char *encTo = "GBK//TRANSLIT";
	 //const char *encTo = "latin1//TRANSLIT";
	 //const char *encTo = "ISO_8859-1//TRANSLIT";
	//const char *encTo = "UNICODE//IGNORE";
	const char *encTo = "UTF-8//TRANSLIT";
	
	
	iconv_t cd = iconv_open(encTo, encFrom);
	if (cd == (iconv_t)-1)
	{
		perror("iconv_open");
		return -1;
	}

	
	char inbuf[1024] = "螺丝中123abc";
	size_t inlen = strlen(inbuf);

	
	size_t outlen = 1024;
	char outbuf[1024] = "";
	memset(outbuf, 0, sizeof(outbuf));

	
	char *srcstart = inbuf;
	char *tempoutbuf = outbuf;

	size_t ret = iconv(cd, (const char **)&srcstart, &inlen, &tempoutbuf, &outlen);
	if (ret == -1)
	{
		perror("iconv");
		return -1;
	}

	printf("inbuf=%s, inlen=%d, outbuf=%s, outlen=%dn", inbuf, inlen, outbuf, outlen);
	for (int i = 0; i < strlen(outbuf); i++)
	{
		printf("%xn", outbuf[i]);
	}

	
	iconv_close(cd);
	return 0;
}

运行结果如下：

3.3 C++代码实现二

/
	//const char *encTo = "UTF-8//IGNORE";
	
	//const char *encFrom = "UNICODE";

	
	iconv_t cd = iconv_open(encTo, encFrom);
	if (cd == (iconv_t)-1)
	{
		perror("iconv_open");
	}

	
	printf("in_buf=%sn", inbuf);

	
	printf("in_len=%dn", *inlen);

	
	char *tmpin = (char *)inbuf;
	char *tmpout = outbuf;
	size_t insize = *inlen;
	size_t outsize = *outlen;

	size_t ret = iconv(cd, &tmpin, inlen, &tmpout, outlen);
	if (ret == -1)
	{
		perror("iconv");
	}

	
	printf("out_buf=%sn", outbuf);

	//存放转换后outbuf占用的空间
	int outlen_real = outsize - (*outlen);
	*outlen = outlen_real;
	printf("out_len=%dn", outlen_real);

	for (int i = 0; i < outlen_real; i++)
	{
		//printf("%2c", outbuf[i]);
		//printf("%xn", outbuf[i]);
	}

	
	iconv_close(cd);
	return outlen_real;
}

//unicode转UTF-8
bool unicode_to_utf8(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("UCS-2LE", "UTF-8//IGNORE", inbuf, inlen, outbuf, outlen);
}

//UTF-8转unicode
bool utf8_to_unicode(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("UTF-8", "UCS-2LE//IGNORE", inbuf, inlen, outbuf, outlen);
}

//gbk转unicode,"UCS-2LE"代表unicode小端模式
bool gbk_to_unicode(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("gb2312", "UCS-2LE//IGNORE", inbuf, inlen, outbuf, outlen);
}

//unicode转gbk
bool unicode_to_gbk(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("UCS-2LE", "gb2312//IGNORE", inbuf, inlen, outbuf, outlen);
}

//gbk转UTF-8
bool gbk_to_utf8(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("GBK", "UTF-8//IGNORE", inbuf, inlen, outbuf, outlen);
}

//UTF-8转gbk
bool utf8_to_gbk(const char *inbuf, size_t *inlen, char *outbuf, size_t *outlen)
{
	return test_libiconv3("UTF-8", "GBK//IGNORE", inbuf, inlen, outbuf, outlen);
}

//以十六进制打印字符串
void printChars(const char *buffer, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%0x,", *buffer++);
	}
	printf("n");
}

测试代码如下：

int main()
{
	// gbk_to_utf8
	printf("n******【gbk_to_utf8】*******n");
	char inbuf[1024] = "111螺丝中=+-()abc222";
	size_t inlen = strlen(inbuf);
	char outbuf[1024] = {};
	size_t outlen = sizeof(outbuf);
	gbk_to_utf8(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);

	// utf8_to_unicode
	printf("n*******【utf8_to_unicode】*******n");
	inlen = outlen;
	outlen = sizeof(outbuf);
	memcpy(inbuf, outbuf, inlen);
	memset(outbuf, 0, outlen);
	utf8_to_unicode(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);

	// unicode_to_utf8
	printf("n******【unicode_to_utf8】*******n");
	inlen = outlen;
	outlen = sizeof(outbuf);
	memcpy(inbuf, outbuf, inlen);
	memset(outbuf, 0, outlen);
	unicode_to_utf8(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);

	// utf8_to_gbk
	printf("n******【utf8_to_gbk】*******n");
	inlen = outlen;
	outlen = sizeof(outbuf);
	memcpy(inbuf, outbuf, inlen);
	memset(outbuf,0, outlen);
	utf8_to_gbk(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);

	// gbk_to_unicode
	printf("n*******【gbk_to_unicode】*******n");
	inlen = outlen;
	outlen = sizeof(outbuf);
	memcpy(inbuf, outbuf, inlen);
	memset(outbuf, 0, outlen);
	gbk_to_unicode(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);

	// unicode_to_gbk
	printf("n********【unicode_to_gbk】********n");
	inlen = outlen;
	outlen = sizeof(outbuf);
	memcpy(inbuf, outbuf, inlen);
	memset(outbuf, 0, outlen);
	unicode_to_gbk(inbuf, &inlen, outbuf, &outlen);
	printf("result:n%sn", outbuf);
	printChars(outbuf, outlen);
}

libiconv的相关测试源码见如下链接：
https://download.csdn.net/download/hhy321/85419981

结语

如果您觉得该方法或代码有一点点用处，可以给作者点个赞，或打赏杯咖啡；╮(￣▽￣)╭
如果您感觉方法或代码不咋地//(ㄒoㄒ)//，就在评论处留言，作者继续改进。o_O???
如果您需要相关功能的代码定制化开发，可以留言私聊作者。(✿◡‿◡)
感谢各位童鞋们的支持！( ´ ▽´ )ﾉ ( ´ ▽´)っ！！！

C++实现ANSI、UTF8、Unicode字符编码互转（libiconv，WideCharToMultiByte）

C/C++/C#相关栏目本月热门文章