C/C++标准输入输出与文件输入输出

矫情吗；* 2022-09-17 06:17 416阅读 0赞

C语言输入输出函数有很多，标准I/O函数中包含了如下几个常用的函数：  
  
标准输入输出：  
  
1. scanf, printf  
  
int scanf(const char \*format, arg\_list)  
scanf主要从标准输入流中获取参数值，format为指定的参数格式及参数类型，如scanf("%s,%d",str,icount);  
  
它要求在标准输入流中输入类似"son of bitch,1000"这样的字符串，同时程序会将"son of bitch"给str,1000给icount。  
  
scanf函数的返回值为int值，即成功赋值的个数，在上例中如果函数调用成功，则会返回2，所以我们在写程序时,可以通过语句  
if( scanf("%s,%d",str,icount) != 2)  
\{  
...  
\}  
来判断用户输入是否正确.  
  
例子：  
\#include <stdio.h>  
\#include <stdlib.h>  
int main()  
\{  
printf("Input Data:\\n");  
char str\[64\];  
int num;  
scanf("%s,%d", str, &num);  
  
  
printf("%s,%d", str, num);  
return 0;  
\}  
  
Input Data:  
nihao,1  
nihao,1,2009091631  
  
此处将","当做了与前面的nhao以及1一起的字符串。注意scanf时，是以空格，制表符以及回车作为变量之间的分割的。  
因此在使用scanf时尽量采用这几个作为分割标记。而不要像scanf("%s,%d", str, &num);，它无法正确输入数据。  
  
int printf(const char \*format, arg\_list)  
printf主要是将格式化字符串输出到标准输出流中，在stdio.h头文件中定义了标准的输入和输出，分别是stdin，stdout。  
  
arg\_list可以是变量名，也可以是表达式，但最终都会以值的形式填充进format中  
  
格式化输入输出：  
1. 格式控制  
格式控制是用双引号括起来的字符串,也称"转换控制字符串",它包含以下两部分信息。  
  
格式说明：由"%"和格式字符组成，如%d,%f,%c，它的作用是把输出数据转换为指定格式输出，格式的说明总是由"%"字符开始的.  
普通字符：需要原样输出的字符，或者是一些有特殊含义的字符，如\\n，\\t。  
\\n 换行  
\\f 清屏并换页  
\\r 回车  
\\t Tab符  
\\xhh 表示一个ASCII码用16进表示，其中hh是1到2个16进制数  
  
2. 输出列表  
就是需要输出的一些数据，也可以是表达式，如果在函数中需要输出多个变量或表达式，则要用逗号隔开。  
  
一些特殊字符的输出：  
单引号，双引号，和反斜杠的输出在前面加转义字符”\\”，如："\\’", "\\"", "\\\\"。  
% 的输出用两个连在一起的%%，即 printf(“%%”);  
  
常用的格式说明如下:  
格式字符  
d 以十进制形式输出带符号整数(正数不输出符号)  
o 以八进制形式输出无符号整数(不输出前缀0)  
x 以十六进制形式输出无符号整数(不输出前缀0x)  
u 以十进制形式输出无符号整数  
f 以小数形式输出单精度实数  
lf 以小数形式输出双精度实数  
e 以指数形式输出单、双精度实数  
g 以%f，%e中较短的输出宽度输出单、双精度实数  
c 输出单个字符  
s 输出字符串  
  
特殊：  
对64位整数的输入输出，在POJ上的C++环境下(即VC)，64位整数是：  
\_\_int64 （注意int前面是两个下划线），输入输出格式为”%I64d”.  
  
在G++环境下(即Dev C++) 64位整数是  
long long 输入输出格式为”%lld”.  
  
输出宽度  
　　用十进制整数来表示输出的最少位数。注意若实际位数多于定义的宽度，则按实际位数输出，若实际位数少于定义的宽度则补以空格或0。  
  
可以在"%"和字母之间插进数字表示最大宽度。  
  
%9.2f 表示输出场宽为9的浮点数，其中小数位为2，整数位为6，小数点占一位，不够9位右对齐。  
%8s 表示输出8个字符的字符串, 不够8个字符右对齐。  
  
