C++：UTF-8、UTF-16、UTF-32之间的编码转换

最新推荐文章于 2022-05-11 11:34:41 发布
最新推荐文章于 2022-05-11 11:34:41 发布
阅读量541 收藏 2
点赞数
文章标签： c/c++
原文链接：https://my.oschina.net/zhangzhihao/blog/70462
版权

开发语言：C++ 

功能描述：

Unicode内码转换器。用于UTF-8、UTF-16（UCS2）、UTF-32（UCS4）之间的编码转换。 

下载地址：

UnicodeConverter.zip 

版本历史：

V1.0 2010年03月12日

  • 完成正式版本。

源代码：

UnicodeConverter.h

 

/* ----------------------------------------------------------
文件名称：UnicodeConverter.h

作者：秦建辉

MSN：splashcn@msn.com

当前版本：V1.0

历史版本：
	V1.0	2010年03月12日
			完成正式版本。

功能描述：
	Unicode内码转换器。用于utf-8、utf-16（UCS2）、utf-32（UCS4）之间的编码转换
 ------------------------------------------------------------ */
#pragma once

#include <windows.h>
#include <stdio.h>
#include <ostream>

using namespace std;

class CUnicodeConverter
{
/* -------------------------------------------------------------
					内码转换
   ------------------------------------------------------------- */
public:
	/*
	功能：将UCS4编码转换成UTF8编码
	参数：
		dwUCS4：要转换的UCS4编码
		pbUTF8：用于存储转换后的UTF8编码。设为NULL，可以获取长度信息（字节数）
	返回值：
		  0：无效的UCS4编码
		1-6：UTF8编码的有效长度
	*/
	static INT UCS4_To_UTF8( DWORD dwUCS4, BYTE* pbUTF8 );

	/*
	功能：将UTF8编码转换成UCS4编码
	参数：
		pbUTF8：要转换的UTF8编码
		dwUCS4：存储转换后的UCS4编码
	返回值：
		  0：参数错误或无效的UTF8编码
		1-6：UTF8编码的有效长度
	*/
	static INT UTF8_To_UCS4( const BYTE* pbUTF8, DWORD& dwUCS4 );

	/*
	功能：将UCS4编码转换成UTF16编码
	参数：
		dwUCS4：要转换的UCS4编码
		pwUTF16：用于存储转换后的UTF16编码。设为NULL，可以获取长度信息（字符数）
	返回值：
		0：无效的UCS4编码
		1：转换成1个UTF16编码
		2：转换成2个UTF16编码
	*/
	static INT UCS4_To_UTF16( DWORD dwUCS4, WORD* pwUTF16 );

	/*
	功能：将UTF16编码转换成UCS4编码
	参数：
		pwUTF16：需要转换的UTF16编码
		dwUCS4：存储转换后的UCS4编码
	返回值：
		0：参数错误或无效的UTF16编码
		1：1个UTF16编码被转换
		2：2个UTF16编码被转换
	*/
	static INT UTF16_To_UCS4( const WORD* pwUTF16, DWORD& dwUCS4 );

	/*
	功能：将UTF8字符串转换成UTF16字符串
	参数：
		pbszUTF8Str：需要转换的UTF8字符串
		pwszUTF16Str：存储转换后的UTF16字符串。设为NULL，可以获取所需长度信息（字符数）
	返回值：
		 0：转换失败
		>0：UTF16字符串长度
	*/
	static INT UTF8Str_To_UTF16Str( const BYTE* pbszUTF8Str, WORD* pwszUTF16Str );

