第一部分
C语言编程常见BUG

本部分主要包括初学者常见问题、基本数据类型、存储类、运算符、流程控制、函数、C语言预处理程序、指针和数组、结构和联合、输入和输出、文件操作等内容。

第1章初学者常见问题

初学编程的人往往会犯一些简单的错误。这些错误看上去不值一提，却是每个程序员成功之路上的拦路虎。这些常见的错误有：字母大小写混淆、容易混淆的字符（如逗号与分号；单引号与双引号；数字‘1’、大写字母‘I’与小写字母‘l’；数字‘0’、大写字母‘O’与小写字母‘o’）、在代码中使用了中文字符、丢失或多余的分号、丢失或多余的大括号、混乱的缩进和对齐等。出现这些错误的根本原因在于编程和调试太少，对程序设计语言的基本语法掌握不够。多编写程序，多调试程序，自己改正程序中的错误，熟练之后就会避免再犯这些简单的错误。

问题1 字母大小写混淆

[例1.1] 已知商品单价和数量，求总价。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int count = 5; //数量
5	float price = 25; //单价
6	float total = price * Count; //计算总价
7	Printf("总价为%.2f\n",total);
8	}

[编译结果]

e:\code\1_1.cpp(6) : error C2065: 'Count' : undeclared identifier

e:\code\1_1.cpp(7) : error C2065: 'Printf' : undeclared identifier

[问题分析]

上面的编译结果给出了错误信息。双击某一错误信息行，该错误信息行会加亮显示，并在程序出现错误的行前面用一个箭头加以指示。第1、2条错误信息分别指出‘Count’、‘Printf’未定义。仔细对照程序，发现程序中如下语句定义了变量‘count’：

int count = 5;

首字母是小写；而

float total = price * Count;

Printf("总价为%.2f\n",total);

这几两句代码中用到的‘Count’和‘Printf’的首字母写成了大写。C语言中是严格区分大小写的，所以编译器认为‘Count’未定义。

‘printf’是产生格式化输出的函数(定义在 stdio.h 中)。程序中把‘printf’误写成了‘Printf’，由于相同的原因，编译器也认为‘Printf’ 未定义。其他关键字如‘if’、‘for’等如果拼写错误或大小写错误也会报同样的错误信息。

[正确代码]

代码修改如下：

6	float total = price * count;
7	printf("总价为%.2f\n",total);

C语言中是严格区分大小写的，只要定义变量的地方和使用这个变量的地方写法一致，就不会出现上面的问题。

[运行结果]

总价为125.00

[小提示]

如果程序编译不通过，编译器会给出错误信息。双击某一错误信息行，该错误信息行会加亮显示，并在程序出现错误的行前面用一个箭头加以指示。有时候，程序中的一个错误会导致多行错误信息，因此，常常修改一条错误后，再重新编译，直到没有错误为止。

问题2 容易混淆的字符

有一些字符的外形看起来很相似，初学C语言编程的人很容易混淆。如逗号与分号；单引号与双引号；数字‘1’、大写字母‘I’与小写字母‘l’；数字‘0’、大写字母‘O’与小写字母‘o’；等等。

[例1.2] 已知学生数学、语文、英语三门课的成绩，求总分和平均分。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	float math = 79;
5	f1oat chinese = 80;
6	float english = 8l;
7
8	float total = math+chinese+engIish; //求总分
9	fIoat average = total/3, //求平均分
10	printf('总分为%.2f，平均分为%.2f\n",total,average);
11	}

[编译结果]

E:\Code\1_2.cpp(5) : error C2065: 'f1oat' : undeclared identifier

E:\Code\1_2.cpp(5) : error C2146: syntax error : missing ';' before identifier 'chinese'

E:\Code\1_2.cpp(5) : error C2065: 'chinese' : undeclared identifier

E:\Code\1_2.cpp(8) : error C2065: 'engIish' : undeclared identifier

E:\Code\1_2.cpp(9) : error C2065: 'fIoat' : undeclared identifier

E:\Code\1_2.cpp(9) : error C2146: syntax error : missing ';' before identifier 'average'

E:\Code\1_2.cpp(9) : error C2065: 'average' : undeclared identifier

E:\Code\1_2.cpp(9) : warning C4244: '=' : conversion from 'float' to 'int', possible loss of data

E:\Code\1_2.cpp(10) : error C2001: newline in constant

E:\Code\1_2.cpp(10) : error C2015: too many characters in constant

E:\Code\1_2.cpp(11) : error C2143: syntax error : missing ')' before '}'

E:\Code\1_2.cpp(11) : error C2143: syntax error : missing ';' before '}'

[问题分析]

让我们逐行分析这些错误提示。

“error C2065: 'f1oat' : undeclared identifier”：f1oat chinese = 80这一句里的“f1oat”中字母‘l’被写成了数字‘1’。

“syntax error : missing ';' before identifier 'chinese'”：同上

“error C2065: 'chinese' : undeclared identifier”：同上

“error C2065: 'engIish' : undeclared identifier”: 'engIish'中字母‘l’被写成了大写字母‘I’。

“error C2065: 'fIoat' : undeclared identifier”: fIoat average = total/3这一句里的“fIoat”中字母‘l’被写成了大写字母‘I’。

“error C2001: newline in constant”: fIoat average = total/3, 这一句最后的分号被写成逗号。

最后3条错误提示是由于printf('总分为%.2f，平均分为%.2f\n",total,average) 这一句里的“printf(”后面的双引号被写成了单引号所致。

以上错误都被更正之后，编译通过，运行结果如下：

总分为167.00，平均分为55.67

奇怪，数学、语文、英语三门课的成绩分别为79、80、81，总分应该为240.00，平均分应该为80.00，运行结果和预期不一致。到底哪里出错呢？原来是float english = 8l这一句里的81被写成了数字‘8’和小写字母‘l’，而8L和8l都表示值为8的长整型数，所以总分算出来为79+80+8=167。

[正确代码]

代码修改如下：

5	float chinese = 80;
6	float english = 81;
7
8	float total = math+chinese+english;
9	float average = total/3;
10	printf("总分为%.2f，平均分为%.2f\n",total,average);

[运行结果]

正确的运行结果如下：

总分为240.00，平均分为80.00

问题3 在代码中使用了中文字符

在录入程序时，如果忘了把输入法切换到英文状态，就会不慎录入中文字符，如逗号、引号和分号，因为中文输入法与英文输入法下键入符号的编码不同，从而导致一系列编译错误。

[例1.3] 已知矩形的长和宽，求该矩形的面积。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int length = 5，int width = 6;
5	int area = length * width；
6	printf(“面积为%d\n",area);
7	}

[编译结果]

e:\code\1_3.cpp(4) : error C2018: unknown character '0xa3'

e:\code\1_3.cpp(4) : error C2018: unknown character '0xac'

e:\code\1_3.cpp(4) : error C2144: syntax error : missing ';' before type 'int'

e:\code\1_3.cpp(5) : error C2018: unknown character '0xa3'

e:\code\1_3.cpp(5) : error C2018: unknown character '0xbb'

e:\code\1_3.cpp(6) : error C2146: syntax error : missing ';' before identifier 'printf'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xa1'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xb0'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xc3'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xe6'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xbb'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xfd'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xce'

e:\code\1_3.cpp(6) : error C2018: unknown character '0xaa'

e:\code\1_3.cpp(6) : error C2143: syntax error : missing ')' before '%'

e:\code\1_3.cpp(6) : error C2660: 'printf' : function does not take 0 parameters

e:\code\1_3.cpp(6) : error C2017: illegal escape sequence

e:\code\1_3.cpp(6) : error C2065: 'd' : undeclared identifier

e:\code\1_3.cpp(6) : error C2001: newline in constant

e:\code\1_3.cpp(6) : error C2146: syntax error : missing ';' before identifier 'n'

e:\code\1_3.cpp(6) : error C2065: 'n' : undeclared identifier

e:\code\1_3.cpp(6) : error C2143: syntax error : missing ';' before 'string'

e:\code\1_3.cpp(7) : error C2143: syntax error : missing ';' before '}'

[问题分析]

上面的编译结果给出了错误提示。令人吃惊的是短短的几行代码居然报了23个错误。不必担心，真正的错误只有3处：int length = 5之后的中文逗号；int area = length * width之后的中文分号；“printf(”与“面积”之间的中文引号。因为一个中文字符的内码占用两个字节，所以会报告类似的错误提示：

e:\code\1_3.cpp(4) : error C2018: unknown character '0xa3'

e:\code\1_3.cpp(4) : error C2018: unknown character '0xac'

凡是有类似错误提示的都是因为代码里用了中文符号。

[正确代码]

只要把中文符号改为对应的英文符号即可。

4	int length = 5, int width = 6;
5	int area = length * width;
6	printf("面积为%d\n",area);

[运行结果]

面积为30

问题4 丢失或多余的分号

初学者还经常丢掉分号，或写了多余的分号。这将导致一系列编译错误。

[例1.4] 计算从1到10的10个整数之和。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int sum = 0;
5	for(int i=1;i<=10;i++);
6	sum += i;
7	printf("sum=%d\n",sum)
8	}

[编译结果]

E:\Code\1_4.cpp(8) : error C2143: syntax error : missing ';' before '}'

[问题分析]

上面的编译结果给出了错误提示。“missing ';' before '}'”告诉我们printf("sum=%d\n",sum)后面少写了一个分号。在此处添加分号，则编译正常，运行结果为：

sum=11

从1到10的10个整数之和应改为55，而不是11。错误原因是for(int i=1;i<=10;i++);这一行最后多了一个分号，导致sum += i并不是在循环体里面循环执行，而是等循环结束之后才执行。因而实际结果为11。

[正确代码]

代码修改如下：

5	for(int i=1;i<=10;i++) //此处删除分号‘;’

7	printf("sum=%d\n",sum); //添加分号‘;’

[运行结果]

sum=55

问题5 丢失或多余的大括号

当程序代码中包括for、if、while、switch等语句时，程序中就会出现较多的‘{’和‘}’。它们是成对出现的。如果丢失了‘{’或‘}’，会导致程序出错。而且编译程序给出的错误信息往往不一定准确指明错误所在的位置，导致调试时遇到困难。

[例1.5] 依次读入10个学生的成绩，判断成绩等级（优、良、中、及格、不及格），统计各等级的人数，并输出。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int excellent=0, good=0, middle=0, pass=0, fail=0;
5	for(int i=0;i<10;i++)
6	{
7	float score;
8	scanf("%f",&score); //输入分数
9	if(score<=100 && score>=90) //优
10	{
11	excellent++;
12	printf("优\n");
13	}
14	else if(score<90 && score>=80) //良
15	good++;
16	printf("良\n");
17	}
18	else if(score<80 && score>=70) //中
19	{
20	middle++;
21	printf("中\n");
22	}
23	else if(score<70 && score>=60) //及格
24	{
25	pass++;
26	printf("及格\n");
27	}
28	else if(score<60 && score>=0) //不及格
29	{
30	fail++;
31	printf("不及格\n");
32	}
33	printf("统计结果：\n优：%d\n", excellent);
34	printf("良：%d\n", good);
35	printf("中：%d\n", middle);
36	printf("及格：%d\n", pass);
37	printf("不及格：%d\n", fail);
38	}

[编译结果]

E:\Code\1_5.cpp(18) : error C2181: illegal else without matching if

E:\Code\1_5.cpp(18) : error C2065: 'score' : undeclared identifier

[问题分析]

第1条错误信息是“legal else without matching if”，意思是else没有与它匹配的if。双击这条错误信息，编辑区焦点自动移到下面这一句代码：

else if(score<80 && score>=70)

但是前面明明有else if(score<90 && score>=80)，为什么还报这个错呢？原来，由于else if(score<90 && score>=80)后面丢失了一个‘{’, 编译器认为printf("良\n")这一句后面的‘}’不是与else if匹配的，而是与for匹配的，导致错误。改正这一句后再编译，仍有错误，错误信息为：

E:\Code\1_5.cpp(40) : fatal error C1004: unexpected end of file found

Error executing cl.exe.

双击这条错误信息行，该错误信息行会加亮显示，并在程序最后一行前面用一个箭头加以指示。这更加令人感到困惑，到底为什么呢？原来，因为printf("优：%d\n", excellent)前面丢失了一个‘}’, 编译器认为代码最后一行的‘}’是与for匹配的，那么main函数的结束‘}’就没有了，所以编译器会报告这样的错误信息。

[正确代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int excellent=0, good=0, middle=0, pass=0, fail=0;
5	for(int i=0;i<10;i++)
6	{
7	float score;
8	scanf("%f",&score);
9	if(score<=100 && score>=90) //优
10	{
11	excellent++;
12	printf("优\n");
13	}
14	else if(score<90 && score>=80) //良
15	{
16	good++;
17	printf("良\n");
18	}
19	else if(score<80 && score>=70) //中
20	{
21	middle++;
22	printf("中\n");
23	}
24	else if(score<70 && score>=60) //及格
25	{
26	pass++;
27	printf("及格\n");
28	}
29	else if(score<60 && score>=0) //不及格
30	{
31	fail++;
32	printf("不及格\n");
33	}
34	}
35	printf("统计结果：\n优：%d\n", excellent);
36	printf("良：%d\n", good);
37	printf("中：%d\n", middle);
38	printf("及格：%d\n", pass);
39	printf("不及格：%d\n", fail);
40	}

[运行结果]

100

优

良

中

不及格

及格

中

良

优

统计结果：

优：3

良：2

中：2

及格：1

不及格：2

问题6 混乱的缩进和对齐

一个程序员需要有良好的编程风格，例如代码行的缩进和对齐。初学者往往忽视这一点，或者认为这无关紧要。实际上混乱的缩进和对齐不仅影响代码的美观，还使代码变得难以理解，降低了工作效率，影响了团队合作。它还降低了代码的质量，增加了代码出错的概率，使程序员不容易找出代码中的错误。

[例1.6] 要求在屏幕上输出如下图形：

###

****

#####

******

#######

********