如果字符串的长度，或整型数位数超过说明的场宽，将按其实际长度输出。  
但对浮点数, 若整数部分位数超过了说明的整数位宽度, 将按实际整数位输出;  
若小数部分位数超过了说明的小数位宽度，则按说明的宽度以四舍五入输出。  
另外，若想在输出值前加一些0, 就应在场宽项前加个0。  
例如: d 表示在输出一个小于4位的数值时, 将在前面补0使其总宽度为4位。  
  
如果用浮点数表示字符或整型量的输出格式，小数点后的数字代表最大宽度，小数点前的数字代表最小宽度。  
例如: %6.9s 表示显示一个长度不小于6且不大于9的字符串。若大于9，则第9个字符以后的内容将被删除。  
  
精度  
精度格式符以"."开头，后跟十进制整数。意义是：如果输出数字，则表示小数的位数；如果输出的是字符，则表示输出字符的个数；  
若实际位数大于所定义的精度数，则截去超过的部分。  
  
标志格式字符  
\- 结果左对齐，右边填空格  
\+ 输出符号(正号或负号)空格输出值为正时冠以空格，为负时冠以负号  
  
例如：  
double c = 24212345.24232;  
printf(“%020.4”); 表示输出精确到小数点后4位，输出占20位，若有空余的位补0。  
  
2. getc,putc  
  
int getc(FILE \*fp)  
getc主要是从文件中读出一个字符.常用的判断文件是否读取结束的语句为:(ch = getc(fp)) != EOF。EOF为文件结束标志，  
定义在stdio.h中，就像EXIT\_SUCCESS，EXIT\_FAILURE定义在stdlib.h中一样，文件也可以被理解为一种流,所以当fp为stdin时，  
getc(stdin)就等同于getchar()了.  
  
int putc(int ch,FILE \*fp)  
putc主要是把字符ch写到文件fp中去。如果fp为stdout，则putc就等同于putchar()了。  
  
\#include <stdio.h>  
\#include <stdlib.h>  
  
int main()  
\{  
FILE \* fp = fopen("tmp.txt", "w+");  
putc('a', fp);  
fflush(fp);  
fclose(fp);  
  
fp = fopen("tmp.txt", "r+");  
int c = getc(fp);  
printf("%c\\n", c);  
fclose(fp);  
  
int ch = getc(stdin);  
putc( ch, stdout);  
putc( '\\n', stdout);  
putc('a', stdout);  
  
return 0;  
\}  
  
3. getchar,putchar  
  
int getchar(void)  
getchar()主要是从标准输入流读取一个字符。默认的标准输入流即stdio.h中定义的stdin。但是从输入流中读取字符时又  
涉及到缓冲的问题，所以并不是在屏幕中敲上一个字符程序就会运行，一般是通过在屏幕上敲上回车键，然后将回车前的字符  
串放在缓冲区中，getchar() 就是在缓冲区中一个一个的读字符。当然也可以在while循环中指定终止字符，如下面的语句:  
while ((c = getchar()) != '\#')  
  
这是以'\#'来结束的。  
  
int putchar(int ch)  
putchar(ch)主要是把字符ch写到标准流stdout中去.  
  
\#include <stdio.h>  
\#include <stdlib.h>  
  
int main()  
\{  
int n;  
while((n = getchar()) != '\#')  
\{  
putchar((char)n);  
\}  
  
return 0;  
\}  
  
4. gets,puts  
  
char \* gets(char \*str)  
gets() 主要是从标准输入流读取字符串并回显，读到换行符时退出，并会将换行符省去。  
  
返回值为获得的字符串的首地址，实现链接操作。  
  
int puts(char \*str)  
puts() 主要是把字符串str写到标准流stdout中去，并会在输出到最后时添加一个换行符。  
  
返回值为0表示正常，非零表示错误  
\#include <stdio.h>  
\#include <stdlib.h>  
  
int main()  
\{  
char str\[256\];  
printf("%s\\n", gets(str));  
  
int ret = puts(str);  
printf("len: %d\\n", ret);  
  
return 0;  
\}  
  
