二进制文件读写两个重要的函数 , fread 和 fwrite , fread 用于读取文件 , fwrite 用于写出文件 ;

fread / fwrite 函数 既可以操作 二进制文件 , 又可以操作 文本文件 ;

getc / putc 函数 , fscanf / fprintf 函数 , fgets / fgets 函数 , 只能用于操作 文本文件 ;

一、fread 函数

fread 函数作用 : 从文件中读取若干字节数据到内存缓冲区中 ;

fread 函数原型 :

size_t fread( void *buffer, size_t size, size_t count, FILE *stream );

void *buffer 参数 : 将文件中的二进制数据读取到该缓冲区中 ;

size_t size 参数 : 读取的 基本单元 字节大小 , 单位是字节 , 一般是 buffer 缓冲的单位大小 ;

• 如果 buffer 缓冲区是 char 数组 , 则该参数的值是 sizeof(char) ;
• 如果 buffer 缓冲区是 int 数组 , 则该参数的值是 sizeof(int) ;

size_t count 参数 : 读取的 基本单元 个数 ;

FILE *stream 参数 : 文件指针 ;

size_t 返回值 : 实际从文件中读取的 基本单元 个数 ; 读取的字节数是 基本单元数 * 基本单元字节大小 ;

代码示例 : 一次性读满整个缓冲区 ;

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};

    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    fread(buffer, sizeof(char), sizeof(buffer), p);

    // 打印读取的内容
    printf("buffer = %s\n", buffer);

    printf("Main End\n");
    return 0;
}

执行结果 :

二、缓冲区受限的情况 ( 循环读取文件 | feof 函数判定文件读取完毕 )

假设缓冲区很小 , 文件很大 , 则需要循环读取文件数据 ;

使用 feof(p) 判定文件是否读取完毕 , 如果返回 true 说明文件没有读取完毕 , 返回 false , 说明文件读取完毕 ;

代码示例 :

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[4] = {0};

    while(!feof(p)){
        memset(buffer, 0, sizeof(buffer));
        // buffer : 将文件读取到内存的位置
        // sizeof(char) : 读取的基本单元字节长度
        // sizeof(buffer) : 读取的基本单元个数,
        //       读取字节个数是 sizeof(buffer) * sizeof(char)
        // p : 文件指针
        fread(buffer, sizeof(char), sizeof(buffer), p);

        // 打印读取的内容
        printf("buffer = %s\n", buffer);
    }

    printf("Main End\n");
    return 0;
}

执行结果 : 读取之后出现乱码 , 这是由于每次读取 $10$ 字节 , 但是字符串必须要以 ‘\0’ 进行结尾 , 如果没有 ‘\0’ 则会一直读取直到出现 ‘\0’ 字符串结尾位置 ;

三、处理乱码问题

为了避免上述打印出现乱码的情况 , char buffer[4] = {0}; 准备了 $4$ 字节缓冲区 , 每次只使用其中的 $3$ 个字节 , 这就能保证最后一个字节必定是 ‘\0’ , 打印时就不会出现乱码 ;

代码示例 :

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[4] = {0};

    while(!feof(p)){
        memset(buffer, 0, sizeof(buffer));
        // buffer : 将文件读取到内存的位置
        // sizeof(char) : 读取的基本单元字节长度
        // sizeof(buffer) : 读取的基本单元个数,
        //       读取字节个数是 sizeof(buffer) * sizeof(char)
        // p : 文件指针
        fread(buffer, sizeof(char), sizeof(buffer) - 1, p);

        // 打印读取的内容
        printf("buffer = %s\n", buffer);
    }

    printf("Main End\n");
    return 0;
}

执行结果 : 每次从文件中读取 缓冲区字节数 - 1 个字节 , 则能完整的将文本打印出来 ;

四、记录读取的字节个数

fread 函数返回值表示读取到的 基本单元 的个数 , 如果设置了 1KB 的缓冲区 , 但是文件中只有 5 字节 , 则 fread 的返回值就是实际读取到的数据个数 ;