#########

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{ for(int i=1;i<10;i++)
4	{
5	for(int j=0;j<i;j++)
6	if((i/2)*2==i)
7	printf("*"); else
8	printf("#");
9	}
10	printf("\n");
11	}
12	}

[编译结果]

E:\Code\1_6.cpp(12) : error C2143: syntax error : missing ';' before '}'

[问题分析]

这段代码混乱不堪，代码没有合理地缩进，成对的大括号也没有对齐。事实上很难看懂。编译产生的错误提示也没有准确指出错误所在。实际上如果使代码合理地缩进和对齐，就可以很容易看出，for(int j=0;j<i;j++)之后缺少了一个‘}’。

[正确代码]

把混乱的代码进行整理，在for(int j=0;j<i;j++)之后加了一个‘}’。

1	#include <stdio.h>
2	void main( )
3	{
4	for(int i=1;i<10;i++)
5	{
6	for(int j=0;j<i;j++)
7	{
8	if((i/2)*2==i)
9	printf("*");
10	else
11	printf("#");
12	}
13	printf("\n");
14	}
15	}

[运行结果]

同题目要求。

[小提示]

如何快速地规范代码缩进格式呢？必须一行一行地改吗？其实，只要选中需要规范的代码，按Alt+F8即可。

练习1

请改正如下程序中的错误。

1) 用#号输出字母E的图案。

1	#include <stdio.h>
2	void main( )
3	{
4	Printf(" ####/n");
5	printf(" #\n");
6	printf(" ####\n");
7	prlntf(" # \n");
8	printf(" ####\n");
9	}

2) 一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

1	#include <stdio.h>
2	#include "math.h"
3	void main( )
4	{
5	long int i,x,y;
6	for(i=1;i<100000;i++);
7	{
8	x=sqrt(i+100);
9	y=sqrt(i+168);
10	if(xx==i+100 && yy==i+168);
11	printf("%ld\n",i);
12	}
13	}

3) 有1、2、3、4四个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

1	#include <stdio.h>
2	void main( )
3	{
4	int i,j,k;
5	printf("\n");
6	for(i=1;i<5;i++)
7	for(j=1;j<5;j++)
8	for (k=1;k<5;k++)
9	{
10	//确保i、j、k三位互不相同
11	if (i!=k && i!=j && j!=k)
12	printf("%d,%d,%d\n",i,j,k);
13	}
14	}
15	}
16	}

第2章基本数据类型

在Ｃ语言中，数据类型可分为：基本数据类型，构造数据类型，指针类型三大类。如下：

基本数据类型最主要的特点是，其值不可以再分解为其它类型，包括整型、浮点型、字符型、空类型、枚举类型等。其中整型又分为短整型（short）、整型（int）、长整型（long），浮点型又分为单精度浮点型（float）和双精度浮点型（double）。

构造数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的，一个构造类型的值可以分解成若干个“成员”，每个“成员”都是一个基本数据类型或者一个构造类型。在C语言中，构造类型有数组类型、结构类型（struct）、联合类型（union）等几种。

指针类型用来表示某个量在内存中的地址。在计算机系统中每一个数据均需要占用一定的内存空间，而每段空间均有唯一的地址与之对应，因此在计算机系统中任意数据均有确定的地址与之对应。C语言中，为了描述数据存放的地址信息，引入指针类型。虽然指针的取值类似于整型量，但这是两个类型完全不同的量，因此不能混为一谈。

在C语言中，数据的基本表现形式是常量和变量。在程序执行过程中，其值不发生改变的量称为常量，它可以不经说明而直接引用。常量可分为整型常量、浮点常量、字符常量、枚举常量等。有时候，可以用一个符号名来代表一个常量，称为符号常量。例如在程序中经常使用圆周率3.14，可以用符号PI来表示，这样在每个用到它的地方只需用PI来代替3.14。如果要把3.14改为3.14159265，只需修改一个地方，而不是每个用到圆周率的地方。

在程序执行过程中，取值可变的量称为变量。在程序中，变量则必须先说明后使用。变量可以分为整型变量、浮点变量、字符变量、枚举变量等。使用变量时，需要注意区别变量名和变量值。变量代表内存中具有特定属性的一个和几个存储单元，它用来存储数据，也就是存储变量的量。变量应该有一个变量名，以便于被引用。变量名必须符合C语言对标识符的规定。

1. 整型数据

（1）整型常量

整型常量即常整数。在C语言中，整型常量通常以十进制整数、八进制整数、十六进制整数来表示。在程序中根据前缀来区分各种不同进制的数。

十进制整数没有前缀，其数码为0～9。25、-90、65535、1398都是合法的十进制整数，而029（不能有前导0）、23D（(含有非十进制数码)则不是合法的十进制整数。

八进制整数必须以0开头，即以0作为八进制数的前缀。数码取值为0～7。八进制数通常是无符号数。015(十进制为13)、0101(十进制为65)、0177777(十进制为65535) 都是合法的八进制数。而26（无前缀0）、03A（包含了非八进制数码）、-017（出现了负号）则不是合法的八进制数。

十六进制整数的前缀为0X或0x。其数码取值为0~9，A~F或a~f。0X2B（十进制为43）、0XA1（十进制为161）、0XFFFF（十进制为65535）是合法的十六进制整常数，而5A（无前缀0X）、0X3H（含有非十六进制数码）则不是合法的十六进制整常数。

在程序中，以上整数的三种表示形式都是合法、有效的。例如，16、020、0x10都表示十进制数16。

（2）整型变量

在C语言中有三种整型变量：整型（int），短整型（short int或short），长整型（long int或long）。ANSI C标准没有具体规定以上各类数据所占内存的字节数，只要求long型数据长度不短于int型，int型数据长度不短于short型。具体由各计算机系统自行决定。在Turbo C中，int型和short型数据都是2个字节，即16位二进制。long型数据是4个字节，即32位二进制。而Visual C++中，short型数据是2个字节，即16位二进制。而int型和long型数据是4个字节，即32位二进制。

一般情况下，整型变量是有符号的，即存储单元的最高位用来表示符号（0为正，1为负）。例如，一个short型数据被分配2个字节，即16位二进制，最高位存储符号，用来存储数据的是15位，存放的数据范围是-32768 ~ 32767。在实际应用中，变量的符号通常是正的，如分数、价格、年龄等。为充分利用变量的数值范围，可以将变量定义为“无符号”类型。只需要在short、int、long之前加上unsigned修饰符即可，如unsigned short、unsigned int、unsigned long. 这样，对于unsigned short来说，用来存储数据的是16位，存放的数据范围是0 ~ 65535，使可以存放正数的范围扩大了一倍。修饰符signed表示有符号数，实际上可以省略。归纳起来，在C语言中可以定义六种整型变量，即：

Ÿ 有符号整型 [signed] int

Ÿ 无符号整型 unsigned int

Ÿ 有符号短整型 [signed] short [int]

Ÿ 无符号短整型 unsigned short [int]

Ÿ 有符号长整型 [signed] long [int]

Ÿ 无符号长整型 unsigned long [int]

表2.1整数类型的数据取值范围

类型	Turbo C		Visual C++
类型	字节数	数值范围	字节数	数值范围
[signed] int	2	-32768 ~ 32767	4	-2147483648~2147483647
unsigned int	2	0 ~ 65535	4	0 ~ 4294967295
[signed] short [int]	2	-32768 ~ 32767	2	-32768 ~ 32767
unsigned short [int]	2	0 ~ 65535	2	0 ~ 65535
[signed] long [int]	4	-2147483648~2147483647	4	-2147483648~2147483647
unsigned long [int]	4	0 ~ 4294967295	4	0 ~ 4294967295

变量说明的一般形式为：类型说明符变量名标识符，变量名标识符，...; 例如：

int a,b,c; (a,b,c为整型变量)

long m,n; (m,n为长整型变量)

unsigned int p,q; (p,q为无符号整型变量)

在说明变量时，应注意：

Ÿ 允许在一个类型说明符后，说明多个相同类型的变量。各变量名之间用逗号间隔。类型说明符与变量名之间至少用一个空格间隔。

Ÿ 最后一个变量名之后必须以“;”号结尾。

Ÿ 变量说明必须放在变量使用之前。

2. 浮点型数据

（1）浮点型常量

在Ｃ语言中，浮点数就是实数。实数有二种形式：

Ÿ 十进制小数形式：由数码0~ 9和小数点组成。如3.2，0.35，-321.897。

Ÿ 指数形式：类似2.5×10⁴的数称为指数形式。计算机中用字母e或E代表以10为底的指数，如2.5E4代表2.5×10⁴。一个浮点数在以指数形式输出时，通常采用“规范化的指数形式”，即在字母e或E之前的小数部分中，小数点左边有且仅有一位非零的数字。

（2）浮点型变量

在Ｃ语言中，浮点型变量分为两类：

Ÿ 单精度型：类型说明符为float，在Turbo C中占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，可提供七位有效数字。例如： float x,y;

Ÿ 双精度型：类型说明符为double，在Turbo C中占8 个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。例如：double a,b,c;

3. 字符型数据

（1）字符常量

字符常量是用单引号括起来的一个字符。例如'a'、'b'、'$'、'?'都是合法的字符常量。

另外，C语言中允许使用转义字符。转义字符是一种特殊的字符常量，以反斜杠"\"开头，后跟一个或几个字符。“转义字符”的意思是把反斜杠"\"后面的字符转换成另外的含意。常用的转义字符见表2.2。

表2.2常用的转义字符及其作用

字符形式	含义	ASCII代码
\n	换行，把当前位置移到下一行开头	10
\t	水平制表（跳到下一制表位置）	9
\b	退格	8
\r	回车	13
\f	换页	12
\a	鸣铃	7
\\	反斜杠"\"	92
\'	单引号	39
\"	双引号	34
\ddd	1～3位八进制数所代表的字符
\xhh	1～2位十六进制数所代表的字符

广义地讲，Ｃ语言字符集中的任何一个字符均可用转义字符来表示。上表中的ddd和hh分别为八进制和十六进制的ASCII代码。

（2）字符变量

字符变量的类型说明符是char，其取值是字符常量，即单个字符。每个字符变量被分配一个字节的内存空间，因此只能存放一个字符。字符值是以ASCII码的形式存放在变量的内存单元之中的。字符变量说明的格式和书写规则都与整型变量相同。例如：char a,b;

（3）字符串常量

字符串常量是由一对双引号括起的字符序列。例如： "CHINA" ，"Hello"，"12.5" 等。在Ｃ语言中没有相应的字符串变量，可以用一个字符数组来存放一个字符串常量。字符串常量和字符常量是不同的量。二者有以下区别：

Ÿ 字符常量由单引号括起来，字符串常量由双引号括起来。

Ÿ 字符常量只能是单个字符，字符串常量则可以含一个或多个字符。

Ÿ 字符常量占一个字节的内存空间，而字符串常量占的内存字节数等于字符串中字符个数加1。这是因为需要在字符串的后面增加字符串结束标志，即字符'\0'(ASCII码为0)。

问题7 整型常量的第一个字符为0引起的误解

[例2.1] 在屏幕上输出两个整型常量（例如10和17）的和。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int a = 10;
5	int b = 017;
6	int c = a + b;
7	printf("a+b=%d\n",c);
8	}

[编译结果]

编译通过。但运行结果是:

a+b=25

[问题分析]

编译虽然通过了，但运行结果是a+b=25。按理说a+b=10+17=27，怎么会等于25呢？

实际上，如果一个整型常量的第一个字符是数字0，那么该常量将被视作八进制数。例如17与017的含义是不同的。前者只是十进制数字17，而后者是八进制数017，即十进制数字15。由于在int b = 017;里把17写成017，导致结果出错。

[正确代码]

代码改动如下：

5	int b = 17; //此处把017改成17

[运行结果]

a+b=27

问题8 将字符常量与字符串常量混淆

[例2.2] 定义一个字符常量，赋值，并输出。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	char s;
5	s = "a";
6	printf("s=%c\n",s);
7	}

[编译结果]

E:\Code\2_2.cpp(5) : error C2440: '=' : cannot convert from 'char [2]' to 'char'

This conversion requires a reinterpret_cast, a C-style cast or function-style cast

[问题分析]

char s;

s="a";

在这里就混淆了字符常量与字符串常量，字符常量是由一对单引号括起来的单个字符，字符串常量是一对双引号括起来的字符序列。C规定以'\0'作为字符串结束标志，它是由系统自动加上的，所以字符串“a”实际上包含两个字符：'a'和'\0'，而把它赋给一个字符变量是不行的。

[正确代码]

代码改动如下：

s = 'a';

[运行结果]

s=a

问题9 混淆‘/’和‘\’

[例2.3] 输入两个数，求二者的商，输出结果。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	float a, b;
5	scanf("%f %f",&a, &b);
6	if(b==0) \判断分母是否为0/
7	{
8	printf("分母为0！/n");
9	}
10	else
11	{
12	float c = a\b;
13	printf("a/b=%.2f/n",c);
14	}
15	}

[编译结果]

E:\Code\2_3.cpp(6) : error C2017: illegal escape sequence

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xc5'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xd0'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xb6'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xcf'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xb7'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xd6'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xc4'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xb8'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xca'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xc7'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xb7'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xf1'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xce'

E:\Code\2_3.cpp(6) : error C2018: unknown character '0xaa'

E:\Code\2_3.cpp(6) : warning C4138: '*/' found outside of comment

E:\Code\2_3.cpp(6) : error C2100: illegal indirection

E:\Code\2_3.cpp(6) : error C2059: syntax error : '/'

E:\Code\2_3.cpp(7) : error C2143: syntax error : missing ';' before '{'

E:\Code\2_3.cpp(10) : error C2181: illegal else without matching if

E:\Code\2_3.cpp(12) : error C2017: illegal escape sequence

E:\Code\2_3.cpp(12) : error C2146: syntax error : missing ';' before identifier 'b'

[问题分析]

‘/’和‘\’这两个符号经常被混淆；注释对应的符号是‘/’，而转义字符是以‘\’开头，除号是‘/’。