文件输入输出：  
  
1. fgets,fputs  
  
char \*fgets(char \*str, int num, FILE \*fp)  
str 是存放读入的字符数组指针，num是最大允许的读入字符数，fp是文件指针。  
fgets的功能是读一行字符，该行的字符数不大于num-1。因为fgets函数会在末尾加上一个空字符以构成一个字符串。  
另外fgets在读取到换行符后不会将其省略。  
  
出现换行字符、读到文件尾或是已读了size-1个字符则停止读取，最后会加上NULL作为字符串结束。  
  
返回值 gets()若成功则返回s指针，返回NULL则表示有错误发生。  
  
int fputs(char \*str, file \*fp)  
fputs() 将str写入fp。fputs与puts的不同之处是fputs在打印时并不添加换行符。  
返回值 若成功则返回写出的字符个数，返回EOF则表示有错误发生。  
  
\#include <stdio.h>  
\#include <stdlib.h>  
int main()  
\{  
FILE \* fp = fopen("temp.txt", "w+");  
  
int ret = fputs("Hello world!", fp);  
printf("%d\\n", ret);  
fputs("\\n", fp);  
fputs("Hello China!", fp);  
  
rewind(fp);  
char str\[256\];  
fgets(str, 255, fp);  
fputs(str, stdout);  
fgets(str, 255, fp);  
fputs(str, stdout);  
  
fclose(fp);  
return 0;  
\}  
  
2. fgetc,fputc  
  
int fgetc(FILE \*fp)  
fgetc从fp的当前位置读取一个字符。若读到文件尾而无数据时便返回EOF  
  
int fputc(int ch, file \*fp)  
fputc是将ch写入fp当前指定位置。  
  
\#include <stdio.h>  
\#include <stdlib.h>  
  
int main()  
\{  
FILE \* fp = fopen("temp.txt", "r+");  
FILE \* fp1 = fopen("tmp.txt", "w+");  
  
  
int c = 0;  
while( (c = fgetc(fp)) != EOF)  
\{  
fputc(c, fp1);  
\}  
fclose(fp);  
fclose(fp1);  
return 0;  
\}  
  
3. fscanf,fprintf  
  
int fscanf(FILE \*fp, char \*format,...)  
fscanf() 按照指定格式从文件中出读出数据，并赋值到参数列表中。  
  
int fprintf(FILE \*fp, char \*format,...)  
fprintf() 将格式化数据写入流式文件中。  
  
\#include<stdio.h>  
int main()  
\{  
char c;  
FILE \*fin,\*fout;  
fin=fopen("data.txt","r");  
fout=fopen("data1.txt","w");  
while(fscanf(fin,"%c",&c)==1)  
fprintf(fout,"%c",c);  
fclose(fin);  
fclose(fout);  
return 0;  
\}  
  
\#include <stdio.h>  
\#include <stdlib.h>  
int main()  
\{  
int year, month, day;  
FILE \*fp = fopen("tmp.txt","w+");  
  
  
fprintf( fp, "%d-%d-%d",2013,9,29);  
rewind(fp);  
while( fscanf( fp, "%d-%d-%d", &year, &month, &day) > 1)  
\{  
printf("Y: %d M: %d D: %d\\n", year, month, day);  
\}  
  
  
fclose(fp);  
return 0;  
\}  
  
4. fread, fwrite  
  
  
size\_t fread(void \* ptr,size\_t size,size\_t nmemb,FILE \* stream);  
fread()用来从文件流中读取数据。  
参数stream为已打开的文件指针，参数ptr指向欲存放读取进来的数据的空间，读取的字符数以参数size\*nmemb来决定。  
fread()会返回实际读取到的nmemb数目，如果此值比参数nmemb来得小，则代表可能读到了文件尾或有错误发生，这时必须  
用feof()或ferror()来决定发生什么情况。  
  
  
返回值 返回实际读取到的nmemb数目。  
  
  
size\_t fwrite(const void \* ptr,size\_t size,size\_t nmemb,FILE \* stream);  
fwrite()用来将数据写入文件流中。  
参数stream为已打开的文件指针，参数ptr指向欲写入的数据地址，总共写入的字符数以参数size\*nmemb来决定。  
fwrite()会返回实际写入的nmemb数目。  
  
