㈠ 请教C语言<stdio.h>头文件下的fread()函数的用法，结合一个简单的例子加上一些解释。
函数原型size_t fread ( void *buffer, size_t size, size_t count, FILE *stream) ;参 数buffer用于接收数据的内存地址size要读写的字节数，单位是字节count要进行读写多少个size字节的数据项,每个元素是count字节.stream输入流#include<stdio.h>#include<string.h>int main(void){ FILE*stream; char msg[]="thisisatest"; char buf[20]; if((stream=fopen("DUMMY.FIL","w+"))==NULL) { fprintf(stderr,"Cannotopenoutputfile.\n"); return 0; } /*writesomedatatothefile*/ fwrite(msg,1,strlen(msg)+1,stream); /*sizeof（char）=1seektothebeginningofthefile*/ fseek(stream,0,SEEK_SET); /*readthedataanddisplayit*/ fread(buf,strlen(msg)+1,1,stream); printf("%s\n",buf); fclose(stream); return0;}
㈡ C语言自定义的头文件
首先使用fopen函数打开这个头文件，使用fread读取这个头文件中的内容，从读取的内容中提取结构体的内容，再用fopen打开要另一个磁盘文件，将提取的结构体内容使用fwrite写入另一个磁盘文件即可。
㈢ C++是否兼容C中的用来读写数据块的函数fread和fwrite ,如若可以，头文件是用哪个
可以。foepn用来打开文件，至于会不会覆盖原有数据就看你使用哪种打开方式，r是只读，不会覆盖；w是写，不存在则创建，存在则覆盖；a是追加，不存在则创建，存在则追加，不会覆盖
㈣ C++的fopen在哪个头文件里
fopen函数在 stdio.h里面。它是用于打开文件的，更加详细的说明如下。FILE *fopen( const char *fname, const char *mode );fopen()函数打开由fname(文件名)指定的文件, 并返回一个关联该文件的流.如果发生错误, fopen()返回NULL. mode(方式)是用于决定文件的用途(例如 用于输入,输出,等等)Mode(方式) 意义 "r" 打开一个用于读取的文本文件 "w" 创建一个用于写入的文本文件 "a" 附加到一个文本文件 "rb" 打开一个用于读取的二进制文件 "wb" 创建一个用于写入的二进制文件 "ab" 附加到一个二进制文件 "r+" 打开一个用于读/写的文本文件 "w+" 创建一个用于读/写的文本文件 "a+" 打开一个用于读/写的文本文件 "rb+" 打开一个用于读/写的二进制文件 "wb+" 创建一个用于读/写的二进制文件 "ab+" 打开一个用于读/写的二进制文件
㈤ vc中如何用fread语句读txt文件
bool DealFile(string fileName) //随便写个函数说明 { FILE *file; DWORD fileSize ,pos; int readLen ; //MAX_BUFFER_LEN 在头文件里定义，这里能够保证数据不丢失，也不至于内存逸出 char *buffer = new char[MAX_BUFFER_LEN]; file = fopen(fileName.c_str(),"r+b"); if(file == NULL) return false; fseek(file,0,2); fileSize = ftell(file); //取得文件的大小 fseek(file,0,0); do{ readLen = fread(buffer,sizeof(char),MAX_BUFFER_LEN,file); if(readLen > 0) { pos += readLen; //对读取的文件做处理 } }while(pos < fileSize); //循环读取文件 delete[] buffer; fclose(file); //释放资源 return true; }
㈥ gcc 中fread用哪个头文件,
在linux下man帮助一下，就可以看到，fread需要引用stdio.h$man freadFREAD(P) FREAD(P)NAME fread – binary inputSYNOPSIS #include <stdio.h> size_t fread(void *restrict ptr, size_t size, size_t nitems,FILE *restrict stream);参数一：接收数据的指针（可以是字符数组，结构数组等）参数二：一块数据的大小，一般我们输入1，表示一个字符的大小参数三：读多少个块（参数2），一般参数2是1，这里就是欲读字节数参数四：文件指针。
㈦ 寻 c语言函数fwrite和fread的源代码
fwrite源代码为：size_t fwrite (const void* ptr,size_t size,size_t nmemb,FILE *fp);头文件在search.h中，有的在stddef.h中fread源代码为：size_t fread(const void* ptr,size_t size,size_t nmemb,FILE *fp);函数参数与fwrite相同
㈧ 使用 fopen 和fread 读文件的问题
DWORD len=fread(pBuf,1,4096,p); 后,p已经自动下移了fseek(p,len,SEEK_SET); ??
㈨ c语言用fopen时，需要加特殊的 头文件吗
使用fopen时，只需将头文件#include<stdio.h>添加进源文件即可。
函数原型：FILE *fopen(char *filename, char *mode);
功版 能：以mode指定的方式打开名为filename的文件
返 回权 值：成功返回文件指针；否则，返回0
举例如下：
#include<stdio.h>//fopen所在的头文件voidmain(){FILE*fp;//定义一个文件指针fpfp=fopen("text1.txt","r");//以只读的方式打开文件名为text1.txt的文件……..fclose(fp);//操作完毕后关闭文件}
㈩ 程序员的自我修养: fread-C语言是怎样读取文件的
为了效率的考虑,不至于频繁调用系统函数和访问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 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, 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).