	/*
	功能：将UTF16字符串转换成UTF8字符串
	参数：
		pwszUTF16Str：需要转换的UTF16字符串
		pbszUTF8Str：存储转换后的UTF8字符串。设为NULL，可以获取所需长度信息（字节数）
	返回值：
		 0：转换失败
		>0：UTF8字符串长度（不包括NULL字符）
	*/
	static INT UTF16Str_To_UTF8Str( const WORD* pwszUTF16Str, BYTE* pbszUTF8Str );

/* -------------------------------------------------------------
					C文件写入操作
   ------------------------------------------------------------- */
public:
	/*
	功能：向文件中写入UTF8编码
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8_By_UCS4( FILE* out, DWORD dwUCS4 );

	/*
	功能：向文件中写入UTF16编码
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16_By_UCS4( FILE* out, DWORD dwUCS4, BOOL isBigEndian = FALSE );

	/*
	功能：将UTF16字符串以UTF8编码输出到文件中
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8Str_By_UTF16Str( FILE* out, const WORD* pwszUTF16Str );
	
	/*
	功能：将UTF8字符串以UTF16编码输出到文件中
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16Str_By_UTF8Str( FILE* out, const BYTE* pbszUTF8Str, BOOL isBigEndian = FALSE );

	/*
	功能：向文件中输出UTF8编码字节序标记
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8_BOM( FILE* out );

	/*
	功能：向文件中输出UTF16编码字节序标记
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16_BOM( FILE* out, BOOL isBigEndian = FALSE );

/* -------------------------------------------------------------
					C++流输出操作
   ------------------------------------------------------------- */
public:
	/*
	功能：向流中写入UTF8编码
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8_By_UCS4( ostream& os, DWORD dwUCS4 );

	/*
	功能：向流中写入UTF16编码
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16_By_UCS4( ostream& os, DWORD dwUCS4, BOOL isBigEndian = FALSE );

	/*
	功能：将UTF16字符串以UTF8编码输出到流中
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8Str_By_UTF16Str( ostream& os, const WORD* pwszUTF16Str );
	
	/*
	功能：将UTF8字符串以UTF16编码输出到流中
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16Str_By_UTF8Str( ostream& os, const BYTE* pbszUTF8Str, BOOL isBigEndian = FALSE );

	/*
	功能：向流中输出UTF8编码字节序标记
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF8_BOM( ostream& os );

	/*
	功能：向流中输出UTF16编码字节序标记
	返回值：
		写入的字节数
	*/
	static UINT Print_UTF16_BOM( ostream& os, BOOL isBigEndian = FALSE );
};

/* ------------------------------
				END
   ------------------------------ */

UnicodeConverter.cpp

 

#include "UnicodeConverter.h"

/* -------------------------------------------------------------
					内码转换
   ------------------------------------------------------------- */

// 转换UCS4编码到UTF8编码
INT CUnicodeConverter::UCS4_To_UTF8( DWORD dwUCS4, BYTE* pbUTF8 )
{
	const BYTE	abPrefix[] = {0, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC};
	const DWORD adwCodeUp[] = {
		0x80,			// U+00000000 ～ U+0000007F
		0x800,			// U+00000080 ～ U+000007FF
		0x10000,		// U+00000800 ～ U+0000FFFF
		0x200000,		// U+00010000 ～ U+001FFFFF
		0x4000000,		// U+00200000 ～ U+03FFFFFF
		0x80000000		// U+04000000 ～ U+7FFFFFFF
	};

	INT	i, iLen;

	// 根据UCS4编码范围确定对应的UTF-8编码字节数
	iLen = sizeof(adwCodeUp) / sizeof(DWORD);
	for( i = 0; i < iLen; i++ )
	{
		if( dwUCS4 < adwCodeUp[i] )
		{
			break;
		}
	}

	if( i == iLen )return 0;	// 无效的UCS4编码
		
	iLen = i + 1;	// UTF-8编码字节数
	if( pbUTF8 != NULL )
	{	// 转换为UTF-8编码
		for( ; i > 0; i-- )
		{
			pbUTF8[i] = static_cast<BYTE>((dwUCS4 & 0x3F) | 0x80);
			dwUCS4 >>= 6;
		}

		pbUTF8[0] = static_cast<BYTE>(dwUCS4 | abPrefix[iLen - 1]);
	}

	return iLen;
}

