您现在的位置： &
C语言中数据的输入和输出
　　§2.5&&& 数据的输入和输出
　　对数据的一种重要的操作是输入输出。没有输出的程序是没有用的，没有输入的程序缺乏灵活性。C语言的输入输出由函数来实现，它提供了多种输入输出函数，使输入输出灵活方便。标准I/O函数库中有一些公用的信息写在头文件stdio.h中，因此使用标准I/O函数时，一般应在程序的开头写上预编译命令#include “stdio.h”，以便把I/O函数要使用的信息包含到程序中来。
　　2.5.1& printf函数
　　printf函数的功能是按照指定的输出格式在标准输出设备上输出数据。它有两种参数：格式控制参数和输出项参数。它们的一般形式为：
　　printf（格式控制参数，输出项1，输出项2，…）
　　格式控制参数以字符串的形式描述，也称为“格式控制字符串”。它由两种成分组成：格式说明和普通字符。普通字符（包括转义字符）将被简单复制地显示。一个格式说明项将引起一个输出参数项的转换与显示，它是由“%”号引出并以一个类型描述符结束的字符串，中间可以是一些可选的附加说明项。下面对组成格式说明的各项加以说明：
　　(1) 格式字符：格式字符用以指定输出项的数据类型的输出格式。字母d用于输出十进制整数，字母x用于输出十六进制整数，字母o用于输出八进制整数，字母u用于输出无符号十进制整数，字母c用于输出字符，字母s用于输出字符串，字母e（或E）用于输出指数形式表示的浮点数，字母f用于输出小数形式表示的浮点数。格式字符与其对应的输出项的类型要一致。
　　(2) 长度修正符l或h：字母l用于长整型数据或双精度型数据，字母 h用于短整型数据。
　　(3) 域宽及精度描述符m.n：m和n分别指数据所占域宽和实型数据的小数位数（不包括小数点）。如果没有指定n时，隐含的精度为6位。
　　(4) 数0用以指定数字前的空位是否用0填补。
　　(5) 负号用以指定输出项左对齐输出。
　　注意：输出数据的实际精度并不主要取决于格式项中的域宽与精度，也不决定于输入的数据精度，而主要取决于数据在机器内的存储精度。
　　2.5.2& scanf函数
　　scanf函数的功能是按照指定的输入格式从标准输入设备把数据传送到地址参数所指定的内存中。其一般形式为：
　　scanf（格式控制参数，地址1，地址2，…）
　　1.地址参数
　　C语言允许间接地使用内存地址，这个地址是通过对变量名“求地址”运算得到的。求地址的运算符为“&”，得到的地址是一种符号地址。例如，“&a”和“&b”分别表示取变量a和变量b的地址。
　　2.格式控制参数
　　scanf中的格式参数基本类似于printf中的格式参数，它有两种成分：格式说明项和输入分隔符。
　　(1)格式说明项：由“%”号和格式字符组成，中间可以是一些可选的附加说明符。其中格式字符和附加说明符基本类似于printf函数中的格式字符和附加说明符。
　　(2)输入流数据分隔：scanf函数从输入数据流中接收非空的字符，再转换成格式项中描述的格式，传送到与格式项对应的地址中去。那么当操作人员在键盘上键入一串字符时，系统怎么知道哪几个字符算作一个数据项呢？有以下几种方法：
　　l根据格式字符的含义从输入流中取得数据，当输入流中数据类型与格式字符要求不符时，就认为这一数据项结束。（一般不推荐使用这种方法）
　　l根据格式项中指定的域宽分隔出数据项。
　　l用默认分隔符分隔出数据项。空格、跳格符和换行符都是默认的数据分隔符。（推荐使用这种方法）
　　例2.5& 设从键盘上输入数据12& 345& 21时，分析以下程序的运行结果。
　　main( )
　　float b,c;
　　printf(“input a b c:”);
　　scanf(“%d%f%f”,&a,&b,&c);
　　printf(“a=%d,b=%f,c=%f”,a,b,c);
　　C语言允许在输入数据时使用用户自己指定的字符来分隔数据。这时应在格式控制参数中的相应位置上出现这些字符。（推荐使用这种方法，常用的是逗号分隔符）
　　例2.6& 设从键盘上输入数据1，976.38时，分析以下程序的运行结果。
　　main( )
　　float b,c;
　　printf(“input a b c:”);
　　scanf(“%d,%f,%f”,&a,&b,&c);
　　printf(“a=%d,b=%f,c=%f \n”,a,b,c);
　　3.scanf函数的停止与返回
　　scanf函数在执行中遇到下面两种情况后结束：
　　(1)格式参数中的格式项用完而正常结束。
　　(2)发生格式项与输入域不匹配时而非正常结束。
　　注意：scanf是一个函数，它也有一个返回值，这个返回值就是成功匹配的项数。
　　4.scanf函数与输入缓冲区
　　在输入数据时，实际上并不是输入完一个数据项就被读入送给一个变量，而是在键入一行字符并按回车键之后才被输入，这一行字符先放在一个缓冲区中，然后按scanf函数格式说明的要求从缓冲区中读数据。如果输入的数据多于一个scanf函数所要求的个数，余下的数据可以为下一个scanf函数接着使用。如果输入的数据少于一个scanf函数所要求的个数，则必须从键盘继续输入数据。
　　例2.7：设从键盘上输入数据12& 24& 36& 48& 60?和72& 84?时，分析以下程序运行结果。
　　main( )
　　int a, b,c,d,e,f:
　　scanf(“%d %d”,&a,&b); scanf(“%d %d”,&c,&d);
　　scanf(“%d”,&e);scanf(“%d”,&f);
　　printf(“a=%d,b=%d,c=%d,d=%d,e=%d,f=%d\n”,a,b,c,d,e,f);
　　说明：第一个scanf函数从缓冲区中读取前2个整数分别给a和b，第2个scanf接着读取下两个整数给c和d，第3个scanf函数接着读取下一个数据给e。此时缓冲区中数据已读完。从键盘再键入一行字符，第4个scanf函数取其中第一个整数，第二个整数没有用上而处于等待状态。
　　2.5.3& getchar函数与putchar函数
　　getchar函数的功能是从标准输入设备上读入一个字符，putchar函数的功能是将形参中的字符输出到标准输出设备上。
　　例2.8& 输入三个字母，如果其中有小写字母就转换成大写字母。
　　#include “stdio.h”
　　main( )
　　char ch1,ch2,ch3;
　　ch1=getchar( );ch2=getchar( );ch3=getchar( );
　　if (ch1&=‘a’&&ch1&=‘z’)ch1=ch1-32;
　　if (ch2&=‘a’&&ch2&=‘z’)ch2=ch2-32;
　　if (ch3&=‘a’&&ch3&=‘z’)ch3=ch3-32;
　　putchar(ch1);putchar(ch2);putchar(ch3);
　　说明：在执行getchar函数时，虽然是读入一个字符，但并不是从键盘按一个字符，该字符就被读入送给一个字符变量，而是等到输入完一行按回车键之后，才将该行的字符输入缓冲区，然后getchar函数从缓冲区中取一个字符给一个字符变量。
　　小结：本章主要介绍了数据类型的概念及其分类，数据型数据和字符型数据在内存中的存储形式、存储空间的长度以及取值范围，常量的书写格式，变量的概念、声明、初始化和对变量的赋值，标识符的命令规则及其分类，算术运算符、关系运算符、逻辑运算符、条件运算符以及由这些运算符构成的表达式，不同数据类型的隐式转换和显式转换，标准输入和输出函数的正确使用。
了解更多相关知识可进入学习C语言输入一行数据并统计其长度_C语言中文网
&&/&&&&/&&
从控制台输入一行数据并计算它的长度；输入空行结束程序
#include &stdio.h&
#define MAXBUF 128
int getline(char line[], int nmax);
int main(void){
char buffer[MAXBUF];
len = getline(buffer, MAXBUF);
if (len==0)
printf(&len = %d, line = %s\n&, len, buffer);
// 提示用户输入一行字符串，最大长度为 nmax，并返回字符串的长度
int getline(char line[], int nmax)
printf(&Enter a string [CR to exit]: &);
while(((c=getchar())!='\n') && len&nmax-1)
line[len++]=c;
line[len]='\0';
可能的输出结果：
Enter a string [CR to exit]: 123456
len = 6, line = 123456&
Enter a string [CR to exit]: C语言中文网
len = 11, line = C语言中文网
Enter a string [CR to exit]: http://see./cpp/
len = 29, line = http://see./cpp/
Enter a string [CR to exit]:
Press any key to continue
推荐文章 TOP10ACM题目中输入数据的处理（C语言版）_C++,C语言_ThinkSAAS
ACM题目中输入数据的处理（C语言版）
ACM题目中输入数据的处理（C语言版）
内容来源： 网络
ACM题目中输入数据的处理（C语言版）
　ACM竞赛题目的输入数据常要求有多组，并且格式多种多样，这是初次登OJ平台的同学的一个障碍。实际上，这些格式可以归为固定的几种类型，本文介绍各种类型的处理方法，以帮助同学们克服这些障碍。　　实际上，这些模式不仅是OJ平台上做题的需要。在平时的自由编程练习中，也可以自行使用这些模式，以提高调试程序的效率。对程序测试的意识也将在此过程中得到提升。
　　本文1-4部分介绍了几种类型输入的处理，第5部分介绍通过输入重定向提高调试程序效率的方法。
最简单的输入
[plain] view plaincopyprint?
1.Description
2.计算 a+b
5.两个整数 a,b
11.Sample Input
14.Sample Output
Description计算 a+bInput两个整数 a,bOutputa+b的值Sample Input1 2Sample Output3　　这种最简单的输入，接受一组输入，针对这组输入计算出值即可。这与平时的程序设计并无差异。解决办法是：
[cpp] view plaincopyprint?
#include &stdio.h&
int main()
scanf("%d %d",&a, &b);
printf("%d
",a+b); //对其他题目，换成要求的复杂处理与输出
#include &stdio.h&
int main()
scanf("%d %d",&a, &b);
printf("%d
//对其他题目，换成要求的复杂处理与输出 return 0;}
一次运行，要输入多组数据，直到读至输入文件末尾（EOF）为止
[plain] view plaincopyprint?
1.Description
2.计算 a + b
5.多组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行
8.每组的两个整数（a和b）求和并输出，每组的求和结果独占一行
10.Sample Input
13.400 516
15.Sample Output
Description计算 a + bInput多组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行 Output每组的两个整数（a和b）求和并输出，每组的求和结果独占一行Sample Input1 510 Sample Output630916　　这种输入包含多对输入数据，需要构造一个循环读取。因为没有指出到底有多少对输入，要有办法判断输入何时结束。解决办法是：
[cpp] view plaincopyprint?
1.#include &stdio.h&
2.int main()
4. int a,b;
5. while(scanf("%d %d",&a, &b) != EOF) // 输入结束时，scanf函数返回值为EOF(-1)，即没有数据输入时会退出while循环
7. printf("%d
9. return 0;
include &stdio.h&int main() { int a,b; while(scanf("%d %d",&a, &b) != EOF) // 输入结束时，scanf函数返回值为EOF(-1)，即没有数据输入时会退出while循环 { printf("%d
",a+b); } return 0; }　　说明：scanf函数返回值就是读出的变量个数，如果一个都没有，则返回值是-1。EOF是一个预定义的常量，等于-1。
一次运行，要输入多组数据，组数由第一个输入数据决定（在开始的时候输入一个N，接下来是N组数据）
[plain] view plaincopyprint?
1.Description
2.计算 a + b
5.第一行是数据的组数N，从第二行是N组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行
8.每组的两个整数（a和b）求和并输出，每组的求和结果独占一行
10.Sample Input
15.Sample Output
Description计算 a + bInput第一行是数据的组数N，从第二行是N组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行 Output每组的两个整数（a和b）求和并输出，每组的求和结果独占一行Sample Input21 510 20Sample Output630　　需要先读入第一行确定组数N，而后写一次执行N次的循环进行处理即可。解决办法是：
[cpp] view plaincopyprint?
1.#include&stdio.h&
2.int main()
4. int n,i;
5. int a,b;
6. scanf("%d",&n);
7. for(i=0;i&n;i++)
9. scanf("%d%d",&a,&b);
10. printf("%d
12. return 0;
include&stdio.h&int main(){ int n,i; int a,b; scanf("%d",&n); for(i=0;i&n;i++) { scanf("%d%d",&a,&b); printf("%d
",a+b); } return 0;}
输入不说明有多少组数据，但以某个特殊输入为结束标志。平时做题中常见诸如“输入学生成绩，以-1结束”，没有学生得-1分的，这个结束数据可以要得。
[plain] view plaincopyprint?
1.Description
2.计算 a + b
5.多组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行。当输入为 0 0 时，输入结束。
8.每组的两个整数（a和b）求和并输出，每组的求和结果独占一行。
10.Sample Input
15.Sample Output
Description计算 a + bInput多组由两个整数（a和b）构成的输入，a和b之间用空格隔开，每组输入单独占一行。当输入为 0 0 时，输入结束。Output每组的两个整数（a和b）求和并输出，每组的求和结果独占一行。Sample Input1 510 200 0Sample Output630　　构造循环对数据进行处理，将是否遇到了要求结束的输入，作为循环是否结束的依据。解决办法是：
[cpp] view plaincopyprint?
1.#include &stdio.h&
2.int main()
4. int a,b;
5. while(scanf("%d %d",&a, &b) &&(a||b))
7. printf("%d
9. return 0;
include &stdio.h&int main(){ int a,b; while(scanf("%d %d",&a, &b) &&(a||b)) { printf("%d
",a+b); } return 0;}
　　有关字符和字符串数据的输入，在此不再多讲，只要将相关的函数用好即可，也可以找到相关资料参考。
利用文件重定向提高调试效率
　　编程得到正确结果前，往往需要多次运行程序，每次运行都需要花费不少的时间从键盘输入数据。每次输入的数据都是相同的时，会给人的心理带来不爽的感觉，并造成时间上的浪费。无论平时练习还是ACM竞赛实战，这些都是可以避免的。方法是，运用重定向。
　　用下面的形式调用函数freopen()会将标准输入stdin重定向到文件input.txt（这个名字可以自己定义）。
[cpp] view plaincopyprint?
1.freopen("input.txt","r",stdin); //设置输入和输出文件
freopen("input.txt","r",stdin); //设置输入和输出文件　　重定向后，原先从键盘（标准输入的默认设备）接受的输入，将统统从文件读取input.txt读取，这就是重定向。程序可以写作：
[cpp] view plaincopyprint?
1.#include&stdio.h&
2.int main()
4. freopen("input.txt","r",stdin); //只加这一句输入将被重定向到文件input.txt
5. int a,b;
6. scanf("%d%d",&a,&b);
7. printf("%d
8. return 0;
include&stdio.h&int main(){ freopen("input.txt","r",stdin); //只加这一句输入将被重定向到文件input.txt int a,b; scanf("%d%d",&a,&b); printf("%d
",a+b); return 0;}　　于是，在运行程序前，将本该由键盘输入的数据，写到文件input.txt中。而在运行程序时，数据将不再需要人去输入。那个快，很享受。
　　需要注意的是，调试通过的程序，千万不要直接提交到OJ平台上去。如果竞赛中这样做了，罚你的20分钟不要算到我的头上。提交的程序要把输入重定向的一行删除，这样才算是符合要求的，可以获得AC的程序。
　　除了删除那一行，还有一种简单的做法是，提交前将这一行前加上注释符"//"，效果是一样的。
[cpp] view plaincopyprint?
1.#include&stdio.h&
2.int main()
4. //freopen("input.txt","r",stdin); //只加这一句输入将被重定向到文件input.txt
5. int a,b;
6. scanf("%d%d",&a,&b);
7. printf("%d
8. return 0;
include&stdio.h&int main(){ //freopen("input.txt","r",stdin); //只加这一句输入将被重定向到文件input.txt int a,b; scanf("%d%d",&a,&b); printf("%d
",a+b); return 0;}
PHP开发框架
开发工具/编程工具
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
让ThinkSAAS更好，把建议拿来。
开发客服微信C语言入门经典(第5版) - 互动出版网
<meta name="Description" content="C语言入门经典(第5版)
作者：(美)霍尔顿(Horton, I.) &&&&
C语言是每一位程序员都应该掌握的基础语言。C语言是微软.NET编程中使用的C#语言的基础；C语言是iPhone、iPad和其他苹果设备编程中使用的Objective-C语言的基础；C语言是在很多环境中(包括GNU项目)被广泛使用的C++语言的基础。C语言也是Linux操作系统及其很多功能的基础。学习C语言可以给编程职业生涯提供牢固的基础，也有助于更好地理解更为现代的语言(如Java)。
C语言是每一位程序员都应该掌握的基础语言。C语言是微软.NET编程中使用的C#语言的基础；C语言是iPhone、iPad和其他苹果设备编程中使用的Objective-C语言的基础；C语言是在很多环境中(包括GNU项目)被广泛使用的C++语言的基础。C语言也是Linux操作系统及其很多功能的基础。学习C语言可以给编程职业生涯提供牢固的基础，也有助于更好地理解更为现代的语言(如Java)。《C语言入门经典(第5版)》主要介绍最基础的计算机语言之一――C语言。《C语言入门经典(第5版)》从最基础的内容开始，步步深入讲解作为一位称职的C语言程序员应该具备的知识和技能。主要内容◆ 阐述C语言的核心特征，例如循环和分支◆ 如何使用指针和指令动态管理内存◆ 如何使用头文件和函数模块化代码◆ 程序如何通过键盘、显示器和数据文件读写数据◆ 如何通过预处理命令在编译时优化代码◆ 如何使用结构有效地管理输入数据《C语言入门经典(第5版)》完整地介绍了一个C应用程序的开发过程，这样你在阅读过程中可以结合实际的应用场景提高编程技能。书中的样例提供了实验的基础，可以通过修改其中的部分代码来对比前后程序运行的结果。后面的练习题用来测试对新知识、新技能的掌握情况，如果需要练习题答案，可以网上下载。阅读完本书，你应该有能力和信心开发自己的C应用程序，并且具备在大型项目中应用C语言思想的技能。第5版详细介绍了C语言的最新国际标准，并且修订涵盖了语言编译器新支持的C11功能。
《C语言入门经典(第5版)》第1章
C语言编程 11.1
C语言 11.2
标准库 21.3
学习C 21.4
创建C程序 21.4.1
编辑 21.4.2
编译 31.4.3
链接 41.4.4
创建第一个程序 51.6
编辑第一个程序 51.7
处理错误 61.8
剖析一个简单的程序 71.8.1
注释 71.8.2
预处理指令 81.8.3
定义main()函数 91.8.4
关键字 101.8.5
函数体 101.8.6
输出信息 111.8.7
参数 111.8.8
控制符 111.8.9
三字母序列 131.9
预处理器 141.10
用C语言开发程序 141.10.1
了解问题 141.10.2
详细设计 151.10.3
实施 151.10.4
测试 151.11
函数及模块化编程 161.12
常见错误 191.13
要点 191.14
小结 201.15
习题 20第2章
编程初步 212.1
计算机的内存 212.2
什么是变量 232.3
存储整数的变量 242.3.1
变量的使用 282.3.2
变量的初始化 292.4
变量与内存 362.4.1
带符号的整数类型 362.4.2
无符号的整数类型 372.4.3
指定整数常量 372.5
使用浮点数 392.6
浮点数变量 412.6.1
使用浮点数完成除法运算 422.6.2
控制输出中的小数位数 432.6.3
控制输出的字段宽度 432.7
较复杂的表达式 442.8
定义命名常量 462.8.1
极限值 492.8.2
sizeof运算符 512.9
选择正确的类型 522.10
强制类型转换 552.10.1
自动转换类型 562.10.2
隐式类型转换的规则 562.10.3
赋值语句中的隐式类型转换 572.11
再谈数值数据类型 582.11.1
字符类型 582.11.2
字符的输入输出 592.11.3
枚举 622.11.4
存储布尔值的变量 642.12
赋值操作的op=形式 652.13
数学函数 662.14
设计一个程序 672.14.1
问题 682.14.2
分析 682.14.3
解决方案 702.15
小结 732.16
练习 74第3章
条件判断 753.1
判断过程 753.1.1
算术比较 753.1.2
基本的if语句 763.1.3
扩展if语句：if-else 793.1.4
在if语句中使用代码块 823.1.5
嵌套的if语句 833.1.6
测试字符 853.1.7
逻辑运算符 883.1.8
条件运算符 913.1.9
运算符的优先级 943.2
多项选择问题 983.2.1
给多项选择使用else-if语句 983.2.2
switch语句 993.2.3
goto语句 1073.3
按位运算符 1083.3.1
按位运算符的op=用法 1103.3.2
使用按位运算符 1113.4
设计程序 1143.4.1
问题 1143.4.2
分析 1143.4.3
解决方案 1143.5
小结 1183.6
练习 118第4章
循环 1194.1
循环 1194.2
递增和递减运算符 1204.3
for循环 1204.4
for循环的一般语法 1244.5
再谈递增和递减运算符 1254.5.1
递增运算符 1254.5.2
递增运算符的前置和后置形式 1254.5.3
递减运算符 1264.6
再论for循环 1274.6.1
修改for循环变量 1294.6.2
没有参数的for循环 1294.6.3
循环内的break语句 1304.6.4
使用for循环限制输入 1324.6.5
生成伪随机整数 1354.6.6
再谈循环控制选项 1374.6.7
浮点类型的循环控制变量 1374.7
while循环 1384.8
嵌套循环 1404.9
嵌套循环和goto语句 1464.10
do-while循环 1474.11
continue语句 1494.12
设计程序 1504.12.1
问题 1504.12.2
分析 1504.12.3
解决方案 1514.13
小结 1624.14
习题 163第5章
数组 1655.1
数组简介 1655.1.1
不用数组的程序 1655.1.2
什么是数组 1675.1.3
使用数组 1685.2
寻址运算符 1715.3
数组和地址 1735.4
数组的初始化 1745.5
确定数组的大小 1755.6
多维数组 1765.7
多维数组的初始化 1785.8
变长数组 1845.9
设计一个程序 1865.9.1
问题 1865.9.2
分析 1865.9.3
解决方案 1875.10
小结 1935.11
习题 193第6章
字符串和文本的应用 1956.1
什么是字符串 1956.2
存储字符串的变量 1976.3
字符串操作 2026.3.1
检查对C11的支持 2026.3.2
确定字符串的长度 2036.3.3
复制字符串 2046.3.4
连接字符串 2046.3.5
比较字符串 2086.3.6
搜索字符串 2116.3.7
单元化字符串 2156.3.8
将换行符读入字符串 2196.4
分析和转换字符串 2216.4.1
转换字符的大小写形式 2236.4.2
将字符串转换成数值 2256.5
设计一个程序 2276.5.1
问题 2276.5.2
分析 2276.5.3
解决方案 2286.6
小结 2336.7
习题 233第7章
指针 2357.1
指针初探 2357.1.1
声明指针 2367.1.2
通过指针访问值 2377.1.3
使用指针 2407.1.4
指向常量的指针 2447.1.5
常量指针 2447.1.6
指针的命名 2457.2
数组和指针 2457.3
多维数组 2487.3.1
多维数组和指针 2527.3.2
访问数组元素 2537.4
内存的使用 2567.4.1
动态内存分配：malloc()函数 2567.4.2
释放动态分配的内存 2577.4.3
用calloc()函数分配内存 2617.4.4
扩展动态分配的内存 2627.5
使用指针处理字符串 2657.5.1
使用指针数组 2667.5.2
指针和数组记号 2727.6
设计程序 2767.6.1
问题 2767.6.2
分析 2777.6.3
解决方案 2777.7
小结 2847.8
习题 285第8章
编程的结构 2878.1
程序的结构 2878.1.1
变量的作用域和生存期 2888.1.2
变量的作用域和函数 2918.2
函数 2918.2.1
定义函数 2918.2.2
return语句 2948.3
按值传递机制 2998.4
函数原型 3008.5
指针用作参数和返回值 3018.5.1
常量参数 3028.5.2
返回指针的风险 3078.6
小结 3108.7
习题 310第9章
函数再探 3139.1
函数指针 3139.1.1
声明函数指针 3139.1.2
通过函数指针调用函数 3149.1.3
函数指针的数组 3169.1.4
作为变元的函数指针 3199.2
函数中的变量 3219.2.1
静态变量：函数内部的追踪 3219.2.2
在函数之间共享变量 3239.3
调用自己的函数：递归 3259.4
变元个数可变的函数 3289.4.1
复制va_list 3319.4.2
长度可变的变元列表的基本规则 3319.5
main()函数 3329.6
结束程序 3339.6.1
abort()函数 3339.6.2
exit()和atexit()函数 3339.6.3
_Exit()函数 3349.6.4
quick_exit()和at_quick_exit()函数 3349.7
提高性能 3359.7.1
内联声明函数 3359.7.2
使用restrict关键字 3359.7.3
_Noreturn函数限定符 3369.8
设计程序 3369.8.1
问题 3369.8.2
分析 3379.8.3
解决方案 3389.9
小结 3519.10
习题 352第10章
基本输入和输出操作 35310.1
输入和输出流 35310.2
标准流 35410.3
键盘输入 35410.3.1
格式化键盘输入 35510.3.2
输入格式控制字符串 35510.3.3
输入格式字符串中的字符 36010.3.4
输入浮点数的各种变化 36210.3.5
读取十六进制和八进制值 36310.3.6
用scanf_s()读取字符 36410.3.7
从键盘上输入字符串 36610.3.8
单个字符的键盘输入 36710.4
屏幕输出 37210.4.1
使用printf_s()的格式化输出 37210.4.2
转义序列 37510.4.3
整数输出 37510.4.4
输出浮点数 37810.4.5
字符输出 37910.5
其他输出函数 38010.5.1
屏幕的非格式化输出 38110.5.2
数组的格式化输出 38110.5.3
数组的格式化输入 38210.6
小结 38210.7
习题 383第11章
结构化数据 38511.1
数据结构：使用struct 38511.1.1
定义结构类型和结构变量 38711.1.2
访问结构成员 38811.1.3
未命名的结构 39011.1.4
结构数组 39111.1.5
表达式中的结构成员 39311.1.6
结构指针 39311.1.7
为结构动态分配内存 39411.2
再探结构成员 39711.2.1
将一个结构作为另一个结构的成员 39711.2.2
声明结构中的结构 39811.2.3
将结构指针用作结构成员 39911.2.4
双向链表 40311.2.5
结构中的位字段 40611.3
结构与函数 40711.3.1
结构作为函数的变元 40711.3.2
结构指针作为函数变元 40811.3.3
作为函数返回值的结构 40911.3.4
二叉树 41411.4
共享内存 42111.5
设计程序 42511.5.1
问题 42511.5.2
分析 42611.5.3
解决方案 42611.6
小结 43811.7
习题 438第12章
处理文件 44112.1
文件的概念 44112.1.1
文件中的位置 44212.1.2
文件流 44212.2
文件访问 44212.2.1
打开文件 44312.2.2
缓存文件操作 44512.2.3
文件重命名 44612.2.4
关闭文件 44712.2.5
删除文件 44712.3
写入文本文件 44812.4
读取文本文件 44912.5
在文本文件中读写字符串 45212.6
格式化文件的输入输出 45612.6.1
格式化文件输出 45612.6.2
格式化文件输入 45712.7
错误处理 45912.8
再探文本文件操作模式 46012.9
freopen_s()函数 46112.10
二进制文件的输入输出 46212.10.1
以二进制模式打开文件 46212.10.2
写入二进制文件 46312.10.3
读取二进制文件 46412.11
在文件中移动 46912.11.1
文件定位操作 46912.11.2
找出我们在文件中的位置 47012.11.3
在文件中设定位置 47112.12
使用临时文件 47712.12.1
创建临时文件 47712.12.2
创建唯一的文件名 47812.13
更新二进制文件 47912.13.1
修改文件的内容 48412.13.2
从键盘输入创建记录 48512.13.3
将记录写入文件 48612.13.4
从文件中读取记录 48612.13.5
写入文件 48712.13.6
列出文件内容 48812.13.7
更新已有的文件内容 48912.14
文件打开模式小结 49512.15
设计程序 49612.15.1
问题 49612.15.2
分析 49612.15.3
解决方案 49612.16
小结 50112.17
习题 501第13章
支持功能 50313.1
预处理 50313.1.1
在程序中包含头文件 50313.1.2
定义自己的头文件 50413.1.3
管理多个源文件 50413.1.4
外部变量 50513.1.5
静态函数 50513.1.6
替换程序源代码 50613.2
宏 50713.2.1
看起来像函数的宏 50713.2.2
字符串作为宏参数 50913.2.3
在宏展开式中结合两个变元 51013.3
多行上的预处理器指令 51013.3.1
预处理器逻辑指令 51113.3.2
条件编译 51113.3.3
测试多个条件 51213.3.4
取消定义的标识符 51213.3.5
测试标识符的指定值的指令 51213.3.6
多项选择 51313.3.7
标准预处理宏 51413.4
调试方法 51513.4.1
集成的调试器 51513.4.2
调试阶段的预处理器 51513.4.3
断言 51913.5
日期和时间函数 52113.5.1
获取时间值 52213.5.2
获取日期 52513.5.3
确定某一天是星期几 52913.6
小结 53113.7
习题 531第14章
高级专用主题 53314.1
使用国际字符集 53314.1.1
理解Unicode 53314.1.2
设置区域 53414.1.3
宽字符类型wchar_t 53514.1.4
宽字符串的操作 53714.1.5
宽字符的文件流操作 54014.1.6
存储Unicode字符的固定大小类型 54114.2
用于可移植性的专用整数类型 54514.2.1
固定宽度的整型 54514.2.2
最小宽度的整型 54514.2.3
最大宽度的整型 54614.3
复数类型 54614.3.1
复数基础 54614.3.2
复数类型和操作 54714.4
用线程编程 55014.4.1
创建线程 55014.4.2
退出线程 55114.4.3
把一个线程连接到另一个线程上 55214.4.4
挂起线程 55514.4.5
管理线程对数据的访问 55514.5
小结 561附录A
计算机中的数学知识 563附录B
ASCII字符代码定义 571附录C
C语言中的保留字 575附录D
输入输出格式说明符 577附录E
标准库头文件 583
C语言是经典的编程语言，凭借其自身简洁、灵活和功能强大等特点，自诞生以来就牢牢占据着流行编程语言的榜首。C语言是强大的编程语言，可以进行从操作系统到设备驱动的各层次开发，可以应用在从大规模传统应用到新兴移动应用的各种领域。C语言也是一门非常优秀的学习程序设计入门语言，其简洁性使得初学者无须学习太多语法就可以开始编写真正的应用程序，很多程序员的职业生涯就是从握手C语言开始的。对于初学者来说，目前市面上介绍C语言入门的书籍太多了，可谓车载斗量，浩若繁星。《C语言入门经典》则是众多C语言学习资源中的经典作品。本书的作者是世界著名的计算机图书大师Ivor Horton。Ivor Horton在IBM工作多年，具有丰富的实践经验，其著作曾帮助无数程序员步入编程的殿堂。《C语言入门经典》作为Ivor Horton的经典之作，一版再版，培养了一代又一代的程序员，对C语言的推广可谓是功不可没。编程语言的学习十分枯燥，学习的过程也特别艰辛，但是学成之后所获得的成就感也是无与伦比的。C语言的灵活性在很大程度上得益于指针，而指针也往往是让初学者头疼的地方，甚至成为一个梦魇。我深知其学习的艰辛，对于自己在学习过程中的彷徨犹豫，挫折困顿，至今还历历在目。《C语言入门经典》循序渐进、深入浅出的讲解，曾经让自己大惑不解的地方，从本书看来则是如此的理所当然，水到渠成。恨自己没在初学之时，早点读到此书。本书在前一版的基础上，最大的变化就是增加了一章：高级应用专题。其中介绍了Unicode字符，可移植性的专用整数类型、复数类型以及线程编程。而线程章节的出现极大地完善了前几版的C语言体系，可谓是一个巨大惊喜。此外，本书在总结前几版的基础上对章节进行了更精确细微的调整，使内容在逻辑上更加合理，读起来更加流畅，更符合阅读习惯。开篇增加了对C语言，标准库的介绍。在第9章中增加了结束程序的详细讲解。第10章基本的输入和输出操作中，使用新的scanf_s()，printf_s()代替了旧版的scanf()和printf()。在第12章中，引入了新的freopen_s()函数以及缓存文件的操作。另外还有一些细微的调整与删除，使得本书更加紧凑与完美。纸上得来终觉浅，绝知此事要躬行。本书的作者深谙此理，在每章都有练习和习题供读者动手实践。学习一门语言没有比动手实践更快、更好的方法了。所以建议读者在每读完一章的时候亲自动手完成练习，而不是“读”过练习，如此方能成为理论和行动上的“巨人”。有人问大师，如何能技近乎道？大师曰：读书，读好书，然后实践之。万事无他，惟手熟尔！在这里要感谢清华大学出版社的李阳和于平编辑，她们为本书的翻译投入了巨大的热情并付出了很多心血。没有你们的帮助和鼓励，本书不可能顺利付梓。对于这本经典之作，译者本着“诚惶诚恐”的态度，在翻译过程中力求“信、达、雅”，但是鉴于译者水平有限，错误和失误在所难免，如有任何意见和建议，请不吝指正。感激不尽！本书全部章节由杨浩翻译，参与翻译活动的还有孔祥亮、陈跃华、杜思明、熊晓磊、曹汉鸣、陶晓云、王通、方峻、李小凤、曹晓松、蒋晓冬、邱培强、洪妍、李亮辉、高娟妮、曹小震、陈笑。最后，希望读者通过阅读本书能早日步入C语言编程的殿堂，领略C语言之美！
欢迎使用《C语言入门经典(第5版)》。研读本书，你就可以成为一位称职的C语言程序员。从许多方面来说，C语言都是学习程序设计的理想起步语言。C语言很简洁，因此无须学习大量的语法便能够开始编写真正的应用程序。除了简明易学以外，它还是一门功能非常强大的语言，并被专业人士广泛应用在各种领域。C语言的强大之处主要体现在，它能够应用于各类层次的开发中，从设备驱动程序和操作系统组件到大规模应用程序，它都能胜任。此外，C语言还可以适用于相对较新的手机应用程序开发上。几乎所有计算机都包含C语言编译器，因此，当你学会了C语言，就可以在任何环境下进行编程。最后一点，掌握C语言可以为理解面向对象的C++语言奠定良好的基础。在作者眼中，有抱负的程序员必将面对三重障碍，即掌握遍布程序设计语言中的各类术语、理解如何使用语言元素(而不仅仅只是知道它们的概念)以及领会如何在实际场景中应用该语言。本书的目的就是将这些障碍降到最低限度。术语是专业人士及优秀业余爱好者之间的交流必不可少的，因此有必要掌握它们。本书将确保你理解这些术语，并自如地在各种环境下使用它们。这样才能更有效地使用大多数软件产品附带的文档，且能轻松地阅读和学习大部分程序设计语言相关的著作。理解语言元素的语法和作用固然是学习C语言过程中的一个重要部分，但认识语言特性如何工作及应用也同等重要。本书不仅采用了代码片段，还在每个章节中使用一些实际应用示例展示语言特性如何应用于特定的问题。这些示例提供了实践的基础，读者可以通过改动代码观察修改后的结果。理解特定背景下的程序设计不仅只是应用个别语言元素。为了帮助读者理解它们，本书大部分章节之后都给出了一个较为复杂的应用程序，以应用本章之前学到的知识。这些程序可以帮助你获得开发应用程序的能力与信心，了解如何联合以及更大范围地应用语言元素。最重要的是，它们能让你了解设计实际应用程序与管理实际代码会碰到的问题。不管学习什么程序设计语言，有几件事情都要意识到。首先，虽然要学的东西很多，但是掌握它们之后，你就会有极大的成就感。其次，学习的过程很有趣，你会深深地体会到这点；第三，只有通过动手实践才能学会编程，这也是本书贯彻的思想。最后，在学习的过程中，肯定会时不时犯许多错误和感到沮丧。当觉得自己完全停滞时，你要做的就是坚持。最终你一定会体验到成功的喜悦，并且回头想想时，你会觉得它也并没有你想象中的那么难。如何使用本书作者认为动手实践是学习编程最好的方法，很快你就会编写第一个程序了。每一章都会有几个将理论应用于实践的程序，它们也是本书的核心所在。建议读者手工键入并运行书中的示例，因为手工键入可以极大地帮助记忆语言元素。此外，你还应当尝试解决每章末尾的所有练习题。当你第一次将一个程序运行成功，尤其是在解决自己的问题后，你会感觉到很大的成就感和惊人的进步速度，那时你一定会觉得一切都挺值得。刚开始，学习的进展不会太快，不过随着逐渐深入，你的学习速度会越来越快。每一章都会涉及许多基础知识，因此在学习新的内容之前，需要花些时间确保理解前面学习过的所有知识。实践各部分的代码，并尝试实现自己的想法，这是学习程序设计语言的一个重要部分。尝试修改书中的程序，看看还能让它们做些什么，那才是有趣之处。不要害怕尝试，如果某些地方不太明白，尝试输入一些变体，看看会出现什么情况。出错并没什么大不了，你会从出错中学到很多知识。一个不错的方法是彻底通读每一章，了解各章的范围，然后回过头来过一遍所有的示例。你可能会觉得某些章末尾的练习题非常难。如果第一次没有完全搞明白，不用担心。之所以第一次觉得困难是因为它们通常都是将你所学的知识应用到了相对复杂的问题中。如果你实在觉得困难的话，可以略过它们继续学习下一章，然后再回头研究这些程序。你甚至可以阅读完整本书再考虑它们。尽管如此，如果你能完成练习的话，说明你取得了真正的进步。本书读者对象《C语言入门经典(第5版)》的目的是教会读者如何尽可能简单快速地编写有用的程序。在阅读完全书后，读者会彻底了解C语言编程。这本教程面向的是那些之前编过一些程序，了解背后的概念，并且希望通过学习C语言进一步扩展知识的读者。尽管如此，本书并未假设读者拥有先前的编程知识，因此如果你刚刚接触编程，本书依然是你的不错选择。使用本书的条件要使用本书，你需要一台安装C编译器和库的计算机以执行书中的示例，以及一个程序文本编译器用于创建源代码文件。你使用的编译器应支持目前C语言国际标准(ISO/IEC ，也被称为C11)。你还需要一个用于创建和修改代码的编辑器，可以采用纯文本编辑器(如记事本(Notepad)或vi)创建源文件。不过，采用专为编辑C语言代码设计的编辑器会更有帮助。以下是作者推荐的两款C语言编译器，均为免费软件：GNU C编译器，GCC，可从http://www.gnu.org下载，它支持多种不同的操作系统环境。面向Microsoft Windows的Pelles C编译器，可从/ pellesc/下载，它提供了一个非常棒的集成开发环境(IDE)。本书采用的约定本书的文本和布局采用了许多不同的样式，以便区分各种不同的信息。大多数样式表达的含义都很明显。程序代码样式如下：int main(void){ printf("Beginning C\n");return 0;}如果代码片段是从前面的实例修改而来，修改过的代码行就用粗体显示，如下所示：i int main(void){printf("Beginning C by Ivor Horton\n");return 0;}当代码出现在文本中时，它的样式会有所不同，如：double。程序代码中还是用了各种“括号”。它们之间的差别非常重要，不同称呼。本书中称()为圆括号，{}为大括号，[]为方括号。
第一章C语言编程C语言是一种功能强大、简洁的计算机语言，通过它可以编写程序，指挥计算机完成指定的任务。我们可以利用C语言创建程序(即一组指令)，并让计算机依指令行事。用C语言编程并不难，本书将用浅显易懂的方法介绍C语言的基础知识，读完本章，读者就可以编写第一个C语言程序了，其实C语言很简单。本章的主要内容：C语言标准标准库的概念如何创建C程序如何组织C程序如何编写在屏幕上显示文本的程序1.1
C语言C是相当灵活的，用于执行计算机程序能完成的几乎所有任务，包括会计应用程序、字处理程序、游戏、操作系统等。它不仅是更高级语言(如C++)的基础，目前还以Objective C的形式开发手机应用程序。Objective C是标准的C加上一小部分面向对象编程功能。C很容易学习，因为它很简洁。因此，如果你立志成为一名程序员，最好从C语言开始学起，能快速而方便地获得编写实际应用程序的足够知识。C语言由一个国际标准定义，目前，其最新版本由ISO/IEC 文档定义。当前的标准一般称为C11，本书介绍的语言遵循C11标准。但要知道，C11定义的一些语言元素是可选的。这表示，遵循C11标准的C编译器可能没有实现该标准中的所有功能。(编译器只是一个程序，它可以把用我们能理解的术语所编写的程序转换为计算机能理解的术语)。本书会标识出C11中的可选语言特性，这样读者就知道，自己的编译器可能不支持它。C11编译器还有可能没有实现C11标准强制的所有语言特性。实现新语言功能是需要时间的，所以编译器开发人员常常采用逐步接近的方式实现它们。这也是程序可能不工作的另一个原因。尽管如此，根据我的经验，C程序不能工作的最常见原因，至少有99.9%的可能性是出现了错误。1.2
标准库C的标准库也在C11标准中指定。标准库定义了编写C程序时常常需要的常量、符号和函数。它还提供了基本C语言的一些可选扩展。取决于机器的特性，例如计算机的输入输出，由标准库以不依赖机器的形式实现。这意味着，在PC中用C代码把数据写入磁盘文件的方式，与在其他计算机上相同，尽管底层的硬件处理相当不同。库提供的标准功能包括大多数程序员都可能需要的功能，例如处理文本字符串或数学计算，这样就免除了自己实现这些功能所需的大量精力。标准库在一系列标准文件――头文件中指定。头文件的扩展名总是.h。为了使一组标准功能可用于C程序文件，只需要将对应的标准头文件包含进来，其方式在本章后面介绍。我们编写的每个程序都会用到标准库。附录E汇总了构成标准库的头文件。1.3
学习C如果对编程非常陌生，则不需要学习C的某些方面，至少在刚开始时不需要学习。这些功能比较特殊，或者不大常用。本书把它们放在第14章，这里读者可以在熟悉其他内容后，再学习它们。所有示例的代码都可以从Apress网站(http://www.apress/com)上下载，但建议读者自己输入本书中的所有示例，即使它们非常简单，也要输入。自己亲自输入，以后就不容易忘记。不要害怕用代码进行实验。犯错对编程而言非常有教育性。早期犯的错误越多，学到的东西就越多。1.4
创建C程序C程序的创建过程有4个基本步骤或过程：编辑编译链接执行这些过程很容易完成(就像翻转手掌一样简单，而且可以随时翻转)，首先介绍每个过程，以及它们对创建C程序的作用。1.4.1
编辑编辑过程就是创建和修改C程序的源代码――我们编写的程序指令称为源代码。有些C编译器带一个编辑器，可帮助管理程序。通常，编辑器是提供了编写、管理、开发与测试程序的环境，有时也称为集成开发环境(Integrated Development Environment，IDE)。也可以用一般的文本编辑器来创建源文件，但它们必须将代码保存为纯文本，而没有嵌入附加的格式化数据。不要使用字处理器(例如微软的Word)，字处理器不适合编写程序代码，因为它们在保存文本时，会附加一些格式化信息。一般来说，如果编译器系统带有编辑器，就会提供很多更便于编写及组织程序的功能。它们通常会自动编排程序文本的格式，并将重要的语言元素以高亮颜色显示，这样不仅让程序容易阅读，还容易找到单词输入错误。在Linux上，最常用的文本编辑器是Vim编辑器，也可以使用GNU Emacs编辑器。对于Microsoft Windows，可以使用许多免费(freeware)或共享(shareware)的程序设计编辑器。这些软件提供了许多功能，例如，高亮显示特殊的语法及代码自动缩进等功能，帮助确保代码是正确的。Emacs编辑器也有Microsoft Windows版本。UNIX环境的Vi和VIM编辑器也可用于Windows，甚至可以使用Notepad++(http://notepad-plus-plus.org/)。当然，也可以购买支持C语言的专业编程开发环境，例如微软或Borland的相关产品，它们能大大提高代码编辑能力。不过，在付款之前，最好检查一下它们支持的C级别是否符合当前的C语言标准C11。因为现在很多编辑器产品主要面向C++开发人员，C语言只是一个次要目标。1.4.2
编译编译器可以将源代码转换成机器语言，在编译的过程中，会找出并报告错误。这个阶段的输入是在编辑期间产生的文件，常称为源文件。编译器能找出程序中很多无效或无法识别的错误，以及结构错误，例如程序的某部分永远不会执行。编译器的输出结果称为对象代码(object code)，存放它们的文件称为对象文件(object file)，这些文件的扩展名在Microsoft Windows环境中通常是.obj，在Linux/UNIX环境中通常是.o。编译器可以在转换过程中找出几种不同类型的错误，它们大都会阻止对象文件的创建。如果编译成功，就会生成一个文件，它与源文件同名，但扩展名是.o或者.obj。如果在UNIX系统下工作，在命令行上编译C程序的标准命令是cc(若编译器是GNU’s Not UNIX(GNU)，则命令为.gcc)。下面是一个示例：cc
myprog.c其中，myporg.c是要编译的程序，如果省略了Cc这个参数，程序还会自动链接。成功编译的结果是生成一个对象文件。大多数C编译器都有标准的编译选项，在命令行(如cc myprog.c)或集成开发环境下的菜单选项(Compile菜单选项)里都可找到。在IDE中编译常常比使用命令行容易得多。编译过程包括两个阶段。第一个阶段称为预处理阶段，在此期间会修改或添加代码，第二个阶段是生成对象代码的实际编译过程。源文件可以包含预处理宏，它们用于添加或修改C程序语句。如果现在不理解它们，不必担心，本书后面将进行详细论述。1.4.3
链接链接器(linker)将源代码文件中由编译器产生的各种对象模块组合起来，再从C语言提供的程序库中添加必要的代码模块，将它们组合成一个可执行的文件。链接器也可以检测和报告错误，例如，遗漏了程序的某个部分，或者引用了一个根本不存在的库组件。实际上，如果程序太大，可将其拆成几个源代码文件，再用链接器连接起来。因为很难一次编写一个很大的程序，也不可能只使用一个文件。如果将它拆成多个小源文件，每个源文件提供程序的一部分功能，程序的开发就容易多了。这些源文件可以分别编译，更容易避免简单输入错误的发生。再者，整个程序可以一点一点地开发，组成程序的源文件通常会用同一个项目名称集成，这个项目名称用于引用整个程序。程序库提供的例程可以执行非C语言的操作，从而支持和扩展了C语言。例如，库中包含的例程支持输入、输出、计算平方根、比较两个字符串，或读取日期和时间信息等操作。链接阶段出现错误，意味着必须重新编辑源代码；反过来，如果链接成功，就会产生一个可执行文件，但这并不一定表示程序能正常工作。在Microsoft Windows环境下，这个可执行文件的扩展名为.exe；在UNIX环境下，没有扩展名，但它是一个可执行的文件类型。多数IDE也有Build(建立)选项，它可一次完成程序的编译和链接。1.4.4
执行执行阶段就是当成功完成了前述3个过程后，运行程序。但是，这个阶段可能会出现各种错误，包括输出错误及什么也不做，甚至使计算机崩溃。不管出现哪种情况，都必须返回编辑阶段，检查并修改源代码。在这个阶段，计算机最终会精确地执行指令。在UNIX和Linux下，只要键入编译和链接后的文件名，即可执行程序。在大多数IDE中，都有一个相应的菜单命令来运行或者执行已编译的程序。这个Run命令或者Execute命令可能有自己的菜单，也可能位于Compile菜单项下。在Windows环境中，运行程序的.exe文件即可，这与运行其他可执行程序一样。在任何环境及任何语言中，开发程序的编辑、编译、链接与执行这4个步骤都是一样的。图1-1总结了创建C程序的各个过程。1.5
创建第一个程序本节先浏览一下创建C语言程序的流程，从输入代码到执行程序的所有4个步骤。在这个阶段，若不了解所键入的代码信息，别担心，笔者会解释每一个步骤。试试看：C程序示例打开编辑器，输入下面的程序，请注意标点符号不要输错，第4行及最后一行的括号是大括号{}，而不是方括号[]或者圆括号()――这很重要。另外一定要键入斜杠(/)，以后也会用到反斜杠(\)。最后别忘了行末的分号(;)。/*
Program 1.1 Your Very First C Program - Displaying Hello World */#include
(stdio.h)int main(void){printf("Hello
world! ");return 0;}在输入了上面的源代码后，将程序保存为hello.c。可以用任意名字替代hello，但扩展名必须是.c。这个扩展名在编写C程序时是一个通用约定，它表示文件的内容是C语言源代码。大多数C编译器都要求源文件的扩展名是.c，否则编译器会拒绝处理它。下面编译程序(如本章前面“编译”一节所述)，链接所有必要的内容，创建一个可执行程序(如本章前面“链接”一节所述)。编译和链接一般在一个操作中完成，通常称为“构建操作”。源代码编译成功后，链接器就添加程序需要的标准库代码，为程序创建一个可执行文件。最后，执行程序。这有几种方式，在Windows环境下，一般只需要在Windows Explorer中双击.exe文件，但最好打开一个命令行窗口，输入执行它的命令，因为在程序执行完毕后，显示输出的窗口就会消失。在所有的操作系统环境上，都可以从命令行上运行程序。只需要启动一个命令行会话，把当前目录改为包含程序可执行文件的目录，再输入程序名，就可以执行它了。如果没有出现错误，就大功告成了。这个程序会在屏幕上输出如下信息：Hello world!1.6
编辑第一个程序我们可以修改程序，在屏幕上输出其他信息，例如可以将程序改成：/*Program 1.2 Your Second C Program */#include (stdio.h)int main(void){printf("\"If at first you don't succeed, try, try, try again!\"");return 0;}这个版本的输出是："If
succeed， try， try， try
again! "在要显示的文本中，\”序列称为转义序列(escape sequence)。文本中包含几个不同的转义序列。\”是在文本中包含双引号的特殊方式，因为双引号通常表示字符串的开头和结尾。转义序列\”使双引号出现在输出的开头和结尾。如果不使用转义序列，不仅双引号不会出现在输出中，而且程序不会编译。本章后面的“控制字符”一节将详细介绍转义序列。修改完源代码后，可以重新编译，链接后执行。反复练习，熟悉整个流程。1.7
处理错误犯错乃人之常情，没什么难为情的。幸好计算机一般不会出错，而且非常擅长于找出我们犯的错误。编译器会列出在源代码中找到的一组错误信息(甚至比我们想象的多)，通常会指出有错误的语句。此时，我们必须返回编辑阶段，找出有错误的代码并更正。有时一个错误会使后面本来正确的语句也出现错误。这多半是程序的其他部分引用了错误语句定义的内容所造成的。当然，定义语句有错，但被定义的内容不一定有错。下面看看源代码在程序中生成了一个错误时，会是什么样的情况。编辑第二个程序示例，将printf()行最后的分号去掉，如下所示：/*Program 1.2 Your Second C Program */#include (stdio.h)int main(void){printf("\"If at first you don't succeed, try, try, try again!\"")return 0;}编译这个程序后，会看到错误信息，具体信息随编译器的不同而略有区别。下面是一个比较常见的错误信息：Syntax
'}'HELLO.C
warning(s)编译器能精确地指出错误及其出处，在这里，printf()行的结尾处需要一个分号。在开始编写程序时，可能有很多错误是简单的拼写错误造成的。还很容易忘了逗号、括号，或按错了键。没关系，许多有经验的老手也常犯这种错误。如前所述，有时一点小错误会造成大灾难，编译器会显示许多不同的错误信息。不要被错误的数量吓倒，仔细看过每一个错误信息后，返回并改掉错误部分，不懂的先不管它，然后再编译一次源文件，就会发现错误一次比一次少。返回编辑器，重新输入分号，再编译，看看有没有其他错误，如果没有错误，程序就可以执行了。1.8
剖析一个简单的程序编写并编译了第一个程序后，下面是另一个非常类似的例子，了解各行代码的作用：/* Program 1.3 Another Simple C Program - Displaying a Quotation */#include
(stdio.h)int
main(void){printf("Beware
March!")；return 0;}这和第一个程序完全相同，这里把它作为练习，用编辑器输入这个示例，编译并执行。若输入完全正确，会看到如下输出：Beware
March!1.8.1
注释上述示例的第一行代码如下：/* Program 1.3 Another Simple C Program - Displaying a Quotation */这不是程序代码，因为它没有告诉电脑执行操作，它只是一个注释，告诉阅读代码的人，这个程序要做什么。位于/*和*/之间的任意文本都是注释。只要编译器在源文件中找到/*，就忽略它后面的内容(即使其中的文本很像程序代码)，一直到表示注释结束的*/为止。/*可以和*/放在同一行代码上，也可以放在不同的代码行上。如果忘记包含对应的*/，编译器就会忽略/*后面的所有内容。下面使用一个注释说明代码的作者及版权所有： /** Written by Ivor Horton* Copyright 2012*/也可以修饰注释，使它们比较突出：/********************************************* Thisisaveryimportantcomment** sopleasereadthis.*********************************************/使用另一种记号，可以在代码行的末尾添加一个注释，如下所示：printf("Beware the Ides of March!");// This line displays a quotation代码行上两个斜杠后面的所有内容都会被编译器忽略。这种形式的注释没有前一种记号那么凌乱，尤其是在注释只占一行的情形下。应养成给程序添加注释的习惯，当然程序也可以没有注释，但在编写较长的程序时，可能会忘记这个程序的作用或工作方式。添加足够的注释，可确保日后自己(和其他程序员)能理解程序的作用和工作方式。下面给程序再添加一些注释：/* Program 1.3 Another Simple C Program - Displaying a Quotation */#include (stdio.h)// This is a preprocessor directiveint main(void)// This identifies the function main(){// This marks the beginning of main()printf("Beware the Ides of March!");// This line outputs a quotationreturn 0;// This returns control to the operating system}// This marks the end of main()可以看出，使用注释是一种非常有效的方式，可以解释程序中要发生的事情。注释可以放在程序中的任意位置，说明代码的一般作用，指定代码是如何工作的。1.8.2
预处理指令下面的代码行：#include (stdio.h)// This is a preprocessor directive严格说来，它不是可执行程序的一部分，但它很重要，事实上程序没有它是不执行的。符号#表示这是一个预处理指令(preprocessing directive)，告诉编译器在编译源代码之前，要先执行一些操作。编译器在编译过程开始之前的预处理阶段处理这些指令。预处理指令相当多，大多放于程序源文件的开头。在这个例子中，编译器要将stdio.h文件的内容包含进来，这个文件称为头文件(header file)，因为它通常放在程序的开头处。在本例中，头文件定义了C标准库中一些函数的信息，但一般情况下，头文件指定的信息应由编译器用于在程序中集成预定义函数或其他全局对象，所以有时需要创建自己的头文件，以用于程序。本例要用到标准库中的printf()函数，所以必须包含stdio.h头文件。stdio.h头文件包含了编译器理解printf()以及其他输入/输出函数所需要的信息。名称stdio是标准输入/输出(standard input/output)的缩写。C语言中所有头文件的扩展名都是.h，本书的后面会用到其他头文件。注意：在一些系统中，头文件名是不区分大小写的，但在#include指令里，这些文件名通常是小写。每个符合C11标准的C编译器都有一些标准的头文件。这些头文件主要包含了与C标准库函数相关的声明。所有符合该标准的C编译器都支持同一组标准库函数，有同一组标准头文件，但一些编译器有额外的库函数，它们提供的功能一般是运行编译器的计算机所专用的。注意：附录E列出了所有的标准头文件。1.8.3
定义main()函数下面的5行指令定义了main()函数：int main(void)// This identifies the function main(){// This marks the beginning of main()printf("Beware the Ides of March!");// This line outputs a quotationreturn 0;// This returns control to the operating system}// This marks the end of main()函数是两个括号之间执行某组操作的一段代码。每个C程序都由一个或多个函数组成，每个C程序都必须有一个main()函数――因为每个程序总是从这个函数开始执行。因此假定创建、编译、链接了一个名为progname.exe的文件。执行它时，操作系统会执行这个程序的main()函数。定义main()函数的第一行代码如下：int main(void)// This identifies the function main()它定义了main()函数的起始，注意这行代码的末尾没有分号。定义main()函数的第一行代码开头是一个关键字int，它表示main()函数的返回值的类型，关键字int表示main()函数返回一个整数值。执行完main()函数后返回的整数值表示返回给操作系统的一个代码，它表示程序的状态。在下面的语句中，指定了执行完main()函数后要返回的值：return 0;// This returns control to the operating system这个return语句结束main()函数的执行，把值0返回给操作系统。从main()函数返回0表示，程序正常终止，而返回非0值表示异常。换言之，在程序结束时，发生了不应发生的事情。紧跟在函数名main后的括号，带有函数main()开始执行时传递给它的信息，在这个例子里，括号内是void，表示没有给函数main()传递任何数据，后面会介绍如何将数据传递给函数main()或程序内的其他函数。函数main()可以调用其他函数，这些函数又可以调用其他函数。对于每个被调用的函数，都可以在函数名后面的括号中给函数传递一些信息。在执行到函数体中的return语句时，就停止执行该函数，将控制权返回给调用函数(对于函数main()，则将控制权返回给操作系统)。一般函数会定义为有返回值或没有返回值。函数返回一个值时，该值总是特定的类型。对于函数main()，返回值的类型是int，即整数。1.8.4
关键字在C语言中，关键字是有特殊意义的字，所以在程序中不能将关键字用于其他目的。关键字也称为保留字。在前面的例子里，int就是一个关键字，void和return也是关键字。C语言有许多关键字，我们在学习C语言的过程中，将逐渐熟悉这些关键字。附录C列出了完整的C语言关键字表。1.8.5
函数体main()函数的一般结构如图l-2所示：图l-2
函数main()的结构函数体是在函数名称后面位于起始及结束两个大括号之间的代码块。它包含了定义函数功能的所有语句。这个例子的main()函数体非常简单，只有两个语句：{// This marks the beginning of main()printf("Beware the Ides of March!");// This line outputs a quotationreturn 0;// This returns control to the operating system}// This marks the end of main()每个函数都必须有函数体，但函数体可以是空的，仅有起始及结束两个大括号，里面没有任何语句，在这种情况下，这个函数什么也不做。这样的函数有什么用？事实上，在开发一个包含很多函数的程序时，这种函数是非常有用的。我们可以声明一些用来解决手头问题的空函数，确定需要完成的编程工作，再为每个函数创建程序代码。这个方法有助于条理分明地、系统地建立程序。注意：程序1.3将大括号单独排为一行，并缩进大括号之间的代码。这么做可清楚地表示括号框起来的语句块从哪里起始和结束。大括号之间的语句通常缩进两个或多个空格，使大括号突出在前。这是个很好的编程格式，可以使语句块更容易阅读。代码中的大括号可以用其他方式摆放。例如：int main(void) {printf("Beware the Ides of March!");// This line outputs a quotationreturn 0;}提示：无论源代码采用什么方式摆放，都要一直采用这种方式，这很重要。1.8.6
输出信息例子中的main()函数体包含了―个调用printf()函数的语句：printf("Beware the Ides of March!");// This line outputs a quotationprintf()是―个标准的库函数，它将函数名后面引号内的信息输出到命令行上(实际上是标准输出流，默认为命令行)。在这个例子中，调用这个函数会显示双引号内的一段警示语：双引号内的字符串称为字符串字面量。注意这行代码用分号作为结尾。1.8.7
参数包含在函数名(如上面语句中的printf()函数)后的圆括号内的项称为参数，它指定要传送给函数的数据。当传送给函数的参数多于一个时，要用逗号分开。在上面的例子中，函数的参数是双引号内的文本字符串。如果不喜欢例子中引号内的文本，可以改用自己想输出的句子。例如，使用如下语句：printf("Out, damned Spot! Out I say!");修改源代码后，必须再次编译及链接程序，才可执行。注意：与C语言中所有可执行的语句一样，printf()行的末尾必须有分号(这与定义语句或指令语句不同)。这是一个很容易犯的错误，尤其是初次使用C编程的人，老是忘了分号。1.8.8
控制符前面的程序可以改为输出两段句子。输入以下的代码：// Program 1.4 Another Simple C Program - Displaying a Quotation#include (stdio.h)int main(void){printf("My formula for success?\nRise early, work late, strike oil.\n");return 0;}输出的结果是：My formula for success?Rise early, work late, strike oil.在printf()语句中，在文本的开头和第一句的后面，增加了字符\n，它是另一个转义序列，代表换行符。这样输出光标就会移动到下一行，后续的输出就会显示在新行上。反斜杠(\)在文本字符串里有特殊的意义，它表示转义序列的开始。反斜杠后面的字符表示是哪种转义序列。对于\n，n表示换行。还有其他许多转义序列。显然，反斜杠是有特殊意义的，所以需要一种方式在字符串中指定反斜杠。为此，应使用两个反斜杠(\\)。输入以下的程序：// Program 1.5 Another Simple C Program - Displaying Great Quotations#include (stdio.h)int main(void){printf("\"It is a wise father that knows his own child.\"\nShakespeare\n");return 0;}输出的结果如下："It is a wise father that knows his own child."Shakespeare输出中包含双引号，因为在字符串中使用了双引号的转义序列。Shakespeare显示在下一行，因为在\”的后面有\n转义序列。在输出字符串中使用转义序列\a可以发出声音，说明发生了有趣或重要的事情。输入以下的程序并执行：// Program 1.6 A Simple C Program C Important#include (stdio.h)int main(void){printf("Be careful!!\n\a");return 0;}这个程序的输出如下所示且带有声音。仔细聆听，电脑的扬声器会发出鸣响。Be
careful!!转义序列\a表示发出鸣响。表1-1是转义序列表。表1-1
转义序列转 义 序 列说
明\n换行\r回车键\b退后一格\f换页\t水平制表符\v垂直制表符\a发出鸣响\?插入问号(?)\"插入双引号(")\'插入单引号(')\\插入反斜杠(\)试着在屏幕上显示多行文本，在该文本中插入空格。使用 \n可以把文本放在多个行上，使用\t可以给文本加上空格。本书将大量使用这些转义序列。1.8.9
三字母序列一般可以直接在字符串中使用问号。\?转义序列存在的唯一原因是，有9个特殊的字母序列，称为三字母序列，这是包含三个字母的序列，分别表示#、[、]、\、^、~、\、{和}：??=转换为#??(转换为[??)转换为]??/转换为\??(转换为{??)转换为}??'转换为^??!转换为}