c语言fread读取文件（c语言fread读取文件失败）

本文目录

• c语言fread读取文件失败
• c语言循环中fread如何读取文件
• C语言fread函数读取文件问题
• C语言如何读取文件
• 标准C语言中如何一次读取某文件中的多行数据
• c语言如何从文件读入，并存放在链表中
• C语言fread()函数读取出问题，求大神解答
• 程序员的自我修养: fread-C语言是怎样读取文件的

c语言fread读取文件失败

这种文本文件一般用不着使用二进制读写

在用二进制读写时需要注意，文本文件中有看不见的字符，比如换行符，在读取时必须考虑它们占用的字符。建议：

char buffer;if ( pFd=fopen("/20190124.txt","r") ) {  if ( !feof(pFd) ) {    fgets(buffer,255,pFd); sscanf(buffer,"%s",version);    fgets(buffer,255,pFd); sscanf(buffer,"%lf%lf",&dLon,&dLat);    fgets(buffer,255,pFd); sscanf(buffer,"%d",&Num);    printf...  }  fclose(pFd);} else { printf("Open file failed\n"); return -1; }

c语言循环中fread如何读取文件

#include 《stdio.h》#include 《stdlib.h》int main(){    int number,i;    FILE *fp;    fp=fopen("number.dat","r");    for(i=0;i《400;i+=100)        fread(number+i,sizeof(int),100,fp);}

C语言fread函数读取文件问题

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

C语言如何读取文件

文件流指针应打文件,要同操作两文件,所要用两文件流指针,像要同操作两箱.程序理解:两箱,fp1,fp2;打箱fp1,fp2,拿1024东西看,同放第二箱fp2,至箱东西完全拿,关闭两箱.例都差,看看stdlibf函数,C文件操作:FILL*pf;//声明指针,指针数组FILEpf或FILE**pf;pf=fopen();fread()orfwrite()......//操作文件fclose(pf)//关闭文件

标准C语言中如何一次读取某文件中的多行数据

有很多种方式可以一次性读取多行数据，具体如何使用，取决于文件内容格式。

一、以fscanf读取。

fscanf读取时，默认会到空白字符截止。所以如果文件中不存在其它空白字符，那么可以以fscanf实现一次性读取多行的效果，比如文件中存储为

12.3name

那么要一次性读取这三行数据，可以使用：

int a;float b;char c;fscanf(fp, "%d%f%s",&a,&b,c);

其中，fp为打开该文件的文件指针， 分别将三行数据读取到三个变量a b c中。 

二、以fread读取。 

fread可以一次性读取若干个数据块，所以如果要读取的文件内容总长度已知，那么可以通过fread一次性读取多行。如

this isformy testonly.

以上数据分4行，包括换行符在内共计25字节。

此时可以使用如下代码一次性读取四行：

char buf;fread(buf, 25, 1, fp);

其中fp为打开该文件的文件指针。

c语言如何从文件读入，并存放在链表中

//举个单链表的例子，首先定义链表成员的结构体 

struct filetext{char buf;

struct filetext *next;}；

//读取文件，并插入进链表的函数，filename为要读取的文件名，head为链表的头节点，函数返回插入新节点后链表的头节点

struct filetext * readfile(char * filename,struct filetext * head)

{ struct filetext * new = (struct filetext *)malloc(sizeof(struct filetext));//定义一个新成员，并给它分配空间

FILE * fp;//读取文件的文件流

struct filetext * p =head;//定义一个p，用来寻找链表中最后一个节点

if((fp=(fopen(filename,"r+")))==NULL)

{//如果打开文件失败，返回head，并提示

printf("open file failure");

return head; }

//然后开始读取文件，放到new的buf中

if(fread(new-》buf,BUFSIZE,1,fp)《1)

{ //如果读取失败，提示，并返回head

printf("read file failure");

return head; }

fclose(fp);

//文件读取完后,进行链表操作

if(!head)//如果传进来的head是个空指针，那么新指针就作为头节点返回

{ new-》next = NULL;

return new; }

while(p-》next) p = p-》next;//把p移动到最后一个节点

p-》next = new;//p的下一个节点为new

new-》next = NULL;//new的下一个节点为空

return head;

//这样这个函数就完成了，你可以写个主函数，定义一个头节点，试下。

扩展资料：

线性表的链式存储表示的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。

因此，为了表示每个数据元素 与其直接后继数据元素 之间的逻辑关系，对数据元素 来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的信息（即直接后继的存储位置）。由这两部分信息组成一个"结点"（如概述旁的图所示），表示线性表中一个数据元素。

线性表的链式存储表示，有一个缺点就是要找一个数，必须要从头开始找起，十分麻烦。根据情况，也可以自己设计链表的其它扩展。但是一般不会在边上附加数据，因为链表的点和边基本上是一一对应的（除了第一个或者最后一个节点，但是也不会产生特殊情况）。

不过有一个特例是如果链表支持在链表的一段中把前和后指针反向，反向标记加在边上可能会更方便。

C语言fread()函数读取出问题，求大神解答

fread() 用于2进制文件的读。被读的文件应当是2进制文件，并且是用 fwrite() 写成的。文件打开 必须 用到 "b" (2进制) -- "rb" "wb" .... 又读又写文件，注意文件指针位置的控制,般动，回绕文件等等，并保证文件及时写出（调 fflush() )。分别读，写文件，注意文件 关闭，文件打开的顺序。

程序员的自我修养: 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 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 《= (SIZE_MAX / elementSize), EINVAL, 0); } count = total = elementSize * num; if (anybuf(stream)) { /* already has buffer, use its size */ streambufsize = stream-》_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).