在本例中，第6行代码居然报了18条错误信息！实际上这只是因为第6行代码中把表示注释的“/*”错误地写成了“\*”导致。因为把表示注释的“/*”错误地写成了“\*”，所以后面的“判断分母是否为0*/”就被认为是程序代码，而不是注释。因此才报了这么多错。第12行代码把除号“/”写成了“\”。重新编译则通过。运行，输入a和b，看到的运行结果如下：

5.2 2.0

a/b=2.60/nPress any key to continue

从结果可以看出，第13行代码中把换行符“\n”错写为“/n”。

[正确代码]

代码改动如下：

6	if(b==0) /判断分母是否为0/

以及

12	float c = a/b;
13	printf("a/b=%.2f\n",c);

[运行结果]

5.2 2.0

a/b=2.60

Press any key to continue

问题10 缺少强制类型转换

如果一个运算符两边的运算数类型不同，先要将其转换为相同的类型，即较低精度类型转换为较高精度类型，然后再参加运算。如两个float型数参加运算，虽然它们类型相同，但仍要先转成double型再进行运算，结果亦为double型。当运算符两边的运算数为不同类型时的转换，如一个long 型数据与一个int型数据一起运算，需要先将int型数据转换为long型，然后两者再进行运算，结果为long型。所有这些转换都是由系统自动进行的，但是，C语言也提供了以显式的形式强制转换类型的机制。

当较低精度类型的数据转换为较高精度类型时，一般只是形式上有所改变，而不影响数据的实质内容，而较高精度类型的数据转换为较低精度类型时则可能引起数据丢失。

当赋值运算符两边的运算对象类型不同时，将发生类型转换，转换的规则是：把赋值运算符右侧表达式的类型转换为左侧变量的类型。

整数相除会降低精度，丢失小数部分。可以在整数相除之前先做强制类型转换，以避免这种危险。

[例2.4] 已知一个整数，求它的倒数并输出。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int x=3;
5	float y = 1/x;
6	printf("x的倒数为：%.2f\n",y);
7	}

[编译结果]

编译通过。

[问题分析]

虽然编译通过了，但运行结果为：

x的倒数为：0.00

实际上，3的倒数保留两位小数应该为0. 33。错误在哪里呢？因为x是整数3，1也是整数，则1/x是整数相除，结果为整数0，不会得到0. 33，进而会影响后边的计算结果。因此，可以把float y = 1/x;改成float y = 1/(float)x，或者改为float y = 1.0/x .当计算不同类型的数据时，一定要注意会不会出现引起错误的自动类型转换，建议最好加上强制转换。

[正确代码]

代码修改如下：

6	float y = 1/(float)x; //或者改为float y = 1.0/x;

[运行结果]

x的倒数为：0.33

问题11 类型转换降低精度

当较低精度类型的数据转换为较高精度类型时，一般只是形式上有所改变，而不影响数据的实质内容，而较高精度类型的数据转换为较低精度类型时则可能有些数据丢失。如int型数值赋给char型变量时，只保留其最低8位，高位部分舍弃。而long型数据赋给int型变量时，将低16位值送给int型变量，而将高16 位截断舍弃。(这里假定int型占两个字节)。

[例2.5] 已知商品价格和折扣率，求折扣后的价格。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	float price = 10.0f; //原价
5	float discount = 0.85f; //折扣
6	int newPrice = price*discount; //计算折扣价
7	printf("折扣后的价格为：%d\n",newPrice);
8	}

[编译结果]

e:\code\2_5.cpp(6) : warning C4244: 'initializing' : conversion from 'float' to 'int', possible loss of data

[问题分析]

编译没有错误，只有一个警告：conversion from 'float' to 'int', possible loss of data.运行结果为：

折扣后的价格为：8

因为两个float值相乘，结果还是float型。将这个结果赋给一个整型变量，结果会舍弃高位部分。

[正确代码]

代码修改如下：

6	float newPrice = price*discount; //计算折扣价
7	printf("折扣后的价格为：%.2f\n",newPrice);

[运行结果]

折扣后的价格为：8.50

练习2

请改正如下程序中的错误。

1) 写一个函数strlen，返回给定字符串的长度。

1	#include <stdio.h>
2	int strlen(char s[])
3	{
4	int i=0;
5	while(s[i] != "\0")
6	++i;
7	return i;
8	}
9
10	void main( )
11	{
12	int len = strlen("Hello,world!");
13	printf("len = %d/n", len);
14	}

2) 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。（结果应该为32.660259，但如下程序的运行结果为21.000000，请改正其中的错误）

1	#include <stdio.h>
2	void main( )
3	{
4	int number=20;
5	int a=2,b=1;
6	float s=0;
7	for(int n=1;n<=number;n++)
8	{
9	s=s+a/b;
10	int t=a;a=a+b;b=t;
11	}
12	printf("sum is %.6f\n",s);
13	}

第3章存储类

在C语言中，每一个数据，不管是常量还是变量，都具有一定的数据类型。实际上，所有的变量不但具有一定的数据类型，还有一个存储类的问题。从编译程序的观点来看，一个变量名就等同于计算机中的某个物理存储单元，在该单元中，存储着用一串二进制数位代表的该变量的当前值。在计算机中，主要有两种单元：存储器单元和寄存器单元。变量存于存储器或寄存器就决定了它的存储类。变量的存储类确定了变量的作用域。

在C语言中有四种存储类：自动变量、寄存器变量、静态变量、外部变量，分别由auto、register、static、extern关键字来说明。

1. 自动变量

自动变量用关键字auto进行说明，其作用域被限制在该变量出现的那一块内。只要那一块或包含在那一块里的任何块被执行，该变量就存在而且可以被引用。如果程序离开了那一块，该变量就不存在。当不需要它们时，它们不占据任何存储空间。

每当一个变量在块内说明时，如果没有给予显式的存储类说明，则该变量就被看成是自动变量。大部分变量都属于这一种。所以说明自动变量的关键字auto是可以缺省的。自动变量可能通过以下方式加以说明：

auto int a;

auto int m = 33;

auto char ch;

……

2. 寄存器变量

在CPU内部的寄存器中进行操作比在存储器上执行起来要快得多。当把一个变量说明为寄存器变量后，编译程序将尽可能地为该变量分配CPU内部的寄存器作为变量的存储单元，以加快运行速度。如果寄存器已经分配完毕，就把该寄存器变量当作自动变量来处理，即放在存储器中；此时，它的作用等价于auto，也只能用于局部变量和函数的参量说明。寄存器变量用register关键字通过以下方式加以说明：

……

实际上，根据具体的机器硬件，对寄存器变量存在一些限制。通常不建议使用它。

3. 静态变量

静态变量具有静态生存期，用static关键字通过以下方式加以说明：

static int a;

static int m = 33;

static char ch;

……

与自动变量一样，如果一个静态变量是在一个函数（或块）内加以说明，则该静态变量是“局部的”，即其作用域被限制在它出现的那一块内。但与自动变量不同的是，静态变量在函数退出时保持其数值。下次再调用这个函数时，静态变量仍包含上次函数退出时的值。

静态变量可以是内部的（即局部于一个函数或块），也可以是外部的。如果静态变量的说明出现于任何函数之前，则这些静态变量对该文件中的所有函数均是已知的，是外部静态变量，但在其他文件中则是未知的。外部静态变量提供了隐藏数据对象的方法。

4. 外部变量

与前三种不同，外部变量的作用域是全局的，而不是局部的。例如：

int x = 10;

void main( )

{

printf(“%d\n”,x);

}

虽然x在main函数之外定义，但在该函数内仍然是可以使用的。如果所用的局部变量和外部变量名字重复了，在发生冲突时，外部变量被屏蔽，局部变量起作用。

总的来说，外部变量必须在函数的外部说明一次，也应在想要使用它的任何函数中用关键字extern再次加以说明。但是只要在函数的外面说明了它，而说明又在同一个源程序文件的上面，则在函数内部就不需要再对外部变量加以说明。如果要在定义外部变量之前，或变量的定义和变量的使用不在同一个文件内，就必须使用extern加以说明。

5. 变量的作用域

变量的作用域就是指变量的有效范围，或者起作用的范围。

在一个函数内部定义的变量只在本函数范围内有效，即只有在本函数内才能使用它们，在此函数之外不能使用这些变量，称为“局部变量”。在函数之外定义的变量是外部变量，也称为“全局变量”。

局部变量可以与全局变量同名。在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，则这两个局部变量的作用域就在自己所在的循环体内。如果在函数内要使用全局变量，需要使用'::'。extern 用于声明一个变量为全局变量。

静态变量的位置在静态存储区中（静态存储区在整个程序运行期间都存在）。未经初始化的全局静态变量会被程序自动初始化为0（自动变量对象的初值是任意的，除非被显示初始化）。

在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。局部静态变量的作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。但是局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对它进行访问。

在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。全局静态变量的作用域与其他全局变量不同。非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。其他文件中可以使用相同名字的变量，不会发生冲突。

在函数的返回类型前加上关键字static，函数就被定义成为静态函数。函数的定义和声明默认情况下是extern的，但静态函数只是在声明它的文件当中可见，不能被其他文件所用。定义静态函数的好处是：其他文件中可以定义相同名字的函数，不会发生冲突；静态函数不能被其他文件所用。

问题12 在使用变量前未定义，或未初始化

[例3.1] 对已知数组中的所有元素累加求和。

[错误代码]

1	#include <stdio.h>
2	void main( )
3	{
4	int a[]={1,2,3,4,5};
5	int sum;
6	for(i=0;i<5;i++)
7	sum+=a[i];
8	printf("%d\n",sum);
9	}

[编译结果]

E:\Code\3_1.cpp(5) : error C2065: 'i' : undeclared identifier

[问题分析]

上面的编译结果提示i没有定义。把第6句改为for(int i=0;i<5;i++)后，编译通过。但运行结果为：

-858993445

明显是错误的。原因是sum未初始化为0。把第5句改为int sum=0;则结果符合预期。

[正确代码]

代码改动如下：

5	int sum=0;
6	for(int i=0;i<5;i++)

[运行结果]

问题13 错误理解静态变量的作用域

静态变量的位置在静态存储区中（静态存储区在整个程序运行期间都存在）。未经初始化的全局静态变量会被程序自动初始化为0（自动变量对象的值是任意的，除非被显示地初始化）。

在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。全局静态变量的作用域与其他全局变量不同：全局静态变量在声明它的文件之外是不可见的。准确地说是从定义之处开始到文件结尾。

[例3.2] 静态变量的作用域演示。

[错误代码]

1	#include "stdafx.h"
2	void count( )
3	{
4	static int num = 0;
5	num++;
6	printf("I have been called %d times\n",num);
7	}
8	void main( )
9	{
10	for(int i=1; i<=3; i++)
11	count( );
12	printf("Total called %d times\n",num);
13	}

[编译结果]

E:\Code\3_2.cpp(14) : error C2065: 'num' : undeclared identifier

[问题分析]

第14行代码试图使用在count函数里定义的静态局部变量num。静态局部变量num是在count函数里定义的，它的作用域局限于count函数内部。可以改用全局变量。

[正确代码]

代码改动如下：

12	//printf("Total called %d times\n",num); 删除此语句，或使用全局变量

[运行结果]

I have been called 1 times

I have been called 2 times

I have been called 3 times

[例3.3] 全局静态变量的作用域演示。

[错误代码]

test1.cpp

1	#include "stdio.h"
2	void display( );
3	extern int n;
4	void main( )
5	{
6	n = 20;
7	printf("%d\n",n);
8	display( );
9	}

test2.cpp

1	#include "stdio.h"
2	static int n;
3	void display( )
4	{
5	n++;
6	printf("%d\n",n);
7	}

[编译结果]

Linking...

test1.obj : error LNK2001: unresolved external symbol "int n" (?n@@3HA)

Debug/test1.exe : fatal error LNK1120: 1 unresolved externals

Error executing link.exe.

[问题分析]

文件分别编译通过，但link的时候test1.cpp中的变量n找不到定义，产生错误。一种解决方法是把display函数放到test1.cpp中，另一种方法是把n定义成全局变量，而不是全局静态变量。但全局变量需要初始化，而未经初始化的全局静态变量会被程序自动初始化为0。

[正确代码]

把两个文件合成一个文件，并改动如下：

1	#include "stdio.h"
2	static int n;
3	void display( )
4	{
5	n++;
6	printf("%d\n",n);
7	}
8	void main( )
9	{
10	n = 20;
11	printf("%d\n",n);
12	display( );
13	}

[运行结果]

问题14 全局变量的错误声明

全局变量一般这样定义：在某个cpp文件中定义全局变量，如int gCount; 然后在要调用的cpp文件里声明extern int gCount;即可。如果还是使用int gCount，那么就会产生LNK2005错误。

头文件的重复包含可能会导致全局变量的错误声明。需要包含的头文件中往往含有变量、函数、类的定义，在其它使用的地方不得不多次被包含，如果头文件中没有相关的宏等防止重复链接的措施，那么就会产生LNK2005错误。解决办法是在需要包含的头文件中做类似的处理：

#ifndef MY_H_FILE //如果没有定义这个宏，宏的名字任意

#define MY_H_FILE //定义这个宏

int gCount；

……. //头文件主体内容

……

#endif

如果不使用宏来做，也可以使用预编译，在头文件中加入：

#pragma once

……. //头文件主体

[例3.4] 使用全局变量，求已售商品的总营业额。

[错误代码]

test1.cpp

1	#include "stdio.h"
2	void Sale(int count,float price);
3	float gTotal;
4	void main( )
5	{
6	gTotal = 0;
7	Sale(5, 20);
8	Sale(32, 3);
9	printf("营业额为%.2f\n", gTotal);
10	}

test2.cpp

1	#include " stdio.h"
2	float gTotal;
3	void Sale(int count, float price)
4	{
5	gTotal += price*count;
6	}

[编译结果]

Linking...

test2.obj : error LNK2005: "float gTotal" (?gTotal@@3MA) already defined in test1.obj