// 转换UTF8编码到UCS4编码
INT CUnicodeConverter::UTF8_To_UCS4( const BYTE* pbUTF8, DWORD& dwUCS4 )
{
	INT		i, iLen;
	BYTE	b;

	if( pbUTF8 == NULL )
	{	// 参数错误
		return 0;
	}

	b = *pbUTF8++;
	if( b < 0x80 )
	{
		dwUCS4 = b;
		return 1;
	}

	if( b < 0xC0 || b > 0xFD )
	{	// 非法UTF8
		return 0; 
	}

	if( b < 0xE0 )
	{
		dwUCS4 = b & 0x1F;
		iLen = 2;
	}
	else if( b < 0xF0 )
	{
		dwUCS4 = b & 0x0F;
		iLen = 3;
	}
	else if( b < 0xF8 )
	{
		dwUCS4 = b & 7;
		iLen = 4;
	}
	else if( b < 0xFC )
	{
		dwUCS4 = b & 3;
		iLen = 5;
	}
	else
	{
		dwUCS4 = b & 1;
		iLen = 6;
	}

	for( i = 1; i < iLen; i++ )
	{
		b = *pbUTF8++;
		if( b < 0x80 || b > 0xBF )
		{	// 非法UTF8
			break;
		}

		dwUCS4 = (dwUCS4 << 6) + (b & 0x3F);
	}

	if( i < iLen )
	{	// 非法UTF8
		return 0;
	}
	else
	{
		return iLen;
	}
}

// 转换UCS4编码到UCS2编码
INT CUnicodeConverter::UCS4_To_UTF16( DWORD dwUCS4, WORD* pwUTF16 )
{
	if( dwUCS4 <= 0xFFFF )
	{
		if( pwUTF16 != NULL )
		{
			*pwUTF16 = static_cast<WORD>(dwUCS4);
		}

		return 1;
	}
	else if( dwUCS4 <= 0xEFFFF )
	{
		if( pwUTF16 != NULL )
		{
			pwUTF16[0] = static_cast<WORD>( 0xD800 + (dwUCS4 >> 10) - 0x40 );	// 高10位
			pwUTF16[1] = static_cast<WORD>( 0xDC00 + (dwUCS4 & 0x03FF) );		// 低10位
		}

		return 2;
	}
	else
	{
		return 0;
	}
}

// 转换UCS2编码到UCS4编码
INT CUnicodeConverter::UTF16_To_UCS4( const WORD* pwUTF16, DWORD& dwUCS4 )
{
	WORD	w1, w2;

	if( pwUTF16 == NULL )
	{	// 参数错误
		return 0;
	}

	w1 = pwUTF16[0];
	if( w1 >= 0xD800 && w1 <= 0xDFFF )
	{	// 编码在替代区域（Surrogate Area）
		if( w1 < 0xDC00 )
		{
			w2 = pwUTF16[1];
			if( w2 >= 0xDC00 && w2 <= 0xDFFF )
			{
				dwUCS4 = (w2 & 0x03FF) + (((w1 & 0x03FF) + 0x40) << 10);
				return 2;
			}
		}

		return 0;	// 非法UTF16编码	
	}
	else
	{
		dwUCS4 = w1;
		return 1;
	}
}

// 转换UTF8字符串到UTF16字符串
INT CUnicodeConverter::UTF8Str_To_UTF16Str( const BYTE* pbszUTF8Str, WORD* pwszUTF16Str )
{
	INT		iNum, iLen;
	DWORD	dwUCS4;

	if( pbszUTF8Str == NULL )
	{	// 参数错误
		return 0;
	}

	iNum = 0;	// 统计有效字符个数
	while( *pbszUTF8Str )
	{	// UTF8编码转换为UCS4编码
		iLen = UTF8_To_UCS4( pbszUTF8Str, dwUCS4 );
		if( iLen == 0 )
		{	// 非法的UTF8编码
			return 0;
		}

		pbszUTF8Str += iLen;

		// UCS4编码转换为UTF16编码
		iLen = UCS4_To_UTF16( dwUCS4, pwszUTF16Str );
		if( iLen == 0 )
		{
			return 0;
		}

		if( pwszUTF16Str != NULL )
		{
			pwszUTF16Str += iLen;
		}
		
		iNum += iLen;
	}

	if( pwszUTF16Str != NULL )
	{
		*pwszUTF16Str = 0;	// 写入字符串结束标记
	}

	return iNum;
}

