发一段UNICODE UTF-8互转代码简洁版

最新推荐文章于 2023-05-22 19:11:07 发布
最新推荐文章于 2023-05-22 19:11:07 发布
阅读量739 收藏
点赞数
分类专栏： 字符编码 文章标签： utf-8 unicode 编码 c


http://bbs.chinaunix.net/thread-1370274-1-1.html


有了这个你可以任意打印unicode表的所有字符, 最近因为要搞一个单字表, 弄了一天才弄出来, 最近代码效率太低了...
主要是对UTF-8编码不熟悉, 今天重新学习了一下, 发上来跟大家共享一下学习成果, 哈哈

gcc -o unicode unicode.c -D_DEBUG_UNICODE
unicode.h

  1. #ifndef _UNICODE_H
  2. #define _UNICODE_H
  3. /* convert unicode to UTF-8 */
  4. unsigned char *UnicodetoUTF8(int unicode, unsigned char *p);
  5. #define UNICODE_TO_UTF8(unicode, e)                                             \
  6. do                                                                              \
  7. {                                                                               \
  8.     if(e && unicode != 0)                                                       \
  9.     {                                                                           \
  10.         if(unicode < 0x80) *e++ = unicode;                                      \
  11.         else if(unicode < 0x800)                                                \
  12.         {                                                                       \
  13.             /*<11011111> < 000 0000 0000>*/                                     \
  14.             *e++ = ((unicode >> 6) & 0x1f)|0xc0;                                \
  15.             *e++ = (unicode & 0x3f)|0x80;                                       \
  16.         }                                                                       \
  17.         else if(unicode < 0x10000)                                              \
  18.         {                                                                       \
  19.             /*<11101111> <0000 0000 0000 0000>*/                                \
  20.             *e++ = ((unicode >> 12) & 0x0f)|0xe0;                               \
  21.             *e++ = ((unicode >> 6) & 0x3f)|0x80;                                \
  22.             *e++ = (unicode & 0x3f)|0x80;                                       \
  23.         }                                                                       \
  24.         else if(unicode < 0x200000)                                             \
  25.         {                                                                       \
  26.             /*<11110111> <0 0000 0000 0000 0000 0000>*/                         \
  27.             *e++ = ((unicode >> 18) & 0x07)|0xf0;                               \
  28.             *e++ = ((unicode >> 12) & 0x3f)|0x80;                               \
  29.             *e++ = ((unicode >> 6) & 0x3f)|0x80;                                \
  30.             *e++ = (unicode & 0x3f)|0x80;                                       \
  31.         }                                                                       \
  32.         else if(unicode < 0x4000000)                                            \
  33.         {                                                                       \
  34.             /*<11111011> <00 0000 0000 0000 0000 0000 0000>*/                   \
  35.             *e++ = ((unicode >> 24) & 0x03)|0xf8 ;                              \
  36.             *e++ = ((unicode >> 18) & 0x3f)|0x80;                               \
  37.             *e++ = ((unicode >> 12) & 0x3f)|0x80;                               \
  38.             *e++ = ((unicode >> 6) & 0x3f)|0x80;                                \
  39.             *e++ = (unicode & 0x3f)|0x80;                                       \
  40.         }                                                                       \
  41.         else                                                                    \
  42.         {                                                                       \
  43.             /*<11111101> <0000 0000 0000 0000 0000 0000 0000 0000>*/            \
  44.             *e++ = ((unicode >> 30) & 0x01)|0xfc;                               \
  45.             *e++ = ((unicode >> 24) & 0x3f)|0x80;                               \
  46.             *e++ = ((unicode >> 18) & 0x3f)|0x80;                               \
  47.             *e++ = ((unicode >> 12) & 0x3f)|0x80;                               \
  48.             *e++ = ((unicode >> 6) & 0x3f)|0x80;                                \
  49.             *e++ = (unicode & 0x3f)|0x80;                                       \
  50.         }                                                                       \
  51.     }                                                                           \
  52. }while(0)

  54. /* convert UTF-8 to unicode */
  55. int UTF8toUnicode(unsigned char *ch, int *unicode);
  56. #define UTF8_TO_UNICODE(p, e, n)                                                \
  57. do                                                                              \
  58. {                                                                               \
  59.     if(p)                                                                       \
  60.     {                                                                           \
  61.         if(*p >= 0xfc)                                                          \
  62.         {                                                                       \
  63.             /*6:<11111100>*/                                                    \
  64.             e = (p[0] & 0x01) << 30;                                            \
  65.             e |= (p[1] & 0x3f) << 24;                                           \
  66.             e |= (p[2] & 0x3f) << 18;                                           \
  67.             e |= (p[3] & 0x3f) << 12;                                           \
  68.             e |= (p[4] & 0x3f) << 6;                                            \
  69.             e |= (p[5] & 0x3f);                                                 \
  70.             n = 6;                                                              \
  71.         }                                                                       \
  72.         else if(*p >= 0xf8)                                                     \
  73.         {                                                                       \
  74.             /*5:<11111000>*/                                                    \
  75.             e = (p[0] & 0x03) << 24;                                            \
  76.             e |= (p[1] & 0x3f) << 18;                                           \
  77.             e |= (p[2] & 0x3f) << 12;                                           \
  78.             e |= (p[3] & 0x3f) << 6;                                            \
  79.             e |= (p[4] & 0x3f);                                                 \
  80.             n = 5;                                                              \
  81.         }                                                                       \
  82.         else if(*p >= 0xf0)                                                     \
  83.         {                                                                       \
  84.             /*4:<11110000>*/                                                    \
  85.             e = (p[0] & 0x07) << 18;                                            \
  86.             e |= (p[1] & 0x3f) << 12;                                           \
  87.             e |= (p[2] & 0x3f) << 6;                                            \
  88.             e |= (p[3] & 0x3f);                                                 \
  89.             n = 4;                                                              \
  90.         }                                                                       \
  91.         else if(*p >= 0xe0)                                                     \
  92.         {                                                                       \
  93.             /*3:<11100000>*/                                                    \
  94.             e = (p[0] & 0x0f) << 12;                                            \
  95.             e |= (p[1] & 0x3f) << 6;                                            \
  96.             e |= (p[2] & 0x3f);                                                 \
  97.             n = 3;                                                              \
  98.         }                                                                       \
  99.         else if(*p >= 0xc0)                                                     \
  100.         {                                                                       \
  101.             /*2:<11000000>*/                                                    \
  102.             e = (p[0] & 0x1f) << 6;                                             \
  103.             e |= (p[1] & 0x3f);                                                 \
  104.             n = 2;                                                              \
  105.         }                                                                       \
  106.         else                                                                    \
  107.         {                                                                       \
  108.             e = p[0];                                                           \
  109.             n = 1;                                                              \
  110.         }                                                                       \
  111.     }                                                                           \
  112. }while(0)
  113. #endif