Debug/test1.exe : fatal error LNK1169: one or more multiply defined symbols found

Error executing link.exe.

[问题分析]

全局变量应该这样定义：在一个cpp文件中定义：“float gTotal;”，在其他cpp文件里声明“extern float gTotal; ”。而在本例中test1.cpp和test2.cpp里都是用的“float gTotal;”应该把其中一个改为“extern float gTotal;”。

[正确代码]

把test1.cpp中的代码改动如下：

3	extern float gTotal;

[运行结果]

营业额为196.00

问题15 滥用全局变量

全局变量有很多优点，但是滥用全局变量会带来很多问题。全局变量不但阻碍了代码重用，而且使代码变得更难维护。它们阻碍代码重用是因为任何使用了全局变量的代码就立刻与之耦合，导致全局变量修改后它们也不得不跟着修改，从而使任何重用都不可能了。它们使代码变得更难维护的原因是很难甄别出哪些代码用了某个特定的全局变量，因为任何代码都有访问它们的权限。全局变量是不设防的。随便哪个维护代码的C++新手，都能使对全局变量有强烈依赖的软件随时崩溃。

有些程序员喜欢使用全局变量，认为它用起来很方便。但这样做很自私，因为软件的维护常常比它的初次开发要花费更多时间，而使用全局变量就意味着把麻烦扔给了维护工程师。在软件要交付之前，或者维护过程中，我们会发现，可能需要增加全局变量，这个变更需要大量时间，涉及到很多（甚至所有）源文件的更改。

所以，在没有必要的情况下，尽量不用全局变量。或者把对于值的访问加上了函数形式的包装，从而获得宝贵的可扩充性。

练习3

请改正如下程序中的错误。

1) 在函数里用静态变量为新学生自动按照先后顺序分配学号。

1	#include <stdio.h>
2	void NewStudent( )
3	{
4	static int NO=0;
5	NO++;
6	printf("新生报到：学号为%d。\n",NO);
7	}
8	void main( )
9	{
10	NewStudent( );
11	printf("刚才报到的新生学号为%d。\n",NO);
12
13	NewStudent( );
14	printf("刚才报到的新生学号为%d。\n",NO);
15
16	NewStudent( );
17	printf("刚才报到的新生学号为%d。\n",NO);
18	}

2) 用全局变量保存学生总数，在函数AddStudent里增加新生数量，在函数Graduate里减去毕业学生数量。最后输出当前学生总数。

ex3_2.cpp

1	#include <stdio.h>
2	#include "func.h"
3	int TotalStudents;
4	void main( )
5	{
6	TotalStudents = 0;
7
8	AddStudent(5);
9	Graduate(1);
10	Graduate(2);
11
12	printf("目前学校共有%d名学生。\n", TotalStudents);
13	}

func.h

1	#include <stdio.h>
2	int TotalStudents;
3	void AddStudent(int n)
4	{
5	TotalStudents += n;
6	}
7	void Graduate(int n)
8	{
9	TotalStudents -= n;
10	}

第4章运算符

Ｃ语言中有丰富的运算符和表达式，使得Ｃ语言功能十分完善，这也是Ｃ语言的主要特点之一。

1. 运算符的种类

Ｃ语言中的运算符可分为以下几类：

（1）算术运算符

包括加(+)、减(–)、乘(*)、除(/)、求余(或称模运算，%)、自增(++)、自减(--)等。

如果参加+、–、*、/ 运算的两个数中有一个是float型或double型，则结果为double型。两个整数相除的结果为整数，舍去小数部分。但是如果除数或被除数中有一个为负值，则舍入的方向是不固定的。多数C编译系统采取“向零取整”的方法，即取整后向零的方向靠拢。

求余运算要求参与运算的量均为整型，其运算结果等于两数相除后的余数。

自增(++)、自减(--)的作用是使变量的值增1或减1，只能用于变量，不能用于常量或表达式。++或--写在变量名的前面和后面具有不同含义。例如：

++i，--i 的含义是在使用i之前，先使i的值加/减1；

i++，i-- 的含义是在使用i之后，使i的值加/减1；

（2）关系运算符

用于比较运算，包括大于(>)、小于(<)、等于(==)、大于等于(>=)、小于等于(<=)和不等于(!=)等。

（3）逻辑运算符

用于逻辑运算。包括与(&&)、或(||)、非(!)。

（4）位操作运算符

按二进制位进行运算。包括位与(&)、位或(|)、位非(~)、位异或(^)、左移(<<)、右移(>>)等。

（5）赋值运算符

包括赋值运算符(=)及其扩展运算符，如复合算术赋值运算符(+=，-=，*=，/=，%=)和复合位运算赋值运算符(&=，|=，^=，>>=，<<=)等。

如果赋值运算符两边的数据类型不相同，系统将自动进行类型转换，即把赋值号右边的类型换成左边的类型。具体规定如下：

Ÿ 实型赋予整型，舍去小数部分。

Ÿ 整型赋予实型，数值不变，以浮点形式存放，即增加小数部分(小数部分的值为0)。

Ÿ 字符型赋予整型，由于字符型为一个字节，而整型为二个字节，故将字符的ASCII码值放到整型量的低八位中，高八位为0。

Ÿ 整型赋予字符型，只把低八位赋予字符量。

复合算术赋值运算符和复合位运算赋值运算符的写法，对初学者可能不习惯，但十分有利于编译处理，能提高编译效率并产生质量较高的目标代码。

（6）条件运算符( ？ : )

这是一个三目运算符，用于条件求值。其一般形式是:

<表达式1>?<表达式2>:<表达式3>;

该运算符的含义是：先求表达式1的值，如果为真，则求表达式2 的值并把它作为整个表达式的值；如果表达式1 的值为假，则求表达式3 的值并把它作为整个表达式的值。

（7）逗号运算符( ，)

用于把若干表达式组合成一个表达式。程序中使用逗号表达式，通常是要分别求逗号表达式内各表达式的值。并不是在所有出现逗号的地方都组成逗号表达式，如在变量说明中，函数参数表中逗号只是用作各变量之间的间隔符。

（8）指针运算符

包括取内容(*)和取地址(&)二种运算。

（9）求字节数运算符

包括(sizeof)，用于计算数据类型所占的字节数。

（10）特殊运算符

包括括号运算符( )，下标运算符[ ]，成员运算符(→和 )等。

2. 优先级

Ｃ语言中，运算符的运算优先级共分为15级，从1级到15级逐渐降低。在表达式中，优先级较高的先于优先级较低的进行运算。而在一个运算量两侧的运算符优先级相同时，则按运算符的结合性所规定的结合方向处理。Ｃ语言中运算符的运算优先级见表4.1（从上到下逐渐降低）。

3. 结合性

在Ｃ语言的表达式中，各运算量参与运算的先后顺序不仅要遵守运算符优先级别的规定，还要受运算符结合性的制约，以便确定是自左向右进行运算还是自右向左进行运算。这种结合性是其它高级语言的运算符所没有的，因此也增加了Ｃ语言的复杂性。

Ｃ语言中各运算符的结合性分为两种，即左结合性(自左至右)和右结合性(自右至左)。双目运算具有左结合性。例如算术运算符的结合性是自左至右，即先左后右。如有表达式x-y+z则y应先与“-”号结合，执行x-y运算，然后再执行+z的运算。这种自左至右的结合方向就称为“左结合性”。而自右至左的结合方向称为“右结合性”。典型的右结合性运算符是赋值运算符。如x=y=z，由于“=”的右结合性，应先执行y=z再执行x=(y=z)运算。自增(++)、自减(--)也具有右结合性。Ｃ语言中运算符的结合性见表4.1。

表4.1 运算符的优先级及结合性

运算符	结合性
运算符	结合性
（） [ ] ->	从左至右
! ~ ++ -- +(正号) -(负号) * (指针所指内容) & sizeof	从右至左
* / %	从左至右
+ -	从左至右
<< >>	从左至右
< <= > >=	从左至右
== !=	从左至右
&（位与）	从左至右
^（位异或）	从左至右
\| （位或）	从左至右
&&（逻辑与）	从左至右
\|\|（逻辑或）	从左至右
？：	从右至左
= += -= 等	从右至左
，	从左至右

问题16 分母为0

在进行除法运算或模运算时不能除以0，一定要做合法性检查。尤其是当运算复杂时，往往会忽视这一点。

[例4.1] 输入x，求y=1/(1-x*x)。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	float x;
5	printf("请输入x：");
6	scanf("%f",&x);
7	float y = 1/(1-x*x);
8	printf("y=%f\n",y);
9	}

[编译结果]

编译通过。

[问题分析]

编译通过。当x不为1时，结果是正确的，如：

请输入x：2

y=-0.333333

但是当x为1时，1-x*x等于0，即分母为0，输出结果如下：

请输入x：1

y=1.#INF00

结果显然不对，应当进行合法性检验，除数为0时，应该输出警告信息。

[正确代码]

把第7~8行代码改为：

7	if(x==1)
8	printf("除数不可以为0!\n");
9	else
10	{
11	float y = 1/(1-x*x);
12	printf("y=%f\n",y);
13	}

[运行结果]

请输入x：1

除数不可以为0!

问题17 对实型变量进行“求余”运算

%是求余运算，得到a/b的整余数。整型变量a和b可以进行求余运算，而实型变量则不允许进行“求余”运算。

[例4.2] 已知两个数，求二者相除的余数。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	float a=5,b=2;
5	printf("a%%b=%d\n",a%b);
6	}

[编译结果]

e:\code\4_2.cpp(5) : error C2296: '%' : illegal, left operand has type 'float'

e:\code\4_2.cpp(5) : error C2297: '%' : illegal, right operand has type 'float'

[问题分析]

实型变量则不允许进行“求余”运算。

[正确代码]

代码改动如下：

4	int a=5,b=2;

[运行结果]

a%b=1

问题18 “=”与“==”混淆

＝表示赋值，而==才表示我们数学中的相等关系。在许多高级语言中，用“=”符号作为关系运算符“等于”。如在BASIC程序中可以写

if (a=3) then a=b

但C语言中，“=”是赋值运算符，“==”是关系运算符。由于习惯问题，初学者往往会把：

if (a==3) a=b;

写成：

if (a=3) a=b;

本来是要判断a是否和3相等，如果a和3相等，就把b值赋给a；结果却直接把3赋给a，而且会导致程序逻辑错误。初学者往往会犯这样的错误。

[例4.3] 求555555的约数中最大的三位数是多少。

根据约数的定义，对于一个整数N，除去1和它自身，能整除N的数即为N的约数。因此，最简单的方法是用2到N-1之间的所有数去除N，即可求出N的全部约数。本例中只需求出555555的约数中最大的三位数，则其取值范围可限制在100到999之间。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	long num = 555555;
5	for(int i=999;i>=100;i--)
6	{
7	int j=num%i;
8	if(j=0)
9	{
10	printf("555555的约数中最大的三位数是%d\n",i);
11	break;
12	}
13	}
14	}

[编译结果]

编译通过。

[问题分析]

虽然编译通过，但运行结果不正确：没有任何屏幕输出。但实际上555555的约数肯定有三位数。问题在哪里呢？printf根本就没有执行到，是不是判断条件的问题呢？仔细检查，发现if(j=0)这一句代码里把“==”错误地写成了赋值号“=”，导致变量j被赋值后其值为0，不满足判断条件，因此永远也无法执行printf这一句代码。

[正确代码]

代码改动如下：

if(j==0)

[运行结果]

555555的约数中最大的三位数是777

问题19 “&”与“&&”，“|”与“||” 混淆

前面说过，“=”与“==”很容易被混淆；同样，将按位与运算符&与逻辑运算符&&，或者将按位或运算符|与逻辑运算符||混淆，也是很容易犯的错误。特别是C语言中按位与运算符&和按位或运算符|，与其他编程语言的按位与运算符和按位或运算符在表现形式上完全不同（如Pascal语言中分别是and和or），更容易让程序员因为受其他编程语言的影响而犯错。按位与运算符&和按位或运算符|对操作数的处理方式是将其视作一个二进制的位序列，分别对每个位进行操作。而逻辑运算符&&和||对操作数的处理方式是则是通常把0视作“假”，把非0值视为“真”。而且，逻辑运算符&&和||在左侧的操作数的值能够确定最终结果时根本不会对右侧操作数求值。

[例4.4] 找出100以内既不能被2整除又不能被3整除的整数。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	for(int i=0;i<100;i++)
5	if(i%2 & i%3)
6	printf("%d\t",i);
7	printf("\n");
8	}

[编译结果]

编译通过。

[问题分析]

该程序的运行结果如下：

1 7 13 19 25 31 37 43 49 55

61 67 73 79 85 91 97

但实际上5、11、17等数字也满足既不能被2整除又不能被3整除的条件。为什么这些数字被丢掉了呢？原来，第5句if(i%2 & i%3)中，错把逻辑运算符&&写成按位与运算符&了。那么这一句代码在运行中时，5%2=1，即二进制数0001；而5%3=2，即二进制数0010；二者按位进行“与”的操作，结果为0，导致结果中漏掉了“5”。其他被漏掉的数字也使基于同样原因。

[正确代码]

代码改动如下：

5	if(i%2 && i%3)

[运行结果]

1 5 7 11 13 17 19 23 25 29

31 35 37 41 43 47 49 53 55 59

61 65 67 71 73 77 79 83 85 89

91 95 97

问题20 “++”、“--”的前置和后置方式

[例4.5] 依次输入5个学生的分数，如果及格，则输出及格人数。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int nSum = 0;
5	int score;
6	for(int i=0;i<5;i++)
7	{
8	scanf("%d",&score);
9	if(score>=60)
10	printf("及格人数:%d\t",nSum++);
11	printf("\n");
12	}
13	}

[编译结果]

编译通过。

[问题分析]

运行结果如下：

及格人数:0

及格人数:1

及格人数:2

及格人数:3

当输入分数90时，此时输出的及格人数居然是0。因为第10行代码

printf("sum:%d\t", ++nSum);