// 转换UTF16字符串到UTF8字符串
INT CUnicodeConverter::UTF16Str_To_UTF8Str( const WORD* pwszUTF16Str, BYTE* pbszUTF8Str )
{
	INT		iNum, iLen;
	DWORD	dwUCS4;

	if( pwszUTF16Str == NULL )
	{	// 参数错误
		return 0;
	}

	iNum = 0;
	while( *pwszUTF16Str )
	{	// UTF16编码转换为UCS4编码
		iLen = UTF16_To_UCS4( pwszUTF16Str, dwUCS4 );
		if( iLen == 0 )
		{	// 非法的UTF16编码
			return 0;	
		}
		
		pwszUTF16Str += iLen;

		// UCS4编码转换为UTF8编码
		iLen = UCS4_To_UTF8( dwUCS4, pbszUTF8Str );
		if( iLen == 0 )
		{
			return 0;
		}

		if( pbszUTF8Str != NULL )
		{
			pbszUTF8Str += iLen;
		}
		
		iNum += iLen;
	}

	if( pbszUTF8Str != NULL )
	{
		*pbszUTF8Str = 0;	// 写入字符串结束标记
	}

	return iNum;
}

/* -------------------------------------------------------------
					C文件写入操作
   ------------------------------------------------------------- */

// 向文件中输出UTF8编码
UINT CUnicodeConverter::Print_UTF8_By_UCS4( FILE* out, DWORD dwUCS4 )
{
	INT		iLen;
	BYTE	abUTF8[8];

	if( out == NULL )
	{
		return 0;
	}

	iLen = UCS4_To_UTF8( dwUCS4, abUTF8 );
	if( iLen == 0 )return 0;

	fwrite( abUTF8, 1, iLen, out );

	return iLen;
}

// 向文件中输出UTF16编码
UINT CUnicodeConverter::Print_UTF16_By_UCS4( FILE* out, DWORD dwUCS4, BOOL isBigEndian )
{
	INT		i, iLen;
	WORD	wCode, awUTF16[2];

	if( out == NULL )
	{
		return 0;
	}

	iLen = UCS4_To_UTF16( dwUCS4, awUTF16 );
	if( iLen == 0 )return 0;

	for( i = 0; i < iLen; i++ )
	{
		wCode = awUTF16[i];
		if( isBigEndian )
		{
			fputc( wCode >> 8, out );	// 输出高位
			fputc( wCode & 0xFF, out );	// 输出低位
		}
		else
		{
			fputc( wCode & 0xFF, out );	// 输出低位
			fputc( wCode >> 8, out );	// 输出高位
		}
	}

	return (iLen << 1);
}

// 将UTF16字符串以UTF8编码输出到文件中
UINT CUnicodeConverter::Print_UTF8Str_By_UTF16Str( FILE* out, const WORD* pwszUTF16Str )
{
	INT		iCount, iLen;
	DWORD	dwUCS4;

	if( (out == NULL) || (pwszUTF16Str == NULL) )
	{
		return 0;
	}

	iCount = 0;
	while( *pwszUTF16Str )
	{	// 将UTF16编码转换成UCS4编码
		iLen = UTF16_To_UCS4( pwszUTF16Str, dwUCS4 );
		if( iLen == 0 )
		{
			break;
		}

		pwszUTF16Str += iLen;

		// 向文件中输出UTF8编码
		iCount += Print_UTF8_By_UCS4( out, dwUCS4 );
	}

	return iCount;	// 输出的字节数
}

// 将UTF8字符串以UTF16编码输出到文件中
UINT CUnicodeConverter::Print_UTF16Str_By_UTF8Str( FILE* out, const BYTE* pbszUTF8Str, BOOL isBigEndian )
{
	INT		iCount, iLen;
	DWORD	dwUCS4;

	if( (out == NULL) || (pbszUTF8Str == NULL) )
	{
		return 0;
	}

	iCount = 0;
	while( *pbszUTF8Str )
	{	// 将UTF16编码转换成UCS4编码
		iLen = UTF8_To_UCS4( pbszUTF8Str, dwUCS4 );
		if( iLen == 0 )
		{
			break;
		}

		pbszUTF8Str += iLen;

		// 向文件中输出UTF8编码
		iCount += Print_UTF16_By_UCS4( out, dwUCS4, isBigEndian );
	}

	return iCount;	// 输出的字节数
}

