linux c 怎么样进行字符编码转换

aishen944

在linux中怎样进行字符编码转换

比如我想把gb2312的字节流转换成utf-8的字节流应该怎么样进行

还有就是编码状态到底是个什么东东 state

希望哪位大哥能小弟指点一下!!!

haohao_h

算你运气好！
应该说gb2312跟utf－8的概念应该不是一个层次上的。gb2312跟unicode都是字符的编码方式，而utf8只是unicode的一种表示方式而已。他们的区别主要在iso8859－1定义的字符集之外（用多字节来表示一个字符）。在linux下有一个iconv库可以完成这些编码之间的转换！
下面的代码是gb2312字节流跟跟utf16字节流之间的转换函数。gb2312跟utf8的转换应该差不多！
两个extern函数为转换入口函数，其它都为内部函数。

1. /*@author:huangh
   
2. *@create time:2005/12/16
   
3. */
   
4. #include <stdio.h>
   
5. #include <iconv.h>
   
6. #include <errno.h>
   
7. #include <stdlib.h>
   
8. #include <string.h>
   
9. 
   
10. #define ALIVE() printf("still alive here [%s]:[%d]\n",__FUNCTION__, __LINE__)
    
11. /*get the low 8 bits of an unsigned short*/
    
12. #define LOWER_SHORT(num) (0x0ff&num)
    
13. /*get the high 8 bits of an unsigned short*/
    
14. #define HIGH_SHORT(num) ((0xff00&num)>>8)
    
15. 
    
16. //#define _BIG_ENDIAN
    
17. //#define DEBUG
    
18. 
    
19. 
    
20. typedef unsigned int char_16;
    
21. 
    
22. static int char16len(char_16 *in_char)
    
23. {
    
24.     int ret = 0;
    
25.     while(in_char[ret])
    
26.     {
    
27.         ret++;
    
28.     }
    
29.     return ret;
    
30. }
    
31. static int gb2312_to_utf16(char *inchar, size_t *in_size, char *outchar, size_t *out_size)
    
32. {
    
33.     iconv_t cd;
    
34.     char **ppinchar = &inchar;
    
35.     char **ppoutchar = &outchar;
    
36.    
    
37.     if ( ( iconv_t )-1 == ( cd = iconv_open( "UCS-2", "GB2312" ) ) )
    
38.     {
    
39.         perror( "iconv_open() error" );
    
40.         return -1;
    
41.     }
    
42.    
    
43.     if ( -1 == iconv( cd, ppinchar, in_size, ppoutchar, out_size ) )
    
44.     {
    
45.         perror( "iconv() error" );
    
46.         goto error;
    
47.     }
    
48. 
    
49.     {
    
50.         int i = 0;
    
51.         char *p = outchar;
    
52.         while(p[i])
    
53.         {
    
54.             printf("%2x:", p[i]);
    
55.             i++;
    
56.         }
    
57.     }
    
58.     iconv_close(cd);
    
59.     return 0;
    
60. error:
    
61.     iconv_close(cd);
    
62.     return -1;
    
63. }
    
64. 
    
65. static int char_to_char16(char *in, size_t in_size, char_16 out[], size_t out_size)
    
66. {
    
67.     int i = 0;
    
68.     unsigned short high, low;
    
69.    
    
70.     printf("insize is [%d], out size is [%d]\n", in_size, out_size);   
    
71.     if(in_size > 2*out_size)
    
72.     {
    
73.         return -1;
    
74.     }
    
75.     ALIVE();
    
76.     for(; i<out_size; i++)
    
77.     {
    
78. #ifdef _BIG_ENDIAN
    
79.         high = in[2*i+1]&0xff;
    
80.         low  = in[2*i]&0xff;
    
81. #else
    
82.         high = in[2*i]&0xff;
    
83.         low  = in[2*i+1]&0xff;
    
84. #endif
    
85.         out[i] = (high<<8)|low;
    
86.     }
    
87.     return 0;
    
88. }
    
89. 
    
90. static int char16_to_char(char_16 in[], size_t size_in, char *out, size_t size_out)
    
91. {
    
92.     int i = 0;
    
93.     if(size_out < 2*size_in)
    
94.     {
    
95.         return -1;
    
96.     }
    
97.     for(; i< size_in; i++)
    
98.     {
    
99. #ifdef _BIG_ENDIAN
    
100.         out[i*2] = LOWER_SHORT(in[i]);
     
101.         out[i*2 + 1] = HIGH_SHORT(in[i]);
     
102. #else
     
103.         out[i*2] = HIGH_SHORT(in[i]);
     
104.         out[i*2 + 1] = LOWER_SHORT(in[i]);
     
105. #endif
     
106.     }
     
107.     return 0;
     
108. }
     
109. static int utf16_to_gb2312(char *inchar, size_t *in_size, char *outchar, size_t *out_size)
     
110. {
     
111.     iconv_t cd;
     
112.     char **ppinchar = &inchar;
     
113.     char **ppoutchar = &outchar;
     
114.    
     
115.     if ( ( iconv_t )-1 == ( cd = iconv_open( "GB2312", "UCS-2") ) )
     
116.     {
     
117.         perror( "iconv_open() error" );
     
118.         return -1;
     
119.     }
     
120.    
     
121.     if ( -1 == iconv( cd, ppinchar, in_size, ppoutchar, out_size ) )
     
122.     {
     
123.         perror( "iconv() error" );
     
124.         goto error;
     
125.     }
     
126. 
     
127.     iconv_close(cd);
     
128.     return 0;
     
129. error:
     
130.     iconv_close(cd);
     
131.     return -1;
     
132. }
     
