小编给大家分享一下在C程序中如何处理UTF-8文本，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！

成都创新互联公司专业为企业提供江阴网站建设、江阴做网站、江阴网站设计、江阴网站制作等企业网站建设、网页设计与制作、江阴企业网站模板建站服务，10余年江阴做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。

UTF-8

互联网的普及, 强烈要求出现一种统一的编码方式. UTF-8就是在互联网上使用最广的一种unicode的实现方式. 其他实现方式还包括UTF-16和UTF-32, 不过在互联网上基本不用.

重复一遍, 这里的关系是, UTF-8是Unicode的实现方式之一.

UTF-8最大的一个特点, 就是它是一种变长的编码方式. 它可以使用1~6个字节表示一个符号, 根据不同的符号而变化字节长度.

UTF-8的编码规则

UTF-8的编码规则很简单, 只有两条:

1) 对于单字节的符号, 字节的第一位设为0, 后面7位为这个符号的unicode码. 因此对于英语字母, UTF-8编码和ASCII码是相同的.

2) 对于n字节的符号(n>1), 第一个字节的前n位都设为1, 第n+1位设为0, 后面字节的前两位一律设为10. 剩下的没有提及的二进制位, 全部为这个符号的unicode码.

如果你对 UTF-8 编码不是非常了解，就不要试图在 C 程序中徒手处理 UTF-8 文本。如果你对 UTF-8 非常了解，就更没必要这样做。找一个提供了 UTF-8 文本处理功能并且可以跨平台运行的 C 库来做这件事吧！

GLib 就是这样的库。

从问题出发

下面的这段文本是 UTF-8 编码的（我之所以如此确定，是因为我用的是 Linux 系统，系统默认的文本编码是 UTF-8）：

我的 C81 每天都在口袋里
   @

我需要在 C 程序中读入这些文本。在读到 '@' 字符时，我需要判定 '@' 左侧与之处于同一行的文本是否都是空白字符。

简单起见，我忽略了文件读取的过程，将上述文本表示为 C 字符串：

gchar *demo_text =
 "我的 C81 每天都在口袋里\n"
 "   @";

注：在 GLib 中，gchar 就是 char，即 typedef char gchar;

下文，当我说『demo_text 字符串』时，指的是以 demo_text 指针的值为基地址的 strlen(demo_text) + 1 个字节的内存空间，这是 C 语言字符串的基本常识。

UTF-8 文本长度与字符定位

为了模拟程序读到 '@' 字符这一时刻，我需要用一个 char * 类型的指针对 demo_text 字符串中的 '@' 字符进行定位。

'@' 字符在 demo_text 的末尾。我需要一个偏移距离，而这个偏移距离就是 demo_text 字串在 UTF-8 编码层次上的长度，通过这个偏移距离，我可以从 demo_text 字符串的基地址跳到 '@' 字符的基地址。

GLib 提供了 g_utf8_strlen 函数计算 UTF-8 字符串长度，因此我可以得到从 demo_text 字串的基地址到 '@' 字符基地址的偏移距离：

glong offset = g_utf8_strlen(demo_text, -1);

结果是 38，恰好是 demo_text 字符串在 UTF-8 编码层次上的长度（不含字串结尾的 null 字符，亦即 '\0' 字符）。

g_utf8_strlen 的原型如下：

glong g_utf8_strlen(const gchar *p, gssize max);

注：glong 即 long，而 gssize 即 signed long。

g_utf8_strlen 第二个参数 max 的设定规则如下：

• 如果它是负数，那么就假定字符串是以 null 结尾的（这是 C 字符串常识），然后统计 UTF-8 字符的个数。

• 如果它为 0，就是不检测字符串长度……这个值纯粹是出来打酱油的。

• 如果它为正数，表示的是字节数。g_utf8_strlen 会按照字节数从字符串中截取字节，然后再统计所截取的字节对应的 UTF-8 字符的个数。

有了偏移距离，就可以在 demo_text 中定位 '@' 字符了，即：

gchar *tail = g_utf8_offset_to_pointer(demo_text, offset - 1);

此时 tail 的值便是 '@' 字符的基地址。

在 UTF-8 文本中游走

现在已经获得了 '@' 的位置，接下来就是从这个位置开始向左（也就是逆序）遍历 demo_text 字符串的其它字符。GLib 为此提供了 g_utf8_prev_char 函数：

gchar * g_utf8_prev_char(const gchar *str, const gchar *p);

借助 g_utf8_prev_char 函数可以从 str 中获得 p 之前的一个 UTF-8 字符的基地址（p 是当前 UTF-8 字符的基地址）。如果 p 与 str 相同，即 p 已经指向了字符串的基地址，那么 g_utf8_find_prev_char 会返回 NULL。