里面的++nSum被写成了nSum++。前者是在使用之前就先加1，后者是使用过后再加1。所以当输入分数90时，此时输出的及格人数是0。

[正确代码]

代码改动如下：

10	printf("及格人数:%d\t", ++nSum);

[运行结果]

及格人数:1

及格人数:2

及格人数:3

及格人数:4

问题21 运算符优先级错误

[例4.6] 已知有两个小于16的二进制数hi和low，要求得到r，其低4位与low一致，高4位与hi一致。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int hi=0xc;
5	int low=0x5;
6	int r = hi<<4 + low;
7	printf("r=%x\n",r);
8	}

[编译结果]

E:\CODE\4_6.cpp(6) : warning C4554: '<<' : check operator precedence for possible error; use parentheses to clarify precedence

[问题分析]

运行结果应该是：

r=c5

但实际上却是：

r=1800

结果出乎意料。问题出在第6行：

int r = hi<<4 + low;

编译器给出警告：warning C4554: '<<' : check operator precedence for possible error; use parentheses to clarify precedence，建议加上括号。因为加法运算符的优先级比移位运算符的优先级高，所以实际上编译器认为：先算4+low，再把hi左移4+low位。

[正确代码]

代码改动如下：

6	int r = (hi<<4) + low;

[运行结果]

r=c5

练习4

请改正如下程序中的错误。

1) 编程求1000以内的所有阿姆斯特朗数（如果一个正整数等于其各个数字的立方和，则称该数为阿姆斯特朗数。如 153=1³+5³+3³）。

1	#include<stdio.h>
2	void main( )
3	{
4	int a[3];
5	printf("1000以内的所有阿姆斯特朗数有:\n");
6
7	for(int i=2;i<1000;i++) /穷举要判定的数i的取值范围2~1000/
8	{
9	for(int t=0, k=1000; k>=10; t++) /截取整数i的各位(从高向低位)/
10	{
11	a[t]=(i%k)/(k/10); /分别赋于a[0]~a[2}/
12	k/=10;
13	}
14	if(a[0]a[0]a[0]+a[1]a[1]a[1]+a[2]a[2]a[2]=i)
15	/判断i是否为阿姆斯特朗数/
16	printf("%5d",i); /若满足条件，则输出/
17	}
18	printf("\n");
19	}

2) 有1、2、3、4四个数字，能组成哪些互不相同且无重复数字的三位数？

1	#include<stdio.h>
2	void main( )
3	{
4	int i,j,k;
5	printf("\n");
6	for(i=1;i<5;i++)
7	for(j=1;j<5;j++)
8	for (k=1;k<5;k++)
9	{
10	if (i!=k & i!=j & j!=k) /确保i、j、k三位互不相同/
11	printf("%d%d%d\n",i,j,k);
12	}
13	}

第5章流程控制

Ｃ语言是一种结构化的程序设计语言，有很强的过程功能和数据结构功能，支持结构化的逻辑结构。从程序流程的角度来看，程序可以分为三种基本结构，即顺序结构、分支结构、循环结构。顺序结构是最简单的一种，依次执行程序中的各条语句。分支结构根据给定的条件进行判断，以决定执行某个分支程序段。循环结构的特点是：在给定条件成立时，反复执行某个程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。这三种基本结构可以组成所有的各种复杂程序。Ｃ语言提供了多种语句来实现这些程序结构。

控制语句用于控制程序的流程，以实现程序的各种结构方式。它们由特定的语句定义符组成。Ｃ语言的控制语句可分为条件判断语句、循环执行语句、转向语句三类。

1. 条件判断语句

（1）if语句

Ｃ语言的if语句有三种基本形式。

Ÿ   if
形式为：
    if(表达式)
        语句；
如果表达式的值为真，则执行其后的语句，否则不执行该语句。

Ÿ   if-else
形式为：
    if(表达式)
        语句1；
    else
        语句2；
如果表达式的值为真，则执行语句1，否则执行语句2 。

Ÿ   if-else if
形式为：
    if(表达式1)
        语句1；
    else if(表达式2)
        语句2；
    else if(表达式3)
        语句3；
    …
    else if(表达式n-1)
         语句 n-1；
    else
         语句n；
依次判断表达式的值，当出现某个值为真时，则执行其对应的语句。然后跳到整个if语句之外继续执行程序。如果所有的表达式均为假，则执行语句n 。然后继续执行后续程序。该语句可用于多分支选择。

（2）switch语句

Ｃ语言还提供了另一种用于多分支选择的switch语句，其一般形式为：

switch(表达式){

case常量表达式1:

语句1;

break;

case常量表达式2:

语句2;

break;

…

case常量表达式n-1:

语句n-1;

break;

default :

语句n;

}

该语句首先计算表达式的值，并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时，即执行其后的语句。如表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。

2. 循环执行语句

（1）for

其一般形式为：

for(表达式1；表达式2；表达式3)

语句；

其中，表达式1通常用来给循环变量赋初值。也允许在for语句外给循环变量赋初值，此时可以省略表达式1。表达式2通常是循环条件，一般为关系表达式或逻辑表达式。表达式3　通常用来修改循环变量的值。这三个表达式都可以是逗号表达式，即每个表达式都可由多个表达式组成。三个表达式都是任选项，都可以省略。

执行for循环时，首先计算表达式1的值，再计算表达式2的值，若值为真(非0)则执行循环体一次，否则跳出循环。然后再计算表达式3的值，再重新计算表达式2的值，反复循环执行。在整个for循环过程中，表达式1只计算一次，表达式2和表达式3则可能计算多次。循环体可能多次执行，也可能一次都不执行。

（2）while

其一般形式为：

while(表达式)

语句；

其中表达式是循环条件，语句为循环体。首先计算表达式的值，当值为真(非0)时，执行循环体语句。while语句中的表达式一般是关系表达或逻辑表达式。循环体如包括有一个以上的语句，则必须用{ }括起来，组成复合语句。应注意循环条件的选择以避免死循环。

（3）do-while

其一般形式为：

语句；

while(表达式)；

其中语句是循环体，表达式是循环条件。先执行循环体语句一次，再判断表达式的值，若为真(非0)则继续循环，否则终止循环。do-while语句和while语句的区别在于do-while是先执行后判断，因此do-while至少要执行一次循环体。而while是先判断后执行，如果条件不满足，则一次循环体语句也不执行。do-while语句可以组成多重循环，而且也可以和while语句相互嵌套。当循环体由多个语句组成时，必须用{ }括起来组成一个复合语句。

3. 转向语句

（1）break

其一般格式是：

break；

break语句只能用在switch 语句或循环语句中，作用是跳出switch语句或跳出本层循环，转去执行后面的程序。使用break语句可以使循环语句有多个出口，在一些场合下使编程更加灵活、方便。

（2）goto

goto语句也称为无条件转移语句，其一般格式如下：

goto 语句标号；

其中语句标号是按标识符规定书写的符号，放在某一行语句的前面，标号后加冒号。语句标号起标识语句的作用，与goto 语句配合使用。

Ｃ语言不限制程序中使用标号的次数，但各标号不得重名。goto语句改变程序流向，转去执行语句标号所标识的语句。goto语句通常与条件语句配合使用。可用来实现条件转移，构成循环，跳出循环体等功能。但在结构化程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序都产生困难。

（3）continue

continue语句只能用在循环体中，其一般格式是：

continue;

其语义是结束本次循环，即不再执行循环体中continue 语句之后的语句，直接转入下一次循环条件的判断与执行。continue语句只结束本层本次的循环，并不跳出循环。

（4）return

return语句只能出现在被调用的函数中，用于返回主调函数。

问题22 逻辑表达式或关系表达式错误

[例5.1] 把学生的成绩从百分制转换为英文等级制（A、B、C、D、E）。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int score=0;
5	char grade; //成绩等级
6	printf("请输入分数：\n");
7	scanf("%d",&score);
8	while(score>=0)
9	{
10	if(score>=90)
11	grade = 'A';
12	else if(80<=score<90)
13	grade = 'B';
14	else if(70<=score<80)
15	grade = 'C';
16	else if(60<=score<70)
17	grade = 'D';
18	else
19	grade = 'E';
20	printf("%d : %c\n", score, grade);
21
22	printf("请输入分数：\n");
23	scanf("%d",&score);
24	}
25	}

[编译结果]

E:\CODE\5_1.cpp(12) : warning C4804: '<' : unsafe use of type 'bool' in operation

E:\CODE\5_1.cpp(14) : warning C4804: '<' : unsafe use of type 'bool' in operation

E:\CODE\5_1.cpp(16) : warning C4804: '<' : unsafe use of type 'bool' in operation

虽然编译通过，但运行结果显然不对；79分以下也被转换为B：

请输入分数：

95 : A

请输入分数：

85 : B

请输入分数：

75 : B

请输入分数：

66 : B

请输入分数：

43 : B

[问题分析]

我们一定要注意C语言的条件与数学表达式之间的区别。例如我们数学中经常写到的0≤x≤9，在C语言中应该写成 x>=0 && x<=9 。上述代码的第12、14、16行代码中就犯了这个错误，导致结果出错。

[正确代码]

代码修改为：

12	else if(score>=80 && score<90)
13	grade = 'B';
14	else if(score>=70 && score<80)
15	grade = 'C';
16	else if(score>=60 && score<70)

[运行结果]

请输入分数：

95 : A

请输入分数：

85 : B

请输入分数：

75 : C

请输入分数：

66 : D

请输入分数：

43 : E

问题23 if-else嵌套不配对

当if语句中的执行语句也是if语句时，则构成了if 语句嵌套的情形。其一般形式可表示如下：

if(表达式1)

if(表达式2)
语句；
或者为

if(表达式1)

{

            if(表达式2)
               语句；
        }

else

if(表达式3)
语句；
在嵌套内的if语句可能又是if-else型的，这将会出现多个if和多个else重叠的情况，这时要特别注意if和else的配对问题。

[例5.2] 依次输入4个点的坐标，判断该点位于哪个象限。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	for(int i=0;i<4;i++)
5	{
6	int x,y;
7	printf("请输入坐标点:\n");
8	scanf("%d,%d",&x,&y);
9	if(x>0)
10	if(y>0)
11	printf("(%d,%d)位于第一象限\n",x,y);
12	else if(y<0)
13	printf("(%d,%d)位于第四象限\n",x,y);
14	else if(x<0)
15	if(y>0)
16	printf("(%d,%d)位于第二象限\n",x,y);
17	else if(y<0)
18	printf("(%d,%d)位于第三象限\n",x,y);
19	else
20	printf("(%d,%d)位于原点或坐标轴上\n",x,y);
21	}
22	}

[编译结果]

编译通过，但运行结果有问题：

请输入坐标点:

1,2

(1,2)位于第一象限

请输入坐标点:

-1,2

请输入坐标点:

-1,-2

请输入坐标点:

1,-4

(1,-4)位于第四象限

当x>0时输出结果是正确的，但是当x<0时，就没有输出结果了。

[问题分析]

为了避免二义性，C语言规定，else 总是与它前面最近的if配对。else最好在写每个条件时要用两个｛｝分别将两个分支先括起来，再添加其中的语句，以保证其配对不易错。

[正确代码]

第9行及以后代码改为：

9	if(x>0)
10	{
11	if(y>0)
12	printf("(%d,%d)位于第一象限\n",x,y);
13	else if(y<0)
14	printf("(%d,%d)位于第四象限\n",x,y);
15	}
16	else if(x<0)
17	{
18	if(y>0)
19	printf("(%d,%d)位于第二象限\n",x,y);
20	else if(y<0)
21	printf("(%d,%d)位于第三象限\n",x,y);
22	}
23	else
24	printf("(%d,%d)位于原点或坐标轴上\n",x,y);
25	}
26	}

[运行结果]

请输入坐标点:

1,2

(1,2)位于第一象限

请输入坐标点:

-1,2

(-1,2)位于第二象限

请输入坐标点:

-1,-2

(-1,-2)位于第三象限

请输入坐标点:

1,-4

(1,-4)位于第四象限

问题24 分号导致的流程变化

初学者常常会丢掉语句结束标记“;”，尤其是for语句中表达式后或do-while语句后的分号，或在if语句、while( )后、for( )后加“;”，导致流程变化。

[例5.3] 读取7个整数值（1—50），每读取一个值，程序打印出该值个数的“*”。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int i,a,n=1;
5	while(n<=7)
6	{
7	do {
8	scanf("%d",&a);
9	}while(a<1\|\|a>50)
10	for(i=1;i<=a;i++);
11	printf("*");
12	printf("\n");
13	n++;
14	}
15	}

[编译结果]

E:\CODE\5_3.cpp(10) : error C2143: syntax error : missing ';' before 'for'

原来是第9行代码“}while(a<1||a>50)”后面没有写分号。更正错误后，编译通过，但运行结果不对:

[问题分析]

do-while语句用于首先执行一次循环体语句，然后开始测试循环条件，当条件为‘真’时继续循环的处理过程。语句格式：

do{

语句;

}while(表达式);

使用中要注意最后一行的分号不要忘了。本例就犯了这样的错误。

另外，第10行代码“for(i=1;i<=a;i++);”后面多了一个分号，导致循环体内没有执行任何语句，只在循环结束后执行了一次“printf("*");”，所以不管输入几，都只输出了一个“*”号。

[正确代码]

代码修改为：

9	}while(a<1\|\|a>50);
10	for(i=1;i<=a;i++) //此处删除分号

[运行结果]

***

*********

********************************

*****

*******

*********

问题25 switch语句:case后面缺少break;

C语言的switch语句的控制流程能够依次通过并执行各个case部分。但是要注意，如果case语句后面没有写break，则程序的控制流程会径直通过case标号，而不受任何影响。

[例5.4] 依次输入3次整数color，当color值分别为1，2，3时，分别输出“red”、“green”、“blue”。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	for(int i=0;i<3;i++)
5	{
6	int color;
7	scanf("%d", &color);
8	switch(color)
9	{
10	case 1:
11	printf("red\n");
12	case 2:
13	printf("green\n");
14	case 3:
15	printf("blue\n");
16	}
17	}
18	}