133. 
     
134. extern int char_to_utf16(char *in_char, char_16 *out_wchar, size_t out_size)
     
135. {
     
136.     size_t in_len = strlen(in_char) + 1;
     
137.     size_t tmp_len = 2*in_len;
     
138.     size_t tmp_len_org;
     
139.     char *tmp;
     
140.    
     
141. 
     
142.     printf("inlen is [%d], out size is [%d]\n", in_len, out_size);   
     
143.     if(in_len > 2*out_size)
     
144.     {
     
145.         return -1;
     
146.     }
     
147. 
     
148.     if(NULL == (tmp = (char *)malloc(tmp_len)))
     
149.     {
     
150.         return -1;
     
151.     }
     
152.     tmp_len_org = tmp_len;
     
153. 
     
154.    
     
155.     if( 0 != gb2312_to_utf16(in_char, &in_len, tmp, &tmp_len))
     
156.     {
     
157.         goto error;
     
158.     }
     
159.     {
     
160.         printf("tmp length is [%d]:[%d]\n", tmp_len, in_len);
     
161.     }
     
162.     if(0 != char_to_char16(tmp, tmp_len_org - tmp_len, out_wchar, out_size))
     
163.     {
     
164.         goto error;
     
165.     }
     
166.    
     
167.     ALIVE();
     
168.     free(tmp);
     
169.     return 0;
     
170. error:
     
171.     free(tmp);
     
172.     return -1;
     
173. }
     
174. 
     
175. extern int utf16_to_char(char_16 *in_char, char *out_char, size_t out_size)
     
176. {
     
177.     size_t in_size = char16len(in_char) + 1;
     
178.     char *tmp;
     
179.     size_t in_len ;
     
180.     size_t out_len;
     
181. 
     
182. #ifdef DEBUG
     
183.     int j;
     
184.     for(j=0;j<in_size;j++)
     
185.     {
     
186.         fprintf(stderr, "[%4x]:",in_char[j]);
     
187.     }
     
188.     fprintf(stderr, "\n");
     
189. #endif
     
190. 
     
191.     if(NULL == (tmp = (char *)malloc(2*in_size)))
     
192.     {
     
193.         return -1;
     
194.     }
     
195.    
     
196.     memset(tmp, 0, 2*in_size);
     
197. 
     
198.     if(0 != char16_to_char(in_char, in_size, tmp, 2*in_size))
     
199.     {
     
200.         goto error;
     
201.     }
     
202. #ifdef DEBUG
     
203.     for(j=0; j<2*in_size; j++)
     
204.     {
     
205.         fprintf(stderr, "[%2x]:",tmp[j]);
     
206.     }
     
207.     fprintf(stderr, "\n");
     
208. #endif
     
209.     in_len = in_size*2;
     
210.     out_len = out_size;
     
211.     if( 0 != (utf16_to_gb2312(tmp, &in_len, out_char, &out_len)))
     
212.     {
     
213.         goto error;
     
214.     }
     
215.    
     
216.    
     
217.     free(tmp);
     
218.     return 0;
     
219. error:
     
220.     free(tmp);
     
221.     return -1;
     
222. }
     

复制代码

另外还有一些资料我明天贴上来！
补充一些文档！
1、什么是UTF－8？它与UNICODE是什么关系？
解答:
Unicode的最初目标，是用1个16位的编码来为超过65000个字符提供映射。但这还不够，它不能覆盖全部历史上的文字，也不能解决传输的问题 (implantation head-ache's)，尤其在那些基于网络的应用中。已有的软件必须做大量的工作来实现16位的数据。
因此，Unicode用一些基本的保留字符制定了三套编码方式。它们分别是UTF-8,UTF-16和UTF-32。正如名字所示，在UTF－8中，字符是以8位序列来编码的，用一个或几个字节来表示一个字符。这种方式的最大好处，是UTF－8保留了ASCII字符的编码做为它的一部分，例如，在UTF－ 8和ASCII中，“A”的编码都是0x41. UTF－16和UTF－32分别是Unicode的16位和32位编码方式。考虑到最初的目的，通常说的Unicode就是指UTF-16。
2、unicode的参考网站
http://www.unicode.org/unicode/standard/principles.html.
3、unicode三种编码之间的转换
http://www.unicode.org/Public/PROGRAMS/CVTUTF/
4、也可以通过查表的方式转换gb2312码和unicode码。表文件见附件gb2312.txt，文件中有使用说明。

aishen944

多谢！！ 在多发点！！  还能不讲讲编码的字节的表示方式！！

MatthewGong

2.    char buff[1024];
3.    size_t buff_len = 1024;
4.    size_t s_len = len;
5.    iconv_t cd = iconv_open("utf-8", "gbk");
6.    if (cd != iconv_t(-1))
7.    {
8.      char* ptr = &buff[0];
9.      size_t remain = buff_len;
10.      size_t d_len = iconv(cd, &s, &s_len, &ptr, &remain);
12.      //for (size_t i=0; i<buff_len-remain; ++i)
13.      //             cout << buff[i];
14.      //cout << '\n';
16.      iconv_close(cd);
17.    }

复制代码

关于编码的字节的表示，你可以用google搜索一下吗。