返回值 返回实际写入的nmemb数目。  
  
  
  
5. freopen  
  
  
FILE \* freopen(const char \* path,const char \* mode,FILE \* stream);  
  
  
文件输入输出重定向。  
参数path字符串包含欲打开的文件路径及文件名，参数mode请参考fopen()说明。参数stream为已打开的文件指针。  
freopen()会将原stream所打开的文件流关闭，然后打开参数path的文件。  
  
\#include<stdio.h>  
  
  
int main()  
\{  
char c;  
freopen( "temp.txt", "r", stdin);  
freopen( "tmp.txt", "w", stdout);  
while(scanf("%c",&c) == 1)  
printf("%c",c);  
return 0;  
\}  
  
这种文件操作方式仍然使用scanf();和printf();  
  
  
  
附注：  
  
  
1. 文件操作类型  
━━━━━━━━━━━━━━━━━━━━━━━━━━━━  
字符 含义  
────────────────────────────────────────────────────────  
"r" 打开文字文件只读  
"w" 创建文字文件只写  
"a" 增补, 如果文件不存在则创建一个  
"r+" 打开一个文字文件读/写  
"w+" 创建一个文字文件读/写  
"a+" 打开或创建一个文件增补  
"b" 二进制文件(可以和上面每一项合用)  
"t" 文这文件(默认项)  
━━━━━━━━━━━━━━━━━━━━━━━━━━━━  
  
  
2. 文件读写指针移动：  
  
int fseek (FILE \*stream, long offset, int fromwhere);  
fseek()函数的作用是将文件的位置指针设置到从fromwhere开始的第offset字节的位置上,  
  
其中fromwhere是下列几个宏定义之一:  
  
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  
 符号常数 数值 含义  
────────────────────────────────────────  
 SEEK\_SET 0 从文件开头  
 SEEK\_CUR 1 从文件指针的现行位置  
 SEEK\_END 2 从文件末尾  
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  
  
  
offset是指文件位置指针从指定开始位置(fromwhere指出的位置)跳过的字节数。它是一个长整型量，以支持大于64K字节的文件。  
fseek()函数一般用于对二进制文件进行操作。  
当fseek()函数返回0时表明操作成功, 返回非0表示失败。  
  
  
C++的输入输出常用函数：  
  
1、getch()和getche()，非缓冲式输入，从键盘读入一个字符。getch()读入字符不显示，由conio.h支持。  
2、cin.get()，getchar()，缓冲式输入，从键盘读入一个字符，并显示。getchar()由stdio.h支持，cin.get()由iostream.h支持  
3、putch()和putchar()，非缓冲式输出，输出一个字符到显示器。putch()由conio.h支持，putchar()由stdio.h支持。  
4、cout.put()，缓冲式输出，输出一个字符到显示器，由iostream.h支持。  
5、gets()和cin.geline()，缓冲式输入，读入一字符串（包括空格，不包括最后的回车），gets()由stdio.h支持，cin.getline()由iostream.h支持。  
6、puts()，非缓冲输出，输出一个字符串，由stdio.h支持。  
7、cin.putback()，把一个字符送回输入缓冲区。  
8、fflush(stdin)，清除输入缓冲区操作，无法清除cin.get()等带来的操作。  
9、cout.flush()，清除输出缓冲区。  
  
cin，cin.get()，cin.getline()，getline()，gets()，getchar  
  
C++程序把输入，输出看作字节流，输入时从输入流中抽取字节，输出时将字节流插入到输出流中，输出/输入的字节可能是来自键盘输入，  
也可能来自外部存储设备或其他程序，或者是来自网络。  
  
C++的iostream库中有几个比较常用的流对象。  
cin：是标准输入流对象，默认关联到标准输入设备键盘  
cout：是标准输出流对象，默认关联到标准输出设备显示器  
cerr，clog：是标准错误流对象，默认关联到标准输出设备显示器。  
  