复制代码


unicode.c

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <unistd.h>
  4. #include <string.h>
  5. #include "unicode.h"
  6. #define CHINA_SET_MAX 8
  7. int outbin(FILE *fp, char ch)
  8. {
  9.     int i = 7;
  10.     while(i >= 0)
  11.     {
  12.         fprintf(fp, "%d", ((ch >> i) & 1));
  13.         i--;
  14.     }
  15. }

  17. /* convert unicode to UTF-8 */
  18. unsigned char *UnicodetoUTF8(int unicode, unsigned char *p)
  19. {
  20.     unsigned char *e = NULL;

  22.     if((e = p))
  23.     {
  24.         if(unicode < 0x80) *e++ = unicode;
  25.         else if(unicode < 0x800)
  26.         {
  27.             /*<11011111> < 000 0000 0000>*/
  28.             *e++ = ((unicode >> 6) & 0x1f)|0xc0;
  29.             *e++ = (unicode & 0x3f)|0x80;
  30.         }
  31.         else if(unicode < 0x10000)
  32.         {
  33.             /*<11101111> <0000 0000 0000 0000>*/
  34.             *e++ = ((unicode >> 12) & 0x0f)|0xe0;
  35.             *e++ = ((unicode >> 6) & 0x3f)|0x80;
  36.             *e++ = (unicode & 0x3f)|0x80;
  37.         }
  38.         else if(unicode < 0x200000)
  39.         {
  40.             /*<11110111> <0 0000 0000 0000 0000 0000>*/
  41.             *e++ = ((unicode >> 18) & 0x07)|0xf0;
  42.             *e++ = ((unicode >> 12) & 0x3f)|0x80;
  43.             *e++ = ((unicode >> 6) & 0x3f)|0x80;
  44.             *e++ = (unicode & 0x3f)|0x80;
  45.         }
  46.         else if(unicode < 0x4000000)
  47.         {
  48.             /*<11111011> <00 0000 0000 0000 0000 0000 0000>*/
  49.             *e++ = ((unicode >> 24) & 0x03)|0xf8 ;
  50.             *e++ = ((unicode >> 18) & 0x3f)|0x80;
  51.             *e++ = ((unicode >> 12) & 0x3f)|0x80;
  52.             *e++ = ((unicode >> 6) & 0x3f)|0x80;
  53.             *e++ = (unicode & 0x3f)|0x80;
  54.         }
  55.         else
  56.         {
  57.             /*<11111101> <0000 0000 0000 0000 0000 0000 0000 0000>*/
  58.             *e++ = ((unicode >> 30) & 0x01)|0xfc;
  59.             *e++ = ((unicode >> 24) & 0x3f)|0x80;
  60.             *e++ = ((unicode >> 18) & 0x3f)|0x80;
  61.             *e++ = ((unicode >> 12) & 0x3f)|0x80;
  62.             *e++ = ((unicode >> 6) & 0x3f)|0x80;
  63.             *e++ = (unicode & 0x3f)|0x80;
  64.         }
  65.     }
  66.     return e;
  67. }

  69. /* convert UTF-8 to unicode */
  70. int UTF8toUnicode(unsigned char *ch, int *unicode)
  71. {
  72.     unsigned char *p = NULL;
  73.     int e = 0, n = 0;

  75.     if((p = ch) && unicode)
  76.     {
  77.         if(*p >= 0xfc)
  78.         {
  79.             /*6:<11111100>*/
  80.             e = (p[0] & 0x01) << 30;
  81.             e |= (p[1] & 0x3f) << 24;
  82.             e |= (p[2] & 0x3f) << 18;
  83.             e |= (p[3] & 0x3f) << 12;
  84.             e |= (p[4] & 0x3f) << 6;
  85.             e |= (p[5] & 0x3f);
  86.             n = 6;
  87.         }
  88.         else if(*p >= 0xf8)
  89.         {
  90.             /*5:<11111000>*/
  91.             e = (p[0] & 0x03) << 24;
  92.             e |= (p[1] & 0x3f) << 18;
  93.             e |= (p[2] & 0x3f) << 12;
  94.             e |= (p[3] & 0x3f) << 6;
  95.             e |= (p[4] & 0x3f);
  96.             n = 5;
  97.         }
  98.         else if(*p >= 0xf0)
  99.         {
  100.             /*4:<11110000>*/
  101.             e = (p[0] & 0x07) << 18;
  102.             e |= (p[1] & 0x3f) << 12;
  103.             e |= (p[2] & 0x3f) << 6;
  104.             e |= (p[3] & 0x3f);
  105.             n = 4;
  106.         }
  107.         else if(*p >= 0xe0)
  108.         {
  109.             /*3:<11100000>*/
  110.             e = (p[0] & 0x0f) << 12;
  111.             e |= (p[1] & 0x3f) << 6;
  112.             e |= (p[2] & 0x3f);
  113.             n = 3;
  114.         }
  115.         else if(*p >= 0xc0)
  116.         {
  117.             /*2:<11000000>*/
  118.             e = (p[0] & 0x1f) << 6;
  119.             e |= (p[1] & 0x3f);
  120.             n = 2;
  121.         }
  122.         else
  123.         {
  124.             e = p[0];
  125.             n = 1;
  126.         }
  127.         *unicode = e;
  128.     }
  129.     return n;
  130. }
  131. #ifdef _DEBUG_UNICODE
  132. int main()
  133. {
  134.     unsigned char ch[CHINA_SET_MAX], *p = NULL, *e = NULL, *s = NULL;
  135.     int i = 0, n = 0, unicode = 0;

  137. #ifdef _OUT_UNICODE_
  138.        for(i = 1; i < 65536; i++)
  139.        {
  140.            p = (unsigned char *)&i;
  141.            outbin(stdout, p[0]);
  142.            fprintf(stdout, " ");
  143.            outbin(stdout, p[1]);
  144.            fprintf(stdout, " ");
  145.            outbin(stdout, p[2]);
  146.            fprintf(stdout, " ");
  147.            outbin(stdout, p[3]);
  148.            e = ch;
  149.            s = unicodetoUTF8(i, e);
  150.            *s = '\0';
  151.            while(*e != 0)
  152.            {
  153.                fprintf(stdout, "[");
  154.                outbin(stdout, *e++);
  155.                fprintf(stdout, "]");
  156.            }
  157.         }
  158. #endif
  159.     //macro functions
  160.     sprintf((char *)ch, "%s", "你");
  161.     e = ch;
  162.     unicode = 0;
  163.     UTF8_TO_UNICODE(e, unicode, n);
  164.     fprintf(stdout, "convert UTF8_TO_UNICODE(%s, %08x, %d)\n", ch, unicode, n);
  165.     memset((char *)ch, 0, CHINA_SET_MAX);
  166.     e = ch;
  167.     UNICODE_TO_UTF8(unicode, e);
  168.     e = '\0';
  169.     fprintf(stdout, "convert UNICODE_TO_UTF8(%08x, %s)\n", unicode, ch);
  170.     //C functions
  171.     unicode = 0;
  172.     if((n = UTF8toUnicode(ch, &unicode)) > 0)
  173.     {
  174.         fprintf(stdout, "convert %d = UTF8toUnicode(%s, %08x)\n", n, ch, unicode);
  175.         memset((char *)ch, 0, CHINA_SET_MAX);
  176.         if((e = UnicodetoUTF8(unicode, ch)) > ch)
  177.         {
  178.             e = '\0';
  179.             fprintf(stdout, "convert UnicodetoUTF8(%08x, %s)\n", unicode, ch);
  180.         }
  181.     }
  182.     return 0;
  183. }
  184. #endif