[编译结果]

编译通过，但运行结果有问题：

red

green

blue

green

blue

Blue

[问题分析]

由于漏写了break语句，case只起标号的作用，而不起判断作用。因此，如果用户输入1，则程序会在输出了“red”之后，继续输出“green”、“blue”。正确写法应在每个分支后再加上“break;”。

[正确代码]

把第8行及以后的代码改写为：

8	switch(color)
9	{
10	case 1:
11	printf("red\n");
12	break;
13	case 2:
14	printf("green\n");
15	break;
16	case 3:
17	printf("blue\n");
18	break;
19	}
20	}
21	}

[运行结果]

red

green

blue

问题26 忽视了while和do-while语句在细节上的区别

[例5.5] 输入整数i，求i+（i+1）+（i+2）+…… + 10。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int a=0,i;
5	scanf("%d",&i);
6	do
7	{
8	a=a+i;
9	i++;
10	}
11	while(i<=10);
12	printf("%d\n",a);
13	}

[编译结果]

编译通过。但是当i>10时结果有问题：

[问题分析]

可以看到，当输入i的值小于或等于10时，结果正确。而当i>10时，结果错误。因为while循环是先判断后执行，而do-while循环是先执行后判断。对于大于10的数while循环一次也不执行循环体，而do-while语句则要执行一次循环体。

[正确代码]

把第6行及以后的代码改写为：

6	while(i<=10)
7	{
8	a=a+i;
9	i++;
10	}
11	printf("%d\n",a);
12	}

[运行结果]

问题27 滥用goto语句

在C/C++等高级编程语言中保留了goto语句，但建议不用或少用。任何程序都可以用顺序、分支和循环结构表示出来。从高级程序语言中去掉goto语句并不影响高级程序语言的编程能力，而且编写的程序的结构更加清晰。

goto语句破坏了程序结构，会使程序结构难于理解，使程序可读性变差。滥用goto语句，可能会导致杂乱的、令人混淆的代码（通常称之为面条式代码）。结构化程序设计方法主张限制使用goto语句，但也不是绝对禁止使用goto语句；一般来说，goto语句主要有两种用途：

1）与if语句一起构成循环结构。

2）从循环体内跳转到循环体外。在C语言中可以使用break语句和continue语句跳出本层循环和结束本次循环，goto语句的使用机会已大大减少，只是需要从多层循环的内层循环跳到外层循环时才用到goto语句。但是这种用法不符合结构化原则，一般不宜采用，只有在不得已时（例如能够大大提高效率）才使用。

[例5.6] 计算奖金：工作量超过1000，奖金为2000元；工作量801~1000，奖金为1000元；工作量301~800，奖金为500元；工作量低于或等于300，奖金为0；工作量为负数时程序结束。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int bonus=0, count=0;
5
6	A: printf("请输入您的工作量：\n");
7	scanf("%d",&count);
8	if(count == -1)
9	goto END;
10	else if(count>1000)
11	bonus = 2000;
12	else if(count>800)
13	bonus = 1000;
14	else if(count>300)
15	bonus = 500;
16	else
17	bonus = 0;
18
19	printf("您的奖金为：%d\n",bonus);
20	goto A;
21	END:
22	printf("再见\n");
23	}

[编译结果]

编译通过，运行结果也没问题。

[问题分析]

在本例中没有必要使用goto语句。用while循环即可。使用goto语句不符合结构化原则，一般不宜采用，只有在不得已时（例如能够大大提高效率）才使用。严格地说，本例代码不算错误，但不建议使用goto语句。

[正确代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int bonus=0, count=0;
5
6	while(count>=0)
7	{
8	printf("请输入您的工作量：\n");
9	scanf("%d",&count);
10
11	if(count>1000)
12	bonus = 2000;
13	else if(count>800)
14	bonus = 1000;
15	else if(count>300)
16	bonus = 500;
17	else
18	bonus = 0;
19
20	printf("您的奖金为：%d\n",bonus);
21	}
22	printf("再见\n");
23	}

[运行结果]

请输入您的工作量：

1200

您的奖金为：2000

请输入您的工作量：

900

您的奖金为：1000

请输入您的工作量：

500

您的奖金为：500

请输入您的工作量：

200

您的奖金为：0

请输入您的工作量：

-1

再见

练习5

请改正如下程序中的错误。

1) 鸡兔共有30只，鸡兔总共有90只脚，请问有多少只鸡，多少只兔？

1	#include<stdio.h>
2	void main( )
3	{
4	for(int i=0;i<30;i++);
5	for(int j=0;j<30;j++)
6	if(i+j==30 && 2i+4j==90)
7	printf("有%d只鸡，%d只兔\n",i,j);
8	}

2) 编写一个简单的计算器，能根据用户输入的两个操作数和运算符来计算加减乘除。

1	#include<stdio.h>
2	void main( )
3	{
4	float a,b;
5	int op;
6	printf("请输入两个操作数：\n");
7	scanf("%f,%f",&a,&b);
8	printf("请选择运算符：\n");
9	printf("1)加 2)减 3)乘 4)除\n");
10	scanf("%d",&op);
11	switch(op)
12	{
13	case 1: //加
14	printf("%f+%f=%f\n",a,b,a+b);
15	case 2: //减
16	printf("%f-%f=%f\n",a,b,a-b);
17	case 3: //乘
18	printf("%f%f=%f\n",a,b,ab);
19	case 4: //除
20	if(b==0)
21	printf("分母为0！\n");
22	else
23	printf("%f/%f=%f\n",a,b,a/b);
24	default:
25	printf("运算符错误！\n");
26	}
27	}

第6章函数

函数是Ｃ程序的基本模块，通过对函数模块的调用来实现特定的功能。Ｃ语言提供了极为丰富的库函数，还允许用户自定义函数。库函数由Ｃ系统提供，用户无须定义，也不必在程序中作类型说明，只需在程序前包含有该函数原型的头文件，即可在程序中直接调用。常用的库函数有printf、scanf、getchar、putchar、gets、puts、strcat等。函数定义的一般形式为：

类型说明符函数名(形式参数表)

{

类型说明

语句

}

其中类型说明符和函数名称为函数头。类型说明符指明了本函数的类型，实际上是函数返回值的类型。函数名是由用户定义的标识符，函数名后有一个括号，其中有形式参数表，形式参数表可以为空，也就是可以不含参数。{ } 中的内容称为函数体。在函数体中也有类型说明，这是对函数体内部所用到的变量的类型说明。如果不要求函数有返回值，此时函数类型说明符可以写为void。

在程序中是通过对函数的调用来执行函数体的，其过程与其它语言的子程序调用相似。在函数调用时也必须给出参数，称为实际参数(简称为实参)。进行函数调用时，主调函数将把实参的值传送给形参，供被调函数使用。

　　Ｃ语言允许函数的递归调用。一个函数在函数体内调用其自身称为递归调用，这种函数称为递归函数。在递归调用中，主调函数同时又是被调函数。执行递归函数将反复调用其自身。为了防止递归调用无终止地进行，必须在函数内加条件判断，满足某种条件后就不再作递归调用，然后逐层返回。

问题28 使用库函数前没有包含头文件

[例6.1] 输入一个角度，求其正弦值。

[错误代码]

1	#include "stdio.h"
2	#define PI 3.14
3	void main( )
4	{
5	int angle;
6	printf("请输入角的大小（度）：\n");
7	scanf("%d",&angle);
8	printf("该角的正弦值为：%.2f\n",sin(angle*PI/180));
9	}

[编译结果]

E:\CODE\6_1.cpp(8) : error C2065: 'sin' : undeclared identifier

[问题分析]

数学函数的声明都在math.h里，本例代码忘了包含math.h，所以编译器认为'sin'没有定义。

代码里的“angle*PI/180”是把角度转换为弧度。

[正确代码]

在前面增加代码：

1	#include "math.h"

[运行结果]

请输入角的大小（度）：

该角的正弦值为：0.50

问题29 使用函数之前未声明

[例6.2] 编写函数，分别计算球、圆柱、圆锥的体积。

[错误代码]

1	#include "stdio.h"
2	#define PI 3.14
3	void main( )
4	{
5	float radius = 2;
6	float height = 5;
7	printf("球的体积为：%.2f\n",BallVolume(radius));
8	printf("圆柱的体积为：%.2f\n",CylinderVolume(radius, height));
9	printf("圆锥的体积为：%.2f\n",ConeVolume(radius, height));
10	}
11	double BallVolume(float radius) //计算球的体积
12	{
13	return PIradiusradiusradius4.0/3.0;
14	}
15	double CylinderVolume(float radius, float height) //计算圆柱的体积
16	{
17	return PIradiusradius*height;
18	}
19	double ConeVolume(float radius, float height) //计算圆锥的体积
20	{
21	return PIradiusradius*height/3.0;
22	}

[编译结果]

E:\CODE\6_2.cpp(7) : error C2065: 'BallVolume' : undeclared identifier

E:\CODE\6_2.cpp(8) : error C2065: 'CylinderVolume' : undeclared identifier

E:\CODE\6_2.cpp(9) : error C2065: 'ConeVolume' : undeclared identifier

E:\CODE\6_2.cpp(13) : error C2373: 'BallVolume' : redefinition; different type modifiers

E:\CODE\6_2.cpp(18) : error C2373: 'CylinderVolume' : redefinition; different type modifiers

E:\CODE\6_2.cpp(23) : error C2373: 'ConeVolume' : redefinition; different type modifiers

[问题分析]

从编译结果看，编译器认为函数BallVolume、CylinderVolume、ConeVolume未定义。原因就是使用函数之前未声明。即使函数已经写好，只要没有声明，编译器就会给出这样的错误信息。

[正确代码]

在main函数之前增加函数BallVolume、CylinderVolume、ConeVolume的声明：

3	double BallVolume(float radius);
4	double CylinderVolume(float radius, float height);
5	double ConeVolume(float radius, float height);

[运行结果]

球的体积为：33.49

圆柱的体积为：62.80

圆锥的体积为：20.93

问题30 函数实参格式不对

[例6.3] 将整数数组A和B的对应元素相加，结果保存到整数数组C的对应元素中。

[错误代码]

1	#include "stdio.h"
2	#define LENGTH 5
3	void AddArray(int arrayA[], int arrayB[], int arrayC[], int n)
4	{
5	for(int i=0;i<n;i++)
6	{
7	arrayC[i] = arrayA[i] + arrayB[i];
8	}
9	}
10	void main( )
11	{
12	int A[LENGTH] = {1,3,5,8,4};
13	int B[LENGTH] = {6,9,15,9,0};
14	int C[LENGTH];
15	for(int i=0;i<LENGTH;i++)
16	{
17	AddArray(A[i],B[i],C[i],LENGTH);
18	printf("%d\t", C[i]);
19	}
20	printf("\n");
21	}

[编译结果]

E:\CODE\6_3.cpp(17) : error C2664: 'AddArray' : cannot convert parameter 1 from 'int' to 'int []'

Conversion from integral type to pointer type requires reinterpret_cast, C-style cast or function-style cast

[问题分析]

本例中函数实参格式不对，函数AddArray的形参是数组，实参却传递了数组中的元素，即一个整数。所以编译器给出错误信息：无法把参数1从'int' 转换为 'int []'。

[正确代码]

把第15行及以后代码改为：

15	AddArray(A,B,C,LENGTH);
16	for(int i=0;i<LENGTH;i++)
17	printf("%d\t", C[i]);
18	printf("\n");
19	}

[运行结果]

7 12 20 17 4

问题31 错误的返回值

[例6.4] 输入两个浮点数，判断是否可以相除，如果可以相除则输出结果，否则提示“分母为0!”。

[错误代码]

1	#include "stdio.h"
2	bool CanDivide(float a,float b)
3	{
4	bool c = (b!=0);
5	}
6	void main( )
7	{
8	float x;
9	float y;
10	scanf("%f,%f",&x,&y);
11	if(CanDivide(x,y)) //判断是否可以相除
12	printf("a/b=%.2f\n",x/y);
13	else
14	printf("分母为0!\n");
15	}

[编译结果]

E:\CODE\6_4.cpp(5) : error C4716: 'CanDivide' : must return a value

[问题分析]

编译器很明白地给出了错误信息：函数'CanDivide'必须返回一个值。

[正确代码]

代码修改如下：

4	return b!=0;

[运行结果]

8,0

分母为0!

问题32 递归时设置了错误的边界条件

[例6.5] 用递归计算10*9*8*7*6*5*4*3*2*1。

[错误代码]

1	#include "stdio.h"
2	int factorial(int j)
3	{
4	int sum;
5	if(j==j-1)
6	sum=1;
7	else
8	{
9	printf("%d",j);
10	if(j>1) printf("*");
11	sum=j*factorial(j-1);
12	}
13	return sum;
14	}
15	void main( )
16	{
17	printf("=%d\n",factorial(10));
18	}

[编译结果]

编译通过。但运行结果出错：

……

6698-6699-6700-6701-6702-6703-6704-6705-6706-6707-6708-6709-6710-6711-6712-6713-6714-6715-6716-6717-6718-6719-6720-6721-6722-6723-6724-6725-6726-6727-6728-6729-6730-6731-6732-6733-6734-6735-6736-6737-6738-6739-6740-6741-6742-6743-6744-6745-6746-6747-6748-6749-6750-6751-6752-6753-6754-6755-6756-6757-6758-6759-6760-6761-6762-6763-6764-6765-6766-6767-6768-6769-6770-6771-6772-6773-6774-6775-6776-6777-6778-6779-6780-6781-6782-6783-6784-6785-6786-6787-6788-6789-6790-6791-6792-6793-6794-6795-6796-6797-6798-6799-6800-6801-6802-6803-6804-6805-6806-6807-6808-6809-6810-6811-6812-6813-6814-6815-6816-6817-6818-6819-6820-6821-6822

……

[问题分析]