代码示例 :

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};
    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    // 返回值 : fread 函数返回值表示读取到的 基本单元 的个数
    size_t count = fread(buffer, sizeof(char), sizeof(buffer) - 1, p);

    // 打印读取的内容
    printf("buffer = %s , read count = %u\n", buffer, count);

    printf("Main End\n");
    return 0;
}

执行结果 :

五、读取到 0 字节的情况

如果 基本单元 大小 $4$ 字节 , 文件中只有 $3$ 字节数据 , 则使用 fread 函数读取文件 , 缓冲区设置 1KB , 则实际读取到的基本单元个数是 $0$ ;

代码示例 :

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};
    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    // 返回值 : fread 函数返回值表示读取到的 基本单元 的个数
    size_t count = fread(buffer, sizeof(int), sizeof(buffer) - 1, p);

    // 打印读取的内容
    printf("buffer = %s , read count = %u\n", buffer, count);

    printf("Main End\n");
    return 0;
}

执行结果 :

六、读取完毕的情况

如果文件已经读取完毕 , 不关闭文件 , 再次调用 fread 函数继续读取 , 则读取到的 基本单元 个数是 $0$ ;

使用 feof(p) 判定文件是否读取完毕 , 如果返回 true 说明文件没有读取完毕 , 返回 false , 说明文件读取完毕 ;

代码示例 :

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};
    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    // 返回值 : fread 函数返回值表示读取到的 基本单元 的个数
    size_t count = fread(buffer, sizeof(char), sizeof(buffer) - 1, p);

    // 打印第一次读取的内容
    printf("First fread : buffer = %s , read count = %u\n", buffer, count);

    count = fread(buffer, sizeof(int), sizeof(buffer) - 1, p);

    // 打印第二次读取的内容
    printf("Second fread : buffer = %s , read count = %u\n", buffer, count);

    printf("Main End\n");
    return 0;
}

执行结果 :

七、读取文本文件 “\n” 与 读取二进制文件 “\r\n” 区别

以下区别只在 Windows 系统存在 , 在 Linux / Unix 中读取文本数据与二进制数据没有区别 ;

使用 ‘rb’ 方式打开文件 , 读取二进制文件 , 然后调用 fread 函数读取文件 ,

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "rb");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};
    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    // 返回值 : fread 函数返回值表示读取到的 基本单元 的个数
    size_t count = fread(buffer, sizeof(char), sizeof(buffer) - 1, p);

    // 打印第一次读取的内容
    printf("fread : buffer = %s , read count = %u\n", buffer, count);

    // 逐个字节打印读取出数据的 ASCII 码
    int i = 0;
    for(i = 0; i < count; i ++){
        printf("buffer[%d] = %x\n", i, buffer[i]);
    }

    printf("Main End\n");
    return 0;
}

执行结果 : 第 $2$ 个索引读取出来的值是 0xd 对应 ‘\r’ , 第 $3$ 个值是 0xa 对应 ‘\n’ ;

注意 : 最后两个字节是空行对应的 “\r\n” ;

fread : buffer = ab
cd
 , read count = 8
buffer[0] = 61
buffer[1] = 62
buffer[2] = d
buffer[3] = a
buffer[4] = 63
buffer[5] = 64
buffer[6] = d
buffer[7] = a
Main End

使用 ‘r’ 方式打开文件 , 读取文本文件 , 然后调用 fread 函数读取文件 ,

#include <stdio.h>

