C 正在将二进制文件加载到未知结构类型

我在读取二进制文件并将其转换为未知类型的结构时遇到问题

• 我真的应该避免在我的 链表代码
• 是因为我使用的是GCC编译器堆栈吗 具有更多数据以方便地存储在内存中的结构，以及 加载函数时不知道这个“偏移量”

我正在用C编写一个通用链表，它是一个头文件，所以我可以在任何地方使用它。因为它将是一个泛型类型列表，所以标题将不知道列表上的数据类型（我正在研究混合类型，所以是结构）。为了保存数据，我只需传递从sizeof（struct）中提取的数据地址和长度。读取是相同的概念，使用fread（container，sizeof（struct），1，FILE），它由调用程序传递，再次使用sizeof（struct）提取se大小。但在实践中，它不起作用

#ifndef LINKEDLIST_H_INCLUDED
#define LINKEDLIST_H_INCLUDED
#include <string.h>

typedef struct tagNode{
    void            *data;
    struct tagNode  *next_Node;
} Node;

typedef struct tagLinkedList{
    Node *Head;
    int   Size;
} LinkedList;

int LinkedList_New(LinkedList *llist){
    llist->Head = NULL;
    llist->Size = 0;
    return 1;
}

int LinkedList_Insert(LinkedList *llist, int index, void *Data, size_t s_Data){
    int cur_index = 0;
    if(index > llist->Size || index < 0)
        index = 0;

    Node *newNode = malloc(sizeof(Node));
    newNode->data = malloc(s_Data);
    if(newNode       == NULL){return 0;}
    if(newNode->data == NULL){return 0;}
    newNode->data = Data;

    Node *currentNode = llist->Head;
    Node *lastNode    = llist->Head;

    if(index == 0){
        newNode->next_Node = llist->Head;
        llist->Head = newNode;
    }else{
        while(llist->Head->next_Node != NULL && cur_index != index){
            if(cur_index == index){
                newNode->next_Node  = currentNode;
                lastNode->next_Node = newNode;
            }else{
                lastNode    = currentNode;
                currentNode = currentNode->next_Node;
                cur_index++;
            }
        }
    }
    llist->Size += 1;
}

int LinkedList_Save(char *Path, LinkedList *llist, size_t sData){
    FILE *fp;
    fp = fopen(Path, "w");
    if(fp == NULL){return -1;}

    Node *currentNode;
    currentNode = llist->Head;

    while(currentNode != NULL){
        fwrite(currentNode->data, sData, 1, fp);
        currentNode = currentNode->next_Node;
    }
    fclose(fp);
    return 1;
}

int LinkedList_Load(char *Path, LinkedList *llist, size_t sData){
    FILE *fp;
    fp = fopen(Path, "r");
    if(fp == NULL){fclose(fp);return -1;}

    while(!feof(fp)){
        void *Data = malloc(sData);
        if(Data == NULL){fclose(fp);return -1;}
        fread(Data, sData, 1, fp);
        LinkedList_Insert(llist, 0, Data, sData);
    }
    fclose(fp);
    return 1;
}
#endif // LINKEDLIST_H_INCLUDED

#如果包含链接列表#
#定义包含的链接列表
#包括
typedef结构标记节点{
作废*数据；
结构标记节点*下一个节点；
}节点；
typedef结构标记链接列表{
节点*头；
整数大小；
}链接列表；
int LinkedList_New（LinkedList*llist）{
llist->Head=NULL；
llist->Size=0；
返回1；
}
int LinkedList_Insert（LinkedList*llist、int索引、void*数据、大小s_数据）{
int cur_指数=0；
如果（索引>列表>大小| |索引<0）
指数=0；
Node*newNode=malloc（sizeof（Node））；
newNode->data=malloc（s_数据）；
如果（newNode==NULL）{返回0；}
如果（newNode->data==NULL）{return 0；}
新建节点->数据=数据；
节点*currentNode=llist->Head；
Node*lastNode=llist->Head；
如果（索引==0）{
newNode->next_Node=llist->Head；
llist->Head=newNode；
}否则{
while（list->Head->next_Node！=NULL&&cur_index！=index）{
if（cur_index==索引）{
新建节点->下一个节点=当前节点；
lastNode->next_Node=newNode；
}否则{
lastNode=currentNode；
currentNode=currentNode->next_Node；
cur_index++；
}
}
}
llist->Size+=1；
}
int LinkedList_Save（字符*路径、LinkedList*列表、大小数据）{
文件*fp；
fp=fopen（路径“w”）；
如果（fp==NULL）{return-1；}
节点*当前节点；
currentNode=llist->Head；
while（currentNode！=NULL）{
fwrite（currentNode->data，sData，1，fp）；
currentNode=currentNode->next_Node；
}
fclose（fp）；
返回1；
}
int LinkedList_加载（字符*路径，LinkedList*llist，大小数据）{
文件*fp；
fp=fopen（路径“r”）；
如果（fp==NULL）{fclose（fp）；返回-1；}
而（！feof（fp））{
void*Data=malloc（sData）；
if（Data==NULL）{fclose（fp）；返回-1；}
fread（数据，sData，1，fp）；
LinkedList_Insert（llist，0，数据，sData）；
}
fclose（fp）；
返回1；
}
#endif//LINKEDLIST_H_包括在内