在递归时忘了设置边界条件或设置了错误的边界条件，容易造成死循环。在本例中，从运行结果来看，程序陷入了死循环。显然是第5行代码中的边界条件是错的：“if(j==j-1)”。

[正确代码]

if(j==0)

[运行结果]

10*9*8*7*6*5*4*3*2*1=3628800

练习6

请改正如下程序中的错误。

1) 编写一个函数，判断是否闰年。

1	void main( )
2	{
3	int year;
4	printf("请输入年份：\n");
5	scanf("%d",&year);
6	if(IsLeapYear(year))
7	printf("%d年是闰年\n",year);
8	else
9	printf("%d年不是闰年\n",year);
10	}
11
12	bool IsLeapYear(int year)
13	{
14	return (year%4==0 && year%100!=0) \|\| (year%400==0);
15	}

2) 编写一个函数，判断一个数是否为素数。

1	#include <stdio.h>
2	#include <math.h>
3	bool IsPrimeNumber(int x)
4	{
5	int i;
6	if(x<2) return 0;
7	for(i=2;i<=sqrt(x);i++)
8	if(x%i==0)
9	return false;
10	}
11
12	void main( )
13	{
14	int n;
15	while(scanf("%d",&n)!=EOF)
16	{
17	if(IsPrimeNumber( ))printf("YES\n");
18	else printf("NO\n");
19	}
20	}

3) 编写一个函数，从键盘获得输入，然后反向打印它们。

1	#include <stdio.h>
2	void antitone( )
3	{
4	char ch;
5	if((ch=getchar( )) != '\n ')
6	antitone( );
7	putchar(ch);
8	}
9	void main( )
10	{
11	antitone( );
12	}

第7章 C语言预处理程序

C语言中应用了一个预处理程序，在将源代码送到编译程序之前，预先由预处理程序处理。Ｃ语言提供了多种预处理功能，如宏定义、文件包含、条件编译等。合理地使用预处理功能编写的程序便于阅读、修改、移植和调试，也有利于模块化程序设计。预处理命令以“#”开头，如包含命令#include、宏定义命令#define等。

1．宏定义（#define）

在Ｃ语言源程序中允许用一个标识符来表示一个字符串，称为“宏”。被定义为“宏”的标识符称为“宏名”。在编译预处理时，对程序中所有出现的“宏名”，都用宏定义中的字符串去代换，称为“宏代换”或“宏展开”。“宏”分为有参数和无参数两种。无参宏定义的一般形式为：

#define 标识符字符串

例如：

#define PI 3.1415926536

对带参数的宏，在调用中，不仅要宏展开，而且要用实参去代换形参。其一般形式为：

#define 宏名(形参表) 字符串

例如：

#define MAX(a,b) (a>b)?a:b

宏展开只是一种简单的代换，字符串中可以含任何字符，可以是常数或者表达式，预处理程序对它不作任何检查。只能在编译已被宏展开后的源程序时才能发现错误。宏定义在行末不必加分号。宏定义必须写在函数之外，其作用域为宏定义命令起到源程序结束。宏名在源程序中若用引号括起来，则预处理程序不对其作宏代换。宏定义允许嵌套，在宏定义的字符串中可以使用已经定义的宏名。习惯上宏名用大写字母表示，以便于与变量区别。

在带参宏定义中，宏名和形参表之间不能有空格出现。形式参数不分配内存单元，因此不必作类型定义。在宏定义中，字符串内的形参通常要用括号括起来以避免出错。

2．文件包含（#include）

文件包含命令的功能是把指定的文件插入该命令行位置，并取代该命令行，从而把指定的文件和当前的源程序文件连成一个源文件。文件包含是C预处理程序的另一个重要功能。文件包含命令的一般形式为：

#include "文件名" 或者 #include <文件名>

例如，用该命令包含库函数的头文件：

#include "stdio.h"

#include "math.h"

包含命令中的文件名可以用双引号括起来，也可以用尖括号括起来。但是这两种形式是有区别的：使用尖括号表示在包含文件目录中去查找(包含目录是由用户在设置环境时设置的)，而不在源文件目录去查找；使用双引号则表示首先在当前的源文件目录中查找，若未找到才到包含目录中去查找。一个include命令只能指定一个被包含文件，若有多个文件要包含，则需用多个include命令。文件包含允许嵌套，即在一个被包含的文件中又可以包含另一个文件。

3．条件编译

预处理程序提供了条件编译功能。可以按不同的条件去编译不同的程序部分，因而产生不同的目标代码文件。条件编译允许只编译源程序中满足条件的程序段，使生成的目标程序较短，从而减少了内存的开销并提高了程序的效率。使用预处理功能便于程序的修改、阅读、移植和调试，也便于实现模块化程序设计。条件编译有三种形式，下面分别介绍：

Ÿ 第一种形式：

#ifdef 标识符

程序段1

#else

程序段2

#endif

它的功能是，如果标识符已被 #define命令定义过则对程序段1进行编译；否则对程序段2进行编译。如果没有程序段2(为空)，本格式中的#else可以没有。

Ÿ 第二种形式：

#ifndef 标识符

程序段1

#else

程序段2

#endif

与第一种形式的区别是将“ifdef”改为“ifndef”。它的功能是，如果标识符未被#define命令定义过则对程序段1进行编译，否则对程序段2进行编译。

Ÿ 第三种形式：

#if 常量表达式

程序段1

#else

程序段2

#endif

它的功能是，如常量表达式的值为真(非0)，则对程序段1 进行编译，否则对程序段2进行编译。

问题33 宏定义格式错误

[例7.1] 输入球的半径，求该球的表面积。

[错误代码]

1	#include "stdio.h"
2	#define PI=3.14;
3	void main( )
4	{
5	float radius;
6	printf("请输入球的半径：\n");
7	scanf("%f",&radius);
8	double S = PIradiusradius*4.0;
9	printf("球的表面积为：%.2f\n", S);
10	}

[编译结果]

E:\code\7_1.cpp(2) : error C2008: '=' : unexpected in macro definition

E:\CODE\7_1.cpp(8) : error C2100: illegal indirection

E:\CODE\7_1.cpp(8) : warning C4552: '*' : operator has no effect; expected operator with side-effect

[问题分析]

宏定义的一般形式可以写成：

#define string1 string2

其中的两个参数string1和string2是两个字符串，程序中出现的string1都由string2来代替。请注意在使用#define时候的一些常见错误:

#define MAX = 100

#define MAX 100;

前者程序中出现的“MAX”都被替换成“= 100”，后者程序中出现的“MAX”都被替换成“100;”，因而都是错的。本例中，第2行代码“#define PI=3.14;”里的“=”应该换成空格，而且后面不加分号。

[正确代码]

代码修改为：

2	#define PI 3.14

[运行结果]

请输入球的半径：

球的表面积为：12.56

问题34 带参数的宏替换错误

[例7.2] 利用带参数的宏替换计算27被3的平方除。

[错误代码]

1	#include "stdio.h"
2	#define square(n) n*n
3	void main( )
4	{
5	printf("%f\n", 27.0/square(3.0));
6	}

[编译结果]

编译通过，但运行结果错误：

27.000000

[问题分析]

第2行代码为“#define square(n) n*n”，则第5行代码变为：

printf("%f\n", 27.0/3.0*3.0);

由于运算是从左往右运行的，所以结果为：

（27.0/3.0）*3.0 = 27.0

要避免这种问题，应该在作宏定义时，用括号把整个宏扩展都括起来。

[正确代码]

代码修改为：

2	#define square(n) (n*n)

[运行结果]

3.000000

问题35 把宏调用混同于函数调用

[例7.3] 计算整数1至10的平方值。

[错误代码]

1	#include "stdio.h"
2	#define square(n) (n*n)
3	void main( )
4	{
5	int i = 1;
6	while(i<=10)
7	printf("%d\n", square(i++));
8	}

[编译结果]

编译通过，但运行结果错误：

只输出了1、3、5、7、9的平方。

[问题分析]

如下宏调用

#define square(n) (n*n)

把square(i++)变为

(i++*i++)

预处理程序在进行字符串进行替换时，是原封不动地、忠实地进行替换。

[正确代码]

把第6行及以后的代码改为：

6	while(i<=10)
7	{
8	printf("%d\n", square(i));
9	i++;
10	}
11	}

[运行结果]

100

问题36 宏定义中多余的空格

[例7.4] 定义一个宏，实现把数值减1的功能。

[错误代码]

1	#include "stdio.h"
2	#define f (x) ((x)-1)
3	void main( )
4	{
5	int n=5;
6	printf("n=%d\n",n);
7	printf("n-1=%d\n",f(n));
8	}

[编译结果]

E:\CODE\7_4.cpp(7) : error C2065: 'x' : undeclared identifier

[问题分析]

前面说过，宏定义的一般形式可以写成：

#define string1 string2

其中的两个参数string1和string2是两个字符串，程序中出现的string1都由string2来代替。本例中，第2行代码中，“f”与“(x)”之间多了空格，导致程序中的“f”都会被替换成“(x) ((x)-1)”，所以编译时才会认为第7行代码中有一个未定义的标识符x。

[正确代码]

代码修改为：

2	#define f(x) ((x)-1)

[运行结果]

n=5

n-1=4

练习7

请改正如下程序中的错误。

1) 输入两个整数，输出二者之和的两倍。

1	#include <stdio.h>
2	#define DOUBLE(a) 2*a;
3	void main( )
4	{
5	int m,n;
6	scanf("%d",&m);
7	scanf("%d",&n);
8	printf("%d与%d之和的两倍是：%d\n", m, n, DOUBLE(m+n));
9	}

2) 计算并输出1*2+2*3+3*4+……+8*9。

1	#include <stdio.h>
2	#define M(n) (n*(n+1))
3	void main( )
4	{
5	int i=1;
6	int sum=0;
7	while(i<9)
8	{
9	sum += M(i++);
10	}
11	printf("%d\n", sum);
12	}

第8章指针和数组

指针是Ｃ语言中广泛使用的一种数据类型，利用指针变量可以表示各种数据结构，能很方便地使用数组和字符串，并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。指针极大地丰富了Ｃ语言的功能。

1．指针和地址

在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等。为了正确地访问这些内存单元，必须为每个内存单元编号，内存单元的编号也叫做地址，通常也称为指针。内存单元的指针和内存单元的内容是两个不同的概念。定义指针的目的是为了通过指针去访问内存单元。指针是一个数据结构的首地址。

定义指针变量的一般形式为：

类型说明符 *变量名；

其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。

未经赋值的指针变量不能使用，否则将造成系统混乱，甚至死机。指针变量的赋值只能赋予地址，否则将引起错误。Ｃ语言中提供了地址运算符&来表示变量的地址。如：

int val;

int *p = &val;

意为把整型变量val 的地址赋予p。Ｃ语言中还提供了指针运算符*，*p是指针变量p所指向的对象。

2．指针和函数参数

前面提到，函数的参数可以是整型、浮点型、字符型等数据类型，这种方式传递实际参数给形式参数，传递过程是单向的值拷贝过程，形式参数的变化不会影响到实际参数的值，因此只能通过return语句将函数的结果返回，无法返回多个值。如果一个函数需要有多个输出，可以将指针变量作为函数的参数，它的作用是将一个变量的地址传送给被调用函数的形参。在函数执行过程中使指针变量所指向的变量值发生变化，函数调用结束后，这些变量值的变化依然会保留下来。请注意，不能企图通过改变形参指针变量的值而使实参指针变量的值改变。

3．指针和数组

在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。在Ｃ语言中，数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

数组说明的一般形式为：

类型说明符数组名 [常量表达式]，……；

其中，类型说明符是任一种基本数据类型或构造数据类型。数组名是用户定义的数组标识符。方括号中的常量表达式被称为数组的长度，表示数组中数据元素的个数。例如：

int val[5]; 说明整型数组val，有5个元素。

char c[8]; 说明字符数组c，有8个元素。

float f[12]; 说明实型数组f，有12个元素。

使用数组需要注意以下几点：

Ÿ 允许在同一个类型说明中，说明多个数组和多个变量。

Ÿ 数组名不能与其它变量名相同

Ÿ 同一个数组中，所有元素的数据类型都是相同的。数组的类型实际上是指数组元素的取值类型。

Ÿ 数组名的书写规则应符合标识符的书写规定。

Ÿ 方括号中常量表达式表示数组元素的个数，但其下标从0开始计算。

Ÿ 不能在方括号中用变量来表示元素的个数，但是可以是符号常数或常量表达式。

在C语言中，指针和数组有很密切的关系。任何可通过数组下标完成的操作都可以通过指针完成。一般来说，用指针更快，但对初学者来说比较难于掌握。例如：

int a[10];

定义了一个长度为10的数组a，包含10个地址相连的元素：a[0]，a[1]，a[2]，… ，a[9]。如下语句：

int *p = &a[0];

使指针p指向数组a的第0个元素，即p包含a[0]的地址，p+i指向p后的第i个元素，*(p+i)是a[i]的内容。对a[i]的引用也可以写成*(a+i)。int *p = &a[0];也可以写成int *p = a;

但是数组名和指针之间有一个区别：指针是变量，p=a和p++都是有意义的操作；但数组名是常量，不是变量，因此象a=p，a++，或p=&a之类的表达式都是非法的。

4．多维数组

只有一个下标的数组称为一维数组，其数组元素也称为单下标变量。在实际问题中有很多量是二维或多维的，因此Ｃ语言允许构造多维数组。有多个下标的数组称为多维数组，其数组元素也称为多下标变量。以二维数组为例，其类型说明的一般形式是：

类型说明符数组名[常量表达式1][常量表达式2]…；

其中常量表达式1表示第一维下标的长度，常量表达式2 表示第二维下标的长度。例如：

int a[3][4];

说明了一个三行四列的数组，数组名为a，其下标变量的类型为整型。该数组的下标变量共有3×4个，即：

a[0][0]，a[0][1]，a[0][2]，a[0][3]

a[1][0]，a[1][1]，a[1][2]，a[1][3]

a[2][0]，a[2][1]，a[2][2]，a[2][3]