// 向文件中输出UTF8字节序标记
UINT CUnicodeConverter::Print_UTF8_BOM( FILE* out )
{
	if( out == NULL )
	{
		return 0;
	}

	fputc( 0xEF, out );
	fputc( 0xBB, out );
	fputc( 0xBF, out );

	return 3;
}

// 向文件中输出UTF16字节序标记
UINT CUnicodeConverter::Print_UTF16_BOM( FILE* out, BOOL isBigEndian )
{
	if( out == NULL )
	{
		return 0;
	}

	if( isBigEndian )
	{
		fputc( 0xFE, out );
		fputc( 0xFF, out );
	}
	else
	{
		fputc( 0xFF, out );
		fputc( 0xFE, out );
	}

	return 2;
}

/* -------------------------------------------------------------
					C++流输出操作
   ------------------------------------------------------------- */

// 向流中输出UTF8编码
UINT CUnicodeConverter::Print_UTF8_By_UCS4( ostream& os, DWORD dwUCS4 )
{
	INT		iLen;
	BYTE	abUTF8[8];

	if( !os )return 0;
	
	iLen = UCS4_To_UTF8( dwUCS4, abUTF8 );
	if( iLen == 0 )return 0;

	os.write( reinterpret_cast<CHAR*>(abUTF8), iLen );

	return iLen;	
}

// 向流中输出UTF16编码
UINT CUnicodeConverter::Print_UTF16_By_UCS4( ostream& os, DWORD dwUCS4, BOOL isBigEndian )
{
	INT		i, iLen;
	WORD	wCode, awUTF16[2];

	if( !os )return 0;
	
	iLen = UCS4_To_UTF16( dwUCS4, awUTF16 );
	if( iLen == 0 )return 0;

	for( i = 0; i < iLen; i++ )
	{
		wCode = awUTF16[i];
		if( isBigEndian )
		{
			os.put( wCode >> 8 );		// 输出高位
			os.put( wCode & 0xFF );		// 输出低位
		}
		else
		{
			os.put( wCode & 0xFF );		// 输出低位
			os.put( wCode >> 8 );		// 输出高位
		}
	}

	return (iLen << 1);
}

// 将UTF16字符串以UTF8编码输出到流中
UINT CUnicodeConverter::Print_UTF8Str_By_UTF16Str( ostream& os, const WORD* pwszUTF16Str )
{
	INT		iCount, iLen;
	DWORD	dwUCS4;

	if( !os || (pwszUTF16Str == NULL) )return 0;
	
	iCount = 0;
	while( *pwszUTF16Str )
	{	// 将UTF16编码转换成UCS4编码
		iLen = UTF16_To_UCS4( pwszUTF16Str, dwUCS4 );
		if( iLen == 0 )
		{
			break;
		}

		pwszUTF16Str += iLen;

		// 向流中输出UTF8编码
		iCount += Print_UTF8_By_UCS4( os, dwUCS4 );
	}

	return iCount;	// 输出的字节数
}

// 将UTF8字符串以UTF16编码输出到流中
UINT CUnicodeConverter::Print_UTF16Str_By_UTF8Str( ostream& os, const BYTE* pbszUTF8Str, BOOL isBigEndian )
{
	INT		iCount, iLen;
	DWORD	dwUCS4;

	if( !os || (pbszUTF8Str == NULL) )return 0;

	iCount = 0;
	while( *pbszUTF8Str )
	{	// 将UTF16编码转换成UCS4编码
		iLen = UTF8_To_UCS4( pbszUTF8Str, dwUCS4 );
		if( iLen == 0 )
		{
			break;
		}

		pbszUTF8Str += iLen;

		// 向流中输出UTF8编码
		iCount += Print_UTF16_By_UCS4( os, dwUCS4, isBigEndian );
	}

	return iCount;	// 输出的字节数
}

// 向流中输出UTF8字节序标记
UINT CUnicodeConverter::Print_UTF8_BOM( ostream& os )
{
	if( !os )return 0;
	
	os.put( 0xEF );
	os.put( 0xBB );
	os.put( 0xBF );

	return 3;	
}

