如何在C语言中实现UTF-8与Unicode转义互转及代码优化

一、反向转换：Unicode码点转UTF-8字节数组 #

首先我们来实现你需要的反向逻辑——把uint32_t类型的Unicode码点转换成对应的UTF-8字节序列。UTF-8的编码规则是标准化的，不需要查表，直接通过位运算就能高效完成：

#include <stdint.h>
#include <string.h>

// 将Unicode码点转换为UTF-8字节数组，返回写入的字节数
// 注意：dest缓冲区需要预留至少4字节的空间
size_t unicode_to_utf8(uint32_t code, uint8_t* dest) {
    if (code <= 0x7F) {
        // 单字节UTF-8：0xxxxxxx
        dest[0] = (uint8_t)code;
        return 1;
    } else if (code <= 0x7FF) {
        // 双字节UTF-8：110xxxxx 10xxxxxx
        dest[0] = 0xC0 | ((code >> 6) & 0x1F);
        dest[1] = 0x80 | (code & 0x3F);
        return 2;
    } else if (code <= 0xFFFF) {
        // 三字节UTF-8：1110xxxx 10xxxxxx 10xxxxxx
        dest[0] = 0xE0 | ((code >> 12) & 0x0F);
        dest[1] = 0x80 | ((code >> 6) & 0x3F);
        dest[2] = 0x80 | (code & 0x3F);
        return 3;
    } else if (code <= 0x10FFFF) {
        // 四字节UTF-8：11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
        dest[0] = 0xF0 | ((code >> 18) & 0x07);
        dest[1] = 0x80 | ((code >> 12) & 0x3F);
        dest[2] = 0x80 | ((code >> 6) & 0x3F);
        dest[3] = 0x80 | (code & 0x3F);
        return 4;
    } else {
        // 无效的Unicode码点（超出U+10FFFF的合法范围）
        return 0;
    }
}

使用示例：

uint32_t code = 0x0105; // 字符ą的Unicode码点
uint8_t utf8_bytes[4];
size_t len = unicode_to_utf8(code, utf8_bytes);
// 此时utf8_bytes为{0xC4, 0x85}，len=2

二、正向转换代码的优化 #

你的原有代码存在几个可以改进的地方，包括冗余的查表逻辑、不完善的内存管理、不完整的UTF-8支持以及错误处理缺陷，以下是优化后的版本：

核心优化点： #

• 移除冗余的unicode查表数组：UTF-8转Unicode可以通过位运算直接计算，不需要预定义数组，减少内存占用和逻辑复杂度。
• 完善多字节UTF-8支持：原代码只处理了2字节的UTF-8，现在支持1-4字节的完整UTF-8序列（覆盖所有合法Unicode字符）。
• 修复内存管理逻辑：原代码中tmpMemoryBuffer的使用完全多余，realloc会自动复制原有数据；同时优化扩容策略，通过翻倍缓冲区大小减少内存分配次数。
• 修复EOF判断错误：getc返回的是int类型，直接转uint8_t会把EOF（-1）变成0xFF，导致错误判断，现在先判断EOF再转换。
• 使用snprintf代替sprintf：避免缓冲区溢出风险，提升代码安全性。
• 增加错误处理：对无效的UTF-8字节序列做了明确的错误提示和资源回收。

优化后的代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>

char* utf8_to_unicode_escape(const char* filename) {
    FILE* fh = fopen(filename, "r");
    if (!fh) {
        fprintf(stderr, "Failed to open target file\n");
        return NULL;
    }

    size_t currentSize = 256; // 初始缓冲区大小，预留'\0'空间
    size_t currentIndex = 0;
    char* result = malloc(currentSize);
    if (!result) {
        fclose(fh);
        fprintf(stderr, "Memory allocation failed\n");
        return NULL;
    }
    memset(result, 0, currentSize);

    int ch;
    while ((ch = getc(fh)) != EOF) {
        uint8_t c = (uint8_t)ch;

        if (c <= 0x7F) {
            // 处理普通ASCII字符
            if (currentIndex + 1 >= currentSize) {
                currentSize *= 2;
                char* tmp = realloc(result, currentSize);
                if (!tmp) {
                    free(result);
                    fclose(fh);
                    fprintf(stderr, "Memory reallocation failed\n");
                    return NULL;
                }
                result = tmp;
            }
            result[currentIndex++] = (char)c;
        } else {
            // 处理多字节UTF-8序列
            uint32_t code = 0;
            int bytes_needed = 0;
            int shift = 0;

            if ((c & 0xE0) == 0xC0) {
                bytes_needed = 1;
                code = c & 0x1F;
                shift = 6;
            } else if ((c & 0xF0) == 0xE0) {
                bytes_needed = 2;
                code = c & 0x0F;
                shift = 12;
            } else if ((c & 0xF8) == 0xF0) {
                bytes_needed = 3;
                code = c & 0x07;
                shift = 18;
            } else {
                fprintf(stderr, "Invalid UTF-8 leading byte: 0x%X\n", c);
                free(result);
                fclose(fh);
                return NULL;
            }

            // 读取后续的UTF-8续字节
            for (int i = 0; i < bytes_needed; i++) {
                ch = getc(fh);
                if (ch == EOF || ((uint8_t)ch & 0xC0) != 0x80) {
                    fprintf(stderr, "Invalid UTF-8 sequence\n");
                    free(result);
                    fclose(fh);
                    return NULL;
                }
                code = (code << 6) | ((uint8_t)ch & 0x3F);
            }

            // 检查缓冲区是否足够容纳"\uXXXX"（6字节）
            if (currentIndex + 6 >= currentSize) {
                currentSize *= 2;
                char* tmp = realloc(result, currentSize);
                if (!tmp) {
                    free(result);
                    fclose(fh);
                    fprintf(stderr, "Memory reallocation failed\n");
                    return NULL;
                }
                result = tmp;
            }

            // 写入Unicode转义序列
            snprintf(result + currentIndex, currentSize - currentIndex, "\\u%04X", code);
            currentIndex += 6;
        }
    }

    // 确保字符串末尾有终止符
    result[currentIndex] = '\0';
    fclose(fh);

    // 可选：缩小缓冲区到实际使用的大小，节省内存
    char* final_result = realloc(result, currentIndex + 1);
    if (final_result) {
        result = final_result;
    }

    return result;
}

// 使用示例
int main() {
    char* escaped = utf8_to_unicode_escape("utf.txt");
    if (escaped) {
        printf("%s\n", escaped);
        free(escaped);
    }
    return 0;
}

额外说明： #

优化后的代码更健壮，能处理所有合法的UTF-8序列，同时对无效的字节序列做了明确的错误处理；内存管理更高效，通过翻倍扩容减少分配次数，最后还可以选择将缓冲区缩小到实际使用的大小，避免内存浪费；snprintf的使用确保不会写入超出缓冲区的内容，提升了代码的安全性。

内容的提问来源于stack exchange，提问作者Igor Galczak