freqzl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unicode与utf8转码代码[纯代码不依赖其他库]
02-11
Unicode与utf8相互转码源码，纯代码，不依赖第三方库（如：iconv，mfc，atl等）
Ubuntu下实现UTF8编码转为Unicode编码 C程序
那个谁的博客
02-10 2338
参考博客：http://blog.csdn.net/tge7618291/article/details/7599902 ubuntu下实现UTF8编码转为Unicode编码 C程序
UNICODE(UTF-16)与UTF-8编码的相互转换
云淡风轻
10-14 2147
我们通常所说的UNICODE其实是UTF-16，下面这几个函数实现UNICODE(UTF-16)与UTF-8编码的相互转换。 [cpp] view plaincopy /**   * This file implement functions of:   *   * 1. UTF-16 character to UTF-8 chaaract
c语言把unicode转换为字符,[C语言]Unicode编码（二）－中文字符刷选
weixin_29560063的博客
05-17 1282
[C语言]Unicode编码(二)－中文字符刷选发布时间：2020-06-30 20:43:20来源：51CTO阅读：1967作者：風子余Unicode编码(二)－中文字符刷选1，UTF－8编码中三字节中文字符的刷选方法如下：intchinese_filter(unsignedcharone,unsignedchartwo){intflag=-1;if(one>=0...
Unicode码转UTF8
憧憬，思考，奋斗，飞翔
08-24 916
Unicode码转UTF8
[首发][NTDLL][Rtl系列]UNICODE互转UTF8-易语言
06-14
标题中的 "[首发][NTDLL][Rtl系列]UNICODE互转UTF8-易语言" 提示我们这个压缩包文件的内容是关于易语言编程中处理字符编码转换的一个教程或示例，特别是涉及到UNICODE（一种广泛使用的字符编码标准）与UTF8（另一种...
demo_gbk_2_utf8.zip
06-05
这段代码定义了一个函数`gbk_to_utf8`，它接受GBK编码的文件路径作为输入，然后创建一个UTF-8编码的新文件并写入转换后的文本。然后，脚本遍历指定文件夹，对每个`.txt`文件进行转换。 通过理解这个过程，我们可以...
「Python入门」Python代码规范（风格）
最新发布
07-17
在类定义、函数定义、流程控制语句（如`if`、`for`、`while`等）以及异常处理语句中，每一段新的代码块都应当使用相同数量的缩进，并且通常推荐使用四个空格作为缩进单位。例如： ```python if a == 0: print(...
EditPlus 3--------->系列说明
03-24
支持ASCII、UNICODE和UTF-8等编码格式间的转换，解决跨平台编码问题。此外，还提供了行首添加、删除、替换等文本处理功能，方便批量修改文本内容。 5. **搜索与替换** 强大的查找和替换功能，支持正则表达式，能...
文本(2022-04-19 162225).zip
04-16
它们使用ASCII或Unicode编码，如UTF-8。在计算机科学中，处理文本文件是基础操作，包括读取、写入和编辑。常见的编程语言如Python、Java都有相应的API来处理这类文件。 2. **Java编程语言**：Java是一种广泛使用的...
UTF8/unicode编码互转代码实现
哈哈星云
05-09 389
代码实现#include <windows.h> #include <wchar.h>int UTF8ToUnicode( char* str , wchar_t * wstr) { int unicodeLen = MultiByteToWideChar( CP_UTF8, 0, str, -1, NU
C语言实现unicode转utf8(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-22 469
C语言实现unicode转utf8(附完整源码)
c语言字节转字符串gbk,不依赖任何系统API,用c语言实现gbk/utf8/unicode编码转换
weixin_32021519的博客
05-17 631
汉字'我'Unicode编码是 0x6211 0110001000010001UTF8编码是 0xe68891 1110011010001000100010001oxc0 110000000xE0 11100000| Unicode符号范围 | UTF-8编码方式n | (十六进制) | (...
Unicode与UTF-8互转(C语言实现)
热门推荐
tge7618291的专栏
05-24 11万+
>                 Tags: encoding,c 1. 基础 1.1 ASCII码 我们知道, 在计算机内部, 所有的信息最终都表示为一个二进制的字符串. 每一个二进制 位(bit)有0和1两种状态, 因此八个二进制位就可以组合出 256种状态, 这被称为一个字 节(byte). 也就是说, 一个字节一共可以用来表示256种不同的状态, 每一个状态对应一
UNICODE与多字节字符集的区别及转换
yxtxiaotian的专栏
09-27 6700
一、一点历史 在计算机中字符通常并不是保存为图像，每个字符都是使用一个编码来表示的，而每个字符究竟使用哪个编码代表，要取决于使用哪个字符集(charset)。 在最初的时候，Internet上只有一种字符集——ANSI的ASCII字符集，它使用7 bits来表示一个字符，总共表示128个字符，其中包括了英文字母、数字、标点符号等常用字符。之后，又进行扩展，使用8 bits表示一个字符，可
字符串和Unicode编码的相互转换
大梦几千秋的博客
07-28 5585
字符串和Unicode编码的相互转换 1、Unicode编码转字符串 public static String unicodeToString(String unicode) { StringBuffer string = new StringBuffer(); //以\u切割 String[] hex = unicode.split("\\\\u"); for (int i = 1; i < hex.length; i++)
mfc Unicode转UTF-8 代码
03-31
以下是将MFC Unicode字符串转换为UTF-8字符串的示例代码： ```cpp CStringW unicodeString = L"这是一段Unicode字符串"; CStringA utf8String; // 获取需要的缓冲区大小 int length = WideCharToMultiByte(CP_UTF8, 0, unicodeString, -1, NULL, 0, NULL, NULL); // 分配缓冲区 char* buffer = new char[length]; // 转换为UTF-8 WideCharToMultiByte(CP_UTF8, 0, unicodeString, -1, buffer, length, NULL, NULL); // 将转换后的字符串存储到CStringA对象中 utf8String = CStringA(buffer); // 释放缓冲区 delete[] buffer; ``` 注意，上述代码中使用了Windows API函数WideCharToMultiByte进行Unicode到UTF-8的转换。该函数的第一个参数CP_UTF8指定了转换为UTF-8编码。第二个参数0表示使用默认行为，第三个参数是输入的Unicode字符串，第四个参数-1表示自动计算输入字符串的长度，第五个参数为输出缓冲区，第六个参数是输出缓冲区大小，第七个和第八个参数可以不用管。转换后的字符串存储在char类型的缓冲区中，需要将其转换为CStringA对象才能在MFC中使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值