C 具有unistd.h读/写功能的读写结构

我正在学习UNIX编程，并尝试读/写系统调用。 我有一个包含一对整数的文件：

4 5

我写这段代码是为了读取数字：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

typedef struct prova {
    int first;
    int second;
} prova_t;

int main(void) {
    int fd;
prova_t origin;
prova_t result;
ssize_t bytes_read;
size_t nbytes;

fd = open("file.bin", O_WRONLY | O_CREAT);
origin.first = 24;
origin.second = 3;
write(fd, &origin, sizeof(prova_t));
close(fd);


fd = open("file.bin", O_RDONLY);
nbytes = sizeof(prova_t);
/* 1.BAD */
bytes_read = read(fd, &result, nbytes);
write(STDOUT_FILENO, &(result.first), sizeof(int));
write(STDOUT_FILENO, &(result.second), sizeof(int));
close(fd);

    /* 2.GOOD */
    nbytes = sizeof(int);
    bytes_read = read(fd, &(result.first), nbytes);
    write(STDOUT_FILENO, &(result.first), bytes_read);
    bytes_read = read(fd, &(result.second), nbytes);
    write(STDOUT_FILENO, &(result.second), bytes_read);

    return 0;
}

在我的第二次尝试中，我一个接一个地读取数字，输出中没有问题

有没有办法用第一种方法读写结构

---

编辑：我更新了代码以反映其他用户的建议，但仍然从文件名中获得奇怪的字符而不是数字，我假设您正在尝试读取文本文件。从unistd读取。h从二进制文件读取。如果您确实试图读取文本文件，则应使用或

要读取二进制结构，请执行以下操作：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

typedef struct prova {
    int first;
    int second;
} prova_t;

int main(void) {
    int fd;
    prova_t result;
    ssize_t bytes_read;
    size_t nbytes;
    prova_t initial;

    // create a binary file
    fd = open("file.bin", O_WRONLY | O_CREAT);
    initial.first = 4;
    initial.second = 5;
    write(fd, &initial, sizeof(prova_t));
    close(fp);

    // read it back
    fd = open("file.bin", O_RDONLY);
    nbytes = sizeof(prova_t);
    bytes_read = read(fd, &result, nbytes);
    write(STDOUT_FILENO, &(result.first), sizeof(int));
    write(STDOUT_FILENO, &(result.second), sizeof(int));
    close(fp);

    return 0;
}

#包括
#包括
#包括
#包括
#包括
typedef结构prova{
int优先；
int秒；
}证明；
内部主（空）{
int-fd；
证明结果；
ssize_t字节_u u读取；
大小n字节；
提供首字母；
//创建一个二进制文件
fd=打开（“file.bin”，O|u WRONLY | O|u CREAT）；
初始值=4；
初始秒=5；
写入（fd和首字母，尺寸（prova_t））；
关闭（fp）；
//读回
fd=打开（“file.bin”，仅限ordu）；
nbytes=尺寸（证明）；
字节\读取=读取（fd和结果，N字节）；
写入（STDOUT_FILENO，&（result.first），sizeof（int））；
写入（STDOUT_FILENO，&（result.second），sizeof（int））；
关闭（fp）；
返回0；
}

您试图读取包含两个int的结构，方法是传递指向某些数据的指针，并告诉read您有一个int的存储空间。第一个应该是

bytes_read = read(fd, &result, sizeof(prova_t));

---

首先，让我们做一个十六进制转储，看看文件中真正存储了什么

hextump-cb.txt

或

od-tx2-tcb.txt

是两个例子（od是八进制转储，在我看来更常见，输出不太漂亮）

如果文件是作为ASCII文本文件创建的（例如使用像vi这样的文本编辑器），那么它就是这个文件的样子。您可以使用

man ascii

双重检查十六进制值

现在，如果您的二进制文件只包含两个8位字节，在系统的本机字节顺序中（例如，x86的小端字节，MIPS的大端字节，PA-RISC，680x0），那么hextump将如下所示：

00000000  04  05                                            |..|
00000004

00000000  04 00 00 00 05 00 00 00                           |........|
00000008

下面是创建（打开和写入）二进制文件并将其读回的代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>     /* uint32_t */
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

/* User has read & write perms, group and others have read permission */ 
const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;

typedef struct prova {
   uint32_t first;
   uint32_t second;
} prova_t;

#define FILENAME "file.b"

/* 'Safe' write */
int safewrite( int fd, const void *p, size_t want) {
   int ret;

   errno = 0;
   while (want) {
      ret = write(fd, (uint8_t *)p, want);
      if (ret <= 0) {
         if (errno != EINTR && errno != EAGAIN) {
            return -1;
         }
         errno = 0;
         continue;
      }
      want -= ret;
      p = (uint8_t*) p + ret;
   }
   return 0;
}

