標籤：

一網打盡中文編碼轉換

07-09
一網打盡中文編碼轉換——6種編碼30個方向的轉換

1.問題提出

在學編程序時，曾經有人問過「你可以編一個記事本程序嗎?」當時很不屑一顧，但是隨著學習MFC的深入，了解到記事本程序也並非易事，難點就是四種編碼之間的轉換。

對於編碼，這是一個令初學者頭疼的問題，特別是對於編碼的轉換，更是難以捉摸。筆者為了完成畢業設計中的一個編碼轉換模塊，研究了中文編碼和常見的字符集後，決定解決"記事本"程序的編碼問題，更進一步完成GB2312、Big5、GBK、Unicode 、Unicode big endian、UTF-8共6種編碼之間的任意轉換。

2.問題解決

(1)編碼基礎知識

a.了解編碼和字符集

這部分內容，我不在贅述，可參見CSDN Ancky的專欄中《各種字符集和編碼詳解》

博客地址:http://blog.csdn.net/ancky/article/details/2034809

b.單位元組、雙位元組、多位元組

這部分內容，可參見我先前翻譯的博文《C++字元串完全指南--第一部分:win32字元編碼》

博客地址:http://blog.csdn.net/ziyuanxiazai123/article/details/7482360

c.區域和代碼頁

這部分內容，可參見博客 http://hi.baidu.com/tzpwater/blog/item/bd4abb0b60bff1db3ac7636a.html

d.中文編碼GB2312、GBK、Big5，這部分內容請參見CSDN lengshine 博客中《GB2312、GBK、Big5漢字編碼》，博客地址:http://blog.csdn.net/lengshine/article/details/5470545

e.Windows程序的字元編碼

這部分內容，可參見博客http://blog.sina.com.cn/s/blog_4e3197f20100a6z2.html 中《Windows程序的字元編碼》

(2)編碼總結

a.六種編碼的特點

六種編碼的特點如下圖所示:

b.編碼存儲差別

ANSI(在簡體中文中默認為GB2312)、Unicode、Unicode big endian 、UTF-8存儲存在差別。

以中文"你好"二字為例，他們存貯格式如下圖所示:

c.GB2312、Big5、GBK編碼的區別

三者中漢字均採用二個位元組表示，但是位元組表示的值範圍有所不同，如下圖所示:

(3)編碼轉換方式

6種編碼互相轉換，由排列組合知識知道共有30個方向的轉換.筆者採用的轉換方法,

多位元組文件與Unicode文件轉換如下圖所示:

多位元組文件之間轉換如下圖所示:

(4)編碼轉換使用的三個函數

a.MultiByteToWideChar

該函數完成多位元組字元串向Unicode寬字元串的轉換.

函數原型為:

int MultiByteToWideChar( UINT CodePage, // 代碼頁 DWORD dwFlags, // 轉換標誌 LPCSTR lpMultiByteStr, // 待轉換的字元串 int cbMultiByte, // 待轉換字元串的位元組數目 LPWSTR lpWideCharStr, // 轉換後寬字元串的存儲空間 int cchWideChar // 轉換後寬字元串的存儲空間大小 以寬字元大小為單位);b.WideCharToMultiByte該函數完成Unicode寬字元串到多位元組字元串的轉換，使用方法具體參見MSDN。以上兩個函數可以完成大部分的字元串轉換，可以將其封裝成多位元組和寬位元組之間的轉換函數:[cpp] view plaincopyprint?

  1. wchar_t*Coder::MByteToWChar(UINTCodePage,LPCSTRlpcszSrcStr)
  2. {
  3. LPWSTRlpcwsStrDes=NULL;
  4. intlen=MultiByteToWideChar(CodePage,0,lpcszSrcStr,-1,NULL,0);
  5. lpcwsStrDes=newwchar_t[len+1];
  6. if(!lpcwsStrDes)
  7. returnNULL;
  8. memset(lpcwsStrDes,0,sizeof(wchar_t)*(len+1));
  9. len=MultiByteToWideChar(CodePage,0,lpcszSrcStr,-1,lpcwsStrDes,len);
  10. if(len)
  11. returnlpcwsStrDes;
  12. else
  13. {
  14. delete[]lpcwsStrDes;
  15. returnNULL;
  16. }
  17. }
  19. char*Coder::WCharToMByte(UINTCodePage,LPCWSTRlpcwszSrcStr)
  20. {
  21. char*lpszDesStr=NULL;
  22. intlen=WideCharToMultiByte(CodePage,0,lpcwszSrcStr,-1,NULL,0,NULL,NULL);
  23. lpszDesStr=newchar[len+1];
  24. memset(lpszDesStr,0,sizeof(char)*(len+1));
  25. if(!lpszDesStr)
  26. returnNULL;
  27. len=WideCharToMultiByte(CodePage,0,lpcwszSrcStr,-1,lpszDesStr,len,NULL,NULL);
  28. if(len)
  29. returnlpszDesStr;
  30. else
  31. {
  32. delete[]lpszDesStr;
  33. returnNULL;
  34. }
  35. }

c.LCMapString依賴於本地機器的字元轉換函數，尤其是中文編碼在轉換時要依賴於本地機器，直接利用上述a、b中敘述的函數會產生錯誤,例如直接從GB2312轉換到Big5，利用

MultiByteToWideChar函數將GB2312轉換到Unicode字元串，然後從Unicode字元串利用函數

WideCharToMultiByte轉換成Big5,將會發生錯誤，錯誤的結果如下圖所示:

因此中文編碼轉換時適當使用LCMapString函數，才能完成正確的轉換.例如:[cpp] view plaincopyprint?

  1. //簡體中文GB2312轉換成繁體中文BIG5
  2. char*Coder::GB2312ToBIG5(constchar*szGB2312Str)
  3. {
  4. LCIDlcid=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_PRC);
  5. intnLength=LCMapString(lcid,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,-1,NULL,0);
  6. char*pBuffer=newchar[nLength+1];
  7. if(!pBuffer)
  8. returnNULL;
  9. LCMapString(lcid,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,-1,pBuffer,nLength);
  10. pBuffer[nLength]=0;
  11. wchar_t*pUnicodeBuff=MByteToWChar(CP_GB2312,pBuffer);
  12. char*pBIG5Buff=WCharToMByte(CP_BIG5,pUnicodeBuff);
  13. delete[]pBuffer;
  14. delete[]pUnicodeBuff;
  15. returnpBIG5Buff;
  16. }