对于本文要解决的问题而言，利用这个函数，可以写出从 demo_text 中的 '@' 字符所在位置开始逆序遍历 '@' 之前的所有 UTF-8 字符的过程：

glong offset = g_utf8_strlen(demo_text, -1);
gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
while (1) {
  viewer = g_utf8_prev_char(viewer);
  if (viewer != demo_text) {
    /* do somthing here */
  } else {
    break;
  }
}

GLib 还提供了一个 g_utf8_next_char，它可以返回当前位置的下一个 UTF-8 字符的基地址。

提取 UTF-8 字符

虽然借助 g_utf8_prev_char 与 g_utf8_next_char 可以让指针在 UTF-8 文本中走动，但是只能将一个指针定位到某个 UTF-8 字符的基地址，如果我们想得到这个 UTF-8 字符，就不是那么容易了。

例如

viewer = g_utf8_prev_char(viewer);

此时，虽然可以将 viewer 向前移动一个 UTF-8 字符宽度的距离，到达了一个新的 UTF-8 字符的基地址，但是如果我想将这个新的 UTF-8 字符打印出来，像下面这样做肯定是不行的：

g_print("%s", viewer);

注：g_print 函数与 C 标准库中的 printf 函数功能基本等价，只不过 g_print 可以借助 g_set_print_handler 函数实现输出的『重定向』。

因为 g_print 要通过 viewer 打印单个 UTF-8 字符，前提是这个 UTF-8 字符之后需要有个 '\0'，这样就是将一个 UTF-8 字符作为一个普通的 C 字符串打印了出来。这个 UTF-8 字符后面不可能有 '\0'，除非它是 demo_text 字符串中的最后一个字符。

要解决这个问题，只能是将 viewer 所指向的 UTF-8 字符相应的字节数据提取出来，放到一个字符数组或在堆中为其创建存储空间，然后再打印这个字符数组或堆空间中的数据。例如：

gchar *new_viewer = g_utf8_next_char(viewer);

sizt_t n = new_viewer - viewer;
gchar *utf8_char = malloc(n + 1);
memcpy(utf8_char, viewer, n);
utf8_char[n] = '\0';
g_print("%s", utf8_char);
free(utf8_char);

这样显然太繁琐了。不过，这意味着我们应该写一个函数专门做这件事。这个函数可取名为 get_utf8_char，定义如下：

static gchar * get_utf8_char(const gchar *base) {
  gchar *new_base = g_utf8_next_char(base);
  gsize n = new_base - base;
  gchar *utf8_char = g_memdup(base, (n + 1));
  utf8_char[n] = '\0';
  return utf8_char;
}

借助这个函数，就可以实现从 demo_text 的 '@' 所在位置开始，逆序打印 '@' 之前的所有 UTF-8 字符：

glong offset = g_utf8_strlen(demo_text, -1);
gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
while (1) {
  gchar outbuf[7] = {'\0'};
  viewer = g_utf8_prev_char(viewer);
  if (viewer != demo_text) {
    gchar *utf8_char = get_utf8_char(viewer);
    g_print("%s", utf8_char);
    g_free(utf8_char);
  } else {
    break;
  }
}
g_print("\n");

注：g_memdup 等价于 C 标准库中的 malloc + memcpy，而 g_free 则等价与 C 标准库中的 free。
空白字符比较

现在，假设给定一个 UTF-8 字符 x，怎么判断它与某个 UTF-8 字符相等？

不要忘记，所谓的一个 UTF-8 字符，本质上只不过是 char * 类型的指针引用的一段内存空间。基于这一事实，利用 C 标准库提供的 strcmp 函数即可实现 UTF-8 字符的比较。

下面，我定义了函数 is_space，用它判断一个 UTF-8 字符是否为空白字符。

static gboolean is_space(const gchar *s) {
  gboolean ret = FALSE;
  char *space_chars_set[] = {" ", "\t", "　"};
  size_t n = sizeof(space_chars_set) / sizeof(space_chars_set[0]);
  for (size_t i = 0; i < n; i++) {
    if (!strcmp(s, space_chars_set[i])) {
      ret = TRUE;
      break;
    }
  }
  return ret;
}

注：gboolean 是 GLib 定义的布尔类型，其值要么是 TRUE，要么是 FALSE。

在 is_space 函数中，我只是判断了三种空白字符类型——英文空格、中文全角空格以及制表符。

虽然回车符与换行符也是空白字符，但是为了解决这篇文章开始时提出的问题，我需要单独为换行符定义一个判断函数：

static gboolean is_line_break(const gchar *s) {
  return (!strcmp(s, "\n") ? TRUE : FALSE);
}

解决问题

现在万事俱备，只欠东风，我们应该着手解决问题了。如果读到此处已经忘记了问题是什么，那么请回顾第一节。

