C语言从文件加载结构体时出现Segmentation fault，如何修复？

嘿，我来帮你搞定这个段错误的问题！你的代码核心问题在于直接对包含std::string的结构体做二进制整体读写——这完全行不通，因为std::string本质是个包含指针的容器，你存到文件里的只是指针地址，不是实际的字符串内容，读回来的时候这个地址早就失效了（原来的堆内存已经被释放或者不属于当前进程），自然会触发段错误。下面给你拆解要修改的地方，以及完整的修复代码：

核心错误分析 #

1. std::string的存储特性：std::string内部并不直接存储字符串内容，而是用指针指向堆上的内存块。sizeof(struct Account)计算的只是结构体中成员的大小（两个指针+一个double），根本不包含实际字符串的长度。你直接把结构体二进制写入文件，存的只是指针值，不是字符串本身。
2. 读取时的内存越界：原load_from_file用while ((i = getc(fp))!=EOF)循环写内存，完全没有限制写入的长度。如果文件内容大于sizeof(struct Account)，就会写到malloc分配的内存之外，直接触发段错误；如果内容更小，结构体的部分成员会处于未初始化状态，同样可能引发问题。

修复方案：逐个成员序列化/反序列化 #

对于包含复杂类型（比如std::string）的结构体，必须分别处理每个成员，不能直接整体拷贝。具体步骤：

• 对于std::string：先写入字符串的长度，再写入字符串的内容；读取时先读长度，再分配对应大小的内存读取内容。
• 对于double这类简单类型：可以直接二进制读写（同一平台下无需担心字节序，跨平台需要额外处理）。

完整修复代码 #

#include <iostream>
#include <cstdio>
#include <string>
#include <cstdlib>

using namespace std;

struct Account {
    string holder_name;
    string holder_password;
    double current_sum;
};

int save_to_file(Account * account);
Account * load_from_file(string holder_name);

int main(){
    Account account = { "BEN", "password", 200.0 };
    if (save_to_file(&account) != 0) {
        cerr << "Failed to save account data" << endl;
        return 1;
    }

    Account *loaded_account = load_from_file("BEN");
    if (loaded_account) {
        cout << "Successfully loaded account:" << endl;
        cout << "Holder Name: " << loaded_account->holder_name << endl;
        cout << "Password: " << loaded_account->holder_password << endl;
        cout << "Current Balance: " << loaded_account->current_sum << endl;
        delete loaded_account; // 记得释放内存，避免泄漏
    }
    return 0;
}

int save_to_file(Account * account){
    const char * filename = account->holder_name.c_str();
    FILE * fp = fopen(filename, "wb");
    if (!fp) {
        perror("Failed to open file for writing");
        return -1;
    }

    // 序列化holder_name：先写长度，再写内容
    size_t name_len = account->holder_name.size();
    fwrite(&name_len, sizeof(size_t), 1, fp);
    fwrite(account->holder_name.data(), sizeof(char), name_len, fp);

    // 序列化holder_password
    size_t pwd_len = account->holder_password.size();
    fwrite(&pwd_len, sizeof(size_t), 1, fp);
    fwrite(account->holder_password.data(), sizeof(char), pwd_len, fp);

    // 序列化current_sum
    fwrite(&account->current_sum, sizeof(double), 1, fp);

    int close_result = fclose(fp);
    return close_result == 0 ? 0 : -1;
}

Account * load_from_file(string holder_name) {
    FILE * fp = fopen(holder_name.c_str(), "rb");
    if (!fp) {
        perror("Error occured while opening file");
        return NULL;
    }

    // 用new分配Account，自动调用std::string的构造函数（malloc不会）
    Account * ptr = new Account();
    if (!ptr) {
        fclose(fp);
        perror("Failed to allocate memory for account");
        return NULL;
    }

    // 反序列化holder_name
    size_t name_len;
    if (fread(&name_len, sizeof(size_t), 1, fp) != 1) {
        delete ptr;
        fclose(fp);
        perror("Failed to read name length");
        return NULL;
    }
    ptr->holder_name.resize(name_len);
    if (fread(&ptr->holder_name[0], sizeof(char), name_len, fp) != name_len) {
        delete ptr;
        fclose(fp);
        perror("Failed to read name content");
        return NULL;
    }

    // 反序列化holder_password
    size_t pwd_len;
    if (fread(&pwd_len, sizeof(size_t), 1, fp) != 1) {
        delete ptr;
        fclose(fp);
        perror("Failed to read password length");
        return NULL;
    }
    ptr->holder_password.resize(pwd_len);
    if (fread(&ptr->holder_password[0], sizeof(char), pwd_len, fp) != pwd_len) {
        delete ptr;
        fclose(fp);
        perror("Failed to read password content");
        return NULL;
    }

    // 反序列化current_sum
    if (fread(&ptr->current_sum, sizeof(double), 1, fp) != 1) {
        delete ptr;
        fclose(fp);
        perror("Failed to read current balance");
        return NULL;
    }

    fclose(fp);
    return ptr;
}

额外注意事项 #

• 内存分配：原代码用malloc分配Account，但std::string需要构造函数初始化内部状态，malloc不会调用构造函数，可能导致未定义行为，所以改用new更安全。
• 跨平台兼容性：如果需要在不同平台间读写文件，要处理字节序问题（比如用htonl/ntohl转换size_t类型），因为不同CPU的字节序（大端/小端）不同。
• 错误处理：修复后的代码增加了更多错误检查，避免因文件读写失败导致的内存泄漏或非法访问。

内容的提问来源于stack exchange，提问作者Iskander Raimbaev