C语言字符串转换问题：重复调用函数返回空串原因及复用方案

问题描述 #

编写了一个仅处理十六进制字符'a'和'b'的decode_hex函数，尝试复用字符串指针r调用该函数时出现异常：第一次转换结果正确，第二次返回空串。代码如下：

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

char * decode_hex(char hex[])
{
   static char bin[9];
   bin[0] = '\0';
   for (int i=0; hex[i]!='\0'; i++)
   {
        switch(hex[i])
        {
            case 'a':
                strcat(bin, "1010");
                break;
            case 'b':
                strcat(bin, "1011");
                break;
        }
    }
    return  bin;
}

int main()
{
   char *r = malloc(9);
   for (int i=0; i<2; i++)
   {
      r[0] = '\0';
      strcat(r, "ab");
      printf("Original string:  %s\n", r);
      r = decode_hex(r);
      printf("Converted string: %s\n\n", r);
   }
}

运行输出：

Original string:  ab
Converted string: 10101011

Original string:  ab
Converted string:

想了解：能否通过r = decode_hex(r)的方式复用字符串？如何避免内存泄漏？

问题根源分析 #

1. 静态数组的覆盖与指针指向混乱

   • decode_hex里的static char bin[9]是静态存储区的数组，生命周期贯穿程序全程。第一次调用后，bin存着10101011，同时r被赋值为bin的地址，原来malloc分配的堆内存地址丢失，已经造成内存泄漏。
   • 第二次循环中，执行r[0] = '\0'时，实际修改的是静态数组bin的第一个元素，把它改成了空字符。接下来调用decode_hex时，函数开头又执行bin[0] = '\0'，然后遍历hex（此时hex指向被清空的bin，也就是空串），自然不会拼接任何二进制字符串，最终返回空串。

2. 内存泄漏的产生

   • 第一次执行r = decode_hex(r)后，原来malloc返回的堆内存地址被覆盖，没有机会调用free，这块内存永远无法被释放，造成泄漏。

解决方案：实现字符串复用并避免内存泄漏 #

要实现r = decode_hex(r)的复用方式，需要让函数操作堆内存而非静态数组，同时管理好内存所有权：

改进后的代码 #

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

char *decode_hex(char *hex)
{
    // 计算需要的二进制字符串长度：每个十六进制字符对应4位二进制
    size_t hex_len = strlen(hex);
    size_t bin_len = hex_len * 4 + 1; // +1 留空字符位置
    
    // 分配堆内存存储结果
    char *bin = malloc(bin_len);
    if (!bin) {
        perror("malloc failed");
        return NULL;
    }
    
    bin[0] = '\0';
    for (size_t i = 0; hex[i] != '\0'; i++)
    {
        switch(hex[i])
        {
            case 'a':
                strcat(bin, "1010");
                break;
            case 'b':
                strcat(bin, "1011");
                break;
            // 可扩展其他十六进制字符的处理
            default:
                // 非法字符处理：清空并释放内存后返回
                free(bin);
                return NULL;
        }
    }
    return bin;
}

int main()
{
    char *r = malloc(9);
    if (!r) {
        perror("malloc failed");
        return 1;
    }
    
    for (int i = 0; i < 2; i++)
    {
        r[0] = '\0';
        strcat(r, "ab");
        printf("Original string:  %s\n", r);
        
        // 保存旧的堆地址，避免丢失
        char *old_r = r;
        r = decode_hex(r);
        // 释放旧内存，防止泄漏
        free(old_r);
        
        if (!r) {
            printf("Converted string: Error\n\n");
            break;
        }
        printf("Converted string: %s\n\n", r);
    }
    
    // 循环结束后释放最后一次分配的内存
    free(r);
    return 0;
}

关键改进点 #

• 使用堆内存存储转换结果：decode_hex不再依赖静态数组，而是动态分配内存，每次调用返回独立的堆内存块，避免静态存储区的冲突问题。
• 手动管理内存生命周期：
  • 调用decode_hex前保存旧的r地址，调用后立即释放旧内存，防止泄漏。
  • 循环结束后释放最后一次转换得到的内存块。
• 错误处理：增加malloc失败的判断，以及非法字符的内存释放逻辑，避免内存泄漏。

能否直接复用原字符串？ #

如果想直接复用原有的堆内存（不重新分配新内存），需要确保原内存的大小足够容纳转换后的二进制字符串。原代码中malloc(9)的空间，对于"ab"转换后的8位二进制（加空字符共9位）刚好够用，但如果原字符串更长（比如4个十六进制字符需要17位空间），原内存就不够了。这种情况下可以预先分配足够大的内存，或者使用如下的原地转换版本：

// 原地转换版本（前提是原内存空间足够容纳转换结果）
char *decode_hex_inplace(char *hex)
{
    size_t hex_len = strlen(hex);
    size_t required_len = hex_len * 4 + 1;
    // 假设传入的hex指向的内存至少有required_len大小，否则会触发缓冲区溢出
    char *bin = hex;
    bin[0] = '\0';
    for (size_t i = 0; hex[i] != '\0'; i++)
    {
        switch(hex[i])
        {
            case 'a':
                strcat(bin, "1010");
                break;
            case 'b':
                strcat(bin, "1011");
                break;
            default:
                bin[0] = '\0';
                return bin;
        }
    }
    return bin;
}

注意：这种方式要求调用者保证传入的内存空间足够，否则会触发缓冲区溢出，风险较高，不推荐在不确定输入长度的场景使用。

内容的提问来源于stack exchange，提问作者Eddy Sorngard