尽管下面这段代码看上去挺丑，但是它能够解决问题。

gboolean is_right_at_sign = TRUE;
glong offset = g_utf8_strlen(demo_text, -1);
gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
while (viewer != demo_text) {
  viewer = g_utf8_prev_char(viewer);
  gchar *utf8_char = get_utf8_char(viewer);
  if (!is_space(utf8_char)) {
    if (!is_line_break(utf8_char)) {
      is_right_at_sign = FALSE;
      g_free(utf8_char);
      break;
    } else {
      g_free(utf8_char);
      break;
    }
  }
  g_free(utf8_char);
}
if (is_right_at_sign) g_print("Right @ !\n");

对上述代码略做简化，可得：

gboolean is_right_at_sign = TRUE;
glong offset = g_utf8_strlen(demo_text, -1);
gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
while (viewer != demo_text) {
  viewer = g_utf8_prev_char(viewer);
  gchar *utf8_char = get_utf8_char(viewer);
  if (!is_space(utf8_char)) {
    if (!is_line_break(utf8_char)) is_right_at_sign = FALSE;
    g_free(utf8_char);
    break;
  }
  g_free(utf8_char);
}
if (is_right_at_sign) g_print("Right @ !\n");

其实，如果将 UTF-8 字符的提取与内存释放过程置入 is_space 与 is_line_break 函数，即：

static gboolean is_space(const gchar *c) {
  gboolean ret = FALSE;
  gchar *utf8_char = get_utf8_char(c);
  char *space_chars_set[] = {" ", "\t", "　"};
  size_t n = sizeof(space_chars_set) / sizeof(space_chars_set[0]);
  for (size_t i = 0; i < n; i++) {
    if (!strcmp(utf8_char, space_chars_set[i])) {
      ret = TRUE;
      break;
    }
  }
  g_free(utf8_char);
  return ret;
}

static gboolean is_line_break(const gchar *c) {
  gboolean ret = FALSE;
  gchar *utf8_char = get_utf8_char(c);
  if (!strcmp(utf8_char, "\n")) ret = TRUE;
  g_free(utf8_char);
  return ret;
}

可以得到进一步的简化结果：

gboolean is_right_at_sign = TRUE;
glong offset = g_utf8_strlen(demo_text, -1);
gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
while (viewer != demo_text) {
  viewer = g_utf8_prev_char(viewer);
  if (!is_space(viewer)) {
    if (!is_line_break(viewer)) is_right_at_sign = FALSE;
    break;
  }
}
if (is_right_at_sign) g_print("Right @ !\n");

附：完整的代码

#include 
#include 

gchar *demo_text =
  "我的 C81 每天都在口袋里\n"
  "      @";

static gchar * get_utf8_char(const gchar *base) {
  gchar *new_base = g_utf8_next_char(base);
  gsize n = new_base - base;
  gchar *utf8_char = g_memdup(base, (n + 1));
  utf8_char[n] = '\0';
  return utf8_char;
}

static gboolean is_space(const gchar *c) {
  gboolean ret = FALSE;
  gchar *utf8_char = get_utf8_char(c);
  char *space_chars_set[] = {" ", "\t", "　"};
  size_t n = sizeof(space_chars_set) / sizeof(space_chars_set[0]);
  for (size_t i = 0; i < n; i++) {
    if (!strcmp(utf8_char, space_chars_set[i])) {
      ret = TRUE;
      break;
    }
  }
  g_free(utf8_char);
  return ret;
}

static gboolean is_line_break(const gchar *c) {
  gboolean ret = FALSE;
  gchar *utf8_char = get_utf8_char(c);
  if (!strcmp(utf8_char, "\n")) ret = TRUE;
  g_free(utf8_char);
  return ret;
}

int main(void) {
  gboolean is_right_at_sign = TRUE;
  glong offset = g_utf8_strlen(demo_text, -1);
  gchar *viewer = g_utf8_offset_to_pointer(demo_text, offset - 1);
  while (viewer != demo_text) {
    viewer = g_utf8_prev_char(viewer);
    if (!is_space(viewer)) {
      if (!is_line_break(viewer)) is_right_at_sign = FALSE;
      break;
    }
  }
  if (is_right_at_sign) g_print("Right @ !\n");

  return 0;
}

若是在 Bash 中使用 gcc 编译这份代码，可使用以下命令：

$ gcc `pkg-config --cflags --libs glib-2.0` utf8-demo.c -o utf8-demo

看完了这篇文章，相信你对“在C程序中如何处理UTF-8文本”有了一定的了解，如果想了解更多相关知识，欢迎关注创新互联行业资讯频道，感谢各位的阅读！

本文题目：在C程序中如何处理UTF-8文本
转载来源：http://csdahua.cn/article/igoohi.html