// 向流中输出UTF16字节序标记
UINT CUnicodeConverter::Print_UTF16_BOM( ostream& os, BOOL isBigEndian )
{
	if( !os )return 0;
	
	if( isBigEndian )
	{
		os.put( 0xFE );
		os.put( 0xFF );
	}
	else
	{
		os.put( 0xFF );
		os.put( 0xFE );
	}

	return 2;
}

/* ------------------------------
				END
   ------------------------------ */

转载于:https://my.oschina.net/zhangzhihao/blog/70462

chuhuangqiao1461
关注
C++ 字符编码转换之UTF-8/UTF-16/UTF-32
S676951的博客
02-27 8473
C++编码格式 参考链接（什么是辅助平面） 参考链接（什么是UCS-2） UCS-2对每一个Unicode码位使用2bytes字集(16位bit); UCS-4对每一个Unicode码位使用4bytes字集(32位bit); UTF-16可看成是UCS-2的父集。在没有辅助平面字符（surrogate code points）前，UTF-16与UCS-2所指的是同一的意思。但当引入辅助平面字符后，就称为UTF-16了。现在若有软件声称自己支持UCS-2编码，那其实是暗指它不能支持在UTF-16中超过2byt
UTF-8、UTF-16、UTF-32编码的相互转换
云彩挂上的二叉树
02-23 1万+
最近在考虑写一个可以跨平台的通用字符串类，首先需要搞定的就是编码转换问题。 vs默认保存代码文件，使用的是本地code（中文即GBK，日文即Shift-JIS），也可以使用带BOM的UTF-8。 gcc则是UTF-8，有无BOM均可（源代码的字符集可以由参数-finput-charset指定）。 那么源代码可以采用带BOM的UTF-8来保存。而windows下的unicode是UTF-16编码；linux则使用UTF-8或UTF-32。因此不论在哪种系统里，程序在处理字符串时都需要考虑UTF编码之间的相互
c++ UTF-8 UTF-16转换
05-01
宽字节和多字节转换，利用C++实现UTF-8和UTF-16之间的转换，包括错误处理
utf8与utf16转换
sdhongjun的专栏
03-14 1万+
1.UTF8与UTF16编码转换 std::string ConvertFromUtf16ToUtf8(const std::wstring&amp; wstr) { std::string convertedString; int requiredSize = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, 0, 0, 0, 0...
utf-8/utf-16转换代码完整版
12-22
最近需要对Linux与Windows平台下的字符传输出现乱码，对字符编码作了深究。参考了网上的UTF-8/UTF-16转换的资料，只有0x10000以下的Unicode编码进行了转换；对其代码进行了修改和补充，可以实现所有的UTF-8/UTF-16的转换，分享给大家。
编程：C++中UTF-8、UTF-16、UTF-32之间的编码转换
hzraymond的专栏
11-08 1821
原：http://blog.csdn.net/jhqin/article/details/5687505 原：http://hxraid.iteye.com/blog/559607 【附2】： UTF-16编码算法 Unicode编码表的专业术语： 代码点 (code point): 指在Unicode编码表中一个字符所对应的代码值。如汉字“一”的代码点是U+4
细说：Unicode, UTF-8, UTF-16, UTF-32, UCS-2, UCS-4
weixin_30924239的博客
03-21 294
1. Unicode与ISO 10646 全世界很多个国家都在为自己的文字编码，并且互不想通，不同的语言字符编码值相同却代表不同的符号（例如：韩文编码EUC-KR中“한국어”的编码值正好是汉字编码GBK中的“茄惫绢”）。因此，同一份文档，拷贝至不同语言的机器，就可能成了乱码，于是人们就想：我们能不能定义一个超大的字符集，它可以容纳全世界所有的文字字符，再对它们统一进行编码，让每一个字符...
utf-8.rar_c++ string utf-8_string to utf-8_utf_utf 8_utf-8
09-24
3. **编码解码**：将UTF-8字符串转换为其他编码，或者从其他编码转换回UTF-8，这通常需要第三方库的帮助。 4. **国际化和本地化**：如果你的程序需要支持多种语言，那么处理UTF-8就显得尤为重要，因为它能表示所有...
UTF-8.rar_utf_utf gb2312_utf 转换_utf-8_utf-8解码
09-14
本文将深入探讨UTF-8和GB2312这两种字符编码，并解释它们之间的转换过程以及相关的解码技术。 首先，UTF-8是一种广泛使用的Unicode字符编码方式。它能够表示Unicode字符集中所有的字符，包括汉字、拉丁字母、希腊...
C++ 编码格式GB2312与UTF-8之间的转换
Mark_1995的博客
05-11 3767
C++编码格式转换 首先介绍一下，VS编码格式是GB2312，是基于中国地区的，而Windows编码格式一般为Unicode，也就是UTF-8格式。 在VS编辑器下，字符串的初始化譬如： char* ch = "中文"; 这样是GB2312格式的。 而我们在Windows程序中直接使用就容易乱码，所以需要把它转为Unicode格式，符合Windows的编码，才不会乱码，而转换之后，你在VS调试的时候你看到的可能是这样的： “字符串中的字符无效” 其实不是真的无效，它只是在VS上显示不出来而已，在Wind
C++实现unicode码转换成UTF-16的加码和解码函数
清流弯弯
08-14 5754
Unicode的实现方式不同于编码方式。一个字符的Unicode编码是确定的，但是在实际存储和传输过程中，由于不同系统平台的设计不一定一致，以及出于节省空间的目的，对Unicode编码的实现方式有所不同。Unicode的实现方式称为Unicode转换格式（UnicodeTransformation Format，简称为UTF）。          对Unicode编码的主要有UTF-16BE
Unicode utf8 utf16 在c++中的使用
weixin_53022668的博客
12-22 3332
在网络通讯中常使用Unicode编码和utf8编码传输数据 utf8是为服务Unicode的一种可变长度字符编码，它的优势在于对ascii完全兼容，ascii在utf8编码为一个字节，在内存上与ascii编码完全相同。 utf16编码一个字符需要2或者4个字节（在windows下unicode编码就是指UTF16） //转换为c字符串的一种方法 std::wstring wstr = L"宽字符串"; const wchar_t* t= wstr.c_str(); int len = wstr
c++——Unicode、UTF-8、UTF-16
www_dong的博客
06-09 2291
计算机起源于美国，上个世纪，他们对英语字符与二进制位之间的关系做了统一规定，并制定了一套字符编码规则，这套编码规则被称为ASCII编码 ASCII 编码一共定义了128个字符的编码规则，用七位二进制表示 ( 0x00 - 0x7F ), 这些字符组成的集合就叫做 ASCII 字符集 随着计算机的普及，在不同的地区和国家又出现了很多字符编码，比如: 大陆的 GB2312、港台的 BIG5, 日本的 Shift JIS等等 由于字符编码不同，计算机在不同国家之间的交流变得很困难，经常会出现乱码的问题，比如
UTF编码转换工具
04-18
可以将Utf编码转换为汉字，配合Reflector使用。
字符编码转换，utf16 utf8 ascii unicode
01-25
utf16 utf8 ascii unicode 所有代码都已经经过验证。而且里面也有相应的例子。 所有的编码格式进行转换，windows平台。
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 进行转换。
C++中的Unicode编码:wchar, UTF-8,UTF-16,UTF-32
linuxheik的专栏
01-11 2255
C++在C11标准中加入了对Unicode编码的支持，新增了wchar_t、char16_t、char32_t内置数据类型。     cout &lt;&lt; sizeof(char) &lt;&lt; endl;     cout &lt;&lt; sizeof(wchar_t) &lt;&lt; endl;     cout &lt;&lt; sizeof(char16_t) &lt;&l...
再议UTF-16的编码
java的涟漪
03-23 2338
上面的文章已经说过UTF-16的来历，但是所有的Unicode都有一个区分，那就是有签名和无签名之分，何为签名呢，就是文件编辑器在Unicode文件的开头字节中自动加入的识别字符。现在来看看UTF-16的区别，UTF-16有两种编码：UTF-16LE和UTF-16BE，这两种编码有分别分为有签名和无签名，要正确读取解析这中文件就要用字符集一一对应，目前在JAVA中的对应方式如下：Unico
GBK和UTF-16编码的转换接口
06-06
包含GBK和UTF16字符集的对照表，用于将GBK字节流和UTF字符串之间的互相转换。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值