我目前的测试对象是：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../LinkedList.h"
typedef struct{
    int a;
    char b[5];
} tempo;

int main(){
    tempo teste = {5, "oito"};

    LinkedList lista;
    LinkedList_New(&lista);
    LinkedList_Insert(&lista, 0, &teste, sizeof(tempo));
    LinkedList_Save("data.txt", &lista, sizeof(tempo));
    printf("%s", ((tempo*)lista.Head->data)->b);
    LinkedList ls2;
    LinkedList_New(&ls2);
    LinkedList_Load("data.txt", &ls2, sizeof(tempo));

    printf("%s", ((tempo*)ls2.Head->data)->b);

    return 1;
}

#包括
#包括
#包括
#包括“./LinkedList.h”
类型定义结构{
INTA；
charb[5]；
}节奏；
int main（）{
节拍测试={5，“oito”}；
LinkedList lista；
LinkedList_New（&lista）；
LinkedList_Insert（&lista，0，&teste，sizeof（tempo））；
LinkedList_Save（“data.txt”和lista，sizeof（tempo））；
printf（“%s”，（（节奏*）列表a.Head->data）->b）；
LinkedList ls2；
LinkedList_New（&ls2）；
LinkedList_Load（“data.txt”&ls2，sizeof（tempo））；
printf（“%s”，（（节拍*）ls2.Head->data）->b）；
返回1；
}

第一个printf向我显示了结构中的b变量，这意味着列表的工作方式与预期的一样

---

但是第二个printf，如果用于显示a变量（int），我得到一个随机数（类似于8712382），如果用于显示b变量，我得到的只是“L”

您的LinkedList\u加载函数有问题。将其更新为以下内容

int LinkedList_Load(char *Path, LinkedList *llist, size_t sData){
        FILE *fp;
        fp = fopen(Path, "rb");
        if(fp == NULL){fclose(fp);return -1;}
        fseek(fp,0L,SEEK_SET);
        while(!feof(fp)){
                void *Data = malloc(sData);
                if(Data == NULL){fclose(fp);return -1;}
                int readed=fread(Data, sData, 1, fp);
                if(readed==0){return -1;}
                /*you were displaying the last reading that contains 
                *nothing, the previous check solves the problem.
                */
                printf("readed %d items:  \n",readed);
                LinkedList_Insert(llist, 0, Data, sData);       
        }
       fclose(fp);

---

}

读取的二进制数据是否在同一类型的环境中生成以避免端性问题？另外，您是否正在考虑结构填充？（从将其读入二进制文件，到将其读回）好吧，因为我将de-sData作为结构的de-size传递，所以我从fp文件将1块sData-size读入数据变量，还是我错了？我的意思是，如果sData是12，我将12字节的1次读取到数据存储器中，对吗？另外，是的，它都是在同一个环境中动态生成的，正如在第二个代码块中看到的一样。这不是一个问题，我正在看结构打包，但是由于它都发生在同一个环境中，程序应该知道如何正确地对齐数据，或者我认为……你看过它生成的文件了吗？1张唱片的尺寸合适吗？char数组应该是显而易见的，如果用于一般用途，建议注意从sizeof（struct）中提取的字符长度。确保您了解包装、填充和对齐边界。关于这一点。您添加的

if

在最后一个

数据上有内存泄漏。如果（readed==0）{free（Data）；return-1；}，则应该是
，
我不这么认为，这并不意味着内存泄漏
fread
如果读取有问题并且与
数据
指针无关，则返回0。我想我找到了！正确读取所有寄存器后，文件仍不处于EOF状态。如中所示，文件中有12个字节，读取12个字节，因此现在im位于文件的第12个字节。但仍然不在EOF中，新的运行已经完成，在第一个索引中写入了一个垃圾内存！我已经检查了编译器，而且列表长度是2。。。。谢谢你指出这一点！是的，这是内存泄漏<代码>数据

来自

malloc

，它是在

fread

之前完成的。如果返回时未将

数据

附加到链表，则链表处于挂起状态（即内存泄漏）。因此，你必须解放我