(5)編碼實現實現Coder類完成編碼轉換工作.Coder類的代碼清單如下:[cpp] view plaincopyprint?

  1. //Coder.h:interfacefortheCoderclass.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #if!defined(AFX_ENCODING_H__2AC955FB_9F8F_4871_9B77_C6C65730507F__INCLUDED_)
  6. #defineAFX_ENCODING_H__2AC955FB_9F8F_4871_9B77_C6C65730507F__INCLUDED_
  8. #if_MSC_VER>1000
  9. #pragmaonce
  10. #endif//_MSC_VER>1000
  11. //-----------------------------------------------------------------------------------------------
  12. //程序用途：實現GB2312、big5、GBK、Unicode、Unicodebigendian、UTF-8六種編碼的任意裝換
  13. //程序作者：湖北師範學院計算機科學與技術學院王定橋
  14. //核心演算法：根據不同編碼特點向其他編碼轉換
  15. //測試結果:在Windows7VC6.0環境下測試通過
  16. //製作時間：2012-04-24
  17. //代碼版權:代碼公開供學習交流使用歡迎指正錯誤改善演算法
  18. //-----------------------------------------------------------------------------------------------
  19. //Windows代碼頁
  20. typedefenumCodeType
  21. {
  22. CP_GB2312=936,
  23. CP_BIG5=950,
  24. CP_GBK=0//此處特殊處理CP_GBK僅作一標誌GBK代碼頁值尚未查得
  25. }CodePages;
  26. //txt文件編碼
  27. typedefenumTextCodeType
  28. {
  29. GB2312=0,
  30. BIG5=1,
  31. GBK=2,
  32. UTF8=3,
  33. UNICODE=4,
  34. UNICODEBIGENDIAN=5,
  35. DefaultCodeType=-1
  36. }TextCode;
  37. classCoder
  38. {
  39. public:
  40. Coder();
  41. virtual~Coder();
  42. public:
  43. //默認一次轉換位元組大小
  44. UINTPREDEFINEDSIZE;
  45. //指定轉換時默認一次轉換位元組大小
  46. voidSetDefaultConvertSize(UINTnCount);
  47. //編碼類型轉換為字元串
  48. CStringCodeTypeToString(TextCodetc);
  49. //文件轉到另一種文件
  50. BOOLFileToOtherFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur=DefaultCodeType);
  51. //Unicode和Unicodebigendian文件之間轉換
  52. BOOLUnicodeEndianFileConvert(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo);
  53. //多位元組文件之間的轉換
  54. BOOLMBFileToMBFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur=DefaultCodeType);
  55. //Unicode和Unicodebigendian文件向多位元組文件轉換
  56. BOOLUnicodeFileToMBFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo);
  57. //多位元組文件向Unicode和Unicodebigendian文件轉換
  58. BOOLMBFileToUnicodeFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur=DefaultCodeType);
  59. //獲取文件編碼類型
  60. TextCodeGetCodeType(CStringfilepath);
  61. //繁體中文BIG5轉換成簡體中文GB2312
  62. char*BIG5ToGB2312(constchar*szBIG5Str);
  63. //簡體中文GB2312轉換成繁體中文BIG5
  64. char*GB2312ToBIG5(constchar*szGB2312Str);
  65. //簡繁中文GBK編碼轉換成簡體中文GB2312
  66. char*GBKToGB2312(constchar*szGBkStr);
  67. //簡體中文GB2312編碼轉換成簡繁中文GBK
  68. char*GB2312ToGBK(constchar*szGB2312Str);
  69. //簡繁中文GBK轉換成繁體中文Big5
  70. char*GBKToBIG5(constchar*szGBKStr);
  71. //繁體中文BIG5轉換到簡繁中文GBK
  72. char*BIG5ToGBK(constchar*szBIG5Str);
  73. //寬字元串向多位元組字元串轉換
  74. char*WCharToMByte(UINTCodePage,LPCWSTRlpcwszSrcStr);
  75. //多位元組字元串向寬字元串轉換
  76. wchar_t*MByteToWChar(UINTCodePage,LPCSTRlpcszSrcStr);
  77. protected:
  78. //獲取編碼類型對應的代碼頁
  79. UINTGetCodePage(TextCodetccur);
  80. //多位元組向多位元組轉換
  81. char*MByteToMByte(UINTCodePageCur,UINTCodePageTo,constchar*szSrcStr);
  82. //Unicode和Unicodebigendian字元串之間的轉換
  83. voidUnicodeEndianConvert(LPWSTRlpwszstr);
  84. //文件頭常量位元組數組
  85. conststaticbyteUNICODEBOM[2];
  86. conststaticbyteUNICODEBEBOM[2];
  87. conststaticbyteUTF8BOM[3];
  88. };
  90. #endif//!defined(AFX_ENCODING_H__2AC955FB_9F8F_4871_9B77_C6C65730507F__INCLUDED_)

