fread 订阅
从给定输入流stream读取最多count个对象到数组buffer中(相当于对每个对象调用size次fgetc),把buffer当作unsigned char数组并顺序保存结果。流的文件位置指示器前进读取的字节数。若出现错误,则流的文件位置指示器的位置不确定。若没有完整地读入最后一个元素,则其值不确定。 展开全文
从给定输入流stream读取最多count个对象到数组buffer中(相当于对每个对象调用size次fgetc),把buffer当作unsigned char数组并顺序保存结果。流的文件位置指示器前进读取的字节数。若出现错误,则流的文件位置指示器的位置不确定。若没有完整地读入最后一个元素,则其值不确定。
信息
属    性
函数
外文名
fread
参    数
buffer,size,count,stream
中文名
fread
功    能
数据读取
freadC/C++语言函数
[1]  定义于头文件从给定输入流stream读取最多count个对象到数组buffer中(相当于以对每个对象调用size次fgetc),把buffer当作unsigned char数组并顺序保存结果。流的文件位置指示器前进读取的字节数。若出现错误,则流的文件位置指示器的位置不确定。若没有完整地读入最后一个元素,则其值不确定。返回成功读取的对象个数,若出现错误或到达文件末尾,则可能小于count。若size或count为零,则fread返回零且不进行其他动作。fread不区分文件尾和错误,因此调用者必须用feof和ferror才能判断发生了什么。
收起全文
精华内容
下载资源
问答
  • Matlab中fread的功能
    2021-04-22 21:15:15

    help fread

    FREAD  Read binary data from file.

    A = FREAD(FID) reads binary data from the specified file

    and writes it into matrix A.  FID is an integer file

    identifier obtained from FOPEN.  MATLAB reads the entire

    file and positions the file pointer at the end of the file

    (see FEOF for details).

    A = FREAD(FID,SIZE) reads the number of elements specified

    by SIZE.  Valid entries for SIZE are:

    N      read N elements into a column vector.

    inf    read to the end of the file.

    [M,N]  read elements to fill an M-by-N matrix, in column order.

    N can be inf, but M can't.

    A = FREAD(FID,SIZE,PRECISION) reads the file according to

    the data format specified by the string PRECISION.  The

    PRECISION input commonly contains a datatype specifier like

    'int' or 'float', followed by an integer giving the size in

    bits.  The SIZE argument is optional when using this syntax.

    Any of the following strings, either the MATLAB version, or

    their C or Fortran equivalent, may be used.  If not specified,

    the default precision is 'uchar'.

    MATLAB    C or Fortran     Description

    'uchar'   'unsigned char'  unsigned character,  8 bits.

    'schar'   'signed char'    signed character,  8 bits.

    'int8'    'integer*1'      integer, 8 bits.

    'int16'   'integer*2'      integer, 16 bits.

    'int32'   'integer*4'      integer, 32 bits.

    'int64'   'integer*8'      integer, 64 bits.

    'uint8'   'integer*1'      unsigned integer, 8 bits.

    'uint16'  'integer*2'      unsigned integer, 16 bits.

    'uint32'  'integer*4'      unsigned integer, 32 bits.

    'uint64'  'integer*8'      unsigned integer, 64 bits.

    'single'  'real*4'         floating point, 32 bits.

    'float32' 'real*4'         floating point, 32 bits.

    'double'  'real*8'         floating point, 64 bits.

    'float64' 'real*8'         floating point, 64 bits.

    The following platform dependent formats are also supported but

    they are not guaranteed to be the same size on all platforms.

    MATLAB    C or Fortran     Description

    'char'    'char*1'         character,  8 bits (signed or unsigned).

    'short'   'short'          integer,  16 bits.

    'int'     'int'            integer,  32 bits.

    'long'    'long'           integer,  32 or 64 bits.

    'ushort'  'unsigned short' unsigned integer,  16 bits.

    'uint'    'unsigned int'   unsigned integer,  32 bits.

    'ulong'   'unsigned long'  unsigned integer,  32 bits or 64 bits.

    'float'   'float'          floating point, 32 bits.

    The following formats map to an input stream of bits rather than

    bytes.

    'bitN'                     signed integer, N bits  (1<=N<=64).

    'ubitN'                    unsigned integer, N bits (1<=N<=64).

    If the input stream is bytes and FREAD reaches the end of file

    (see FEOF) in the middle of reading the number of bytes required

    for an element, the partial result is ignored. However, if the

    input stream is bits, then the partial result is returned as the

    last value.  If an error occurs before reaching the end of file,

    only full elements read up to that point are used.

    By default, numeric values are returned in class 'double' arrays.

    To return numeric values stored in classes other than double,

    create your PRECISION argument by first specifying your source

    format, then following it by '=>', and finally specifying your

    destination format. If the source and destination formats are the

    same then the following shorthand notation may be used:

    *source

    which means:

    source=>source

    For example,

    uint8=>uint8               read in unsigned 8-bit integers and

    save them in an unsigned 8-bit integer

    array

    *uint8                     shorthand version of previous example

    bit4=>int8                 read in signed 4-bit integers packed

    in bytes and save them in a signed

    8-bit integer array (each 4-bit

    integer becomes one 8-bit integer)

    double=>real*4             read in doubles, convert and save

    as a 32-bit floating point array

    A = FREAD(FID,SIZE,PRECISION,SKIP) includes a SKIP argument that

    specifies the number of bytes to skip after each PRECISION value

    is read. If PRECISION specifies a bit source format, like 'bitN' or

    'ubitN', the SKIP argument is interpreted as the number of bits to

    skip.  The SIZE argument is optional when using this syntax.

    When SKIP is used, the PRECISION string may contain a positive

    integer repetition factor of the form 'N*' which prepends the source

    format of the PRECISION argument, like '40*uchar'.  Note that 40*uchar

    for the PRECISION alone is equivalent to '40*uchar=>double', not

    '40*uchar=>uchar'.  With SKIP specified, FREAD reads in, at most, a

    repetition factor number of values (default of 1), does a skip of

    input specified by the SKIP argument, reads in another block of values

    and does a skip of input, etc. until SIZE number of values have been

    read.  If a SKIP argument is not specified, the repetition factor is

    ignored.  Repetition with skip is useful for extracting data in

    noncontiguous fields from fixed length records.

    For example,

    s = fread(fid,120,'40*uchar=>uchar',8);

    reads in 120 characters in blocks of 40 each separated by 8

    characters.

    A = FREAD(FID,SIZE,PRECISION,SKIP,MACHINEFORMAT) treats the data

    read as having a format given by the string MACHINEFORMAT. You

    can obtain the MACHINEFORMAT argument from the output of the

    FOPEN function.   The SIZE and SKIP arguments are optional when

    using this syntax.

    MACHINEFORMAT is one of the following strings:

    Full Precision Support:

    'native'      or 'n' - local machine format - the default

    'ieee-le'     or 'l' - IEEE floating point with little-endian

    byte ordering

    'ieee-be'     or 'b' - IEEE floating point with big-endian

    byte ordering

    'vaxd'        or 'd' - VAX D floating point and VAX ordering

    'vaxg'        or 'g' - VAX G floating point and VAX ordering

    'ieee-le.l64' or 'a' - IEEE floating point with little-endian

    byte ordering and 64 bit long data type

    'ieee-be.l64' or 's' - IEEE floating point with big-endian byte

    ordering and 64 bit long data type.

    Limited Precision Support: (double or equivalent)

    'cray'        or 'c' - Cray floating point with big-endian

    byte ordering

    See FOPEN on how to read Big and Little Endian files.

    [A, COUNT] = FREAD(...) Optional output argument COUNT returns

    the number of elements successfully read.

    Examples:

    The file alphabet.txt contains the 26 letters of the English

    alphabet, all capitalized. Open the file for read access with

    fopen, and read the first five elements into output c. Because

    a precision has not been specified, MATLAB uses the default

    precision of uchar, and the output is numeric:

    fid = fopen('alphabet.txt', 'r');

    c = fread(fid, 5)'

    c =

    65    66    67    68    69

    fclose(fid);

    This time, specify that you want each element read as an unsigned

    8-bit integer and output as a character. (Using a precision of

    'char=>char' or '*char' will produce the same result):

    fid = fopen('alphabet.txt', 'r');

    c = fread(fid, 5, 'uint8=>char')'

    c =

    ABCDE

    fclose(fid);

    See also fwrite, fseek, fscanf, fgetl, fgets, load, fopen, feof.

    Overloaded functions or methods (ones with the same name in other directories)       help serial/fread.m       help udp/fread.m       help icinterface/fread.m

    更多相关内容
  • 为什么fread(),fwrite()的返回值总是为0,但是文件读写正常 初学C语言文件操作的新人,总会犯这个错误,明明文件读 写成功 ,但是返回值总是为0,而不是读写成功的字节数,原因是因为...
  • php fread函数用于读取文件(可安全用于二进制文件),其语法是fread(file,length),参数file必需,指规定要读取打开文件,length 必需,指规定要读取的最大字节数。 php fread函数怎么用? 定义和用法 fread() 函数...
  • php fread函数用于从文件中读取一定长度的字符,本文章向大家介绍fread读取文件的实例以及使用该函数读取文件需要注意的几个地方,需要的朋友可以参考一下。
  • 【C 语言】文件操作 ( fread 函数 )

    千次阅读 多人点赞 2021-05-27 21:48:00
    一、fread 函数、 二、缓冲区受限的情况 ( 循环读取文件 | feof 函数判定文件读取完毕 )、 三、处理乱码问题、 四、记录读取的字节个数、 五、读取到 0 字节的情况、 六、读取完毕的情况、 七、读取文本文件 "\n" 与...



    二进制文件读写两个重要的函数 , 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 10 10 字节 , 但是字符串必须要以 ‘\0’ 进行结尾 , 如果没有 ‘\0’ 则会一直读取直到出现 ‘\0’ 字符串结尾位置 ;

    在这里插入图片描述



    三、处理乱码问题



    为了避免上述打印出现乱码的情况 , char buffer[4] = {0}; 准备了 4 4 4 字节缓冲区 , 每次只使用其中的 3 3 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 4 4 字节 , 文件中只有 3 3 3 字节数据 , 则使用 fread 函数读取文件 , 缓冲区设置 1KB , 则实际读取到的基本单元个数是 0 0 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 0 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 2 2 个索引读取出来的值是 0xd 对应 ‘\r’ , 第 3 3 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 2 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
    

    在这里插入图片描述

    展开全文
  • 随读 Fread 批量文本转MP3,同时可以制作LRC,之前传的版本不能转,音质有所提高,有中英文混渎插件,设置好中英文语音库,才能正常使用。绿色软件,解压可用。
  • fread是一个函数,它从文件流中读数据,最多读取count个项,每个项size个字节,如果调用成功返回实际读取到的项个数(小于或等于count),如果不成功或读到文件末尾返回0。返回真实读取的项数,若大于count则意味着...

    fread是一个函数,它从文件流中读数据,最多读取count个项,每个项size个字节,如果调用成功返回实际读取到的项个数(小于或等于count),如果不成功或读到文件末尾返回0。返回真实读取的项数,若大于count则意味着产生了错误。另外,产生错误后,文件位置指示器是无法确定的。若其他stream或buffer为空指针,或在unicode模式中写入的字节数为奇数,此函数设置errno为EINVAL以及返回0.

    fread函数——c语言中fread函数怎么用

    C语言中:fread是一个函数。从一个文件流中读数据,最多读取count个元素,每个元素size字节,如果调用成功返回实际读取到的元素个数,如果不成功或读到文件末尾返回0。函数原型:size_tfread(void*buffer,size_tsize,size_tcount,FILE*stream);参数:buffer用于接收数据的内存地址size要读的每个数据项的字节数,单位是字节count要读数据项的个数,每个数据项size个字节.stream输入流的指针返回值:返回实际读取的元素个数。如果返回值与count不相同,则可能文件结尾或发生错误。从ferror和feof获取错误信息或检测是否到达文件结尾。

    da30dc76df12f7a319140c905f3a5811.png

    C中fread()函数的返回值

    这个问题很容易搞错,并导致很多问题,需要强调的是fread函数返回的并不是字节数。

    realRead=fread(buf,item,count,fp)(每次读item大小的数据块,分count次来读。)

    而是返回的是成功有效的读取的item元素的个数,而成功读入的字节数则是realRead*sizeof(item)

    一般说来realRead是小于count的,很巧的情况就刚好为count.除非文件大小刚好为item大小的整数倍。

    返回的是真实读入item元素的个数,虽然读了count次,但是真正读到的有效个数为realRead个

    真实读入字节数就为realRead*sizeof(item)

    RETURNVALUE

    freadandfwritereturnthenumberofitemssuccessfullyreadorwritten(i.e.,notthenumberof

    characters).Ifanerroroccurs,ortheend-of-fileisreached,thereturnvalueisashortitem

    count(orzero).

    freaddoesnotdistinguishbetweenend-of-fileanderror,andcallersmustusefeof(3)andferror(3)

    todeterminewhichoccurred.

    fread(从文件流读取数据)

    表头文件#include

    定义函数size_tfread(void*ptr,size_tsize,size_tcount,FILE*stream);

    函数说明fread()用来从文件流中读取数据。参数stream为已打开的文件指针,参数ptr指向欲存放读取进来的数据空间,读取的字节数以参数size*count来决定。

    Fread()会返回实际读取到的count数目,如果此值比参数count来得小,则代表可能读到了文件尾了或者有错误发生(前者几率大),这时必须用feof()或ferror()来决定发生什么情况。

    返回值返回实际读取到的count数目。

    fread返回的不是字节数,

    当且仅当下面这么用的时候,返回值才是字节数(当然因为恰好一个数据块大小为1个字节,相当于realRead*1)

    charbuff[size];

    FILE*fp;

    realRead=fread(buff,1,size,fp);

    如果是:fread(buff,size,1,fp)

    返回1表示读取了size字节,返回0表示读取数量不够size字节

    直接在文件中读写结构体的程序是不可移植的,如果在一种平台上编译运行writebin.c程序,把生成的recfile文件拷到另一种平台并在该平台上编译运行readbin.c程序,则不能保证正确读出文件的内容,因为不同平台的大小端可能不同(因而对整型数据的存储方式不同),如果大家还想了解更多与之有关的信息,欢迎关注我们

    推荐阅读

    fwrite函数 fwrite函数用法 | 文军营销fwrite()是C语言标准库中的一个文件处理函数,C语言函数,向文件写入一个数据块,功能是向指定的文件中写入若干数据块,如成功执行则返回实际写入的数据块数目。...floor函数 C语言中floor函数如何使用 | 文军营销在c语言编程的过程当中,我们经常可以看到floor函数,floor在英文当中是地板的意思,那么在c语言当中是什么意思呢?接下来我们就一起来好好的了解一下这一个函数的基本语法和使用方式吧。 floor函数——floor函数基本语法 ...sqrt函数怎么使用 C语言中的sqrt函数使用方法介绍 | 文军营销sqrt函数是什么函数?sqrt函数怎么使用呢?对于这两个问题,相信这是很多第一次看到该函数人最先想到的问题,当然这两个问题也是了解该函数最主要的方面。因此今天小编就来说一说在c语言当中sqrt函数是如何使用的。

    展开全文
  • C语言读写二进制文件的使用
  • Matlab中fread函数用法

    千次阅读 2020-12-22 09:44:27
    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,...

    目录

    语法

    说明

    示例

    读取整个文件的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) 另外指定在文件中读取字节或位时的顺序。sizeAskip参数是可选的。
    • [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

    sizeA 输入的格式输出数组 A 的维度。
    Inf列向量,其中的每个元素包含文件中的一个值。
    n具有 n 个元素的列向量。
    [m,n]m×n 矩阵,按列顺序填充。n可以为 Inf,但m不能为该值。

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

    precision 输入的格式说明
    source输入值属于source指定的类。输出矩阵A为类 double
    示例:'int16'
    source=>output输入值属于 source 指定的类。输出矩阵 A 的类由 output 指定。
    示例:'int8=>char'
    *source输入值和输出矩阵 A 属于 source 指定的类。对于 bitn 或 ubitn 精度,输出具有可包含输入的最小类。
    例如:'*ubit18'
    这等同于 'ubit18=>uint32'

    N*source 或
    N*source=>output

    在跳过 skip 参数指定的字节数之前读取 N 值。
    例如:'4*int8'

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

    值类型精度位(字节)

    无符号整数

    'uint'

    32 (4)

    'uint8'

    8 (1)

    'uint16'

    16 (2)

    'uint32'

    32 (4)

    'uint64'

    64 (8)

    'uchar'

    8 (1)

    'unsigned char'

    8 (1)

    'ushort'

    16 (2)

    'ulong'

    32 (4)

    'ubitn'

    1 ≤ n ≤ 64

    有符号整数

    'int'

    32 (4)

    'int8'

    8 (1)

    'int16'

    16 (2)

    'int32'

    32 (4)

    'int64'

    64 (8)

    'integer*1'

    8 (1)

    'integer*2'

    16 (2)

    'integer*4'

    32 (4)

    'integer*8'

    64 (8)

    'schar'

    8 (1)

    'signed char'

    8 (1)

    'short'

    16 (2)

    'long'

    32 (4)

    'bitn'

    1 ≤ n ≤ 64

    浮点数

    'single'

    32 (4)

    'double'

    64 (8)

    'float'

    32 (4)

    'float32'

    32 (4)

    'float64'

    64 (8)

    'real*4'

    32 (4)

    'real*8'

    64 (8)

    字符

    'char*1'

    8 (1)

    'char'

    依赖于与文件关联的编码方案。使用fopen设置编码。

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

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

    'n' 或 'native'

    系统字节排序方式(默认)

    'b' 或 'ieee-be'

    Big-endian 排序

    'l' 或 'ieee-le'

    Little-endian 排序

    's' 或 'ieee-be.l64'

    Big-endian 排序,64 位长数据类型

    'a' 或 'ieee-le.l64'

    Little-endian 排序,64 位长数据类型

            默认情况下,当前支持的所有平台都使用 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);                                %关闭文件

    展开全文
  • fread和fwrite用法详解

    2021-05-13 09:25:12
    1、fwrite的用法。...是数据项item的大小,这里需要说明的是,读写函数fread()和fwrite()是按照数据项item来读写的,一次读或者写一个数据项,而不是按照字节读写的。数据项可以是一个int数据,char...
  • fread语法:string fread ( resource $handle , int $length )fread()读取到的字节长度由处理引用的文件指针。读尽快停止对符合下列条件之一:已经读取的字节长度!eof(文件结束)达到一包可用网络(流)已阅读8192字节...
  • fread

    2015-12-10 20:33:58
    [转自 http://blog.csdn.net/foxliucong/article/details/4736956和http://blog.csdn.net/abclixu123/article/details/8284680 ] 1 fread(从文件流读取数据) ... 定义函数 size_t fread(void * ptr,si
  • 说明 string fread ( int handle, int length ) fread() 从文件指针 handle 读取最多 length 个字节。该函数在读取完最多 length 个字节数,或到达 EOF 的时候,或(对于网络流)当一个包可用时,或(在打开用户空间...
  • fread和fwrite是一对,用fwrite写的必须用fread来读。 同样的数据,使用fprintf和fwrite写下去的是不一样的,但是使用其相应的读命令读上来的数据会是一样的。 文件格式:文本文件(ASCII文件)和二进制文件。我们...
  • fread函数返回值

    2021-05-14 13:49:21
    fread函数原型:size_tfread (void*buffer,size_tsize,size_tcount,FILE*stream) ;size和count的含义:每次读count个块,每块为size字节fread的返回值含义为:读到的块数,假定现在返回值为num(size太具有歧义,会让...
  • C语言实现文件的拷贝,主要利用函数 fread 和 函数 fwrite ,主要介绍了读取到文件末尾的数据该如何做的内容。
  • fread.ui是电子书设备的 GNU / Linux发行版的正在进行的电子书阅读器,Web浏览器和主要UI。 fread.ui旨在在总内存为256 MB的系统上良好运行,同时提供现代电子书阅读器期望的所有高级文本呈现选项(使用webkit)。 ...
  • c语言中fread的用法

    2021-05-19 10:50:07
    fread是以记录为单位的I/O函数,fread和fwrite函数一般用于二进制文件的输入输出。下面小编就跟你们详细介绍下c语言中fread的用法,希望对你们有用。c语言中fread的用法如下:#include size_t fwrite(const void *...
  • C语言fread函数

    2021-05-20 18:37:23
    我再继续做那个课程表程序,既然有了fwrite就会有fread,下面我就把我整理的fread函数的相关用法和注意事项,分享给大家。fread是一个函数。从一个文件流中读数据,最多读取count个元素,每个元素size字节,如果调用...
  • fread函数的返回值

    2022-03-10 18:08:59
    size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream); //每次写入size个 读取nmemb次 size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream); 返回值 RETURN VALUE On ...
  • 作者 : 卿笃军 函数原型 size_t fread ( void * buffer , size_t size , size_t count , FILE * stream ) ; 参 数 buffer 用于接收数据的 内存地址 size 要读写的字节数 ,单位是字节 count 要进行读写多少...
  • 一.fread 函数简介 二.fread 函数使用 三.猜你喜欢 零基础 C/C++ 学习路线推荐 : C/C++ 学习目录 >> C 语言基础入门 一.fread 函数简介 C 语言 fread 函数用于读取文件中的数据到指定缓冲区中,fread 函数...
  • 对我而言, fread的主要调用形式是这样的:data = fread(fid, N, 'str')fid不用说,自然是文件句柄(如fid=fopen('abc.txt' ,'r')),N是读入的元素个数,'str'是格式。在以前不会用的时候,格式...
  • c语言fread函数的用法

    千次阅读 2021-05-22 03:44:26
    C语言中:fread是一个函数。从一个文件流中读数据,最多读取count个元素,每个元素size字节,如果调用成功返回实际读取到的元素个数,如果不成功或读到文件末尾返回 0。下面我们来看看c语言fread函数的用法。fread()...
  • fread的超时时间

    2021-04-26 20:59:51
    fread的超时时间如果我不发送该字符串,那么我在PHP中的fread将永远被阻塞。// PHP代码$id = 'done'; //Unique string$app = 'c:/wamp/www/tcl/bin/tclsh84.exe';$descriptorspec = array(0 => ar...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,412
精华内容 40,964
关键字:

fread

友情链接: OpenPLC Firmware.rar