C语言函数返回string变量后值被意外覆盖的问题求助

各位大佬好，我遇到一个奇怪的问题，想请教下大家。我写了一个计算可读性等级的C函数，返回对应的等级字符串。如果把函数返回值存到变量后马上打印，结果是对的，但如果中间多调用几次printf，再打印这个变量就变成空字符串了，具体情况如下：

我的函数实现： #

//Get Readability: Coleman-Liau Index Formula: ((0.0588 * Average # of letters per 100 words) - (0.296 * Average # of sentences per 100 words) - 15.8)

string get_readability(float avg_letters, float avg_sentences)
{
    //Store as int so that it rounds the resulting index number
    int index = (0.0588 * avg_letters) - (0.296 * avg_sentences) - 15.8;
    //printf("Index: %i\n", index);//debug

    //Return the grade level
    if (index < 1)
    {
        return "Before Grade 1";
    }
    else if (index > 16)
    {
        return "Grade 16+";
    }
    else
    {
        //Create char array for result in order to concat the index number
        char result[8] = "Grade ";
        char grade[2];
        sprintf(grade, "%i", index);//Convert int to string
        strcat(result, grade);

        //Convert char array to string in order to return results
        string result_str = result;
        return result_str;
    }
}

测试代码： #

// 情况1：直接打印，结果正确
string reading_level = get_readability(464.29f, 28.57f);
printf("%s\n", reading_level);

// 情况2：中间加几个printf后，打印出空行
string reading_level = get_readability(464.29f, 28.57f);
printf("\n");
printf("\n");
printf("\n");
printf("%s\n", reading_level);

我查了下资料，感觉可能是函数返回的时候，返回的是局部变量的指针，之后调用printf的时候覆盖了这块内存？但我不太明白具体是怎么回事，毕竟我没有用指针传参啊。

问题分析与解决方案 #

兄弟，你猜的方向完全正确！问题的核心就出在函数里的char result[8]这个局部数组上：

它是分配在栈内存上的，当get_readability函数执行完毕返回时，这个函数的栈帧会被销毁，栈上的result数组所在的内存会被标记为可复用空间。

• 为什么直接打印没问题？因为刚返回时，栈内存的内容还没被覆盖，你的reading_level（大概率是你自己typedef的char* string类型）指向的还是这块栈内存的地址，此时内容还完好，所以打印正常。
• 为什么加几个printf后就变空了？因为printf本身也会使用栈内存，后续的printf调用会覆盖原来result数组所在的栈空间，导致你指向的地址里的内容被破坏，自然打印出空白。

如果你的string是C++的std::string，理论上它会自动拷贝栈上的内容到自己的堆内存存储，不会出现这个问题，所以你应该是在纯C环境里把string定义成了char*的别名。

给你几个可行的解决方案：

方案1：使用动态内存分配

在函数里用malloc分配堆内存，堆内存不会随函数栈帧销毁而释放，记得使用完后要free避免内存泄漏：

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

typedef char* string;

string get_readability(float avg_letters, float avg_sentences)
{
    int index = (0.0588 * avg_letters) - (0.296 * avg_sentences) - 15.8;

    if (index < 1)
    {
        // 字面量字符串存在全局内存，可直接返回
        return "Before Grade 1";
    }
    else if (index > 16)
    {
        return "Grade 16+";
    }
    else
    {
        // 分配足够内存，"Grade XX"最多需要8字节（含结束符）
        char* result = malloc(8);
        if (result == NULL) {
            // 处理内存分配失败的情况
            return NULL;
        }
        sprintf(result, "Grade %d", index);
        return result;
    }
}

// 调用示例
int main() {
    string reading_level = get_readability(464.29f, 28.57f);
    printf("%s\n", reading_level);
    free(reading_level); // 用完记得释放内存
    return 0;
}

方案2：让调用者提供缓冲区

把结果写入调用者传入的缓冲区，内存由调用者管理，彻底避免栈内存问题：

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

typedef char* string;

void get_readability(float avg_letters, float avg_sentences, char* buffer, size_t buffer_size)
{
    int index = (0.0588 * avg_letters) - (0.296 * avg_sentences) - 15.8;

    if (index < 1)
    {
        strncpy(buffer, "Before Grade 1", buffer_size - 1);
    }
    else if (index > 16)
    {
        strncpy(buffer, "Grade 16+", buffer_size - 1);
    }
    else
    {
        snprintf(buffer, buffer_size, "Grade %d", index);
    }
    // 确保字符串以'\0'结尾
    buffer[buffer_size - 1] = '\0';
}

// 调用示例
int main() {
    char reading_level[32]; // 定义足够大的缓冲区
    get_readability(464.29f, 28.57f, reading_level, sizeof(reading_level));
    printf("\n");
    printf("\n");
    printf("\n");
    printf("%s\n", reading_level); // 无论中间加多少printf都没问题
    return 0;
}

方案3：如果用C++，直接用std::string

C++的std::string会自动管理内存，拷贝栈上的内容到内部存储，完全不用担心野指针问题：

#include <string>
#include <cstdio>

std::string get_readability(float avg_letters, float avg_sentences)
{
    int index = (0.0588 * avg_letters) - (0.296 * avg_sentences) - 15.8;

    if (index < 1)
    {
        return "Before Grade 1";
    }
    else if (index > 16)
    {
        return "Grade 16+";
    }
    else
    {
        char grade[8];
        sprintf(grade, "Grade %d", index);
        return std::string(grade);
    }
}

// 调用示例
int main() {
    std::string reading_level = get_readability(464.29f, 28.57f);
    printf("\n");
    printf("\n");
    printf("\n");
    printf("%s\n", reading_level.c_str());
    return 0;
}

总结一下：核心问题就是返回了栈上局部变量的指针/地址，栈内存会在函数返回后被复用，后续函数调用会覆盖这块内存导致数据丢失。只要避免返回栈内存的指针，改用堆内存、调用者缓冲区或者C++的std::string就能解决问题啦。

备注：内容来源于stack exchange，提问作者Tyler Mason