[cpp] view plaincopyprint?

  1. //Coder.cpp:implementationoftheCoderclass.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include"stdafx.h"
  6. #include"Coder.h"
  7. #include"Encoding.h"
  9. #ifdef_DEBUG
  10. #undefTHIS_FILE
  11. staticcharTHIS_FILE[]=__FILE__;
  12. #definenewDEBUG_NEW
  13. #endif
  15. //////////////////////////////////////////////////////////////////////
  16. //Construction/Destruction
  17. //////////////////////////////////////////////////////////////////////
  18. //初始化文件頭常量
  19. /*static*/constbyteCoder::UNICODEBOM[2]={0xFF,0xFE};
  20. /*static*/constbyteCoder::UNICODEBEBOM[2]={0xFE,0xFF};
  21. /*static*/constbyteCoder::UTF8BOM[3]={0xEF,0xBB,0xBF};
  22. Coder::Coder()
  23. {
  24. PREDEFINEDSIZE=2097152;//默認一次轉換位元組大小2M位元組
  25. }
  26. Coder::~Coder()
  27. {
  29. }
  30. //繁體中文BIG5轉換成簡體中文GB2312
  31. char*Coder::BIG5ToGB2312(constchar*szBIG5Str)
  32. {
  33. CStringmsg;
  34. LCIDlcid=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_PRC);
  35. wchar_t*szUnicodeBuff=MByteToWChar(CP_BIG5,szBIG5Str);
  36. char*szGB2312Buff=WCharToMByte(CP_GB2312,szUnicodeBuff);
  37. intnLength=LCMapString(lcid,LCMAP_SIMPLIFIED_CHINESE,szGB2312Buff,-1,NULL,0);
  38. char*pBuffer=newchar[nLength+1];
  39. if(!pBuffer)
  40. returnNULL;
  41. memset(pBuffer,0,sizeof(char)*(nLength+1));
  42. LCMapString(0x0804,LCMAP_SIMPLIFIED_CHINESE,szGB2312Buff,-1,pBuffer,nLength);
  43. delete[]szUnicodeBuff;
  44. delete[]szGB2312Buff;
  45. returnpBuffer;
  46. }
  47. //GB2312轉GBK
  48. char*Coder::GB2312ToGBK(constchar*szGB2312Str)
  49. {
  50. intnStrLen=strlen(szGB2312Str);
  51. if(!nStrLen)
  52. returnNULL;
  53. LCIDwLCID=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_PRC);
  54. intnReturn=LCMapString(wLCID,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,nStrLen,NULL,0);
  55. if(!nReturn)
  56. returnNULL;
  57. char*pcBuf=newchar[nReturn+1];
  58. if(!pcBuf)
  59. returnNULL;
  60. memset(pcBuf,0,sizeof(char)*(nReturn+1));
  61. wLCID=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_PRC);
  62. LCMapString(wLCID,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,nReturn,pcBuf,nReturn);
  63. returnpcBuf;
  64. }
  65. //GBK轉換成GB2312
  66. char*Coder::GBKToGB2312(constchar*szGBKStr)
  67. {
  68. intnStrLen=strlen(szGBKStr);
  69. if(!nStrLen)
  70. returnNULL;
  71. LCIDwLCID=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_BIG5);
  72. intnReturn=LCMapString(wLCID,LCMAP_SIMPLIFIED_CHINESE,szGBKStr,nStrLen,NULL,0);
  73. if(!nReturn)
  74. returnNULL;
  75. char*pcBuf=newchar[nReturn+1];
  76. memset(pcBuf,0,sizeof(char)*(nReturn+1));
  77. wLCID=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_BIG5);
  78. LCMapString(wLCID,LCMAP_SIMPLIFIED_CHINESE,szGBKStr,nReturn,pcBuf,nReturn);
  79. returnpcBuf;
  80. }
  81. //簡繁中文GBK轉換成繁體中文Big5
  82. char*Coder::GBKToBIG5(constchar*szGBKStr)
  83. {
  84. char*pTemp=NULL;
  85. char*pBuffer=NULL;
  86. pTemp=GBKToGB2312(szGBKStr);
  87. pBuffer=GB2312ToBIG5(pTemp);
  88. delete[]pTemp;
  89. returnpBuffer;
  90. }
  91. //繁體中文BIG5轉換到簡繁中文GBK
  92. char*Coder::BIG5ToGBK(constchar*szBIG5Str)
  93. {
  94. char*pTemp=NULL;
  95. char*pBuffer=NULL;
  96. pTemp=BIG5ToGB2312(szBIG5Str);
  97. pBuffer=GB2312ToGBK(pTemp);
  98. delete[]pTemp;
  99. returnpBuffer;
  100. }
  101. //簡體中文GB2312轉換成繁體中文BIG5
  102. char*Coder::GB2312ToBIG5(constchar*szGB2312Str)
  103. {
  104. LCIDlcid=MAKELCID(MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED),SORT_CHINESE_PRC);
  105. intnLength=LCMapString(lcid,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,-1,NULL,0);
  106. char*pBuffer=newchar[nLength+1];
  107. if(!pBuffer)
  108. returnNULL;
  109. LCMapString(lcid,LCMAP_TRADITIONAL_CHINESE,szGB2312Str,-1,pBuffer,nLength);
  110. pBuffer[nLength]=0;
  111. wchar_t*pUnicodeBuff=MByteToWChar(CP_GB2312,pBuffer);
  112. char*pBIG5Buff=WCharToMByte(CP_BIG5,pUnicodeBuff);
  113. delete[]pBuffer;
  114. delete[]pUnicodeBuff;
  115. returnpBIG5Buff;
  116. }
  117. //獲取文件編碼類型
  118. //Unicode編碼文件通過讀取文件頭判別
  119. //中文編碼通過統計文件編碼類別來判別判別次數最多為30次
  120. //中文編碼的判別存在誤差
  121. TextCodeCoder::GetCodeType(CStringfilepath)
  122. {
  123. CFilefile;
  124. bytebuf[3];//unsignedchar
  125. TextCodetctemp;
  126. if(file.Open(filepath,CFile::modeRead))
  127. {
  128. file.Read(buf,3);
  129. if(buf[0]==UTF8BOM[0]&&buf[1]==UTF8BOM[1]&&buf[2]==UTF8BOM[2])
  130. returnUTF8;
  131. else
  132. if(buf[0]==UNICODEBOM[0]&&buf[1]==UNICODEBOM[1])
  133. returnUNICODE;
  134. else
  135. if(buf[0]==UNICODEBEBOM[0]&&buf[1]==UNICODEBEBOM[1])
  136. returnUNICODEBIGENDIAN;
  137. else
  138. {
  139. inttime=30;
  140. while(file.Read(buf,2)&&time)
  141. {
  142. if((buf[0]>=176&&buf[0]<=247)&&(buf[1]>=160&&buf[1]<=254))
  143. tctemp=GB2312;
  144. else
  145. if((buf[0]>=129&&buf[0]<=255)&&((buf[1]>=64&&buf[1]<=126)||(buf[1]>=161&&buf[1]<=254)))
  146. tctemp=BIG5;
  147. else
  148. if((buf[0]>=129&&buf[0]<=254)&&(buf[1]>=64&&buf[1]<=254))
  149. tctemp=GBK;
  150. time--;
  151. file.Seek(100,CFile::current);//跳過一定位元組利於統計全文
  152. }
  153. returntctemp;
  154. }
  155. }
  156. else
  157. returnGB2312;
  158. }
  159. //多位元組文件轉換為UNICODE、UNICODEbigendian文件
  160. BOOLCoder::MBFileToUnicodeFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur)
  161. {
  162. TextCodecurtc;
  163. CFilefilesource,filesave;;
  164. char*pChSrc=NULL;
  165. char*pChTemp=NULL;
  166. wchar_t*pwChDes=NULL;
  167. DWORDfilelength,readlen,len;
  168. intbufferlen,strlength;
  169. UINTCodePage;
  170. //由於存在誤差允許用戶自定義轉換
  171. if(tcCur!=DefaultCodeType)
  172. curtc=tcCur;
  173. else
  174. curtc=GetCodeType(filesourcepath);
  175. if(curtc>UTF8||tcTo<UNICODE||curtc==tcTo)
  176. returnFALSE;
  177. //源文件打開失敗或者源文件無內容後者保存文件建立失敗均返迴轉換失敗
  178. if(!filesource.Open(filesourcepath,CFile::modeRead)||0==(filelength=filesource.GetLength()))
  179. returnFALSE;
  180. if(!filesave.Open(filesavepath,CFile::modeCreate|CFile::modeWrite))
  181. returnFALSE;
  182. //預分配內存分配失敗則轉換失敗
  183. if(filelength<PREDEFINEDSIZE)
  184. bufferlen=filelength;
  185. else
  186. bufferlen=PREDEFINEDSIZE;
  187. pChSrc=newchar[bufferlen+1];
  188. if(!pChSrc)
  189. returnFALSE;
  190. //根據當前文件類別指定轉換代碼頁
  191. switch(curtc)
  192. {
  193. caseGB2312:
  194. CodePage=CP_GB2312;
  195. break;
  196. caseGBK:
  197. CodePage=CP_GB2312;//特殊處理
  198. break;
  199. caseBIG5:
  200. CodePage=CP_BIG5;
  201. break;
  202. caseUTF8:
  203. CodePage=CP_UTF8;
  204. break;
  205. default:
  206. break;
  207. }
  208. //UTF8文件跳過文件
  209. if(UTF8==curtc)
  210. filesource.Seek(3*sizeof(byte),CFile::begin);
  211. //寫入文件頭
  212. if(UNICODEBIGENDIAN==tcTo)
  213. filesave.Write(&UNICODEBEBOM,2*sizeof(byte));
  214. else
  215. filesave.Write(&UNICODEBOM,2*sizeof(byte));
  216. //讀取文件分段轉換知道結束
  217. while(filelength>0)
  218. {
  219. memset(pChSrc,0,sizeof(char)*(bufferlen+1));
  220. if(filelength>PREDEFINEDSIZE)
  221. len=PREDEFINEDSIZE;
  222. else
  223. len=filelength;
  224. readlen=filesource.Read(pChSrc,len);
  225. if(!readlen)
  226. break;
  227. //GBK轉換為GB2312處理
  228. if(GBK==curtc)
  229. {
  230. pChTemp=pChSrc;
  231. pChSrc=GBKToGB2312(pChSrc);
  232. }
  233. pwChDes=MByteToWChar(CodePage,pChSrc);
  234. if(pwChDes)
  235. {
  236. if(UNICODEBIGENDIAN==tcTo)
  237. UnicodeEndianConvert(pwChDes);
  238. strlength=wcslen(pwChDes)*2;//這裡注意寫入文件的長度
  239. filesave.Write(pwChDes,strlength);
  240. filesave.Flush();
  241. filelength-=readlen;
  242. }
  243. else
  244. break;
  245. }
  246. delete[]pChSrc;
  247. delete[]pChTemp;
  248. delete[]pwChDes;
  249. returnTRUE;
  250. }
  251. //
  252. wchar_t*Coder::MByteToWChar(UINTCodePage,LPCSTRlpcszSrcStr)
  253. {
  254. LPWSTRlpcwsStrDes=NULL;
  255. intlen=MultiByteToWideChar(CodePage,0,lpcszSrcStr,-1,NULL,0);
  256. lpcwsStrDes=newwchar_t[len+1];
  257. if(!lpcwsStrDes)
  258. returnNULL;
  259. memset(lpcwsStrDes,0,sizeof(wchar_t)*(len+1));
  260. len=MultiByteToWideChar(CodePage,0,lpcszSrcStr,-1,lpcwsStrDes,len);
  261. if(len)
  262. returnlpcwsStrDes;
  263. else
  264. {
  265. delete[]lpcwsStrDes;
  266. returnNULL;
  267. }
  268. }
  270. char*Coder::WCharToMByte(UINTCodePage,LPCWSTRlpcwszSrcStr)
  271. {
  272. char*lpszDesStr=NULL;
  273. intlen=WideCharToMultiByte(CodePage,0,lpcwszSrcStr,-1,NULL,0,NULL,NULL);
  274. lpszDesStr=newchar[len+1];
  275. memset(lpszDesStr,0,sizeof(char)*(len+1));
  276. if(!lpszDesStr)
  277. returnNULL;
  278. len=WideCharToMultiByte(CodePage,0,lpcwszSrcStr,-1,lpszDesStr,len,NULL,NULL);
  279. if(len)
  280. returnlpszDesStr;
  281. else
  282. {
  283. delete[]lpszDesStr;
  284. returnNULL;
  285. }
  286. }
  287. //Unicode和Unicodebigendian之間位元組序的轉換
  288. voidCoder::UnicodeEndianConvert(LPWSTRlpwszstr)
  289. {
  290. wchar_twchtemp[2];
  291. longindex;
  292. intlen=wcslen(lpwszstr);
  293. if(!len)
  294. return;
  295. //交換高低位元組直到遇到結束符
  296. index=0;
  297. while(index<len)
  298. {
  299. wchtemp[0]=lpwszstr[index];
  300. wchtemp[1]=lpwszstr[index+1];
  302. unsignedcharhigh,low;
  303. high=(wchtemp[0]&0xFF00)>>8;
  304. low=wchtemp[0]&0x00FF;
  305. wchtemp[0]=(low<<8)|high;
  306. high=(wchtemp[1]&0xFF00)>>8;
  307. low=wchtemp[1]&0x00FF;
  308. wchtemp[1]=(low<<8)|high;
  310. lpwszstr[index]=wchtemp[0];
  311. lpwszstr[index+1]=wchtemp[1];
  312. index+=2;
  313. }
  314. }
  315. //Unicode和Unicodebigendian文件向多位元組文件轉換
  316. BOOLCoder::UnicodeFileToMBFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo)
  317. {
  318. TextCodecurtc;
  319. CFilefilesource,filesave;;
  320. char*pChDes=NULL;
  321. char*pChTemp=NULL;
  322. wchar_t*pwChSrc=NULL;
  323. DWORDfilelength,readlen,len;
  324. intbufferlen,strlength;
  325. UINTCodePage;
  326. curtc=GetCodeType(filesourcepath);
  327. //文件轉換類型錯誤則轉換失敗
  328. if(curtc<=UTF8||tcTo>UTF8||curtc==tcTo)
  329. returnFALSE;
  330. //源文件打開失敗或者源文件無內容後者保存文件建立失敗均轉換失敗
  331. if(!filesource.Open(filesourcepath,CFile::modeRead)||0==(filelength=filesource.GetLength()))
  332. returnFALSE;
  333. if(!filesave.Open(filesavepath,CFile::modeCreate|CFile::modeWrite))
  334. returnFALSE;
  335. //預分配內存分配失敗則轉換失敗
  336. if(filelength<PREDEFINEDSIZE)
  337. bufferlen=filelength;
  338. else
  339. bufferlen=PREDEFINEDSIZE;
  340. pwChSrc=newwchar_t[(bufferlen/2)+1];
  341. if(!pwChSrc)
  342. returnFALSE;
  343. //預先決定代碼頁
  344. switch(tcTo)
  345. {
  346. caseGB2312:
  347. CodePage=CP_GB2312;
  348. break;
  349. caseGBK:
  350. CodePage=CP_GB2312;//特殊處理
  351. break;
  352. caseBIG5:
  353. CodePage=CP_GB2312;//特殊處理
  354. break;
  355. caseUTF8:
  356. CodePage=CP_UTF8;
  357. break;
  358. default:
  359. break;
  360. }
  361. filesource.Seek(sizeof(wchar_t),CFile::begin);
  362. while(filelength>0)
  363. {
  364. memset(pwChSrc,0,sizeof(wchar_t)*((bufferlen/2)+1));
  365. if(filelength>PREDEFINEDSIZE)
  366. len=PREDEFINEDSIZE;
  367. else
  368. len=filelength;
  369. readlen=filesource.Read(pwChSrc,len);
  370. if(!readlen)
  371. break;
  372. if(UNICODEBIGENDIAN==curtc)
  373. UnicodeEndianConvert(pwChSrc);
  374. pChDes=WCharToMByte(CodePage,pwChSrc);
  375. //GBK無法直接轉換BIG5直接轉換會產生錯誤二者均先轉到GB2312然後再轉到目的類型
  376. if(GBK==tcTo)
  377. {
  378. pChTemp=pChDes;
  379. pChDes=GB2312ToGBK(pChDes);
  380. }
  381. if(BIG5==tcTo)
  382. {
  383. pChTemp=pChDes;
  384. pChDes=GB2312ToBIG5(pChDes);
  385. }
  386. if(pChDes)
  387. {
  388. strlength=strlen(pChDes);
  389. filesave.Write(pChDes,strlength);
  390. filesave.Flush();
  391. filelength-=readlen;
  392. }
  393. else
  394. break;
  395. }
  396. delete[]pChDes;
  397. delete[]pChTemp;
  398. delete[]pwChSrc;
  399. returnTRUE;
  400. }
  401. //多位元組文件轉為多位元組文件
  402. //多位元組轉為多位元組時，一般先轉為UNICODE類型，再轉換到指定目的類型，實行兩次轉換
  403. BOOLCoder::MBFileToMBFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur)
  404. {
  405. BOOLbret=FALSE;
  406. TextCodecurtc;
  407. CFilefilesource,filesave;
  408. char*pChDes=NULL;
  409. char*pChSrc=NULL;
  410. DWORDfilelength,readlen,len;
  411. intbufferlen,strlength;
  412. UINTCodePageCur,CodePageTo;
  413. //由於存在誤差允許用戶自定義轉換
  414. if(DefaultCodeType!=tcCur)
  415. curtc=tcCur;
  416. else
  417. curtc=GetCodeType(filesourcepath);
  418. //轉換類型錯誤則返迴轉換失敗
  419. if(curtc>UTF8||tcTo>UTF8||curtc==tcTo)
  420. returnFALSE;
  421. //源文件打開失敗或者源文件無內容後者保存文件建立失敗均返迴轉換失敗
  422. if(!filesource.Open(filesourcepath,CFile::modeRead)||0==(filelength=filesource.GetLength()))
  423. returnFALSE;
  424. if(!filesave.Open(filesavepath,CFile::modeCreate|CFile::modeWrite))
  425. returnFALSE;
  426. //預分配內存分配失敗則轉換失敗
  427. if(filelength<PREDEFINEDSIZE)
  428. bufferlen=filelength;
  429. else
  430. bufferlen=PREDEFINEDSIZE;
  431. pChSrc=newchar[bufferlen+1];
  432. if(!pChSrc)
  433. returnFALSE;
  434. if(UTF8==curtc)
  435. filesource.Seek(3*sizeof(byte),CFile::begin);
  436. CodePageCur=GetCodePage(curtc);
  437. CodePageTo=GetCodePage(tcTo);
  438. while(filelength>0)
  439. {
  440. memset(pChSrc,0,sizeof(char)*(bufferlen+1));
  441. if(filelength>PREDEFINEDSIZE)
  442. len=PREDEFINEDSIZE;
  443. else
  444. len=filelength;
  445. readlen=filesource.Read(pChSrc,len);
  446. if(!readlen)
  447. break;
  448. pChDes=MByteToMByte(CodePageCur,CodePageTo,pChSrc);
  449. if(pChDes)
  450. {
  451. strlength=strlen(pChDes);
  452. filesave.Write(pChDes,strlength);
  453. filelength-=readlen;
  454. }
  455. else
  456. break;
  457. }
  458. delete[]pChSrc;
  459. delete[]pChDes;
  460. returnTRUE;
  461. }
  462. //Unicode和Unicodebigendian文件之間轉換
  463. BOOLCoder::UnicodeEndianFileConvert(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo)
  464. {
  465. TextCodecurtc=GetCodeType(filesourcepath);
  466. if(curtc!=UNICODE&&curtc!=UNICODEBIGENDIAN)
  467. returnFALSE;
  468. if(curtc==tcTo)
  469. returnFALSE;
  470. CFilefilesource,filesave;;
  471. wchar_t*pwChDes;
  472. DWORDlength;
  473. if(!filesource.Open(filesourcepath,CFile::modeRead)||!filesave.Open(filesavepath,CFile::modeCreate|CFile::modeWrite))
  474. returnFALSE;
  475. length=filesource.GetLength();
  476. if(!length)
  477. returnFALSE;
  478. pwChDes=newwchar_t[(length/2)+1];
  479. if(!pwChDes)
  480. returnFALSE;
  481. memset(pwChDes,0,sizeof(wchar_t)*((length/2)+1));
  482. filesource.Read(pwChDes,length);
  483. UnicodeEndianConvert(pwChDes);
  484. length=wcslen(pwChDes)*2;
  485. if(UNICODE==tcTo)
  486. filesave.Write(&UNICODEBOM,2*sizeof(byte));
  487. else
  488. filesave.Write(&UNICODEBEBOM,2*sizeof(byte));
  489. filesave.Write(pwChDes,length);
  490. filesave.Flush();
  491. delete[]pwChDes;
  492. returnTRUE;
  493. }
  494. //文件轉到另一種文件
  495. //6種格式文件兩兩轉換共計30種轉換
  496. BOOLCoder::FileToOtherFile(CStringfilesourcepath,CStringfilesavepath,TextCodetcTo,TextCodetcCur)
  497. {
  498. TextCodecurtc;
  499. BOOLbret=FALSE;
  500. if(DefaultCodeType!=tcCur)
  501. curtc=tcCur;
  502. else
  503. curtc=GetCodeType(filesourcepath);
  504. if(curtc==tcTo)
  505. returnFALSE;
  506. //UNICODE和UNICODEbigendian文件之間轉換共2種
  507. if(curtc>=UNICODE&&tcTo>=UNICODE)
  508. bret=UnicodeEndianFileConvert(filesourcepath,filesavepath,tcTo);
  509. else
  510. //多位元組文件向UNICODE和UNICODEbigendian文件之間轉換共8種
  511. if(curtc<UNICODE&&tcTo>=UNICODE)
  512. bret=MBFileToUnicodeFile(filesourcepath,filesavepath,tcTo,curtc);
  513. else
  514. //UNICODE和UNICODEbigendian文件向多位元組文件轉換共8種
  515. if(curtc>=UNICODE&&tcTo<UNICODE)
  516. bret=UnicodeFileToMBFile(filesourcepath,filesavepath,tcTo);
  517. else
  518. //多位元組文件之間轉換共12種
  519. if(curtc<UNICODE&&tcTo<UNICODE)
  520. bret=MBFileToMBFile(filesourcepath,filesavepath,tcTo,curtc);
  521. returnbret;
  522. }
  523. //編碼類型轉換為字元串
  524. CStringCoder::CodeTypeToString(TextCodetc)
  525. {
  526. CStringstrtype;
  527. switch(tc)
  528. {
  529. caseGB2312:
  530. strtype=_T("GB2312");
  531. break;
  532. caseBIG5:
  533. strtype=_T("Big5");
  534. break;
  535. caseGBK:
  536. strtype=_T("GBK");
  537. break;
  538. caseUTF8:
  539. strtype=_T("UTF-8");
  540. break;
  541. caseUNICODE:
  542. strtype=_T("Unicode");
  543. break;
  544. caseUNICODEBIGENDIAN:
  545. strtype=_T("Unicodebigendian");
  546. break;
  547. }
  548. returnstrtype;
  549. }
  550. //多位元組向多位元組轉換
  551. char*Coder::MByteToMByte(UINTCodePageCur,UINTCodePageTo,constchar*szSrcStr)
  552. {
  553. char*pchDes=NULL;
  554. char*pchTemp=NULL;
  555. wchar_t*pwchtemp=NULL;
  556. //三種中文編碼之間轉換
  557. if(CodePageCur!=CP_UTF8&&CodePageTo!=CP_UTF8)
  558. {
  559. switch(CodePageCur)
  560. {
  561. caseCP_GB2312:
  562. {
  563. if(CP_BIG5==CodePageTo)
  564. pchDes=GB2312ToBIG5(szSrcStr);
  565. else
  566. pchDes=GB2312ToGBK(szSrcStr);
  567. break;
  568. }
  569. caseCP_BIG5:
  570. {
  571. if(CP_GB2312==CodePageTo)
  572. pchDes=BIG5ToGB2312(szSrcStr);
  573. else
  574. pchDes=BIG5ToGBK(szSrcStr);
  575. break;
  576. }
  577. caseCP_GBK:
  578. {
  579. if(CP_GB2312==CodePageTo)
  580. pchDes=GBKToGB2312(szSrcStr);
  581. else
  582. pchDes=GBKToBIG5(szSrcStr);
  583. break;
  584. }
  585. }
  586. }
  587. else
  588. {//從UTF-8轉到其他多位元組直接轉到GB2312其他形式用GB2312做中間形式
  589. if(CP_UTF8==CodePageCur)
  590. {
  591. pwchtemp=MByteToWChar(CodePageCur,szSrcStr);
  592. if(CP_GB2312==CodePageTo)
  593. {
  594. pchDes=WCharToMByte(CP_GB2312,pwchtemp);
  595. }
  596. else
  597. {
  598. pchTemp=WCharToMByte(CP_GB2312,pwchtemp);
  599. if(CP_GBK==CodePageTo)
  600. pchDes=GB2312ToGBK(pchTemp);
  601. else
  602. pchDes=GB2312ToBIG5(pchTemp);
  603. }
  604. }
  605. //從其他多位元組轉到UTF-8
  606. else
  607. {
  608. if(CP_GBK==CodePageCur)
  609. {
  611. pchTemp=GBKToGB2312(szSrcStr);
  612. pwchtemp=MByteToWChar(CP_GB2312,pchTemp);
  613. }
  614. else
  615. pwchtemp=MByteToWChar(CodePageCur,szSrcStr);
  616. pchDes=WCharToMByte(CodePageTo,pwchtemp);
  617. }
  618. }
  619. delete[]pchTemp;
  620. delete[]pwchtemp;
  621. returnpchDes;
  622. }
  623. //獲取編碼類型對應的代碼頁
  624. UINTCoder::GetCodePage(TextCodetccur)
  625. {
  626. UINTCodePage;
  627. switch(tccur)
  628. {
  629. caseGB2312:
  630. CodePage=CP_GB2312;
  631. break;
  632. caseBIG5:
  633. CodePage=CP_BIG5;
  634. break;
  635. caseGBK:
  636. CodePage=CP_GBK;
  637. break;
  638. caseUTF8:
  639. CodePage=CP_UTF8;
  640. break;
  641. caseUNICODEBIGENDIAN:
  642. caseUNICODE:
  643. break;
  644. }
  645. returnCodePage;
  646. }
  647. //指定轉換時默認一次轉換位元組大小
  648. voidCoder::SetDefaultConvertSize(UINTnCount)
  649. {
  650. if(nCount!=0)
  651. PREDEFINEDSIZE=nCount;
  652. }

3.運行效果 在win7 VC 6.0下測試六種編碼的轉換測試通過，30個方向的轉換如下圖所示:

測試程序運行效果如下圖所示:

GB2312轉換到GBK編碼效果如下圖所示:

UTF-8轉換到Big5編碼的效果如下圖所示:

本文代碼及轉碼程序下載 ：http://download.csdn.net/user/ziyuanxiazai123

4.尚未解決的問題

(1)LCMapString函數的理解還不完全熟悉，其中參數偏多，理解需要一定基礎知識。

(2)為什麼記事本程序的轉碼後存在些亂碼,亂碼是正確的嗎?因為我的程序使用了中間過渡形式，因此沒有任何亂碼。

(3)是否有更簡單和清晰的方式實現編碼轉換，待進一步研究。


推薦閱讀：

※簡繁轉換易錯字43例（下）
※如何將星座的赤經和赤緯轉換為地球上的經度緯度.（最好寫的詳細點.）
※時間轉換7
※虛實轉換全在腰
※梅竹再講;我編輯的[...顏色值..轉換器] 的應用和圖片編輯方法

TAG:編碼 | 中文 | 轉換 |