1、cin  
2、cin.get()  
3、cin.getline()  
4、getline()  
5、gets()  
6、getchar()  
  
1、cin>>  
  
最基本，也是最常用的用法，输入一个数字：  
\#include <iostream>  
using namespace std;  
main ()  
\{  
int a,b;  
cin>>a>>b;  
cout<<a+b<<endl;  
\}  
输入：2\[回车\]3\[回车\]  
输出：5  
  
接受一个字符串，遇 空格、TAB、回车都会结束  
\#include <iostream>  
using namespace std;  
main ()  
\{  
char a\[20\];  
cin>>a;  
cout<<a<<endl;  
\}  
  
输入：jkljkljkl  
输出：jkljkljkl  
输入：jkljkl jkljkl //遇空格结束  
输出：jkljkl  
  
2、cin.get()  
cin.get(字符变量名)可以用来接收字符  
\#include <iostream>  
using namespace std;  
main ()  
\{  
char ch;  
ch = cin.get(); // 或者 cin.get(ch);  
cout<<ch<<endl;  
\}  
输入：jljkljkl  
输出：j  
  
cin.get( 字符数组名, 接收字符数目)用来接收一行字符串,可以接收空格  
\#include <iostream>  
using namespace std;  
main ()  
\{  
char a\[20\];  
cin.get(a,20);  
cout<<a<<endl;  
\}  
  
输入：jkl jkl jkl  
输出：jkl jkl jkl  
输入：abcdeabcdeabcdeabcdeabcde （输入25个字符）  
输出：abcdeabcdeabcdeabcd （接收19个字符+1个'\\0'）  
  
cin.get(无参数) 没有参数主要是用于舍弃输入流中的不需要的字符或者舍弃回车，弥补cin.get(字符数组名,接收字符数目)的不足。  
  
3、cin.getline() // 接受一个字符串，可以接收空格并输出  
\#include <iostream>  
using namespace std;  
main ()  
\{  
char m\[20\];  
cin.getline( m, 5);  
cout << m << endl;  
\}  
输入：jkljkljkl  
输出：jklj  
接受5个字符到m中，其中最后一个为'\\0'，所以只看到4个字符输出。如果把5改成20：  
输入：jkljkljkl  
输出：jkljkljkl  
输入：jklf fjlsjf fjsdklf  
输出：jklf fjlsjf fjsdklf  
  
延伸：  
cin.getline()实际上有三个参数，cin.getline(接受字符串的空间m,接受个数5,结束字符)  
当第三个参数省略时，系统默认为'\\0'。如果将例子中cin.getline()改为cin.getline(m,5,'a');，指定结束字符为'a'  
当输入jlkjkljkl时输出jklj，输入jkaljkljkl时，输出jk。  
  
当用在多维数组中的时候，也可以用cin.getline(m\[i\],20)之类的用法：  
\#include<iostream>  
\#include<string>  
using namespace std;  
main ()  
\{  
char m\[3\]\[20\];  
for(int i=0;i<3;i++)  
\{  
cout<<"\\n请输入第"<<i+1<<"个字符串："<<endl;  
cin.getline(m\[i\],20);  
\}  
cout<<endl;  
for(int j=0;j<3;j++)  
cout<<"输出m\["<<j<<"\]的值:"<<m\[j\]<<endl;  
\}  
  
请输入第1个字符串：  
kskr1  
请输入第2个字符串：  
kskr2  
请输入第3个字符串：  
kskr3  
输出m\[0\]的值:kskr1  
输出m\[1\]的值:kskr2  
输出m\[2\]的值:kskr3  
  
4、getline()  
  
接受一个字符串，可以接收空格并输出，需包含“\#include<string>”  
  
\#include<iostream>  
\#include<string>  
using namespace std;  
main ()  
\{  
string str;  
getline(cin,str);  
cout<<str<<endl;  
\}  
  
输入：jkljkljkl  
输出：jkljkljkl  
输入：jkl jfksldfj jklsjfl  
输出：jkl jfksldfj jklsjfl  
  
