Unicode码和UTF-8编码的C语言转换代码

1. 1) 将一个字符的Unicode(UCS-2和UCS-4)编码转换成UTF-8编码.  
2.   
3. // #c---  
4. /***************************************************************************** 
5.  * 将一个字符的Unicode(UCS-2和UCS-4)编码转换成UTF-8编码. 
6.  * 
7.  * 參数: 
8.  *    unic     字符的Unicode编码值 
9.  *    pOutput  指向输出的用于存储UTF8编码值的缓冲区的指针 
10.  *    outsize  pOutput缓冲的大小 
11.  * 
12.  * 返回值: 
13.  *    返回转换后的字符的UTF8编码所占的字节数, 假设出错则返回 0 . 
14.  * 
15.  * 注意: 
16.  *     1. UTF8没有字节序问题, 可是Unicode有字节序要求; 
17.  *        字节序分为大端(Big Endian)和小端(Little Endian)两种; 
18.  *        在Intel处理器中採用小端法表示, 在此採用小端法表示. (低地址存低位) 
19.  *     2. 请保证 pOutput 缓冲区有最少有 6 字节的空间大小! 
20.  ****************************************************************************/  
21. int enc_unicode_to_utf8_one(unsigned long unic, unsigned char *pOutput,  
22.         int outSize)  
23. {  
24.     assert(pOutput != NULL);  
25.     assert(outSize >= 6);  
26.   
27.     if ( unic <= 0x0000007F )  
28.     {  
29.         // * U-00000000 - U-0000007F:  0xxxxxxx  
30.         *pOutput     = (unic & 0x7F);  
31.         return 1;  
32.     }  
33.     else if ( unic >= 0x00000080 && unic <= 0x000007FF )  
34.     {  
35.         // * U-00000080 - U-000007FF:  110xxxxx 10xxxxxx  
36.         *(pOutput+1) = (unic & 0x3F) | 0x80;  
37.         *pOutput     = ((unic >> 6) & 0x1F) | 0xC0;  
38.         return 2;  
39.     }  
40.     else if ( unic >= 0x00000800 && unic <= 0x0000FFFF )  
41.     {  
42.         // * U-00000800 - U-0000FFFF:  1110xxxx 10xxxxxx 10xxxxxx  
43.         *(pOutput+2) = (unic & 0x3F) | 0x80;  
44.         *(pOutput+1) = ((unic >>  6) & 0x3F) | 0x80;  
45.         *pOutput     = ((unic >> 12) & 0x0F) | 0xE0;  
46.         return 3;  
47.     }  
48.     else if ( unic >= 0x00010000 && unic <= 0x001FFFFF )  
49.     {  
50.         // * U-00010000 - U-001FFFFF:  11110xxx 10xxxxxx 10xxxxxx 10xxxxxx  
51.         *(pOutput+3) = (unic & 0x3F) | 0x80;  
52.         *(pOutput+2) = ((unic >>  6) & 0x3F) | 0x80;  
53.         *(pOutput+1) = ((unic >> 12) & 0x3F) | 0x80;  
54.         *pOutput     = ((unic >> 18) & 0x07) | 0xF0;  
55.         return 4;  
56.     }  
57.     else if ( unic >= 0x00200000 && unic <= 0x03FFFFFF )  
58.     {  
59.         // * U-00200000 - U-03FFFFFF:  111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx  
60.         *(pOutput+4) = (unic & 0x3F) | 0x80;  
61.         *(pOutput+3) = ((unic >>  6) & 0x3F) | 0x80;  
62.         *(pOutput+2) = ((unic >> 12) & 0x3F) | 0x80;  
63.         *(pOutput+1) = ((unic >> 18) & 0x3F) | 0x80;  
64.         *pOutput     = ((unic >> 24) & 0x03) | 0xF8;  
65.         return 5;  
66.     }  
67.     else if ( unic >= 0x04000000 && unic <= 0x7FFFFFFF )  
68.     {  
69.         // * U-04000000 - U-7FFFFFFF:  1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx  
70.         *(pOutput+5) = (unic & 0x3F) | 0x80;  
71.         *(pOutput+4) = ((unic >>  6) & 0x3F) | 0x80;  
72.         *(pOutput+3) = ((unic >> 12) & 0x3F) | 0x80;  
73.         *(pOutput+2) = ((unic >> 18) & 0x3F) | 0x80;  
74.         *(pOutput+1) = ((unic >> 24) & 0x3F) | 0x80;  
75.         *pOutput     = ((unic >> 30) & 0x01) | 0xFC;  
76.         return 6;  
77.     }  
78.   
79.     return 0;  
80. }  

1. // #c---end  

[cpp]  view plain copy

1. 2) 将一个字符的UTF8编码转换成Unicode(UCS-2和UCS-4)编码.
   
2. 
   