int main()
{
    // 使用 "rb" 读取二进制方式打开文件
    FILE *p = fopen("D:\\a.txt", "r");

    // 用于接收读取数据的缓冲区
    char buffer[1024] = {0};
    // buffer : 将文件读取到内存的位置
    // sizeof(char) : 读取的基本单元字节长度
    // sizeof(buffer) : 读取的基本单元个数,
    //       读取字节个数是 sizeof(buffer) * sizeof(char)
    // p : 文件指针
    // 返回值 : fread 函数返回值表示读取到的 基本单元 的个数
    size_t count = fread(buffer, sizeof(char), sizeof(buffer) - 1, p);

    // 打印第一次读取的内容
    printf("fread : buffer = %s , read count = %u\n", buffer, count);

    // 逐个字节打印读取出数据的 ASCII 码
    int i = 0;
    for(i = 0; i < count; i ++){
        printf("buffer[%d] = %x\n", i, buffer[i]);
    }

    printf("Main End\n");
    return 0;
}

执行结果 : 第 $2$ 个索引读取出来的值是 0xa 对应 ‘\n’ ;

最后的空行只有一个 ‘\n’ ;

fread : buffer = ab
cd
 , read count = 6
buffer[0] = 61
buffer[1] = 62
buffer[2] = a
buffer[3] = 63
buffer[4] = 64
buffer[5] = a
Main End

目录

语法

说明

示例

读取整个文件的uint8数据

读取包含双精度数据的整个文件

读取文本文件

读取文件中的选定行或列

读取二进制编码的十进制值的位数

        fread函数读取二进制文件中的数据。

语法

A = fread(fileID)

A = fread(fileID,sizeA)

A = fread(fileID,sizeA,precision)

A = fread(fileID,sizeA,precision,skip)

A = fread(fileID,sizeA,precision,skip,machinefmt)

[A,count] = fread(___)

说明

• A = fread(fileID) 将打开的二进制文件中的数据读取到列向量A中，并将文件指针定位在文件结尾标记处。该二进制文件由文件标识符fileID指示。使用fopen可打开文件并获取fileID值。读取文件后，请调用fclose(fileID) 来关闭文件。
• A = fread(fileID,sizeA) 将文件数据读取到维度为sizeA的数组A中，并将文件指针定位到最后读取的值之后。fread按列顺序填充 A。
• A = fread(fileID,sizeA, precision ) 根据precision描述的格式和大小解释文件中的值。sizeA参数为可选参数。
• A = fread(fileID,sizeA, precision ,skip) 在读取文件中的每个值之后将跳过 skip指定的字节或位数。sizeA参数为可选参数。
• A = fread(fileID,sizeA, precision ,skip,machinefmt) 另外指定在文件中读取字节或位时的顺序。sizeA和skip参数是可选的。
• [A,count] = fread(___) 还将返回 fread 读取到 A 中的字符数。可以将此语法与前面语法中的任何输入参数结合使用。

示例

读取整个文件的uint8数据

        将一个九元素向量写入到示例文件nine.bin 中。

fileID = fopen('nine.bin','w');
fwrite(fileID,[1:9]);
fclose(fileID);

        将文件中的所有数据读取到double类的向量中。默认情况下，fread 一次读取文件中的1个字节，将每个字节解释为一个8位无符号整数 (uint8)，并返回一个double数组。

fileID = fopen('nine.bin');
A = fread(fileID)
A = 9×1

     1
     2
     3
     4
     5
     6
     7
     8
     9

  fread返回一个列向量，文件中的每个字节对应一个元素。查看 A 的相关信息。

whos A
  Name      Size            Bytes  Class     Attributes

  A         9x1                72  double   

        关闭文件。

fclose(fileID);

读取包含双精度数据的整个文件

        创建一个名为 doubledata.bin 并且包含九个双精度值的文件。

fileID = fopen('doubledata.bin','w');
fwrite(fileID,magic(3),'double');
fclose(fileID);

        打开文件 doubledata.bin，并将文件中的数据读取到一个 3×3 数组 A。指定源数据为 double 类。

fileID = fopen('doubledata.bin');
A = fread(fileID,[3 3],'double')
A = 3×3

     8     1     6
     3     5     7
     4     9     2

        关闭文件。

fclose(fileID);

读取文本文件

        读取文件 fread.m 的内容。转置输出数组 A 以便其为行向量。

