c - 如何访问结构数组中的结构

Question

在一项学校作业中，我必须对位于二进制文件中的结构元素进行排序。我想我已经设法对它进行排序，但是我在打印结果时遇到了问题。我不知道如何访问结构的元素，因为数据必须从文件中读取，所以我只有数组中第一个结构的地址。 (我认为它应该保留在数组中以便我可以使用 qsort。)

这是主要代码:

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

typedef struct {
char name[32];
double value;
} record;

int nuvu(record* a, record* b){
    if(a->name < b->name) return -1;
    if(a->name > b->name) return 1;
    if(a->value < b->value) return -1;
    if(a->value > b->value) return 1;
}

int main()
{
    long N;
    unsigned char* p = readfile( "d.bin", &N );
    char* s;
    scanf("%s",&s);

    int k= N/sizeof(record);
    qsort(p,k,sizeof(record),(int(*)(const void*, const void *))nuvu);

    printf???

    free(p);
    return 0;
}

附加:读取文件.c

#include "readfile.h"
unsigned char* readfile( char* filename, long* pN )
{
    FILE* f= fopen(filename,"rb");
    if(f==0){
        *pN=-1;
        return 0;
    }
    fseek(f,0,SEEK_END);
    *pN=ftell(f);
    fseek(f,0,SEEK_SET);

    char*p=malloc(*pN);
    if(p==0){
        *pN=-2;
        fclose(f);
        return 0;
    }
    size_t r = fread(p,1,*pN,f);
    if(r!=*pN){
        *pN=-3;
        fclose(f);
        free(p);
        return 0;
    }
    fclose(f);
    return p;
}

读取文件.h

#ifndef __READFILE_H
#define __READFILE_H

#include <stdio.h>
#include <stdlib.h>
unsigned char* readfile(char* filename, long* pN);

#endif /* __READFILE_H */

Answer 1

您似乎遇到的最大困惑是“我如何读回我的结构数组？”

unsigned char* p = readfile( "d.bin", &N );

无从下手。从二进制文件读取记录到结构数组的概念，是从文件中读取 sizeof (struct record) 字节到类型为 struct record 的存储中。 (这将暂时忽略数据序列化的缺乏、填充和可移植性问题，以及我们正在使用 typedef 的事实)。

知道文件大小，并知道 sizeof (struct record) 允许您 (1) 验证将从文件中读取的记录数，例如(nbytes/sizeof (struct record)) 和 (2) 确定是否有任何剩余的杂散字节将不会成为读取的一部分(例如 if (nbytes/sizeof (struct record) != 0)) 如果存在，您至少应该警告。

根据您必须读取的记录数量以及该数量是否有上限将决定您是否可以使用固定大小的数组(或 VLA)或是否需要动态分配(和重新分配)地址未知数量的记录或防止 StackOverflow.. 无论您如何处理为您的记录创建存储 - 确保您不写入超出您创建的存储范围。

下面，出于示例目的，我们将简单地处理一个包含 100 记录的数组。适合堆栈的内容与何时需要动态分配之间的分界线将取决于编译器，但任何时候开始考虑数万条记录时，您都需要查阅编译器文档并开始考虑动态分配。

fread 提供了一种简单的方法来从文件中读取二进制记录并验证您实际读取的记录数是否达到了您打算读取的数量。例如，假设在 rec 中声明了一个包含 100 记录的数组，您可以执行如下操作:

enum { MAXC = 32, MAXS = 100 }; /* if you need constants, define them */
...
    record rec[MAXS] = {{ .name = "" }};    /* array of 100 records */
    ...
    nrec = nbytes / sizeof *rec;   /* number of records based on file size */

    /* read / validate nrec records from file */
    if (fread (rec, sizeof *rec, nrec, fp) != nrec) {
        perror (fn);
        return 1;
    }

从文件中成功读取记录后，使用 qsort 对记录进行排序(按 name 或按 value)需要您了解比较函数中要比较的 const void * 指针将是 指向 rec 的指针，因此您必须在比较函数中提供适当的转换以访问和比较值。例如，要对 name 执行字符串比较，您可以执行类似于以下操作的操作:

/** record string comparison on name */
int reccmpname (const void *a, const void *b)
{
    const record *ra = a,
                 *rb = b;
    return strcmp (ra->name, rb->name);
}

除此之外，您的代码缺少的其余部分是过程中每个步骤的验证。始终，始终，验证您使用的任何函数的返回并处理您遇到的任何错误。一个最小的例子，如果不在单独的源文件之间拆分代码，可能如下所示。拆分成单独的源文件留给你。

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

enum { MAXC = 32, MAXS = 100 }; /* if you need constants, define them */

typedef struct {
    char name[MAXC];
    double value;
} record;

/** record string comparison on name */
int reccmpname (const void *a, const void *b)
{
    const record *ra = a,
                 *rb = b;
    return strcmp (ra->name, rb->name);
}

int main (int argc, char **argv) {

    record rec[MAXS] = {{ .name = "" }};    /* array of 100 records */
    size_t nrec = 0;                        /* number of records from file */
    long nbytes = 0;                        /* number of bytes in file */
    char *fn = argc > 1 ? argv[1] : "dat/records.bin";
    FILE *fp = fopen (fn, "rb");

    if (!fp) {  /* validate file open for reading */
        fprintf (stderr, "error: file open failed '%s'.\n", argv[1]);
        return 1;
    }

    if (fseek (fp, 0, SEEK_END) == -1) {    /* validate seek to end */
        perror ("fseek");
        return 1;
    }
    nbytes = ftell (fp);                    /* number of bytes in file */
    if (nbytes == -1) {
        perror ("ftell");
        return 1;
    }
    if (fseek (fp, 0, SEEK_SET) == -1) {    /* validate seek to start */
        perror ("fseek");
        return 1;
    }

    if (nbytes % sizeof *rec != 0) /* does file contain even no. or records? */
        fprintf (stderr, "warning: file size not multiple of record size.\n");

    nrec = nbytes / sizeof *rec;   /* number of records based on file size */

    /* read / validate nrec records from file */
    if (fread (rec, sizeof *rec, nrec, fp) != nrec) {
        perror (fn);
        return 1;
    }
    fclose (fp);    /* close file */

    printf ("\n=== unsorted records ===\n\n");  /* output unsorted */
    for (size_t i = 0; i < nrec; i++)
        printf ("%-32s  %g\n", rec[i].name, rec[i].value);

    qsort (rec, nrec, sizeof *rec, reccmpname); /* qsort records */

    printf ("\n=== sorted records ===\n\n");    /* output sorted */
    for (size_t i = 0; i < nrec; i++)
        printf ("%-32s  %g\n", rec[i].name, rec[i].value);

    return 0;
}

注意:所使用的数据文件仅包含 100 个结构记录，其中字典单词作为 name，随机值作为 value 在写入之前进行了打乱文件。

示例使用/输出

$ ./bin/struct_rd_name_val_recs

=== unsorted records ===

Abscess                           4.15871e+08
Abject                            3.5743e+08
Abo                               6.87659e+08
Aboard                            2.02028e+09
Abase                             3.34319e+08
...
=== sorted records ===

A                                 3.66907e+08
Aaa                               5.59224e+07
Aaas                              1.45617e+09
Aardvark                          1.72828e+09
Aarhus                            1.95723e+09

如果您有任何问题，请告诉我。