和cin.getline()类似，但是cin.getline()属于istream流，而getline()属于string流，是不一样的两个函数  
  
5、gets()  
  
接受一个字符串，可以接收空格并输出，需包含“\#include<string>”  
  
\#include<iostream>  
\#include<string>  
using namespace std;  
main ()  
\{  
char m\[20\];  
gets(m);  //不能写成m=gets();  
cout<<m<<endl;  
\}  
  
输入：jkljkljkl  
输出：jkljkljkl  
输入：jkl jkl jkl  
输出：jkl jkl jkl  
  
类似cin.getline()里面的一个例子，gets()同样可以用在多维数组里面：  
\#include<iostream>  
\#include<string>  
using namespace std;  
main ()  
\{  
char m\[3\]\[20\];  
for(int i=0;i<3;i++)  
\{  
cout<<"\\n请输入第"<<i+1<<"个字符串："<<endl;  
gets(m\[i\]);  
\}  
cout<<endl;  
  
for(int j=0;j<3;j++)  
cout<<"输出m\["<<j<<"\]的值:"<<m\[j\]<<endl;  
\}  
  
请输入第1个字符串：  
kskr1  
请输入第2个字符串：  
kskr2  
请输入第3个字符串：  
kskr3  
  
输出m\[0\]的值:kskr1  
输出m\[1\]的值:kskr2  
输出m\[2\]的值:kskr3  
  
自我感觉gets()和cin.getline()的用法很类似，只不过cin.getline()多一个参数罢了；  
这里顺带说明一下，对于本文中的这个kskr1,kskr2,kskr3的例子，对于cin>>也可以适用，原因是这里输入的没有空格。  
如果输入了空格，比如“ks kr jkl\[回车\]”那么cin就会已经接收到3个字符串，“ks,kr,jkl”；再如“kskr 1\[回车\]kskr 2\[回车\]”，  
那么则接收“kskr,1,kskr”；这不是我们所要的结果！而cin.getline()和gets()因为可以接收空格，所以不会产生这个错误。  
  
6、getchar()  
  
接受一个字符，需包含“\#include<string>”  
\#include<iostream>  
\#include<string>  
using namespace std;  
main ()  
\{  
char ch;  
ch = getchar(); // 不能写成getchar(ch);  
cout<<ch<<endl;  
\}  
  
输入：jkljkljkl  
输出：j  
  
//getchar()是C语言的函数，C++也可以兼容，但是尽量不用或少用；  
  
C++ 通过以下几个类支持文件的输入输出：  
  
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 二进制方式  
  
这些标识符可以被组合使用，中间以”或”操作符(|)间隔。   
file.open ("example.bin", ios::out | ios::app | ios::binary);  
  
ofstream, ifstream 和 fstream所有这些类的成员函数open 都包含了一个默认打开文件的方式，这三个类的默认方式各不相同： 类 参数的默认方式  
  
ofstream ios::out | ios::trunc  
ifstream ios::in  
fstream ios::in | ios::out  
  
只有当函数被调用时没有声明方式参数的情况下，默认值才会被采用。如果函数被调用时声明了任何参数，默认值将被完全改写，而不会与调用参数组合。  
由于对类ofstream, ifstream 和 fstream 的对象所进行的第一个操作通常都是打开文件，这些类都有一个构造函数可以直接调用open函数，并拥有同样的参数。  
这样，我们就可以通过以下方式进行与上面同样的定义对象和打开文件的操作：ofstream file("example.bin", ios::out|ios::app|ios::binary);  
  
两种打开文件的方式都是正确的。可以通过调用成员函数is\_open()来检查一个文件是否已经被顺利的打开了：bool is\_open();  
它返回一个布尔(bool)值，为真（true）代表文件已经被顺利打开，假( false )则相反。  
  
关闭文件(Closing a file)  
当文件读写操作完成之后，我们必须将文件关闭以使文件重新变为可访问的。关闭文件需要调用成员函数close()，它负责将缓存中的数据排放出来并关闭文件。它的格式很简单：void close ();