3. /***************************************************************************** 
4.  * 将一个字符的UTF8编码转换成Unicode(UCS-2和UCS-4)编码. 
5.  * 
6.  * 參数: 
7.  *    pInput      指向输入缓冲区, 以UTF-8编码 
8.  *    Unic        指向输出缓冲区, 其保存的数据即是Unicode编码值, 
9.  *                类型为unsigned long . 
10.  * 
11.  * 返回值: 
12.  *    成功则返回该字符的UTF8编码所占用的字节数; 失败则返回0. 
13.  * 
14.  * 注意: 
15.  *     1. UTF8没有字节序问题, 可是Unicode有字节序要求; 
16.  *        字节序分为大端(Big Endian)和小端(Little Endian)两种; 
17.  *        在Intel处理器中採用小端法表示, 在此採用小端法表示. (低地址存低位) 
18.  ****************************************************************************/  
19. int enc_utf8_to_unicode_one(const unsigned char* pInput, unsigned long *Unic)  
20. {  
21.     assert(pInput != NULL && Unic != NULL);  
22.   
23.     // b1 表示UTF-8编码的pInput中的高字节, b2 表示次高字节, ...  
24.     char b1, b2, b3, b4, b5, b6;  
25.   
26.     *Unic = 0x0; // 把 *Unic 初始化为全零  
27.     int utfbytes = enc_get_utf8_size(*pInput);  
28.     unsigned char *pOutput = (unsigned char *) Unic;  
29.   
30.     switch ( utfbytes )  
31.     {  
32.         case 1:  
33.             *pOutput     = *pInput;  
34.             utfbytes    += 1;  
35.             break;  
36.         case 2:  
37.             b1 = *pInput;  
38.             b2 = *(pInput + 1);  
39.             if ( (b2 & 0xE0) != 0x80 )  
40.                 return 0;  
41.             *pOutput     = (b1 << 6) + (b2 & 0x3F);  
42.             *(pOutput+1) = (b1 >> 2) & 0x07;  
43.             break;  
44.         case 3:  
45.             b1 = *pInput;  
46.             b2 = *(pInput + 1);  
47.             b3 = *(pInput + 2);  
48.             if ( ((b2 & 0xC0) != 0x80) || ((b3 & 0xC0) != 0x80) )  
49.                 return 0;  
50.             *pOutput     = (b2 << 6) + (b3 & 0x3F);  
51.             *(pOutput+1) = (b1 << 4) + ((b2 >> 2) & 0x0F);  
52.             break;  
53.         case 4:  
54.             b1 = *pInput;  
55.             b2 = *(pInput + 1);  
56.             b3 = *(pInput + 2);  
57.             b4 = *(pInput + 3);  
58.             if ( ((b2 & 0xC0) != 0x80) || ((b3 & 0xC0) != 0x80)  
59.                     || ((b4 & 0xC0) != 0x80) )  
60.                 return 0;  
61.             *pOutput     = (b3 << 6) + (b4 & 0x3F);   //UTF-8转Unicode存在逆序存放问题
62.             *(pOutput+1) = (b2 << 4) + ((b3 >> 2) & 0x0F);  
63.             *(pOutput+2) = ((b1 << 2) & 0x1C)  + ((b2 >> 4) & 0x03);  
64.             break;  
65.         case 5:  
66.             b1 = *pInput;  
67.             b2 = *(pInput + 1);  
68.             b3 = *(pInput + 2);  
69.             b4 = *(pInput + 3);  
70.             b5 = *(pInput + 4);  
71.             if ( ((b2 & 0xC0) != 0x80) || ((b3 & 0xC0) != 0x80)  
72.                     || ((b4 & 0xC0) != 0x80) || ((b5 & 0xC0) != 0x80) )  
73.                 return 0;  
74.             *pOutput     = (b4 << 6) + (b5 & 0x3F);  
75.             *(pOutput+1) = (b3 << 4) + ((b4 >> 2) & 0x0F);  
76.             *(pOutput+2) = (b2 << 2) + ((b3 >> 4) & 0x03);  
77.             *(pOutput+3) = (b1 << 6);  
78.             break;  
79.         case 6:  
80.             b1 = *pInput;  
81.             b2 = *(pInput + 1);  
82.             b3 = *(pInput + 2);  
83.             b4 = *(pInput + 3);  
84.             b5 = *(pInput + 4);  
85.             b6 = *(pInput + 5);  
86.             if ( ((b2 & 0xC0) != 0x80) || ((b3 & 0xC0) != 0x80)  
87.                     || ((b4 & 0xC0) != 0x80) || ((b5 & 0xC0) != 0x80)  
88.                     || ((b6 & 0xC0) != 0x80) )  
89.                 return 0;  
90.             *pOutput     = (b5 << 6) + (b6 & 0x3F);  
91.             *(pOutput+1) = (b5 << 4) + ((b6 >> 2) & 0x0F);  
92.             *(pOutput+2) = (b3 << 2) + ((b4 >> 4) & 0x03);  
93.             *(pOutput+3) = ((b1 << 6) & 0x40) + (b2 & 0x3F);  
94.             break;  
95.         default:  
96.             return 0;  
97.             break;  
98.     }  
99.   
100.     return utfbytes;  
101. }  
102. // #c---end