C++文件操作函数
C语言文件操作函数大全
C语言文件操作函数13.1C语言文件1,两种文件存取方式(输入,输出方式)顺序存取直接存取2,数据的两种存放形式文本文件二进制文件13.2文件指针定义文件类型指针变量的一般形式:FILE *指针变量名;例如:FILE *fp1,*fp2;13.3打开文件在使用文件之前,需打开文件.在C里使用fopen函数打开文件.格式为:fopen(文件名,文件使用方式);此函数返回一个指向FILE类型的指针.如:FILE *fp;fp=fopen("file_1","r");如果调用成功,fp就指向file_1,否则返回为NULL,所以为了保证文件的正确使用,要进行测试.采用如下语句:If((fp=fopen("file_1","r"))==NULL){printf("Cannot open this file\n");exit(0);}最常用的文件使用方式及其含义如下:1,"r".为读而打开文本文件.(不存在则出错) 2,"rb".为读而打开二进制文件.3,"w".为写而打开文本文件.(若不存在则新建,反之,则从文件起始位置写,原内容将被覆盖) 4,"wb".为写而打开二进制文件.5,"a".为在文件后面添加数据而打开文本文件.(若不存在,则新建;反之,在原文件后追加)6,"ab".为在文件后面添加数据而打开一个二进制文件.最常用的文件使用方式及其含义如下:7,"r+".为读和写而打开文本文件.(读时,从头开始;在写数据时,新数据只覆盖所占的空间,其后不变) 8,"rb+".为读和写而打开二进制文件.只是在随后的读写时,可以由位置函数设置读和写的起始位置. 9,"w+".首先建立一个新文件,进行写操作,随后可以从头开始读.(若文件存在,原内容将全部消失) 10,"wb+".功能与"w+"同.只是在随后的读写时,可以由位置函数设置读和写的起始位置.最常用的文件使用方式及其含义如下:11,"a+".功能与"a"相同;只是在文件尾部添加新的数据后,可以从头开始读.12,"ab+".功能与"a+"相同;只是在文件尾部添加新数据之后,可以由位置函数设置开始读的起始位置. 13.4关闭文件当文件的读写操作完成之后,使用fclose函数关闭文件.格式如下:fclose(文件指针)如:fclose(fp);13.5调用fgetc和fputc函数进行输入和输出1,调用fputc函数输出一个字符功能是:将字符ch写到文件指针fp所指的文件中去.当输出成功,putc函数返回所输出的字符;否则,返回一个EOF值.EOF是在stdio.h库函数文件中定义的符号常量,其值等于-1.13.5调用fgetc和fputc函数进行输入和输出例如:把从键盘输入的文本按原样输出到名为file_1.dat文件中,用字符@作为键盘输入结束标志. #includeVoid main(){FILE *fpout;char ch;if(fpout=fpopen("file_1","w")==NULL){printf("Cannot open this file!\n");exit(0);}ch=getchar();while(ch!='@'){ fputc(ch,fpout); ch=getchar(); }fclose(fpout);}2.调用fgetc函数输入一个字符功能是:从pf指定的文件中读如一个字符,并把它作为函数值返回.例如:把一个已存在磁盘上的file_1.dat文本文件中的内容,原样输出到终端屏幕上.#includevoid main(){FILE *fpin;char ch;if((fpin=fopen("file_1.dat","r"))==NULL){ printf("Cann't open this file!\n");exit(0);} ch=fgetc(fpin);while (ch!=EOF){ putchar(ch); ch=fgetc(fpin);}fclose(fpin);}13.6判断文件结束函数feofEOF可以作为文本文件的结束标志,但不能作为二进制文件的结束符.feof函数既可以判断二进制文件,又可以判断文本文件.例:编写程序,用于把一个文本文件(源)复制到另一个文件(目的)中,源文件名和目的文件名由命令行输入.命令形式如下:可执行程序名源文件名目的文件名#includevoid filecopy(FILE* ,FILE *);void main(int argc,char *argv[]){FILE *fpin,*fpout;if(argc==3){ fpin=fopen(argv[1],"r");fpout=fopen(argv[2],"w");filecopy(fpin,fpout);fclose(fpin);fclose(fpout);}else if(argc>3)printf("The file names too many!!\n";elseprintf("There are no file names for input or output!!\n );}void filecopy(FILE *fpin,FILE *fpout){char ch;ch=getc(fpin);while(!feof(fpin)){putc(ch,fpout); ch=getc(fpin);}}13.7fscanf函数和fprintf函数1,fscanf函数fscanf只能从文本文件中按格式输入,和scanf函数相似,只不过输入的对象是磁盘上文本文件中的数据.调用形式为:fscanf(文件指针,格式控制字符串,输入项表)例如:fscanf(fp,"%d%d",&a,&b);fscanf(stdin,"%d%d",&a,&b);等价于scanf("%d%d",&a,&b);3.fprintf函数fprintf函数按格式将内存中的数据转换成对应的字符,并以ASCII代码形式输出到文本文件中.Fprintf 函数和printf函数相似,只是将输出的内容按格式存放到磁盘的文本文件中.调用形式如下:fprintf(文件指针,格式控制字符串,输出项表)如:fprintf(fp,"%d %d",x,y);以下语句 fprintf(stdout,"%d %d",x,y)13.8fgets函数和fputs函数1,fgets函数fgets函数用来从文件中读入字符串.调用形式如下: fgets(str,n,fp);函数功能是:从fp所指文件中读入n-1个字符放入str 为起始地址的空间内;如果在未读满n-1个字符时,则遇到换行符或一个EOF结束本次读操作,并已str作为函数值返回. 13.8fgets函数和fputs函数2,fputs函数fput函数把字符串输出到文件中.函数调用形式如下: fputs(str,fp);注意:为了便于读入,在输出字符串时,应当人为的加诸如"\n"这样的字符串.#include <stdio.h>#include <iostream>int main(int argc, char *argv[]){char arr[10] ;char *ap = "hello!" ;FILE *fp ;if ((fp = fopen("hello.txt", "wt+")) == NULL) {printf("error!") ;exit(1) ;}fputs(ap, fp) ;rewind(fp) ; //fgets(arr, 10, fp) ;printf("%s\n", arr) ;fclose(fp) ;return 0 ;}13.9fread函数和fwrite函数例如有如下结构体:struct st{char num[8];float mk[5];}pers[30];以下循环将把这30个元素中的数据输出到fp所指文件中.for(i=0;i<30;i++)fwrite(&pers[i],sizeof(struct st),1,fp);13.9fread函数和fwrite函数以下语句从fp所指的文件中再次将每个学生数据逐个读入到pers数组中.i=0;fread(&pers[i],sizeof(struct st),1,fp);while(!feof(fp)){ i++;fread(&pers[i],sizeof(struct st),1,fp);}13.10文件定位函数1,fseek函数fseek函数用来移动文件位置指针到指定的位置上,接着的读或写操作将从此位置开始.函数的调用形式如下:fseek(pf,offset,origin)pf:文件指针offset:以字节为单位的位移量,为长整形.origin:是起始点,用来指定位移量是以哪个位置为基准的.1,fseek函数位移量的表示方法标识符数字代表的起始点SEEK_SET 0 文件开始SEEK_END 2 文件末尾SEEK_CUR 1 文件当前位置假设pf已指向一个二进制文件,则;fseek(pf,30L,SEEK_SET)fseek(pf,-10L*sizeof(int),SEEK_END)对于文本文件,位移量必须是0;如:fseek(pf,0L,SEEK_SET)fseek(pf,0L,SEEK_END)2. ftell函数ftell函数用以获得文件当前位置指针的位置,函数给出当前位置指针相对于文件开头的字节数.如;long t;t=ftell(pf);当函数调用出错时,函数返回-1L.我们可以通过以下方式来测试一个文件的长度: fseek(fp,0L,SEEK_END);t=ftell(fp);3.rewind函数调用形式为:rewind(pf);函数没有返回值.函数的功能是使文件的位置指针回到文件的开头.13.10文件应用在磁盘上的test.txt文件中放有10个不小于2的正整数,用函数调用方式编写程序.要求实现:1,在被调函数prime中,判断和统计10个整数中的素数以及个数.2,在主函数中将全部素数追加到磁盘文件test.txt的尾部,同时输出到屏幕上.#include#includeInt prime(int a[],int n){int I,j,k=0,flag=0;for(i=0;i { for(j=2;j if(a[i]%j==0){ flag=0; break;}else flag=1;if(flag){a[k]=a[i];k++;}}return k; }void main(){int n,I,a[10];FILE *fp;fp=fopen("test1-2.txt","r+");for(n=0;n<10;n++)fscanf(fp,"%d",&a[n]);n=prime(a,n);fseek(fp,o,2);for(i=0;i {printf("%3d",a[i]);fprintf(fp,"%3d",a[i]);}fclose(fp);}文件操作函数全clearerr（清除文件流的错误旗标）相关函数feof表头文件#include<stdio.h>定义函数void clearerr(FILE * stream);函数说明clearerr（）清除参数stream指定的文件流所使用的错误旗标。
C语言文件操作函数freopen详细解析
C语⾔⽂件操作函数freopen详细解析今天做USACO ⽤到了⽂件的操作。
之前做USACO只是格式化的些写 freopen("xxx.in","r",stdin)和"freopen("xxx.out","w",stdout)"替换⼀个流，或者说重新分配⽂件指针，实现重定向。
如果stream流已经打开，则先关闭该流。
如果该流已经定向，则freopen将会清除该定向。
此函数⼀般⽤于将⼀个指定的⽂件打开⼀个预定义的流：标准输⼊、标准输出或者标准出错。
FILE *freopen(const char *filename,const char *type, FILE *stream);头⽂件：stdio.h例1：复制代码代码如下:#include <stdio.h>#include <stdlib.h>int main(){if(freopen("file.txt","w",stdout)==NULL)fprintf(stderr,"error\n");printf("This is in the file\n"); //这句话会在file.txt中显⽰。
fclose(stdout); //使⽤fclose()函数就可以把<A href="/view/266782.htm" target=_blank>缓冲区</A>内最后剩余的数据输出到磁盘⽂件中，并释放⽂件指针和有关的缓冲区。
return 0;}例2：复制代码代码如下://⾸先在同路径下创建⼀个in.txt⽂本⽂档写⼊若⼲数字#include <stdio.h>#include <stdlib.h>int main(){freopen("in.txt","r",stdin); //从in.txt 中读⼊数据freopen("out.txt","w",stdout); // 将最后数据写⼊out.txt中int a,b;while(scanf("%d%d",&a,&b)!=EOF) //数据是从in.txt中输⼊的printf("%d\n",a+b); //写⼊out.txt中fclose(stdin);fclose(stdout);return 0;}freopen("CON","w",stdout) 表⽰在控制台窗⼝上写⼊数据；例3：复制代码代码如下:#include <stdio.h>#include <stdlib.h>int main(){// FILE *stream;freopen("file1.txt","w",stdout);printf("this is in file1.txt"); // 这句话在file1.txt中显⽰freopen("CON","w",stdout);printf("And this is in command.\n"); //这句话在控制台上显⽰return 0;}例5：关于fread 可以通过下⾯的程序，⼀看就知道什么意思了复制代码代码如下:#include <stdio.h>#include <stdlib.h>int main(){FILE *streamchar s[102400]="";if((stream=freopen("file.txt","r",stdin))==null)exit(-1);fread(s,1,1024,stdin); // 读取file.txt中1到1024位，放⼊s中，我是这么理解的 printf("%s\n",s);return 0;}。
归纳整理Linux下C语言常用的库函数----文件操作
归纳整理Linux下C语⾔常⽤的库函数----⽂件操作在没有IDE的时候，记住⼀些常⽤的库函数的函数名、参数、基本⽤法及注意事项是很有必要的。
参照Linux_C_HS.chm的⽬录，我⼤致将常⽤的函数分为⼀下⼏类：1. 内存及字符串控制及操作2. 字符串转换3. 字符测试4. ⽂件操作5. 时间⽇期6. 常⽤数学函数7. ⽂件内容操作8. ⽂件权限控制9. 进程操作10. 线程操作11. Socket操作12. 信号处理13. 数据结构及算法这次主要总结的是上⾯⿊⾊部分，关于⽂件操作的函数。
系统调⽤归类** 函数名⽤法备注**1. int open(const char *pathname, int flags); open and possibly create a file or device flags 必须包含O_RDONLY, O_WRONLY, or O_RDWR中的任何⼀个**2. int open(const char *pathname, int flags, mode_t mode); UP mode只是在flags中包含O_CREAT时才有效**3. int fsync(int fd); synchronize a file's in-core state with storage device 写完数据close前必须先同步，以防意外**4. off_t lseek(int fd, off_t offset, int whence); 定位⽂件位置第三个参数可以为SEEK_SET SEEK_CUR SEEK_END**5. ssize_t read(int fildes, void *buf, size_t nbyte); UP ⽂件位置会随读取的字节数移动**6. ssize_t write(int fildes, const void *buf, size_t nbyte); UP UP**7. int close(int fd); UP UP**8. void *mmap(void *addr, size_t length, int prot, int flags, 内存映射先⽤fstat得到⽂件⼤⼩，然后使⽤该函数将⽂件内容映射到内存中，然后就可以int fd, off_t offset); 直接调⽤字符串函数操作。
C语言文件操作命令
C语言文件操作函数大全clearerr（清除文件流的错误旗标）相关函数 feof表头文件 #include<stdio.h>定义函数 void clearerr(FILE * stream);函数说明 clearerr（）清除参数stream指定的文件流所使用的错误旗标。
返回值fclose（关闭文件）相关函数 close，fflush，fopen，setbuf表头文件 #include<stdio.h>定义函数 int fclose(FILE * stream);函数说明 fclose()用来关闭先前fopen()打开的文件。
此动作会让缓冲区内的数据写入文件中，并释放系统所提供的文件资源。
返回值若关文件动作成功则返回0，有错误发生时则返回EOF并把错误代码存到errno。
错误代码 EBADF表示参数stream非已打开的文件。
范例请参考fopen（）。
fdopen（将文件描述词转为文件指针）相关函数 fopen，open，fclose表头文件 #include<stdio.h>定义函数 FILE * fdopen(int fildes,const char * mode);函数说明 fdopen()会将参数fildes 的文件描述词，转换为对应的文件指针后返回。
参数mode 字符串则代表着文件指针的流形态，此形态必须和原先文件描述词读写模式相同。
关于mode 字符串格式请参考fopen()。
返回值转换成功时返回指向该流的文件指针。
失败则返回NULL，并把错误代码存在errno中。
范例#include<stdio.h>main(){FILE * fp =fdopen(0,”w+”);fprintf(fp,”%s\n”,”hello!”);fclose(fp);}执行 hello!feof（检查文件流是否读到了文件尾）相关函数 fopen，fgetc，fgets，fread表头文件 #include<stdio.h>定义函数 int feof(FILE * stream);函数说明 feof()用来侦测是否读取到了文件尾，尾数stream为fopen（）所返回之文件指针。
c语言 文件操作函数
c语言文件操作函数C语言文件操作函数C语言文件操作函数是C语言提供的一种文件操作方式，可以通过这些函数来读取、写入和修改文件。
文件操作函数可以帮助我们完成很多与文件有关的任务，比如读取配置文件、保存用户数据等。
在本文中，将介绍C语言中常用的文件操作函数。
打开文件在C语言中，我们可以使用fopen()函数来打开一个文件。
该函数的原型如下：FILE *fopen(const char *filename, const char *mode);其中，filename表示要打开的文件名，mode表示打开文件的模式。
mode的取值如下：- "r"：以只读方式打开文件- "w"：以写方式打开文件，如果文件不存在，则创建该文件；如果文件已存在，则清空该文件- "a"：以写方式打开文件，如果文件不存在，则创建该文件；如果文件已存在，则在文件末尾追加数据- "r+"：以读写方式打开文件，文件必须存在- "w+"：以读写方式打开文件，如果文件不存在，则创建该文件；如果文件已存在，则清空该文件- "a+"：以读写方式打开文件，如果文件不存在，则创建该文件；如果文件已存在，则在文件末尾追加数据例如，我们可以使用以下代码来打开一个名为example.txt的文件：FILE *fp;fp = fopen("example.txt", "w+");if (fp == NULL) {printf("Open file failed!\n");}在打开文件之后，我们可以使用fclose()函数来关闭文件，释放文件资源。
例如：fclose(fp);读取文件在C语言中，我们可以使用fscanf()函数从文件中读取数据。
该函数的原型如下：int fscanf(FILE *stream, const char *format, ...);其中，stream表示要读取数据的文件，format表示数据的格式。
c语言常用函数大全及详解
c语言常用函数大全及详解C语言是一种通用的、面向过程的编程语言，被广泛应用于系统软件、嵌入式开发以及科学计算领域。
在C语言中，函数是一种模块化编程的基本方法，通过函数可以将一段代码进行封装和复用，提高了代码的可读性和可维护性。
本文将介绍一些C语言中常用的函数，并详细解释其用法及重要参数。
一、数学函数1. abs()函数函数原型：int abs(int x);函数功能：返回x的绝对值。
参数说明：x为一个整数。
2. pow()函数函数原型：double pow(double x, double y);函数功能：计算x的y次方。
参数说明：x和y为两个double类型的实数。
3. sqrt()函数函数原型：double sqrt(double x);函数功能：计算x的平方根。
参数说明：x为一个double类型的实数。
二、字符串函数1. strcpy()函数函数原型：char* strcpy(char* destination, const char* source);函数功能：将source字符串复制到destination字符串。
参数说明：destination为目标字符串，source为源字符串。
2. strlen()函数函数原型：size_t strlen(const char* str);函数功能：计算str字符串的长度。
参数说明：str为一个以'\0'结尾的字符串。
3. strcat()函数函数原型：char* strcat(char* destination, const char* source);函数功能：将source字符串拼接到destination字符串的末尾。
参数说明：destination为目标字符串，source为源字符串。
三、文件操作函数1. fopen()函数函数原型：FILE* fopen(const char* filename, const char* mode);函数功能：打开一个文件，并返回文件指针。
C语言文件操作函数大全
C语言文件操作函数大全1. `fopen`：打开文件```FILE* fopen(const char* filename, const char* mode);```该函数用于打开一个文件，成功打开返回文件指针，打开失败返回`NULL`。
`filename` 是要打开的文件名，`mode` 是打开模式，常用的模式有 "r"（只读）、"w"（可写，若文件不存在则创建新文件）、"a"（追加模式）。
2. `fclose`：关闭文件```int fclose(FILE* stream);```该函数用于关闭一个文件，成功关闭返回0，关闭失败返回 `EOF`。
`stream` 是要关闭的文件指针。
3. `fread`：读取文件内容```size_t fread(void* ptr, size_t size, size_t count, FILE* stream);```该函数从文件中读取内容，存储到指定的内存块。
`ptr` 是指向要读取数据的内存块的指针，`size` 是每个数据项的大小，`count` 是要读取的数据项数目。
4. `fwrite`：写入文件内容```size_t fwrite(const void* ptr, size_t size, size_t count, FILE* stream);```该函数将指定的内存块内容写入文件。
`ptr` 是指向要写入数据的内存块的指针，`size` 是每个数据项的大小，`count` 是要写入的数据项数目。
5. `fgetc`：读取一个字符```int fgetc(FILE* stream);```该函数从文件中读取一个字符，成功读取返回字符对应的整数值，读取失败或到达文件末尾返回`EOF`。
6. `fputc`：写入一个字符```int fputc(int c, FILE* stream);```该函数将一个字符写入文件，成功写入返回写入的字符，写入失败返回`EOF`。
Linux常用C函数（文件操作篇）[方案]
![Linux常用C函数（文件操作篇）[方案]](https://img.taocdn.com/s3/m/fb5fb1a868dc5022aaea998fcc22bcd126ff42ec.png)
Linux 常用C函数(文件操作篇)close（关闭文件）open，fcntl，shutdown，unlink，fclose表头文件 #include<unistd.h>定义函数 int close(int fd);函数说明当使用完文件后若已不再需要则可使用close()关闭该文件，二close()会让数据写回磁盘，并释放该文件所占用的资源。
参数fd为先前由open()或creat()所返回的文件描述词。
返回值若文件顺利关闭则返回0，发生错误时返回-1。
错误代码 EBADF 参数fd 非有效的文件描述词或该文件已关闭。
附加说明虽然在进程结束时，系统会自动关闭已打开的文件，但仍建议自行关闭文件，并确实检查返回值。
范例参考open()creat（建立文件）相关函数 read，write，fcntl，close，link，stat，umask，unlink，fopen表头文件 #include<sys/types.h>#include<sys/stat.h>#include<fcntl.h>定义函数 int creat(const char * pathname, mode_tmode);函数说明参数pathname指向欲建立的文件路径字符串。
Creat()相当于使用下列的调用方式调用open()open(const char * pathname ,(O_CREAT|O_WRONLY|O_TRUNC));错误代码关于参数mode请参考open（）函数。
返回值 creat()会返回新的文件描述词，若有错误发生则会返回-1，并把错误代码设给errno。
EEXIST 参数pathname所指的文件已存在。
EACCESS 参数pathname 所指定的文件不符合所要求测试的权限EROFS 欲打开写入权限的文件存在于只读文件系统内EFAULT 参数pathname 指针超出可存取的内存空间EINVAL 参数mode 不正确。
C语言文件操作函数大全
gets()函数执行时，只要未遇到换行符或文件结束标志，将一直读下去。因此读到什么时候为止，需要用户进行控制，否则可能造成存储区的溢出。
int fclose(FILE *stream);
它表示该函数将关闭FILE指针对应的文件，并返回一个整数值。若成功地关闭了文件，则返回一个0值，否则返回一个非0值。常用以下方法进行测试：
if(fclose(fp)!=0)
在TC中，putc()等价于fput(),getc()等价于fgetc()。
putchar(c)相当于fputc(c,stdout)；getchar()相当于fgetc(stdin)。
注意，这里使用char ch,其实是不科学的，因为最后判断结束标志时，是看ch!=EOF,而EOF的值为-1，这显然和char是不能比较的。所以，某些使用，我们都定义成int ch。
fopen(char *filename,char *type);
其中*filename是要打开文件的文件名指针，一般用双引号括起来的文件名表示，也可使用双反斜杠隔开的路径名。而*type参数表示了对打开文件的操作方式。其可采用的操作方式如下：
方式 含义
{
if(fgets(str,128,fp)!=NULL) printf("%s",str);
}
fclose(fp);
}
n=fcloseall();
时，n应为4。
3.文件的读写
(1).读写文件中字符的函数(一次只读写文件中的一个字符)：
int fgetc(FILE *stream);
int fgetchar(void);
#include "stdio.h"
c语言中open函数的参数
c语言中open函数的参数open函数是C语言中常用的一个函数，用于打开文件。
它的参数包括文件名和打开模式，通过这些参数可以实现对文件的读取或写入操作。
本文将深入探讨open函数的参数及其使用方法。
在C语言中，open函数的第一个参数是文件名。
文件名必须是一个字符串，用于指定要操作的文件的路径和名称。
这个参数是必需的，因为open函数需要知道要打开的文件是哪一个。
文件名可以是相对路径或绝对路径。
相对路径是相对于当前工作目录的路径，而绝对路径是从根目录开始的完整路径。
在指定文件名时，我们需要注意路径分隔符的使用。
在Windows系统中，路径分隔符是反斜杠（\），而在Unix或Linux系统中，路径分隔符是斜杠（/）。
除了文件名，open函数的第二个参数也非常重要。
这个参数是打开模式，用于指定打开文件的目的。
常见的打开模式包括读取模式（"r"）、写入模式（"w"）和追加模式（"a"）。
读取模式用于打开一个已存在的文件并读取其中的内容，写入模式用于创建一个新文件并写入内容，而追加模式用于在已存在的文件末尾添加内容。
除了这三种基本的打开模式，open函数还支持一些其他的模式。
例如，"r+"模式既可以读取文件内容，又可以写入文件内容；"w+"模式既可以创建新文件，又可以读取和写入文件内容。
此外，还有一些特殊的模式，如二进制模式（"b"），用于处理二进制文件；文本模式（"t"），用于处理文本文件。
在使用open函数时，我们需要注意一些细节。
首先，我们必须检查open函数的返回值，以确保文件成功打开。
当文件打开成功时，open函数会返回一个文件描述符，该描述符可以用于后续的文件操作。
如果文件打开失败，open函数会返回-1，表示打开文件出现错误。
我们还需要注意文件的权限问题。
C文件操作函数
C 文件操作函数//------------------------------------------------------------------------------宏 EXIT_SUCCESS 程序成功终止宏 EXIT_FAILURE 程序非成功终止//------------------------------------------------------------------------------/----------------------------------------------------------\| 标准文件及与其相关联的文件指针 ||----------------------------------------------------------|| 标 准 文 件 文 件 指 针 一般使用的设备 || 标准输入 stdin 键盘 || 标准输出 stdout 显示器 || 标准错误输出 stderr 显示器 |\----------------------------------------------------------///------------------------------------------------------------------------------FILE * fp;char fname[33] = "文件名";if((fp = fopen(fname, "r")) != NULL) // 如果成功打开文件{}fclose(fp); // 关闭fp指向的文件//------------------------------------------------------------------------------FILE * fp;char arr[7] = "文件名";fp = fopen(arr, "r");if(fp != NULL)fclose(fp); // 关闭fp指向的文件ch = getc(stdin); // 相当于 getchar(); 一般 getchar() 是由 getc() 函数定义的putc(ch, stdout); // 相当于 putchar(ch); 一般 putchar() 是由 putc() 函数定义的//------------------------------------------------------------------------------fopen() 接受两个参数，第一个是文件名字符串，第二个是打开方式如果没有成功打开文件，fopen() 函数返回 NULL，否则返回 FILE 指针//--------------------------------------------------------------------// // 表 13.1 fopen()函数的模式字符串 // //--------------------------------------------------------------------// // 模式字符串 | 意义 ////--------------------------------------------------------------------// // "r" | 打开一个文本文件，可以读取文件 // //--------------------------------------------------------------------// // "w" | 打开一个文本文件，可以写入文件，先将文件的长度截 // // | 为零。
fopen 参数
fopen 参数fopen()函数是C语言中常用的文件操作函数之一，用于打开一个文件并返回一个文件指针，以便进行后续的文件读写操作。
fopen()函数的常用格式为：```cFILE *fopen(const char *filename, const char *mode);```其中，filename为要打开的文件名，可以是相对路径或绝对路径；mode为打开模式，用于指定文件打开的方式。
- "r"：只读方式打开文件，文件必须存在，否则打开失败。
- "w"：只写方式打开文件，如果文件不存在，则创建新文件；如果文件存在，则将文件的长度截短为0。
- "a"：追加方式打开文件，如果文件不存在，则创建新文件；如果文件存在，则将数据追加到文件尾部。
- "rb"："r"模式下的二进制文件读取，文件必须存在，否则打开失败。
- "wb"："w"模式下的二进制文件写入，如果文件不存在，则创建新文件；如果文件存在，则将文件的长度截短为0。
- "ab"："a"模式下的二进制文件追加。
除了以上常用模式，fopen()函数还支持其他一些模式，例如读写模式、二进制读写模式等，可以根据实际需要来使用。
在使用fopen()函数时，需要注意以下几点：- 打开文件成功后，应该判断文件指针是否为空，以确保文件已经正确打开。
- 在读取或写入文件之前，应该对文件指针进行相应的移动操作，以指向需要处理的文件位置。
- 在文件读写完成后，应该关闭文件，以释放文件相关的资源。
下面是一个例子，演示了如何使用fopen()函数读取一个文本文件：```c#include <stdio.h>// 打开文件fp = fopen("test.txt", "r");// 判断文件指针是否为空if (fp == NULL) {printf("打开文件失败！\n");return 1;}return 0;}```这个例子中，我们打开了一个名为test.txt的文件，并以只读方式打开。
C语言文件操作函数大全
C语言文件操作函数大全C语言提供了丰富的文件操作函数，可以实现对文件的读取、写入、关闭等操作。
下面是一些常用的文件操作函数的介绍：1. fopen(函数：用于打开一个文件，并返回一个指向该文件的文件指针。
函数原型为：FILE *fopen(const char *filename, const char*mode)。
filename为要打开的文件名，mode为打开方式，包括读取（"r"）、写入（"w"）、追加（"a"）等。
2. fclose(函数：用于关闭一个文件，释放文件指针所占用的资源。
函数原型为：int fclose(FILE *stream)。
stream为指向要关闭文件的指针。
3. fread(函数：用于从文件中读取数据，并将读取得到的数据存储在指定的内存区域中。
函数原型为：size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)。
ptr为存储读取数据的内存区域的指针，size为每个数据项的大小，nmemb为要读取的数据项的个数，stream为要读取数据的文件指针。
4. fwrite(函数：用于将数据写入到文件中。
函数原型为：size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream)。
ptr为要写入的数据的内存区域的指针，size为每个数据项的大小，nmemb为要写入的数据项的个数，stream为要写入数据的文件指针。
5. fprintf(函数：用于向文件中写入格式化的数据。
函数原型为：int fprintf(FILE *stream, const char *format, ...)。
stream为要写入数据的文件指针，format为格式化字符串，后面可以跟上需要写入的数据。
C语言文件操作函数大全（超详细）
C语⾔⽂件操作函数⼤全（超详细）相关函数 open，fclose表头⽂件 #include<stdio.h>定义函数 FILE * fopen(const char * path,const char * mode);函数说明参数path字符串包含欲打开的⽂件路径及⽂件名，参数mode字符串则代表着流形态。
r 打开只读⽂件，该⽂件必须存在。
r+ 打开可读写的⽂件，该⽂件必须存在。
w 打开只写⽂件，若⽂件存在则⽂件长度清为0，即该⽂件内容会消失。
若⽂件不存在则建⽴该⽂件。
w+ 打开可读写⽂件，若⽂件存在则⽂件长度清为零，即该⽂件内容会消失。
若⽂件不存在则建⽴该⽂件。
a 以附加的⽅式打开只写⽂件。
若⽂件不存在，则会建⽴该⽂件，如果⽂件存在，写⼊的数据会被加到⽂件尾，即⽂件原先的内容会被保留。
a+ 以附加⽅式打开可读写的⽂件。
若⽂件不存在，则会建⽴该⽂件，如果⽂件存在，写⼊的数据会被加到⽂件尾后，即⽂件原先的内容会被保留。
复制代码代码如下:r Open text file for reading. The stream is positioned at the beginning of the file.r+ Open for reading and writing. The stream is positioned at the beginning of the file.w Truncate file to zero length or create text file for writing. The stream is positioned at the beginning of the file.w+ Open for reading and writing. The file is created if it does not exist, otherwise it is truncated. The stream is posi‐tioned at the beginning of the file.a Open for appending (writing at end of file). The file is created if it does not exist. The stream is positioned at theend of the file.a+ Open for reading and appending (writing at end of file). The file is created if it does not exist. The initial file posi‐tion for reading is at the beginning of the file, but output is always appended to the end of the file.上述的形态字符串都可以再加⼀个b字符，如rb、w+b或ab＋等组合，加⼊b 字符⽤来告诉函数库打开的⽂件为⼆进制⽂件，⽽⾮纯⽂字⽂件。
c语言打开文件并读取文件内容的方法
C语言是一种广泛应用的计算机编程语言，它具有高效性和灵活性，因此在文件操作方面也具有很强的能力。
在C语言中，打开文件并读取文件内容是常见的操作之一，下面将介绍C语言中打开文件并读取文件内容的方法。
一、打开文件在C语言中，可以使用fopen函数来打开文件。
fopen函数的原型为：```cFILE *fopen(const char *filename, const char *mode);```其中，filename为要打开的文件名，mode为打开文件的模式。
常用的模式有：1. "r"：以只读方式打开文件，文件必须存在，如果文件不存在则打开失败。
2. "w"：以只写方式打开文件，文件不存在则创建新文件，如果文件已存在则清空文件内容。
3. "a"：以附加模式打开文件，文件不存在则创建新文件，文件指针定位到文件末尾，如果文件存在则保留文件内容。
示例代码如下：```c#include <stdio.h>int m本人n() {FILE *fp;char *filename = "test.txt"; char *mode = "r";fp = fopen(filename, mode); if (fp == NULL) {printf("文件打开失败\n"); return 1;}// 其他操作fclose(fp);return 0;}```二、读取文件内容在打开文件之后，可以使用fgetc、fgets等函数来读取文件内容。
1. 使用fgetc函数逐字符读取文件内容：```cint fgetc(FILE *stream);```示例代码如下：```c#include <stdio.h>int m本人n() {FILE *fp;char *filename = "test.txt";char *mode = "r";int ch;fp = fopen(filename, mode);if (fp == NULL) {printf("文件打开失败\n");return 1;}while ((ch = fgetc(fp)) != EOF) {putchar(ch);}fclose(fp);return 0;}```2. 使用fgets函数按行读取文件内容：```cchar *fgets(char *str, int n, FILE *stream); ```示例代码如下：```c#include <stdio.h>int m本人n() {FILE *fp;char *filename = "test.txt";char *mode = "r";char buffer[255];fp = fopen(filename, mode);if (fp == NULL) {printf("文件打开失败\n");return 1;}while (fgets(buffer, 255, fp) != NULL) {printf("s", buffer);}fclose(fp);return 0;}```以上就是C语言中打开文件并读取文件内容的方法。
c语言中读取文件大小的函数
c语言中读取文件大小的函数【实用版】目录1.C 语言中文件的概念和操作2.读取文件大小的函数3.fopen 函数4.fseek 函数5.ftell 函数6.fclose 函数7.示例代码正文一、C 语言中文件的概念和操作在 C 语言中，文件被视为一个字符序列，可以使用不同的函数对其进行操作。
文件操作主要包括打开、读取、写入、关闭等。
二、读取文件大小的函数要读取文件大小，可以使用以下三个函数：1.fopen 函数：用于打开文件。
该函数需要两个参数，分别是文件路径和打开模式。
打开模式可以是只读（r）、写入（w）或追加（a）等。
2.fseek 函数：用于设置文件指针的位置。
该函数需要三个参数，分别是文件指针、位置和基准位置。
基准位置可以是文件开头（0）、文件末尾（2）或当前位置（1）。
3.ftell 函数：用于获取文件指针的位置。
该函数只需要一个参数，即文件指针。
三、示例代码下面是一个读取文件大小的示例代码：```c#include <stdio.h>#include <stdlib.h>int main() {FILE *file;long long size;file = fopen("example.txt", "r");if (file == NULL) {printf("Error: cannot open file. ");exit(1);}fseek(file, 0, SEEK_END);size = ftell(file);fclose(file);printf("File size: %lld bytes.", size);return 0;}```在这个示例中，我们首先使用 fopen 函数以只读模式打开名为“example.txt”的文件。
然后使用 fseek 函数将文件指针移动到文件末尾，接着使用 ftell 函数获取文件指针的位置，该位置即为文件大小。
c语言操作函数
c语言操作函数
C语言中的操作函数包括各种数据类型的处理函数、字符串处理函数、文件操作函数等，它们是C语言编程中不可或缺的一部分。
其中，数据类型的处理函数包括数值类型的处理函数和字符类型的处理函数，如int、float、double、char等类型的处理函数，包括转换、比较、运算等功能；字符串处理函数包括字符串常量处理函数和字符串变量处理函数，如strlen、strcpy、strcat等函数，用于字符串的复制、拼接、查找等功能；文件操作函数包括文件的打开、关闭、读写、复制等操作，如fopen、fclose、fread、fwrite等函数，用于文件的读写和管理等功能。
通过熟练掌握这些操作函数，可以大大提高C语言编程的效率和代码的可读性。
- 1 -。
C语言实用文件操作函数freopen详解
C语言文件操作函数freopen详解今天做USACO 用到了文件的操作。
之前做USACO只是格式化的些写freopen(xxx.in,r,stdin) 和freopen(xxx.out,w,stdout) 百度百科上是这么介绍的：函数名: freopen功能: 替换一个流，或者说重新分配文件指针，实现重定向。
如果stream流已经打开，则先关闭该流。
如果该流已经定向，则freopen将会清除该定向。
此函数一般用于将一个指定的文件打开一个预定义的流：标准输入、标准输出或者标准出错。
用法: FILE *freopen(const char *filename,const char *type, FILE *stream);头文件：stdio.h例1：复制代码代码如下:#include#includeint main(){if(freopen(file.txt,w,stdout)==NULL)fprintf(stderr,errorn);printf(This is in the filen); //这句话会在file.txt中显示。
fclose(stdout); //使用fclose()函数就可以把缓冲区内最后剩余的数据输出到磁盘文件中，并释放文件指针和有关的缓冲区。
return 0;}例2：复制代码代码如下://首先在同路径下创建一个in.txt文本文档写入若干数字#include#incll fclose(stdout);return 0;}freopen(CON,w,stdout) 表示在控制台窗口上写入数据；例3：复制代码代码如下:#include#includeint main(){// FILE *stream;freopen(file1.txt,w,stdout);printf(this is in file1.txt); // 这句话在file1.txt中显示freopen(CON,w,stdout);printf(And this is in command.n); //这句话在控制台上显示return 0;}例5：关于fread 可以通过下面的程序，一看就知道什么意思了复制代码代码如下:#include#includeint main(){FILE *streamchar s[102400]=;if((stream=freopen(file.txt,r,stdin))==null)exit(-1);fread(s,1,1024,stdin); // 读取file.txt中1到1024位，放入s 中，我是这么理解的printf(%sn,s);return 0;}。
c语言中fwrite函数的用法
c语言中fwrite函数的用法fwrite函数在C语言中是一个十分重要的文件操作函数，它可以将数据写入文件中。
通过使用fwrite函数，我们可以将变量数据以二进制格式写入文件中，这使得我们能够将标准输出中的数据保存到文件中，甚至将程序计算出来的数组数据保存到文件中。
接下来我们将会分步骤地详细讲解C语言中fwrite函数的使用方法。
**第一步：打开文件**在使用fwrite函数之前，我们需要首先打开文件。
打开文件可以使用fopen函数。
在使用fopen函数之前，需要包含stdio.h头文件。
比如下面的代码：```#include <stdio.h>#include <stdlib.h>int main(){FILE *fp;fp = fopen("data.txt","wb");if(fp == NULL){printf("错误，无法打开文件");exit(1);}fwrite("hello world", sizeof("hello world"), 1, fp);fclose(fp);return 0;}```在上述代码中，我们需要打开文件data.txt并指定使用二进制写入模式（"wb"）。
如果文件打开失败，我们将输出错误信息。
接下来，我们通过fwrite函数将数据写入到文件中，并在写入操作结束后，使用fclose函数关闭文件。
**第二步：写入数据**在文件打开后，我们可以调用fwrite函数将数据写入文件中，fwrite函数的语法为：```size_t fwrite ( const void * ptr, size_t size, size_t count, FILE * stream );```参数解释：- ptr：指向资料存储区域的指针;- size：每次要写入的每个数据元素的字节数；- count：要进行写入size字节数的数据次数；- stream：指向FILE型态（文件流）结构的指针。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C++文件操作详解 时间：2008-08-23 作者：佚名编辑：本站点击：3962 [ 评论]--c++文件操作详解2008-07-22 10:39C++ 通过以下几个类支持文件的输入输出：ofstream: 写操作（输出）的文件类(由ostream引申而来)ifstream: 读操作（输入）的文件类(由istream引申而来)fstream: 可同时读写操作的文件类(由iostream引申而来)打开文件(Open a file)对这些类的一个对象所做的第一个操作通常就是将它和一个真正的文件联系起来，也就是说打开一个文件。
被打开的文件在程序中由一个流对象(stream object)来表示(这些类的一个实例) ，而对这个流对象所做的任何输入输出操作实际就是对该文件所做的操作。
要通过一个流对象打开一个文件，我们使用它的成员函数open()：void open (const char * filename, openmode mode);这里filename 是一个字符串，代表要打开的文件名，mode 是以下标志符的一个组合：ios::in 为输入(读)而打开文件ios::out 为输出(写)而打开文件ios::ate 初始位置：文件尾ios::app 所有输出附加在文件末尾ios::trunc如果文件已存在则先删除该文件ios::binary 二进制方式这些标识符可以被组合使用，中间以”或”操作符(|)间隔。
例如，如果我们想要以二进制方式打开文件"example.bin" 来写入一些数据，我们可以通过以下方式调用成员函数open（）来实现：ofstream file;file.open ("example.bin", ios::out | ios::app | ios::binary);ofstream, ifstream和fstream所有这些类的成员函数open 都包含了一个默认打开文件的方式，这三个类的默认方式各不相同：类参数的默认方式ofstreamios::out | ios::truncifstreamios::infstreamios::in | ios::out只有当函数被调用时没有声明方式参数的情况下，默认值才会被采用。
如果函数被调用时声明了任何参数，默认值将被完全改写，而不会与调用参数组合。
由于对类ofstream, ifstream和fstream的对象所进行的第一个操作通常都是打开文件，这些类都有一个构造函数可以直接调用open 函数，并拥有同样的参数。
这样，我们就可以通过以下方式进行与上面同样的定义对象和打开文件的操作：ofstream file ("example.bin", ios::out | ios::app | ios::binary);两种打开文件的方式都是正确的。
你可以通过调用成员函数is_open()来检查一个文件是否已经被顺利的打开了：boolis_open();它返回一个布尔(bool)值，为真（true）代表文件已经被顺利打开，假( false )则相反。
关闭文件(Closing a file)当文件读写操作完成之后，我们必须将文件关闭以使文件重新变为可访问的。
关闭文件需要调用成员函数close()，它负责将缓存中的数据排放出来并关闭文件。
它的格式很简单：void close ();这个函数一旦被调用，原先的流对象(stream object)就可以被用来打开其它的文件了，这个文件也就可以重新被其它的进程(process)所有访问了。
为防止流对象被销毁时还联系着打开的文件，析构函数(destructor)将会自动调用关闭函数close。
文本文件(Text mode files)类ofstream, ifstream和fstream是分别从ostream, istream和iostream中引申而来的。
这就是为什么fstream的对象可以使用其父类的成员来访问数据。
一般来说，我们将使用这些类与同控制台(console)交互同样的成员函数(cin和cout)来进行输入输出。
如下面的例题所示，我们使用重载的插入操作符<<：// writing on a text file#include <fiostream.h>int main () {ofstreamexamplefile ("example.txt");if (examplefile.is_open()) {examplefile<< "This is a line.\n";examplefile<< "This is another line.\n";examplefile.close();}return 0;}file example.txtThis is a line.This is another line.从文件中读入数据也可以用与cin的使用同样的方法：// reading a text file#include <iostream.h>#include <fstream.h>#include <stdlib.h>int main () {char buffer[256];ifstreamexamplefile ("example.txt");if (! examplefile.is_open()){ cout<< "Error opening file"; exit (1); }while (! examplefile.eof() ) {examplefile.getline (buffer,100);cout<< buffer <<endl;}return 0;}This is a line.This is another line.上面的例子读入一个文本文件的内容，然后将它打印到屏幕上。
注意我们使用了一个新的成员函数叫做eof，它是ifstream从类ios中继承过来的，当到达文件末尾时返回true 。
状态标志符的验证(Verification of state flags)除了eof()以外，还有一些验证流的状态的成员函数（所有都返回bool型返回值）：bad()如果在读写过程中出错，返回true 。
例如：当我们要对一个不是打开为写状态的文件进行写入时，或者我们要写入的设备没有剩余空间的时候。
fail()除了与bad() 同样的情况下会返回true 以外，加上格式错误时也返回true ，例如当想要读入一个整数，而获得了一个字母的时候。
eof()如果读文件到达文件末尾，返回true。
good()这是最通用的：如果调用以上任何一个函数返回true 的话，此函数返回false 。
要想重置以上成员函数所检查的状态标志，你可以使用成员函数clear()，没有参数。
获得和设置流指针(get and put stream pointers)所有输入/输出流对象(i/o streams objects)都有至少一个流指针：ifstream，类似istream, 有一个被称为get pointer的指针，指向下一个将被读取的元素。
ofstream, 类似ostream, 有一个指针put pointer ，指向写入下一个元素的位置。
fstream, 类似iostream, 同时继承了get 和put我们可以通过使用以下成员函数来读出或配置这些指向流中读写位置的流指针：tellg() 和tellp()这两个成员函数不用传入参数，返回pos_type类型的值(根据ANSI-C++ 标准) ，就是一个整数，代表当前get 流指针的位置(用tellg) 或put 流指针的位置(用tellp).seekg() 和seekp()这对函数分别用来改变流指针get 和put的位置。
两个函数都被重载为两种不同的原型：seekg ( pos_type position );seekp ( pos_type position );使用这个原型，流指针被改变为指向从文件开始计算的一个绝对位置。
要求传入的参数类型与函数tellg和tellp的返回值类型相同。
seekg ( off_type offset, seekdir direction );seekp ( off_type offset, seekdir direction );使用这个原型可以指定由参数direction决定的一个具体的指针开始计算的一个位移(offset)。
它可以是：ios::beg 从流开始位置计算的位移ios::cur 从流指针当前位置开始计算的位移ios::end 从流末尾处开始计算的位移流指针get 和put 的值对文本文件(text file)和二进制文件(binary file)的计算方法都是不同的，因为文本模式的文件中某些特殊字符可能被修改。
由于这个原因，建议对以文本文件模式打开的文件总是使用seekg和seekp的第一种原型，而且不要对tellg或tellp的返回值进行修改。
对二进制文件，你可以任意使用这些函数，应该不会有任何意外的行为产生。
以下例子使用这些函数来获得一个二进制文件的大小：// obtaining file size#include <iostream.h>#include <fstream.h>const char * filename = "example.txt";int main () {longl,m;ifstream file (filename, ios::in|ios::binary);l = file.tellg();file.seekg (0, ios::end);m = file.tellg();file.close();cout<< "size of " << filename;cout<< " is " << (m-l) << " bytes.\n";return 0;}size of example.txt is 40 bytes.二进制文件(Binary files)在二进制文件中，使用<<和>>，以及函数（如getline）来操作符输入和输出数据，没有什么实际意义，虽然它们是符合语法的。