fileID = fopen('fread.m');
A = fread(fileID,'*char')';
fclose(fileID);

  fread 返回字符数组 A。

读取文件中的选定行或列

        创建一个名为 nine.bin 并且包含1 - 9中的值的文件。以uint16值形式写入数据。

fileID = fopen('nine.bin','w');
fwrite(fileID,[1:9],'uint16');
fclose(fileID);

        将前六个值读取到一个 3×2 数组中。指定源数据为 uint16 类。

fileID = fopen('nine.bin');
A = fread(fileID,[3,2],'uint16')
A = 3×2

     1     4
     2     5
     3     6

  fread返回使用文件nine.bin中的前六个值逐列填充的一个数组。

        返回到文件的开头。

frewind(fileID)

        一次读取两个值，并在读取下一个值之前跳过一个值。使用 precision 值 '2*uint16' 指定此格式。因为数据为 uint16 类，所以一个值由 2 个字节表示。因此，将 skip 参数指定为 2。

precision = '2*uint16';
skip = 2;
B = fread(fileID,[2,3],precision,skip)
B = 2×3

     1     4     7
     2     5     8

   fread 返回使用 nine.bin 中的值逐列填充的一个 2×3 数组。

        关闭文件。

fclose(fileID);

读取二进制编码的十进制值的位数

        创建一个包含二进制编码小数 (BCD) 值的文件。

str = ['AB'; 'CD'; 'EF'; 'FA'];

fileID = fopen('bcd.bin','w');
fwrite(fileID,hex2dec(str),'ubit8');
fclose(fileID);

        一次读取 1 个字节。

fileID = fopen('bcd.bin');
onebyte = fread(fileID,4,'*ubit8');

        显示 BCD 值。

disp(dec2hex(onebyte))
AB
CD
EF
FA

        使用frewind返回到文件的开头。如果在 little-endian 系统上一次读取 4 位数，则结果将以错误顺序显示。

frewind(fileID)

err = fread(fileID,8,'*ubit4');
disp(dec2hex(err))
B
A
D
C
F
E
A
F

        使用 frewind 返回到文件的开头。与之前一样一次读取数据的 4 位，但指定 big-endian 排序以显示正确的结果。

frewind(fileID)

correct = fread(fileID,8,'*ubit4','ieee-be');
disp(dec2hex(correct))
A
B
C
D
E
F
F
A

        关闭文件。

fclose(fileID);

        已打开二进制文件的文件标识符，指定为整数。使用fread读取文件之前，必须使用fopen打开文件并获取fileID。

        要读取的值的类和大小（以位为单位），以下列形式之一指定为字符向量或字符串标量。（可选）输入可指定输出矩阵 A 的类。

        下表显示了 source 和 output 的可能值。

        对于source的大多数值，如果 fread 在读取完整值之前达到文件的末尾，则不会返回最终值的结果。但是，如果source是bitn或ubitn，则fread将返回最后一个值的部分结果。 读取每个值之后要跳过的字节数，指定为标量。如果将precision指定为bitn或ubitn，请以位为单位指定skip。

        使用skip参数从固定长度记录的非连续字段中读取数据。读取文件中的字节的顺序，指定为字符向量或字符串标量。将 machinefmt 指定为下表中列出的值之一。对于bitn和ubitn精度，machinefmt指定字节中位的读取顺序，而字节的读取顺序仍与系统字节顺序相同。

        默认情况下，当前支持的所有平台都使用 little-endian 排序方式对新文件进行排序。现有二进制文件可以使用 big-endian 或 little-endian 排序方式。

        文件数据，以列向量形式返回。如果指定sizeA参数，则A是指定大小的矩阵。A中的数据为类double，除非在precision参数中指定不同的类。读取的字符数，以标量值形式返回。

        注：matlab读取.dat文件

file='name.dat';           
fid=fopen(file,'rb');                     %打开数据文件
data=fread(fid,[x,y],'double');             %读取文件数据
fclose(fid);                                %关闭文件