二维数组在概念上是二维的，即是说其下标在两个方向上变化，但是，实际的硬件存储器却是连续编址的，也就是说存储器单元是按一维线性排列的。如何在一维存储器中存放二维数组呢？在Ｃ语言中，是按行排列的，即放完一行之后顺次放入第二行。以a[3][4]为例，先存放a[0]行，再存放a[1]行，最后存放a[2]行。由于数组a说明为int类型，在Visual C++中，该类型占4个字节的内存空间，所以每个元素均占有4个字节。

5．指针数组

一个数组的元素值为指针则构成指针数组。指针数组是一组有序的指针的集合。指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

　　指针数组说明的一般形式为：

类型说明符 *数组名[数组长度]

其中，类型说明符为指针值所指向的变量的类型。例如：int *p[2] 表示p是一个指针数组，它有两个数组元素，每个元素值都是一个指针，指向整型变量。通常可用一个指针数组来指向一个二维数组。

6．指向指针的指针

如果一个指针变量存放的内容是另一个指针变量的地址，则称为指向指针的指针。通过指针访问变量称为间接访问。如果通过指向指针的指针来访问变量则构成了二级或多级间接访问。在Ｃ语言程序中，对间接访问的级数并未明确限制，但是间接访问级数太多时不容易理解，也容易出错，因此，一般很少超过二级间接访问。指向指针的指针变量说明的一般形式为：

类型说明符** 指针变量名；

例如： int** p; 表示p是一个指针变量，它指向另一个指针变量，而这个指针变量指向一个整型量。

7．指针与多维数组

C语言把二维数组看作是一维数组的集合，即二维数组是一个元素为一维数组的特殊一维数组。多维数组可以依次类推。例如二维数组

int a[m][n]；

可以看作是由m个一维数组

a[0]、a[1]、… 、a[m-2]、a[m-1]

构成。这m个一维数组都有n个元素，即每个a[i]都是由n个int类型的变量

a[i][0]、a[i][1]、… 、a[i][n-1]

组成的int类型的数组。

8．指向函数的指针

在C语言中，函数本身不是变量，但可以定义指向函数的指针，这种指针可以被赋值、存放于数组之中，传递给函数及作为函数的返回值等。指向函数的指针是个变量，因而能够被赋值，从而指向不同的函数。

问题37 数组越界

[例8.1] 利用循环给数组各元素赋值为0~9，然后按照逆序输出各元素的值。

[错误代码]

1	#include "stdio.h"
2	void main( )
3	{
4	int a[10];
5	for(int i=1;i<=10;i++)
6	{
7	a[i] = i-1;
8	}
9	for(i=10;i>=1;i--)
10	{
11	printf("%d\t", a[i]);
12	}
13	printf("\n");
14	}

[编译结果]

编译通过，但运行时报错：

图8.1数组越界

[问题分析]

本例中，定义了int数组a[10]，下标采用循环变量i，从1到10。实际上，数组下标应该是从0到9，即10个数组元素是a[0] 、a[1]、a[2]、a[3]、a[4]、a[5]、a[6]、a[7]、a[8]、a[9]，不包括a[10]。所以，本例中的问题是数组越界，导致程序运行时报错。

[正确代码]

代码修改如下：

5	for(int i=0;i<10;i++)
6	{
7	a[i] = i;
8	}
9	for(i=9;i>=0;i--)

[运行结果]

9 8 7 6 5 4 3 2 1 0

问题38 定义数组时误用变量

[例8.2] 输入学生数量，再输入每个学生的成绩，判断是否及格。

[错误代码]

1	#include "stdio.h"
2	#include "stdlib.h"
3	void main( )
4	{
5	int n;
6	printf("请输入学生数量：");
7	scanf("%d", &n);
8
9	int a[n];
10	for(int i=0;i<n;i++)
11	{
12	printf("请输入第%d个学生成绩：", i+1);
13	scanf("%d", &a[i]);
14	if(a[i]>=60)
15	printf("及格!\n");
16	else
17	printf("不及格!\n");
18	}
19	}

[编译结果]

E:\CODE\8_2.cpp(9) : error C2057: expected constant expression

E:\CODE\8_2.cpp(9) : error C2466: cannot allocate an array of constant size 0

E:\CODE\8_2.cpp(9) : error C2133: 'a' : unknown size

[问题分析]

数组名后用方括号括起来的是常量表达式，可以包括常量和符号常量。即C不允许对数组的大小作动态定义。可以用malloc动态分配内存，最后用free释放内存。所以，把第9行代码

int a[n];

改为：

int* a = (int*)malloc(n*sizeof(int));

最后用

free(a);

释放内存。

另外，如果内存不够，malloc函数会返回一个空指针来表示“内存分配失败”。所以，一定要判断返回指针是否为空指针，才能访问该指针。如果内存分配失败时没有判断返回指针是否为空指针，就对其进行操作的话，会导致程序出错。

[正确代码]

第8行之后的代码改为：

9	int* a = (int)malloc(nsizeof(int));
10	if(a)
11	{
12	for(int i=0;i<n;i++)
13	{
14	printf("请输入第%d个学生成绩：", i+1);
15	scanf("%d", &a[i]);
16	if(a[i]>=60)
17	printf("及格!\n");
18	else
19	printf("不及格!\n");
20	}
21	free(a);
22	}
23	}

[运行结果]

请输入学生数量：3

请输入第1个学生成绩：89

及格!

请输入第2个学生成绩：40

不及格!

请输入第3个学生成绩：60

及格!

问题39 动态分配内存空间不够

[例8.3] 已知一个字符数组s，为另一个字符数组t动态分配空间，把s的内容复制到t。

[错误代码]

1	#include "stdio.h"
2	#include "stdlib.h"
3	#include "string.h"
4	void main( )
5	{
6	char s[] = "hello!";
7	char* t = (char*)malloc(strlen(s));
8	strcpy(t,s);
9	printf("%s\n",t);
10	free(t);
11	}

[编译结果]

编译通过，运行时虽然输出结果正确，但程序报错：

图8.2动态分配内存空间不够

[问题分析]

使用strcpy和strcat对字符数组进行操作，必须为其预留足够的空间。否则虽然程序编译通过，但会导致字符串操作数组越界，从而导致潜在的程序错误。本例中为t分配的空间大小是strlen(s)，看起来正好够用。但实际上字符串是以空字符‘\0’结尾的，非配空间时需要多一个字符的空间。所以，为t分配的空间大小应该是strlen(s)+1。

另外，如果使用malloc分配的空间必须用free释放。如果忘记释放（例如在本例中去掉free(t);这一行代码），可能不会弹出上图中的错误窗口，但会导致潜在的程序错误。

[正确代码]

代码修改为：

7	char* t = (char*)malloc(strlen(s)+1);

[运行结果]

hello!

问题40 内存泄漏

动态分配的内存空间必须释放。如果忘记释放，则系统无法把这些内存再分配给应用程序使用，称为内存泄露。内存泄露会导致系统运行速度变慢，严重时甚至死机。

[例8.4] 循环输入你喜爱的水果，输入exit则退出。

[错误代码]

1	#include "stdio.h"
2	#include "stdlib.h"
3	#include "string.h"
4	char* GetName( )
5	{
6	char* s = (char*)malloc(20);
7	printf("请输入你喜爱的水果：");
8	scanf("%s",s);
9	return s;
10	}
11	void main( )
12	{
13	char *p = NULL;
14	while(1)
15	{
16	p = GetName( );
17	if(!strcmp(p,"exit"))
18	{
19	break;
20	}
21	printf("你喜欢吃%s。\n",p);
22	}
23	}

[编译结果]

编译正常，运行结果也正常。

[问题分析]

动态分配的内存必须显示地释放。如果一个程序需要连续很多天、每天24小时运行（例如工厂里的生产线自动控制程序），那么即使只有很少的内存泄漏，也会很快耗尽内存导致死机。本例中，在函数GetName( )中用malloc动态分配内存，返回char*指针，却没有释放内存，导致内存泄漏。应该在循环结束的时候，用free(p) 释放内存。注意，如果用户输入exit，则应该用break结束循环，这时候不要忘记用free(p) 释放内存，否则仍有内存泄漏。

[正确代码]

第17行及之后的代码改为：

17	if(!strcmp(p,"exit"))
18	{
19	free(p);
20	break;
21	}
22	printf("你喜欢吃%s。\n",p);
23	free(p);
	}
	}

[运行结果]

请输入你喜爱的水果：苹果

你喜欢吃苹果。

请输入你喜爱的水果：榴莲

你喜欢吃榴莲。

请输入你喜爱的水果：exit

问题41 访问悬空指针

[例8.5] 访问悬空指针。

[错误代码]

1	#include "stdio.h"
2	#include "stdlib.h"
3	#include "string.h"
4	void main( )
5	{
6	char* s = (char*)malloc(10);
7	char* t = s;
8	strcpy(s,"hello!");
9	printf("s:%s\n",s);
10	printf("t:%s\n",t);
11	free(s);
12	s=NULL;
13	printf("free s.\n");
14	printf("s:%s\n",s);
15	printf("t:%s\n",t);
16	}

[编译结果]

编译通过，但运行结果有问题：

s:hello!

t:hello!

free s.

s:(null)

t:葺葺葺葺葺葺葺

[问题分析]

本例中指针s指向malloc分配的内存空间。语句char* t = s使t也指向这个空间。free(s)之后，实际上s和t都变成了悬空指针。s=NULL语句把s变成空指针，却忘记了指针t. 此后，程序中访问了指针t，结果出现了莫名其妙的结果，输出了“t:葺葺葺葺葺葺葺”。

使用指针时一定要避免指针定义后未赋值就引用。如果在定义时不知道赋什么值，可以用p=NULL赋初值，以避免引起的灾难性错误。在释放指针所指向的内存空间后，记得把该指针变量赋为NULL，避免访问悬空指针带来的灾难性错误。

[正确代码]

在第14行处插入一行代码：

t=NULL;

[运行结果]

s:hello!

t:hello!

free s.

s:(null)

t:(null)

练习8

请改正如下程序中的错误。

1) 求一个3*3矩阵对角线元素之和。

1	#include <stdio.h>
2	void main( )
3	{
4	int n=3;
5	float a[n][n],sum=0;
6	int i,j;
7	printf("请输入矩阵元素:\n");
8	for(i=1;i<=3;i++)
9	for(j=1;j<=3;j++)
10	scanf("%f",&a[i][j]);
11	for(i=1;i<=3;i++)
12	sum=sum+a[i][i];
13	printf("矩阵对角线元素之和是：%6.2f\n",sum);
14	}

2) 动态分配内存，复制一个已知的整型数组。

1	#include <stdio.h>
2	#include <stdlib.h>
3	int* CloneArray(int* pArray, int len);
4	void main( )
5	{
6	int x[3] = {2,3,4};
7	int* pNewArray = CloneArray(x,3);
8	if(!pNewArray) return;
9	for(int i=0;i<3;i++)
10	printf("%d\t",pNewArray[i]);
11	printf("\n");
12	}
13	int* CloneArray(int* pArray, int len)
14	{
15	int* p = (int*)malloc(len);
16	for(int i=0;i<3;i++)
17	p[i] = pArray[i];
18	return p;
19	}

第9章结构和联合

1．结构

“结构”是一种构造类型，是由若干“成员”组成的。每一个成员可以是一个基本数据类型或者是另一个构造类型。结构在说明和使用之前必须先定义。定义结构变量的一般格式为:

struct 结构名

{

数据类型成员名;

...

} 结构变量;

结构名是结构的标识符。结构成员的类型可以为整型、浮点型、字符型、指针型等数据类型，或者是另一个构造类型。例如：

struct student

{

int num;

char name[20];

char sex;

float score;

} st;

构成结构的每一个类型变量称为结构成员，它象数组的元素一样，但数组中元素是以下标来访问的，而结构是按变量名字来访问成员的。结构是一种新的数据类型，同样可以有结构数组和结构指针。结构数组就是具有相同结构类型的变量集合。结构指针是指向结构的指针。它由一个加在结构变量名前的"*" 操作符来定义。使用时需注意以下几点：

Ÿ 定义的结构变量或结构指针变量同样有局部变量和全程变量之分。

Ÿ 与数组名的含义不同，结构变量名不是指向该结构的地址，因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。

Ÿ 结构可以嵌套

2．联合

联合是一种特殊形式的变量，表示几个变量共用一块内存，在不同的时间保存不同的数据类型和不同长度的变量。联合说明和联合变量定义与结构十分相似。其形式为:

union 联合名{

数据类型成员名;

...

} 联合变量名;

例如：

union data{

int i;

char mm;

} d;

在联合变量d中，整型量i和字符mm共用同一内存空间。

结构和联合有下列区别:

（1）结构和联合都是由多个不同的数据类型成员组成，但在任何同一时刻，联合中只存放了一个被选中的成员，而结构的所有成员都存在。

（2）对于联合的不同成员赋值，将会对其它成员重写，原来成员的值就不存在了，而对于结构的不同成员赋值是互不影响的。

问题42 结构的嵌套

[例9.1] 定义结构STUDENT，存储学生姓名和生日（结构date嵌套在STUDENT里）。

[错误代码]

1	#include "stdio.h"
2	#include "string.h"
3	struct STUDENT
4	{
5	char name[20];
6	struct date
7	{
8	int year,month,day;
9	}birthday
10	}
11	void main( )
12	{
13	STUDENT tom;
14	strcpy(tom.name, "Tom");
15	tom.year = 1990;
16	tom.month = 5;
17	tom.day = 4;
18
19	printf("姓名:%s\n",tom.name);
20	printf("生日:%d年%d月%d日\n",tom.year,tom.month,tom.day);
21	}

[编译结果]

E:\CODE\9_1.cpp(10) : error C2143: syntax error : missing ';' before '}'

E:\CODE\9_1.cpp(11) : error C2628: 'STUDENT' followed by 'void' is illegal (did you forget a ';'?)

E:\CODE\9_1.cpp(15) : error C2039: 'year' : is not a member of 'STUDENT'