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

开发语言：C++

功能描述：

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

下载地址：

UnicodeConverter.zip

版本历史：

V1.02010年03月12日

• 完成正式版本。

源代码：

UnicodeConverter.h

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

作者：秦建辉

MSN：[e-mail]

当前版本：V1.0

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

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

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

usingnamespacestd;

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

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

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

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

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

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

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

/*
功能：向文件中写入UTF16编码
返回值：
写入的字节数
*/
staticUINTPrint_UTF16_By_UCS4(FILE*out,DWORDdwUCS4,BOOLisBigEndian=FALSE);

/*
功能：将UTF16字符串以UTF8编码输出到文件中
返回值：
写入的字节数
*/
staticUINTPrint_UTF8Str_By_UTF16Str(FILE*out,constWORD*pwszUTF16Str);

/*
功能：将UTF8字符串以UTF16编码输出到文件中
返回值：
写入的字节数
*/
staticUINTPrint_UTF16Str_By_UTF8Str(FILE*out,constBYTE*pbszUTF8Str,BOOLisBigEndian=FALSE);

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

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

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

/*
功能：向流中写入UTF16编码
返回值：
写入的字节数
*/
staticUINTPrint_UTF16_By_UCS4(ostream&os,DWORDdwUCS4,BOOLisBigEndian=FALSE);

/*
功能：将UTF16字符串以UTF8编码输出到流中
返回值：
写入的字节数
*/
staticUINTPrint_UTF8Str_By_UTF16Str(ostream&os,constWORD*pwszUTF16Str);

/*
功能：将UTF8字符串以UTF16编码输出到流中
返回值：
写入的字节数
*/
staticUINTPrint_UTF16Str_By_UTF8Str(ostream&os,constBYTE*pbszUTF8Str,BOOLisBigEndian=FALSE);

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

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

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

UnicodeConverter.cpp

#include"UnicodeConverter.h"

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

//转换UCS4编码到UTF8编码
INTCUnicodeConverter::UCS4_To_UTF8(DWORDdwUCS4,BYTE*pbUTF8)
{
constBYTEabPrefix[]={0,0xC0,0xE0,0xF0,0xF8,0xFC};
constDWORDadwCodeUp[]={
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
};

INTi,iLen;

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

if(i==iLen)return0;//无效的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]);
}

returniLen;
}

//转换UTF8编码到UCS4编码
INTCUnicodeConverter::UTF8_To_UCS4(constBYTE*pbUTF8,DWORD&dwUCS4)
{
INTi,iLen;
BYTEb;

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

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

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

if(b<0xE0)
{
dwUCS4=b&0x1F;
iLen=2;
}
elseif(b<0xF0)
{
dwUCS4=b&0x0F;
iLen=3;
}
elseif(b<0xF8)
{
dwUCS4=b&7;
iLen=4;
}
elseif(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
return0;
}
else
{
returniLen;
}
}

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

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

return2;
}
else
{
return0;
}
}

//转换UCS2编码到UCS4编码
INTCUnicodeConverter::UTF16_To_UCS4(constWORD*pwUTF16,DWORD&dwUCS4)
{
WORDw1,w2;

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

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

return0;//非法UTF16编码
}
else
{
dwUCS4=w1;
return1;
}
}

//转换UTF8字符串到UTF16字符串
INTCUnicodeConverter::UTF8Str_To_UTF16Str(constBYTE*pbszUTF8Str,WORD*pwszUTF16Str)
{
INTiNum,iLen;
DWORDdwUCS4;

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

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

pbszUTF8Str+=iLen;

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

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

iNum+=iLen;
}

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

returniNum;
}

//转换UTF16字符串到UTF8字符串
INTCUnicodeConverter::UTF16Str_To_UTF8Str(constWORD*pwszUTF16Str,BYTE*pbszUTF8Str)
{
INTiNum,iLen;
DWORDdwUCS4;

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

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

pwszUTF16Str+=iLen;

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

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

iNum+=iLen;
}

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

returniNum;
}

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

//向文件中输出UTF8编码
UINTCUnicodeConverter::Print_UTF8_By_UCS4(FILE*out,DWORDdwUCS4)
{
INTiLen;
BYTEabUTF8[8];

if(out==NULL)
{
return0;
}

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

fwrite(abUTF8,1,iLen,out);

returniLen;
}

//向文件中输出UTF16编码
UINTCUnicodeConverter::Print_UTF16_By_UCS4(FILE*out,DWORDdwUCS4,BOOLisBigEndian)
{
INTi,iLen;
WORDwCode,awUTF16[2];

if(out==NULL)
{
return0;
}

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

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编码输出到文件中
UINTCUnicodeConverter::Print_UTF8Str_By_UTF16Str(FILE*out,constWORD*pwszUTF16Str)
{
INTiCount,iLen;
DWORDdwUCS4;

if((out==NULL)||(pwszUTF16Str==NULL))
{
return0;
}

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);
}

returniCount;//输出的字节数
}

//将UTF8字符串以UTF16编码输出到文件中
UINTCUnicodeConverter::Print_UTF16Str_By_UTF8Str(FILE*out,constBYTE*pbszUTF8Str,BOOLisBigEndian)
{
INTiCount,iLen;
DWORDdwUCS4;

if((out==NULL)||(pbszUTF8Str==NULL))
{
return0;
}

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);
}

returniCount;//输出的字节数
}

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

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

return3;
}

//向文件中输出UTF16字节序标记
UINTCUnicodeConverter::Print_UTF16_BOM(FILE*out,BOOLisBigEndian)
{
if(out==NULL)
{
return0;
}

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

return2;
}

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

//向流中输出UTF8编码
UINTCUnicodeConverter::Print_UTF8_By_UCS4(ostream&os,DWORDdwUCS4)
{
INTiLen;
BYTEabUTF8[8];

if(!os)return0;

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

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

returniLen;
}

//向流中输出UTF16编码
UINTCUnicodeConverter::Print_UTF16_By_UCS4(ostream&os,DWORDdwUCS4,BOOLisBigEndian)
{
INTi,iLen;
WORDwCode,awUTF16[2];

if(!os)return0;

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

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编码输出到流中
UINTCUnicodeConverter::Print_UTF8Str_By_UTF16Str(ostream&os,constWORD*pwszUTF16Str)
{
INTiCount,iLen;
DWORDdwUCS4;

if(!os||(pwszUTF16Str==NULL))return0;

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);
}

returniCount;//输出的字节数
}

//将UTF8字符串以UTF16编码输出到流中
UINTCUnicodeConverter::Print_UTF16Str_By_UTF8Str(ostream&os,constBYTE*pbszUTF8Str,BOOLisBigEndian)
{
INTiCount,iLen;
DWORDdwUCS4;

if(!os||(pbszUTF8Str==NULL))return0;

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);
}

returniCount;//输出的字节数
}

//向流中输出UTF8字节序标记
UINTCUnicodeConverter::Print_UTF8_BOM(ostream&os)
{
if(!os)return0;

os.put(0xEF);
os.put(0xBB);
os.put(0xBF);

return3;
}

//向流中输出UTF16字节序标记
UINTCUnicodeConverter::Print_UTF16_BOM(ostream&os,BOOLisBigEndian)
{
if(!os)return0;

if(isBigEndian)
{
os.put(0xFE);
os.put(0xFF);
}
else
{
os.put(0xFF);
os.put(0xFE);
}

return2;
}

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

转自：http://blog.csdn.net/jhqin/article/details/5687505