int saferead(int fd, const void *p, size_t want) {
   int ret;

   errno = 0;
   while (want) {
      ret = read(fd, (uint8_t*)p, want);
      if( ret == 0 )
         return -1;  /* EOF */
      if (ret <= 0) {
         if( errno != EINTR && errno != EAGAIN ) {
            return -1;
         }
         errno = 0;
         continue;
      }
      want -= ret;
      p = (uint8_t*) p + ret;
   }
   return 0;
}


int main(int argc, char **argv) {
   int fd;
   prova_t result;
   size_t nbytes;

   /* Create file */
   fd = creat(FILENAME, mode);
   if (fd < 0) {
      fprintf(stderr, "Unable to open " FILENAME ": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }
   nbytes = sizeof(prova_t);

   result.first = 4;
   result.second = 5;

   if (0 != safewrite(fd, &result, nbytes)) {
      fprintf(stderr, "Unable to write to " FILENAME ": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }

   close(fd);
   fd = -1;

   /* Reopen and read from binary file */
   fd = open(FILENAME, O_RDONLY);
   nbytes = sizeof(prova_t);

   if (0 != saferead(fd, &result, nbytes)) {
      fprintf(stderr, "Unable to read file \"" FILENAME "\": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }
   close(fd);

   printf( "Read: %d %d (%#.02x%.02x)\n",
         result.first, result.second,
         result.first, result.second);

   return EXIT_SUCCESS;
}

---

因为整数被指定为32位整数（32位/8位/字节=4字节）。我使用的是64位系统（little-endian，x86），所以我希望显式，以便您的结果应该匹配，假设little-endian。

包括flatbuffers/util.h，分别有save和load函数

SaveFile（const char*name，const char*buf，size\t len，
布尔二进制）

LoadFile（const char*name，bool二进制，std:：string*buf）
谢谢：这是剪切粘贴中的一个输入错误。现在是正确的，但输出总是被破坏谢谢。我知道还有其他的方法：我在问是否可以只使用写/读系统调用来读取然后在stdout结构上打印。嗯，这是有道理的，但它不起作用。它只打印奇怪的字符：（这是因为二进制数直接写入stdout，而不是将其转换为文本。例如，要使用write（）查看字符“4”的显示），您必须将其数值写入36。@Lars：我会对您的评论进行投票，但“4”的ASCII值为0x34=52@ninjalj你说得对-我不应该用内存写。DeadMG是对的，但我想知道是否还有其他方面：你的输入文件是否包含文本“4 5”，还是以二进制形式保存数字4和5的二进制文件？阅读其他建议我尝试使用write和Reading-back在文件上编写结构，但问题仍然存在。我更新了代码我应该注意一个非常重要的细节，因为在读取过程中处理二进制文件时，不能依赖将结构作为在C语言中，编译器有权以静默方式填充结构以对齐结构成员，以便在内存边界上访问。参考：和Michael Crawford的+1用于实际执行正确的操作，即检查实际读取或写入的字节数。
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdint.h>     /* uint32_t */
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

/* User has read & write perms, group and others have read permission */ 
const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;

typedef struct prova {
   uint32_t first;
   uint32_t second;
} prova_t;

#define FILENAME "file.b"

/* 'Safe' write */
int safewrite( int fd, const void *p, size_t want) {
   int ret;

   errno = 0;
   while (want) {
      ret = write(fd, (uint8_t *)p, want);
      if (ret <= 0) {
         if (errno != EINTR && errno != EAGAIN) {
            return -1;
         }
         errno = 0;
         continue;
      }
      want -= ret;
      p = (uint8_t*) p + ret;
   }
   return 0;
}

int saferead(int fd, const void *p, size_t want) {
   int ret;

   errno = 0;
   while (want) {
      ret = read(fd, (uint8_t*)p, want);
      if( ret == 0 )
         return -1;  /* EOF */
      if (ret <= 0) {
         if( errno != EINTR && errno != EAGAIN ) {
            return -1;
         }
         errno = 0;
         continue;
      }
      want -= ret;
      p = (uint8_t*) p + ret;
   }
   return 0;
}


int main(int argc, char **argv) {
   int fd;
   prova_t result;
   size_t nbytes;

   /* Create file */
   fd = creat(FILENAME, mode);
   if (fd < 0) {
      fprintf(stderr, "Unable to open " FILENAME ": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }
   nbytes = sizeof(prova_t);

   result.first = 4;
   result.second = 5;

   if (0 != safewrite(fd, &result, nbytes)) {
      fprintf(stderr, "Unable to write to " FILENAME ": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }

   close(fd);
   fd = -1;

   /* Reopen and read from binary file */
   fd = open(FILENAME, O_RDONLY);
   nbytes = sizeof(prova_t);

   if (0 != saferead(fd, &result, nbytes)) {
      fprintf(stderr, "Unable to read file \"" FILENAME "\": %s\n",
            strerror(errno));
      exit(EXIT_FAILURE);
   }
   close(fd);

   printf( "Read: %d %d (%#.02x%.02x)\n",
         result.first, result.second,
         result.first, result.second);

   return EXIT_SUCCESS;
}

00000000  04 00 00 00 05 00 00 00                           |........|
00000008