|
🍺ASCII相关文章汇总如下🍺：
🎈ASCII码对照表（255个ascii字符汇总）🎈🎈ASCII码对照表（Unicode 字符集列表）🎈🎈ASCII码对照表（emoji表情符号）🎈🎈ASCII码对照表（Python代码实现打印）🎈🎈ASCII码对照表（C++17 实现ANSI、UTF8、Unicode编码互转）🎈
文章目录
1、简介1.1 ANSI1.2 Unicode1.3 UTF81.4 Little endian / Big endian
2、C++标准库2.1 MultiByteToWideChar / WideCharToMultiByte2.2 wcsrtombs / mbsrtowcs2.3 codecvt
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进行显示）。
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。
1.4 Little endian / Big endian
以汉字严为例，Unicode 码是4E25，需要用两个字节存储，一个字节是4E，另一个字节是25。存储的时候，4E在前，25在后，这就是 Big endian 方式；25在前，4E在后，这是 Little endian 方式。
第一个字节在前，就是"大头方式"（Big endian），第二个字节在前就是"小头方式"（Little endian）。
2、C++标准库
2.1 MultiByteToWideChar / WideCharToMultiByte
MultiByteToWideChar：是一种windows API 函数，该函数映射一个字符串到一个宽字符（unicode）的字符串。由该函数映射的字符串没必要是多字节字符组。
int MultiByteToWideChar(
[in] UINT CodePage,
[in] DWORD dwFlags,
[in] _In_NLS_string_(cbMultiByte)LPCCH lpMultiByteStr,
[in] int cbMultiByte,
[out, optional] LPWSTR lpWideCharStr,
[in] int cchWideChar
);
测试代码：
catch (std::exception e)
{
// Save in-memory logging buffer to a log file on error.
::std::wstring wideWhat;
if (e.what() != nullptr)
{
int convertResult = MultiByteToWideChar(CP_UTF8, 0, e.what(), (int)strlen(e.what()), NULL, 0);
if (convertResult
wideWhat.resize(convertResult + 10);
convertResult = MultiByteToWideChar(CP_UTF8, 0, e.what(), (int)strlen(e.what()), &wideWhat[0], (int)wideWhat.size());
if (convertResult
wideWhat.insert(0, L"Exception occurred: ");
}
}
}
else
{
wideWhat = L"Exception occurred: Unknown.";
}
Platform::String^ errorMessage = ref new Platform::String(wideWhat.c_str());
// The session added the channel at level Warning. Log the message at
// level Error which is above (more critical than) Warning, which
// means it will actually get logged.
_channel->LogMessage(errorMessage, LoggingLevel::Error);
SaveLogInMemoryToFileAsync().then([=](StorageFile^ logFile) {
_logFileGeneratedCount++;
StatusChanged(this, ref new LoggingScenarioEventArgs(LoggingScenarioEventType::LogFileGenerated, logFile->Path->Data()));
}).wait();
}
WideCharToMultiByte：是一个函数，该函数可以映射一个unicode字符串到一个多字节字符串，执行转换的代码页、接收转换字符串、允许额外的控制等操作。
int WideCharToMultiByte(
[in] UINT CodePage,
[in] DWORD dwFlags,
[in] _In_NLS_string_(cchWideChar)LPCWCH lpWideCharStr,
[in] int cchWideChar,
[out, optional] LPSTR lpMultiByteStr,
[in] int cbMultiByte,
[in, optional] LPCCH lpDefaultChar,
[out, optional] LPBOOL lpUsedDefaultChar
);
测试代码：
ISDSC_STATUS DiscpUnicodeToAnsiSize(
IN __in PWCHAR UnicodeString,
OUT ULONG *AnsiSizeInBytes
)
/*++
Routine Description:
This routine will return the length needed to represent the unicode
string as ANSI
Arguments:
UnicodeString is the unicode string whose ansi length is returned
*AnsiSizeInBytes is number of bytes needed to represent unicode
string as ANSI
Return Value:
ERROR_SUCCESS or error code
--*/
{
_try
{
*AnsiSizeInBytes = WideCharToMultiByte(CP_ACP,
0,
UnicodeString,
-1,
NULL,
0, NULL, NULL);
} _except(EXCEPTION_EXECUTE_HANDLER) {
return(ERROR_NOACCESS);
}
return((*AnsiSizeInBytes == 0) ? GetLastError() : ERROR_SUCCESS);
}
2.2 wcsrtombs / mbsrtowcs
wcsrtombs ：将宽字符字符串转换为多字节字符串表示形式。 此函数有一个更安全的版本；请参阅 wcsrtombs_s。
size_t wcsrtombs(
char *mbstr,
const wchar_t **wcstr,
sizeof count,
mbstate_t *mbstate
);
template
size_t wcsrtombs(
char (&mbstr)[size],
const wchar_t **wcstr,
sizeof count,
mbstate_t *mbstate
); // C++ only
测试代码如下：
// crt_wcsrtombs.cpp
// compile with: /W3
// This code example converts a wide
// character string into a multibyte
// character string.
#include
#include
#include
#include
#define MB_BUFFER_SIZE 100
int main()
{
const wchar_t wcString[] =
{L"Every good boy does fine."};
const wchar_t *wcsIndirectString = wcString;
char mbString[MB_BUFFER_SIZE];
size_t countConverted;
mbstate_t mbstate;
// Reset to initial shift state
::memset((void*)&mbstate, 0, sizeof(mbstate));
countConverted = wcsrtombs(mbString, &wcsIndirectString,
MB_BUFFER_SIZE, &mbstate); // C4996
// Note: wcsrtombs is deprecated; consider using wcsrtombs_s
if (errno == EILSEQ)
{
printf( "An encoding error was detected in the string.\n" );
}
else
{
printf( "The string was successfuly converted.\n" );
}
}
mbsrtowcs：将当前区域设置中的多字节字符字符串转换为相应的宽字符字符串，其中重启功能位于多字节字符的中间。 提供此函数的一个更安全的版本；请参阅 mbsrtowcs_s。
size_t mbsrtowcs(
wchar_t *wcstr,
const char **mbstr,
sizeof count,
mbstate_t *mbstate
);
template
size_t mbsrtowcs(
wchar_t (&wcstr)[size],
const char **mbstr,
sizeof count,
mbstate_t *mbstate
); // C++ only
2.3 codecvt
https://docs.microsoft.com/zh-cn/cpp/standard-library/codecvt-class?view=msvc-170 codecvt类：描述可用作区域设置方面的对象的类模板。 它可以控制用于在程序中对字符进行编码的值序列和用于对程序外部字符进行编码的值序列之间的转换。
std:codecvt的特化，std::codecvt跟std::codecvt_byname 都可以用，当然直接转没办法，需要用宽字符集中转一下。
template
class codecvt : public locale::facet, codecvt_base;
例子1：
#include
#include
#include
#include
int main()
{
// UTF-8 data. The character U+1d10b, musical sign segno, does not fit in UCS2
std::string utf8 = u8"z\u6c34\U0001d10b";
// the UTF-8 / UTF-16 standard conversion facet
std::wstring_convert utf16conv;
std::u16string utf16 = utf16conv.from_bytes(utf8);
std::cout
std::u16string ucs2 = ucs2conv.from_bytes(utf8.substr(0, ucs2conv.converted()));
std::cout
// string的编码方式为utf8，则采用：
std::string wstring2utf8string(const std::wstring& str)
{
static std::wstring_convert strCnv;
return strCnv.to_bytes(str);
}
std::wstring utf8string2wstring(const std::string& str)
{
static std::wstring_convert strCnv;
return strCnv.from_bytes(str);
}
// string的编码方式为除utf8外的其它编码方式，可采用：其中locale = "chs", "CHS", "zh-cn"，或.936
std::string wstring2string(const std::wstring& str, const std::string& locale)
{
typedef std::codecvt_byname F;
static std::wstring_convert strCnv(new F(locale));
return strCnv.to_bytes(str);
}
std::wstring string2wstring(const std::string& str, const std::string& locale)
{
typedef std::codecvt_byname F;
static std::wstring_convert strCnv(new F(locale));
return strCnv.from_bytes(str);
}
}
例子5：
using fs = filesystem;
string gbk_str;
fs::path path{gbk_str, locale("zh_CN.gbk")};
u8string utf_str = path.u8string();
例子6：FxEncodeUtil.h：
/***************************************************************
* @file FxEncodeUtil.h
* @brief C++实现GB2312(ANSI)、UTF8、Unicode字符编码互转
* @author 爱看书的小沐
* @version 1.0
* @date 2022-5-18
* @platform Visual Studio 2017 / Win10 win64
* @languages C++
**************************************************************/
#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：
/***************************************************************
* @file FxEncodeUtil.cpp
* @brief C++实现GB2312(ANSI)、UTF8、Unicode字符编码互转
* @author 爱看书的小沐
* @version 1.0
* @date 2022-5-18
* @platform Visual Studio 2017 / Win10 win64
* @languages C++
**************************************************************/
#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
std::wstring_convert wcv;
ret = wcv.from_bytes(str);
}
catch (const std::exception &e)
{
std::cerr };
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)
{
/*LCID lciid = GetUserDefaultLCID();
wchar_t szLocName[255] = L"\0";
int len = 255;
GetUserDefaultLocaleName(szLocName, len);
char *curLocale = setlocale(LC_ALL, NULL);
// setlocale(LC_ALL, NULL);
// setlocale( LC_ALL, "en-US" );
// setlocale(LC_ALL, "chs");
setlocale(LC_ALL, "zh-CN");*/
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++代码实现一
//***********************************************************************
// Purpose: 基于libiconv库的C++实现字符编码互转（测试用例1）
// Author: 爱看书的小沐
// Date: 2022-5-19
// Languages: C++
// Platform: Visual Studio 2017
// OS: Win10 win64
// ***********************************************************************
#include
#include "libiconv/iconv.h"
#pragma comment(lib, "libiconv.lib")
int test_libiconv1()
{
char *curLocale = setlocale(LC_ALL, NULL);
setlocale(LC_ALL, "chs");
/* 源编码 */
const char *encFrom = "GBK";
/* 目的编码, TRANSLIT：遇到无法转换的字符就找相近字符替换
* IGNORE ：遇到无法转换字符跳过*/
//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";
/* 获得转换句柄
*@param encTo 目标编码方式
*@param encFrom 源编码方式
*
* */
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] = "\0";
memset(outbuf, 0, sizeof(outbuf));
/* 由于iconv()函数会修改指针，所以要保存源指针 */
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=%d\n", inbuf, inlen, outbuf, outlen);
for (int i = 0; i
char *curLocale = setlocale(LC_ALL, NULL);
setlocale(LC_ALL, "chs");
char buf_out[1024];
char *str_in, *str_out;
int len_in, len_out, ret;
iconv_t c_pt;
if ((c_pt = iconv_open(encTo, encFrom)) == (iconv_t)-1)
{
printf("iconv_open false: %s ==> %s\n", encFrom, encTo);
return NULL;
}
iconv(c_pt, NULL, NULL, NULL, NULL);
len_in = strlen(inStr) + 1;
len_out = 1024;
str_in = (char *)inStr;
str_out = buf_out;
ret = iconv(c_pt, (const char**)&str_in, (size_t *)&len_in, &str_out, (size_t *)&len_out);
if (ret == -1)
{
perror("iconv");
return NULL;
}
iconv_close(c_pt);
return buf_out;
}
int main()
{
char* p = NULL;
p = test_libiconv2("GBK", "UTF-8//TRANSLIT", "螺丝中123abc+-=,.?*$%#@");
if(p) std::cout
perror("iconv_open");
}
/* 需要转换的字符串 */
printf("in_buf=%s\n", inbuf);
/* 打印需要转换的字符串的长度 */
printf("in_len=%d\n", *inlen);
/* 由于iconv()函数会修改指针，所以要保存源指针 */
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=%s\n", outbuf);
//存放转换后outbuf占用的空间
int outlen_real = outsize - (*outlen);
*outlen = outlen_real;
printf("out_len=%d\n", outlen_real);
for (int i = 0; i
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
// 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%s\n", 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%s\n", 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%s\n", 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%s\n", 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%s\n", 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%s\n", outbuf);
printChars(outbuf, outlen);
}
libiconv的相关测试源码见如下链接： https://download.csdn.net/download/hhy321/85419981
结语
如果您觉得该方法或代码有一点点用处，可以给作者点个赞，或打赏杯咖啡；╮(￣▽￣)╭ 如果您感觉方法或代码不咋地//(ㄒoㄒ)//，就在评论处留言，作者继续改进。o_O??? 如果您需要相关功能的代码定制化开发，可以留言私聊作者。(✿◡‿◡) 感谢各位童鞋们的支持！( ´ ▽´ )ﾉ ( ´ ▽´)っ！！！
|