fread读取整个文件,fread函数怎么读取文件的全部内容
fread读取整个文件,fread函数怎么读取文件的全部内容详细介绍
本文目录一览： fread函数的用法
fread函数可从文件中读取二进制数据。
语法：
A＝fread（fid，count）
A＝fread（fid，count，precision）
其中fid为指针所指文件中的当前位置，count指读取的数据个数，precision表示以什么格式的数据类型读取数据。
fread：从给定输入流stream读取最多count个对象到数组buffer中（相当于以对每个对象调用count次fgetc），把buffer当作unsignedchar数组并顺序保存结果。流的文件位置指示器前进读取的字节数。
R语言 -- fread() 函数快速读取大表格
平时读取一个表格文件通常使用 read.table 函数，但当遇到上百M或上G的文件时，就读的非常慢了。
有个函数 fread() ，来自 data.table 包，可以更快地读取表格文件，速度可以快 近十倍 。
比如现在有个基因组注释文件 Homo_sapiens.GRCh37.87.gtf ，大小为1.1G，分别使用 read.table() 和 fread() 读取所用的时间分别为：
时间分别为30s 和 4s ！
而且对于很大的表格，fread()还会提供读取进度条，非常滴友好~
fread函数怎么读取文件的全部内容
fread是一个函数。从一个文件流中读数据，最多读取count个元素，每个元素size字节，如果调用成功返回实际读取到的元素个数，如果不成功或读到文件末尾返回 0。 函数原型 size_t fread ( void *buffer, size_t size, size_t count, FILE *stream)...
matlab 中关于fread函数的用法
“fread”以二进制形式，从文件读出数据。
语法1：[a,count]=fread(fid,size,precision)
语法2：[a,count]=fread(fid,size,precision,skip)
size: 不指定 ：到尾返回读。
N : 读出N个数据，构成列向量。
inf : 读出fid指向的打开的文件的全部数据。
[M,N] : 读出N个数据，构成列向量，填入M*N矩阵
precision(精度)
precision(精度)规定了以浮点数、整型数、字符读出时位。matlab 的precision(精度)的表达式与c语言、fortran语言、是一致的。不规定precision(精度)，则字符默认为： ucher、则数值默认为：双精度 。
以下precision(精度)将保证读出具有一致的体积。
MATLAB C or Fortran Descriphon(精度)
'char' 'char*l' 8 位，字符型
'uchar' 'unsigned char' 8 位
'schar' 'signed char' 8 位，字符型
'int8' 'integer*1' 8 位，整型数
'intl6' 'integer*2' 16 位，整型数.
'int32' 'integer*4' 32 位，整型数.
'int64' 'integer*8' 64 位，整型数
'uint8' 'integer*l' 8 位
'uintl6' 'integer*2' 16 位
'uint32' 'integer*4' 32 位
'uint64' 'integer*8' 64 位
'float32' 'real*4' 浮点数, 32 位
'float64' 'real*8' 浮点数, 32 位
以下precision(精度)将不保证读出具有一致的体积。
MATLAB C or Fortran Descriphon(精度)
'short' 'short' 16 位，整型数
'int' 'int' 32 位，整型数
'long' 'long' 32 (64) 位，整型数
'uShort' 'Unsigned short' 16 位
'uint' 'Unsigned int' 32 位
'ulong' 'unsigned long' 32 (64) 位
'float' 'float' 浮点数, 32 位
'double' 'double' 浮点数, 64 位
以下precision(精度)规定读出指定的体积n。
'bitN' N位，整型数 1<=N<=64
'ubitN' N位， 1<=N<=64
文件必须在Matlab可以搜索的路径中。
一般为提高速度，直接指定位置，比如指定C盘文件myfile
fid=fread('C:\myfile','r')
fread函数在MATLAB中的功能：fread函数可从文件中读取二进制数据
用法：
A = fread(fid, count)
A = fread(fid, count, precision)
其中fid为指针所指文件中的当前位置，count指读取的数据个数， precision表示以什么格式的数据类型读取数据。
扩展资料：
fread函数在PHP中：
(PHP 4, PHP 5)
fread：读取文件（可安全用于二进制文件）
stringfread( int handle, int length )
fread()从文件指针handle读取最多 length 个字节。 该函数在读取完 length 个字节数，或到达 EOF 的时候，或（对于网络流）当一个包可用时就会停止读取文件，视乎先碰到哪种情况。
在区分二进制文件和文本文件的系统上（如 Windows）打开文件时，fopen() 函数的 mode 参数要加上 'b'。
当从网络流或者管道读取时，例如在读取从远程文件或popen()以及proc_open()的返回时，读取会在一个包可用之后停止。这意味着应该如下例所示将数据收集起来合并成大块。
如果只是想将一个文件的内容读入到一个字符串中，用file_get_contents()，它的性能比上面的代码好得多。
参考资料：百度百科-fread函数
c语言循环中fread如何读取文件
#include
#include
int main(){ int number[400],i; FILE *fp; fp=fopen("number.dat","r"); for(i=0;i<400;i+=100) fread(number+i,sizeof(int),100,fp);}
如何使用fread函数循环读取二进制文件
在读写二进制文件的时候，必须确保文件的打开形式是以 二进制读写的形式打开的， 即：文件的打开形式必须是 "rb", "wb" 要不然，读写数据的时候，就会出现错误。 函数使用说明： FILE * fopen(const char * path,const char * mode); 参数path字
在读写二进制文件的时候，必须确保文件的打开形式是以
二进制读写的形式打开的，
即：文件的打开形式必须是
"rb",
"wb"
要不然，读写数据的时候，就会出现错误。
函数使用说明：
file
*
fopen(const
char
*
path,const
char
*
mode);
参数path字符串包含欲打开的文件路径及文件名，
参数mode字符串则代表着流形态。mode有下列几种形态字符串:
r
打开只读文件，该文件必须存在。
r+
打开可读写的文件，该文件必须存在。
rb+
读写打开一个二进制文件，只允许读写数据。
rt+
读写打开一个文本文件，允许读和写。
w
打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
w+
打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
a
以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（eof符保留）
a+
以附加方式打开可读写的文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾后，即文件原先的内容会被保留。
（原来的eof符不保留）
wb
只写打开或新建一个二进制文件；只允许写数据。
wb+
读写打开或建立一个二进制文件，允许读和写。
wt+
读写打开或着建立一个文本文件；允许读写。
at+
读写打开一个文本文件，允许读或在文本末追加数据。
ab+
读写打开一个二进制文件，允许读或在文件末追加数据。
上述的形态字符串都可以再加一个b字符，如rb、w+b或ab＋等组合，加入b
字符用来告诉函数库打开的文件为二进制文件，而非纯文字文件。不过在posix系统，包含linux都会忽略该字符。由fopen()所建立的新文件会具有s_irusr|s_iwusr|s_irgrp|s_iwgrp|s_iroth|s_iwoth(0666)权限，此文件权限也会参考umask
值。
有些c编译系统可能不完全提供所有这些功能，有的c版本不用"r+","w+","a+",而用"rw","wr","ar"等，读者注意所用系统的规定。
返回值
文件顺利打开后，指向该流的文件指针就会被返回。若果文件打开失败则返回null，并把错误代码存在errno
中
附加说明
一般而言，开文件后会作一些文件读取或写入的动作，若开文件失败，接下来的读写动作也无法顺利进行，所以在fopen()后请作错误判断及处理。
fread函数和fwrite函数
1.函数功能
用来读写一个数据块。
2.一般调用形式
fread(buffer,size,count,fp);
fwrite(buffer,size,count,fp);
3.说明
（1）buffer：是一个指针，对fread来说，它是读入数据的存放地址。对fwrite来说，是要输出数据的地址。
（2）size：要读写的字节数；
（3）count:要进行读写多少个size字节的数据项；
（4）fp:文件型指针。
程序员的自我修养： fread-C语言是怎样读取文件的
1、C语言标准库提供了一系列文件操作函数。文件操作函数一般以f+单词的形式来命名(f是file的简写)，其声明位于stdio.h头文件当中。例如：fopen、fclose函数用于文件打开与关闭；fscanf、fgets函数用于文件读取；fprintf、fputs函数用于文件写入；ftell、fseek函数用于文件操作位置的获取与设置。一般的C语言教程都有文件操作一章，可以找本教材进一步学习。2、例程：
#include
int a;char b,c[100];int main(){ FILE * fp1 = fopen("input.txt", "r");//打开输入文件 FILE * fp2 = fopen("output.txt", "w");//打开输出文件 if (fp1==NULL || fp2==NULL) {//若打开文件失败则退出 puts("不能打开文件！"); rturn 0; } fscanf(fp1,"%d",&a);//从输入文件读取一个整数 b=fgetc(fp1);//从输入文件读取一个字符 fgets(c,100,fp1);//从输入文件读取一行字符串 printf("%ld",ftell(fp1));//输出fp1指针当前位置相对于文件首的偏移字节数 fputs(c,fp2);//向输出文件写入一行字符串 fputc(b,fp2);//向输出文件写入一个字符 fprintf(fp2,"%d",a);//向输出文件写入一个整数 fclose(fp1);//关闭输入文件 fclose(fp2);//关闭输出文件，相当于保存 return 0;}
为了效率的考虑,不至于频繁调用系统函数和访问IO设备,MSVC CRT的fread采用缓冲设计. C语言提供的关于缓冲的函数有:int flush(FILE* stream); int setvbuf(FILE* stream, char* buf, int mode, size_t size); /* 缓冲模式mode有: 1. 无缓冲模式 _IONBF 2. 行缓冲模式 _IOLBF 每收到一个换行符(/n或/r/n), 就将缓冲flush掉 3. 全缓冲模式 _IOFBF 仅当缓冲满时才进行flush */ void setbuf(FILE* stream, char* buf); 等价于 (void)setvbuf(stream, buf, _IOBBF, BUFSIZ); fread的调用过程大概是:fread -> fread_s(增加缓冲溢出保护, 加锁) -> _fread_nolock_s(循环读取,缓冲) -> _read(换行符转换) -> ReadFile(读取文件) 加注释的FILE结构如下:struct _iobuf { char *_ptr; int _cnt; //剩余未读的字节数 char *_base; //文件的缓冲基址 int _flag; //打开文件的属性 int _file; //打开文件的编号 int _charbuf; int _bufsiz; //文件的缓冲的总的大小 char *_tmpfname; }; typedef struct _iobuf FILE; 核心函数_fread_nolock_s(循环读取,缓冲)如下:size_t __cdecl _fread_nolock_s( void *buffer, size_t bufferSize, size_t elementSize, size_t num, FILE *stream ) { char *data; /* point inside the destination buffer to where we need to copy the read chars */当前放进字节的尾部 size_t dataSize; /* space left in the destionation buffer (in bytes) //buffer中剩余字节数*/ size_t total; /* total bytes to read //总共要读的字节数*/ size_t count; /* num bytes left to read //剩下要读的字节数*/ unsigned streambufsize; /* size of stream buffer */ unsigned nbytes; /* how much to read now */ unsigned nread; /* how much we did read */ int c; /* a temp char */ /* initialize local vars */ data = buffer; dataSize = bufferSize; if (elementSize == 0 || num == 0) { return 0; } /* validation */ _VALIDATE_RETURN((buffer != NULL), EINVAL, 0); if (stream == NULL || num > (SIZE_MAX / elementSize)) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN((stream != NULL), EINVAL, 0); _VALIDATE_RETURN(num _bufsiz; } else { /* assume will get _INTERNAL_BUFSIZ buffer */ streambufsize = _INTERNAL_BUFSIZ; } /* here is the main loop -- we go through here until we're done */ while (count != 0) { /* if the buffer exists and has characters, copy them to user buffer */ if (anybuf(stream) && stream->_cnt != 0) { if(stream->_cnt < 0) { _ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0)); stream->_flag |= _IOERR; return (total - count) / elementSize; } /* how much do we want? (unsigned)count : stream->_cnt; if (nbytes > dataSize) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } memcpy_s(data, dataSize, stream->_ptr, nbytes); /* update stream and amt of data read */ count -= nbytes; stream->_cnt -= nbytes; stream->_ptr += nbytes; data += nbytes; dataSize -= nbytes; } else if (count >= streambufsize) { /* If we have more than streambufsize chars to read, get data by calling read with an integral number of bufsiz blocks. Note that if the stream is text mode, read will return less chars than we ordered. */ if (streambufsize) { /* In 64bit apps size_t is bigger than unsigned * (which is 32bit even in 64 bit machines), so * we need to split the read into INT_MAX chunks * since _read() only support up to _signed_ int * (even though the in parameter is unsigned). */ if (count > INT_MAX) { /* calc chars to read -- the largest multiple of streambufsize * smaller then INT_MAX */ nbytes = (unsigned)(INT_MAX - INT_MAX % streambufsize); } else { /* calc chars to read -- (count/streambufsize) * streambufsize */ nbytes = (unsigned)(count - count % streambufsize); } } else { nbytes = (count > INT_MAX)?(unsigned)INT_MAX: (unsigned)count; } if (nbytes > dataSize) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } nread = _read(_fileno(stream), data, nbytes); if (nread == 0) { /* end of file -- out of here */ stream->_flag |= _IOEOF; return (total - count) / elementSize; } else if (nread == (unsigned)-1) { /* error -- out of here */ stream->_flag |= _IOERR; return (total - count) / elementSize; } /* update count and data to reflect read */ count -= nread; data += nread; dataSize -= nread; } else { /* less than streambufsize chars to read, so call _filbuf to fill buffer */ if ((c = _filbuf(stream)) == EOF) { /* error or eof, stream flags set by _filbuf */ return (total - count) / elementSize; } /* _filbuf returned a char -- store it */ if (dataSize == 0) { if (bufferSize != SIZE_MAX) { memset(buffer, _BUFFER_FILL_PATTERN, bufferSize); } _VALIDATE_RETURN(("buffer too small", 0), ERANGE, 0) } *data++ = (char) c; --count; --dataSize; /* update buffer size */ streambufsize = stream->_bufsiz; } } /* we finished successfully, so just return num */ return num; } 其中,int __cdecl _filwbuf ( FILE *str ) #endif /* _UNICODE */ { REG1 FILE *stream=NULL; /* In safecrt, we assume we always have a buffer */ _VALIDATE_RETURN(str != NULL, EINVAL, _TEOF); /* Init pointer to _iob2 entry. */ stream = str; if (!inuse(stream) || stream->_flag & _IOSTRG) return(_TEOF); if (stream->_flag & _IOWRT) { stream->_flag |= _IOERR; return(_TEOF); } stream->_flag |= _IOREAD; /* Get a buffer, if necessary. */ if (!anybuf(stream)) { #ifndef _SAFECRT_IMPL _getbuf(stream); #else /* _SAFECRT_IMPL */ /* In safecrt, we assume we always have a buffer */ _VALIDATE_RETURN(FALSE, EINVAL, _TEOF); #endif /* _SAFECRT_IMPL */ } else { stream->_ptr = stream->_base; } stream->_cnt = _read(_fileno(stream), stream->_base, stream->_bufsiz); #ifndef _UNICODE if ((stream->_cnt == 0) || (stream->_cnt == -1)) { #else /* _UNICODE */ if ((stream->_cnt == 0) || (stream->_cnt == 1) || stream->_cnt == -1) { #endif /* _UNICODE */ stream->_flag |= stream->_cnt ? _IOERR : _IOEOF; stream->_cnt = 0; return(_TEOF); } if ( !(stream->_flag & (_IOWRT|_IORW)) && ((_osfile_safe(_fileno(stream)) & (FTEXT|FEOFLAG)) == (FTEXT|FEOFLAG)) ) stream->_flag |= _IOCTRLZ; /* Check for small _bufsiz (_SMALL_BUFSIZ). If it is small and if it is our buffer, then this must be the first _filbuf after an fseek on a read-access-only stream. Restore _bufsiz to its larger value (_INTERNAL_BUFSIZ) so that the next _filbuf call, if one is made, will fill the whole buffer. */ if ( (stream->_bufsiz == _SMALL_BUFSIZ) && (stream->_flag & _IOMYBUF) && !(stream->_flag & _IOSETVBUF) ) { stream->_bufsiz = _INTERNAL_BUFSIZ; } #ifndef _UNICODE stream->_cnt--; return(0xff & *stream->_ptr++); #else /* _UNICODE */ stream->_cnt -= sizeof(wchar_t); return (0xffff & *((wchar_t *)(stream->_ptr))++); #endif /* _UNICODE */ } 代码中分了三种情况:1) 缓冲区不为空此时, 把缓冲区中的数据复制到传入的字符数组中. 2) 缓冲区为空, 需要读取的数据大于缓冲的尺寸此时, 直接调用函数_fread把文件中的内容写到传入的字符数组中. 3) 缓冲区为空, 需要读取的数据不大于缓冲的尺寸此时, 调用函数_fread读满缓冲区, 并再写缓冲区的一个字符到传入的字符数组中. 若未读满传入的字符数组, 循环执行上述1~3过程, 直到读满或读到文件末尾(EOF).
C语言如何用fread()和fwrite()实现对文本文件的整行读写呢，文本文件中每一行的字符个数不一定相同
最好用fgets()来读取一行，该函数自动读取一行。
写的时候你就可以自己随意定啦！你在buf后面加个换行符'\n'就行了，fwrite()就会自动换行了。
比如：
FILE* fp = fopen("c:\\test.txt","rw"); //打开文件
if( fp == NULL )
return;
char achBuf[256] = {0};
fgets( achBuf,fp ); //读取一行，直到遇到换行符结束
memset( achBuf,0,256 );
strcpy(achBuf,"Hello,world!\n"); //内容随意，别忘了加个换行符
fwrite( achBuf,1,strlen(achBuf)+1,fp ); //写入一行
fclose(fp); //关闭文件
fread()和fwrite()主要是用来读写二进制文件的。
如果是文本文件建议使用fprintf()和fscanf()
如果一次读取一行，用fgets()最方便了。
C语言fread函数读取的个数怎么决定
如果是按结构体读 或者按变量类型读 可以用文件总大小除以sizeof(元素结构类型)
比如写入 的是int值 可以获得文件大小然后除以sizeof(int)
如果写入的是结构体 那么就是文件大小除以sizeof(结构体)
int main(){FILE *fp;fp=fopen( "file.txt", "r");fseek(fp, 0L, SEEK_END );printf(" file size = %d\n", ftell(fp) ); //文件大小return 0;}
函数原型：size_t fread(void *buffer, size_t size, size_t count, FILE *stream);fread是用来读取块数据的，主要就是结构体类型的数据。因此，它的count是结构体对象的数量，size是sizeof(struct xxx)，还有就是读取二进制文件，使用fread可以一次性把整个二进制文件读取到内存缓冲区当中，那么size就是文件的字节大小了，而count则设置为1；也可以一次读取一个字符的数据即size=1，那么读取的次数count就是整个文件的大小了。因此，读取的次数count要看实际情况来决定，没有定式的，要灵活运用吧。