在程序中一般用cout和插入运算符“”实现输出，cout流在内存中有相应的缓冲区。有时用户还有特殊的输出要求，例如只输出一个字符。ostream类除了提供上面介绍过的用于格式控制的成员函数外，还提供了专用于输出单个字符的成员函数put。如：
目前创新互联建站已为近1000家的企业提供了网站建设、域名、虚拟主机、网站托管、服务器租用、企业网站设计、临夏网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
cout.put('a');
调用该函数的结果是在屏幕上显示一个字符a。put函数的参数可以是字符或字符的ASCII代码(也可以是一个整型表达式)。如
cout.put(65 + 32);
也显示字符a，因为97是字符a的ASCII代码。
可以在一个语句中连续调用put函数。如：
cout.put(71).put(79).put(79). put(68).put('\n');
在屏幕上显示GOOD。
[例13.4] 有一个字符串"BASIC"，要求把它们按相反的顺序输出。
#include iostreamusing namespace std;int main( )
{ char *a="BASIC";//字符指针指向'B'
for(int i=4;i=0;i--)
cout.put(*(a+i)); //从最后一个字符开始输出
cout.put('\n'); return 0;
}
除了使用cout.put函数输出一个字符外，还可以用putchar函数输出一个字符。putchar函数是C语言中使用的，在stdio.h头文件中定义。C++保留了这个函数，在iostream头文件中定义。
[例13.4] 也可以改用putchar函数实现。
#include iostream //也可以用#include stdio.h，同时不要下一行using namespace std;int main( )
{ char *a="BASIC"; for(int i=4;i=0;i--)
putchar(*(a+i));
putchar('\n');
}
成员函数put不仅可以用cout流对象来调用，而且也可以用ostream类的其他流对象调用。
cin输入流详解
标准输入流是从标准输入设备(键盘)流向程序的数据。在头文件iostream.h中定义了cin、cout、cerr、clog 4个流对象（详情请查看：与C++输入输出有关的类和对象），cin是输入流，cout、cerr、clog是输出流。
cin是istream类的对象，它从标准输入设备(键盘)获取数据，程序中的变量通过流提取符“”从流中提取数据。流提取符“”从流中提取数据时通常跳过输入流中的空格、tab键、换行符等空白字符。
注意：只有在输入完数据再按回车键后，该行数据才被送入键盘缓冲区，形成输入流，提取运算符“”才能从中提取数据。需要注意保证从流中读取数据能正常进行。
例如：
int a,b;
cinab;
若从键盘上输入
21 abc↙
变量a从输入流中提取整数21，提取操作成功，此时cin流处于正常状态。但在变量b准备提取一个整数时，遇到了字母a，显然提取操作失败了，此时，cin流被置为出错状态。只有在正常状态时，才能从输入流中提取数据。
当遇到无效字符或遇到文件结束符（不是换行符，是文件中的数据已读完）时，输入流cin就处于出错状态，即无法正常提取数据。此时对cin流的所有提取操作将终止。在 IBM PC及其兼容机中，以Ctrl + Z表示文件结束符。在UNIX和Macintosh系统中，以 Ctrl + D表示文件结束符。当输入流cin处于出错状态时，如果测试cin的值，可以发现它的值为false(假)，即cin为0值。如果输入流在正常状态，cin的值为true(真)，即cin为 一个非0值。可以通过测试cin的值，判断流对象是否处于正常状态和提取操作是否成功。如：
if(!cn) //流cin处于出销状态，无法正常提取数据
cout"error";
[例13.5] 通过测试cin的真值，判断流对象是否处于正常状态。
#include iostreamusing namespace std;int main( )
{ float grade;
cout"enter grade:"; while(cingrade)//能从cin流读取数据 { if(grade=85) coutgrade"GOOD!"endl; if(grade60) coutgrade"fail!"endl;
cout"enter grade:";
}
cout"The end."endl; return 0;
}
流提取符“”不断地从流中提取数据（每次提取一个浮点数），如果成功，就陚给 grade，此时cin为真，若不成功则cin为假。如果键入文件结束符，表示数据已完。
运行情况如下：
enter grade: 67↙
enter grade: 89↙
89 GOOD!
enter grade: 56↙
56 fail!
enter grade: 100↙
100 GOOD!
enter grade: ^Z↙//键入文件结束符
The end.
在遇到文件结束符时，程序结束。如果某次输入的数据为
enter grade: 100/2↙
流提取符""提取100，赋给grade，进行if语句的处理。然后再遇到"/"，认为是无效字符，cin返回0。循环结束，输出"The end."。
在不同的C++系统下运行此程序，在最后的处理上有些不同。以上是在GCC环境下运行程序的结果，如果在VC++环境（笔者使用win7系统）下运行此程序，在键入Ctrl + Z 时，需要敲击两次回车，程序才输出"The end."。
get()函数读入一个字符
get()函数是cin输入流对象的成员函数，它有3种形式：无参数的，有一个参数的，有3个参数的。
1) 不带参数的get函数
其调用形式为
cin.get()
用来从指定的输入流中提取一个字符（包括空白字符），函数的返回值就是读入的字符。 若遇到输入流中的文件结束符，则函数值返回文件结束标志EOF(End Of File)，一般以-1代表EOF，用-1而不用0或正值，是考虑到不与字符的ASCII代码混淆，但不同的C ++系统所用的EOF值有可能不同。
[例13.6] 用get函数读入字符。
#include iostreamusing namespace std;int main( )
{ int c;
cout"enter a sentence:"endl; while((c=cin.get())!=EOF)
cout.put(c); return 0;
}
运行情况如下：
enter a sentence:
I study C++ very hard.↙(输入一行字符)
I study C++ very hard. (输出该行字符)
^Z↙(程序结束)
C语言中的getchar函数与流成员函数cin.get( )的功能相同，C++保留了C的这种用法，可以用getchar(c)从键盘读入一个字符赋给c。
2) 有一个参数的get函数
其调用形式为
cin.get(ch)
其作用是从输入流中读取一个字符，赋给字符变量ch。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。例13.6可以改写如下：
#include iostreamusing namespace std;int main( )
{ char c;
cout"enter a sentence:"endl; while(cin.get(c)) //读取一个字符赋给字符变量c,如果读取成功,cin.get(c)为真 {cout.put(c);}
cout"end"endl; return 0;
}
3) 有3个参数的get函数
其调用形式为
cin.get(字符数组, 字符个数n, 终止字符)
或
cin.get(字符指针, 字符个数n, 终止字符)
其作用是从输入流中读取n-1个字符，赋给指定的字符数组(或字符指针指向的数组)，如果在读取n-1个字符之前遇到指定的终止字符，则提前结束读取。如果读取成功则函数返回true(真)，如失败(遇文件结束符) 则函数返回false(假)。再将例13.6改写如下：
#include iostreamusing namespace std;int main( )
{ char ch[20];
cout"enter a sentence:"endl;
cin.get(ch,10,'\\n');//指定换行符为终止字符
coutchendl; return 0;
}
运行情况如下：
enter a sentence:
I study C++ very hard.↙
I study
在输入流中有22个字符，但由于在get函数中指定的n为10，读取n -1个（即9个）字符并赋给字符数组ch中前9个元素。有人可能要问：指定n-10，为什么只读取9个字符呢？因为存放的是一个字符串，因此在9个字符之后要加入一个字符串结束标志，实际上存放到数组中的是10个字符。请读者思考：如果不加入字符串结束标志，会 出现什么情况？结果是：在用“coutch”;输出数组中的字符时，不是输出读入的字符串，而是数组中的全部元素。大家可以亲自测试一下ch[9]（即数组中第10个元素）的值是什么。
如果输入↙
abcde
即未读完第9个字符就遇到终止字符、读取操作终止，前5个字符已存放到数组ch[0]到ch[4]中，ch[5]中存放'\0'。
如果在get函数中指定的n为20，而输入22个字符，则将输入流中前19个字符赋给字符数组ch中前19个元素，再加入一个'\0'。
get函数中第3个参数可以省写，此时默认为'\n'。下面两行等价：
cin.get(ch,10,'\\n');
cin.get(ch,10);
终止字符也可以用其他字符。如
cin.get(ch,10,'x');
在遇到字符'x'时停止读取操作。
可以把流看作是一种数据的载体，通过它可以实现数据交换和传输。就像水流是一串水组成的 计算机中的数据流就是由一串数据组成的东西。
C++的输入输出流及文件操作
1. C++保留C的输入输出单个字符的函数
(1) putchar(c) —— 字符输出
例程：
#include
using namespace std;
int main()
{
char a,b,c;
a='B'; b='O';c='Y';
putchar(a); putchar(b); putchar(c);putchar('/n');
putchar(66);putchar(79);putchar(89);putchar(10); //10是换行的ASCII码
return 0;
}
(2) getchar() ——字符输入函数
例程：
#include
using namespace std;
int main()
{
char c;
c=getchar();
putchar(c+32); //转化为小写字母,大小写之间包括[ / ] ^ - 、6个字符，因此不加26加32。'A'=65
putchar('/n');
return 0;
}
也可用cout来输出： cout(c=getchar()+32);
2. scanf()、printf()函数的输入和输出
scanf(格式控制,输出表列);
printf(格式控制,输出表列);
例程：
#include
using namespace std;
int main()
{
int a;
float b;
char c;
scanf("%d % c % f", a,c,b);
printf("a=%d, b=%f, c=%c /n",a,b,c);
return 0;
}
3. 标准输入输出流cin、cout
包括头文件#include
输入输出流的控制符要加入头文件 #include
cout"dec:"
cout.put(97); //显示a字符--使用cout的成员函数put(c)
cin成员函数get()
(1) 不带参数的
char c=cin.get(); //用cin的成员函数get()从键盘读入一个字符到c中去
(2) 带一个参数的
cin.get(ch); //从输入的流中接受一个字符，并赋给字符变量ch
(3) 带三个参数的
cin.get(字符数组,字符的个数n,终止字符)
例程：
#include
using namespace std;
int main()
{
char ch[20];
cout"in put a string:"
cin.get(ch,10,'/n'); /*取得输入流的前10-1=9个字符赋值给ch数组的前9个元素，并规定换行符为为输入流的终止结束符*/
cout
return 0;
}
如输入：1 2 34567890 //按换行键终止流输入
则输出：1 2 34567 //只读得前9个送入ch数组中
cin的成员函数getline() ——从输入流中读入一行字符
cin.getline(字符数组(或字符指针),字符的个数n,终止字符)
例程：
#include
using namespace std;
int main()
{
char ch[20];
cout"input a string:"
cinch;
cout"The string read with cin is:"
cin.getline(ch,20,'/'); //读取19个字符到ch数组或遇到'/'结束
cout"The second part is:"
cin.getline(ch,20); //读取19个字符到ch数组或遇到'/n'结束,遇到'/'仍作为字符读入
cout"The third part is:"
return 0;
}
istream类的其他的成员函数如:eof(),在输入流中读取数据，如果到达末尾（遇到文件结束符），则eof()返回真，否则为假.
例程：
#include
using namespace std;
int main()
{
char c;
while(!cin.eof()) //若未遇到文件结束符
if((c=cin,get())!=' ') //检查读入的字符是否为空格字符
cout.put(c);
return 0;
}
4. 磁盘文件的打开和关闭
打开
ofstream outfile;
if(outfile.open("f1.data",ios::app)==0) // 打开
cout"打开失败！";
……………………
outfile.close(); //关闭
5. 文件写入
#include
#include
#include //一定不能少了，否则报错 error C2679
using namespace std;
int main()
{
string str;
ofstream out("d.txt",ios::out); //等价于ofstream out("d.txt")
if(!out) //若打开失败，out返回0值
{
cerr"打开失败！"
exit(0);
}
str="床前明月光/n疑是地上霜/n举头望明月/n低头思故乡/n";
out return 0;
}
6. 读文件到控制台
#include
#include
#include
using namespace std;
int main()
{
ifstream infile("d://new//d.txt",ios::in); //定义输入文件的流对象，以输入方式打开磁盘文件d.txt,第二个参数可去
if(!infile)
{
cerr"打开失败！" exit(1);
}
for(string str;getline(infile,str);) //逐行打开并逐行显示，因此在循环中实现
cout infile.close();
return 0;
}
或把 for(string str;getline(in,str);)
cout
两句改为 string str;
while(getline(in,str))
cout
7. 文件复制
#include
#include
#include
using namespace std;
int main()
{
ifstream in("d.txt");
if(!in)
{
cerr"打开源文件失败!" exit(1);
}
ofstream out("b.txt");
if(!out)
{
cerr"打开目的文件失败!" exit(1);
}
for(string str;getline(in,str);)
out cout"文件复制成功!"
in.close();
out.close();
return 0;
}
8. 自定义一个文件读入的函数 void display( char *filename)
#include
#include
#include
using namespace std;
void display(char *filename)
{
ifstream infile(filename,ios::in);
if(!infile)
{
cerr"打开失败！" exit(1);
}
char ch;
while(infile.get(ch))
cout.put(ch);
cout infile.close();
}
int main()
{
display("d.txt");
return 0;
}
9.关于文件读写的综合应用
#include
#include
using namespace std;
//从键盘读入字母并存入文件“d.txt”中
void save_to_file()
{
ofstream ofile("d.txt");
if(!ofile)
{
cerr"打开失败d.txt！" exit(1);
}
char c[80];
cin.getline(c,80); //从键盘逐个读入一行字符
for(int i=0;c[i]!=0;i++) //对字符逐个处理，知道遇到'/n'结束
if(c[i]=65 c[i]=90||c[i]=97 c[i]=122)
{
ofile.put(c[i]); //将字母存入磁盘文件d.txt
cout }
cout ofile.close();
}
//将"d.txt"中的字母转化为大写字母并存入"out.txt"中
void get_from_file()
{
char ch;
ifstream infile("d.txt");
if(!infile)
{
cerr"打开失败d.txt！" exit(1);
}
ofstream outfile("out.txt");
if(!infile)
{
cerr"打开失败out.txt！" exit(1);
}
while(infile.get(ch)) //逐个读入字符成功后执行下面的语句
{
if(ch=97 ch=122)
ch=ch-32;
outfile.put(ch);
cout }
cout infile.close();
outfile.close();
}
int main()
{
save_to_file();
get_from_file();
return 0;
}
=========================== C/C++的字符或字符数组的读入函数总结=====================
1、cin
1、cin.get()
2、cin.getline()
3、getline()
4、gets()
5、getchar()
1、cin
用法1：最基本，也是最常用的用法，输入一个数字：
#include
using namespace std;
main ()
{
int a,b;
cinab;
cout}
输入：2[回车]3[回车]
输出：5
用法2：接受一个字符串，遇“空格”、“TAB”、“回车”都结束
#include
using namespace std;
main ()
{
char a[20];
cina;
cout}
输入：jkljkljkl
输出：jkljkljkl
输入：jkljkl jkljkl //遇空格结束
输出：jkljkl
2、cin.get()
用法1： cin.get(字符变量名)可以用来接收字符
#include
using namespace std;
main ()
{
char ch;
ch=cin.get(); //或者cin.get(ch);
cout}
输入：jljkljkl
输出：j
用法2：cin.get(字符数组名,接收字符数目)用来接收一行字符串,可以接收空格
#include
using namespace std;
main ()
{
char a[20];
cin.get(a,20);
cout}
输入：jkl jkl jkl
输出：jkl jkl jkl
输入：abcdeabcdeabcdeabcdeabcde （输入25个字符）
输出：abcdeabcdeabcdeabcd （接收19个字符+1个'/0'）
3、cin.getline() // 接受一个字符串，可以接收空格并输出
getline 会将换行符替换为空字符
#include
using namespace std;
main ()
{
char m[20];
cin.getline(m,5);
cout}
输入：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');当输入jlkjkljkl时输出jklj，输入jkaljkljkl时，输出jk
当用在多维数组中的时候，也可以用cin.getline(m[i],20)之类的用法：
#include
#include
using namespace std;
main ()
{
char m[3][20];
for(int i=0;i3;i++)
{
cout"/n请输入第"cin.getline(m[i],20);
}
coutfor(int j=0;j3;j++)
cout"输出m["
}
请输入第1个字符串：
kskr1
请输入第2个字符串：
kskr2
请输入第3个字符串：
kskr3
输出m[0]的值:kskr1
输出m[1]的值:kskr2
输出m[2]的值:kskr3
4、getline() // 接受一个字符串，可以接收空格并输出，需包含“#include”
#include
#include
using namespace std;
main ()
{
string str;
getline(cin,str);
cout}
输入：jkljkljkl
输出：jkljkljkl
输入：jkl jfksldfj jklsjfl
输出：jkl jfksldfj jklsjfl
和cin.getline()类似，但是cin.getline()属于istream流，而getline()属于string流，是不一样的两个函数
5、gets() // 接受一个字符串，可以接收空格并输出，需包含“#include”
#include
#include
using namespace std;
main ()
{
char m[20];
gets(m); //不能写成m=gets();
cout}
输入：jkljkljkl
输出：jkljkljkl
输入：jkl jkl jkl
输出：jkl jkl jkl
类似cin.getline()里面的一个例子，gets()同样可以用在多维数组里面：
#include
#include
using namespace std;
main ()
{
char m[3][20];
for(int i=0;i3;i++)
{
cout"/n请输入第"gets(m[i]);
}
coutfor(int j=0;j3;j++)
cout"输出m["
}
请输入第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”
#include
#include
using namespace std;
main ()
{
char ch;
ch=getchar(); //不能写成getchar(ch);
cout}
输入：jkljkljkl
输出：j
//getchar()是C语言的函数，C++也可以兼容，但是尽量不用或少用；
总结：
1.读入一行
gets(char a[]); //接受一行，遇回车结束
gets(m[i]) //可用于多维数组中
cin.get(char a[],int 5,'/n') //将字符数组a的前5个字符读入，遇到换行符结束；比如:a bc12ds，将会读入4个字符 a bc,外加一个'/0'；
// 一般第三个参数不写，默认为'/0'
eg:
#include
#include
using namespace std;
main ()
{
string str;
getline(cin,str);
cout}
2.读入一个字符
getchar() //接受一个字符，需包含“#include”
char ch =getchar();
cin.get(char c) 或者 cin.get()
char ch=cin.get(); 或者cin.get(ch)
getline()和cin.getline()类似，但是cin.getline()属于istream流，而getline()属于string流，是不一样的两个函数
cin.getline(char a[],int 5,'/n') //将字符数组a的前5个字符读入，遇换行符结束;如:a bc12ds，将会读入4个字符 a bc,外加一个'/0'；
// 一般第三个参数不写，默认为'/0'
cin.getline(m[i],20) //可用于多维数组中
getline() // 接受一个字符串，可以接收空格并输出，需包含“#include"
C语言中stdin流的用法:
stdin是C语言中标准输入流，一般用于获取键盘输入到缓冲区里的东西。
访问stdin，可用stdio.h中提供的以下几个函数：
(1)scanf、getchar来从stdin流中获取指定的数据。scanf根据第一个参数指定的格式符将数据读入后续参数指定的内存位置中；getchar从stdin流中读取一个字符并返回。
(2)可以使用一般的访问输入流的函数来访问stdin，比如：fscanf、fgetc，使用方法和scanf、getchar类似，只是多了一个参数指定文件流。当然，scanf和getchar的具体实现就是通过调用fscanf和fgetc，这样可以提高代码利用率。
(3)可以用fflush和rewind这两个函数来刷新stdin，来清空缓冲区中已有的内容，不过这种方法不是标准方法，当stdin被重定向到文件时，这会导致指针重新指向文件开头。
C语言从stdin读取一行字符串的方法如下：
gets
gets函数的头文件是stdio.h,原型如下：
char *gets(char *s);
gets从stdin中读入一行内容到s指定的buffer中，当遇到换行符或EOF时读取结束。读取成功时，返回s地址；失败时返回null。需要注意的是，gets会将行末尾的'\n'字符或EOF替换成'\0'，这样，gets读取的内容中不包括'\n'字符。如果要获取读取字符串的长度，可以调用strlen函数获得。
fgets
fgets函数的头文件是stdio.h,原型如下：
char *fgets(char *s, int size, FILE*stream);
fgets从stream中读取最多size-1大小的内容到s指定的buffer中，当遇到换行符或EOF时读取结束。读取成功时，返回s地址；失败时返回null。需要注意的是，fgets会在所读取的内容后面添加'\0'，这样，fgets读取的内容中会包括行末尾的'\n'字符。如果要获取读取字符串的长度，可以调用strlen函数获得。
getline
getline函数的头文件是stdio.h,原型如下:
ssize_t getline(char **lineptr,size_t *n, FILE *stream);
getline从stream中读取一行内容到*lineptr所指定的buffer中，当遇到换行符或EOF时读取结束。＊n是*lineptr所指定的buffer的大小，如果＊n小于读入的内容长度，getline会自动扩展buffer长度，并更新*lineptr和*n的值。读取成功时，返回读入的字符个数；失败时返回-1。需要注意的是，gelines读取的内容中会包括行末尾的'\n'字符。
C语言输入输出函数有很多，bai标准I/O函数du中包含了如下几个常用的函数：
scanf,printf,getc,putc,getchar,putchar,gets,puts,fgets,fputs,fgetc,fputc,fscanf,fprintf等.
int scanf(const char *format, arg_list)
scanf主要从标准zhi输入流中获取dao参数值,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){...}来判断用户输入是否正确.
int printf(const char *format, arg_list)
printf主要是将格式化字符串输出到标准输出流中,在stdio.h头文件中定义了标准的输入和输出,分别是stdin,stdout.
arg_list可以是变量名,也可以是表达式,但最终都会以值的形式填充进format中.
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()了.
int getchar(void)
getchar主要是从标准输入流读取一个字符.默认的标准输入流即stdio.h中定义的stdin.但是从输入流中读取字符时又
涉及到缓冲的问题,所以并不是在屏幕中敲上一个字符程序就会运行,一般是通过在屏幕上敲上回车键,然后将回车前的字符
串放在缓冲区中,getchar就是在缓冲区中一个一个的读字符.当然也可以在while循环中指定终止字符,如下面的语句:
while ((c = getchar()) != '#')这是以#来结束的.
int putchar(int ch)
putchar(ch)主要是把字符ch写到标准流stdout中去.
char * gets(char *str)
gets主要是从标准输入流读取字符串并回显，读到换行符时退出,并会将换行符省去.
int puts(char *str)
puts主要是把字符串str写到标准流stdout中去,并会在输出到最后时添加一个换行符.
char *fgets(char *str, int num, FILE *fp)
str是存放读入的字符数组指针,num是最大允许的读入字符数,fp是文件指针.fgets的功能是读一行字符，该行的字符数
不大于num-1.因为fgets函数会在末尾加上一个空字符以构成一个字符串.另外fgets在读取到换行符后不会将其省略.
int fputs(char *str, file *fp)
fputs将str写入fp.fputs与puts的不同之处是fputs在打印时并不添加换行符.
int fgetc(FILE *fp)
fgetc从fp的当前位置读取一个字符.
int fputc(int ch, file *fp)
fputc是将ch写入fp当前指定位置.
int fscanf(FILE *fp, char *format,...)
fscanf按照指定格式从文件中出读出数据,并赋值到参数列表中.
int fprintf(FILE *fp, char *format,...)
fprintf将格式化数据写入流式文件中.
