全国计算机等级考试
二级C语言程序设计（知识总结）
公共基础知识部分：
第一章：数据结构与算法
1.1算法
算法：指解题方案的准确而完整的描述。
算法的可解：对于一个问题，如果可以通过一个计算机程序，在有限的空间内运行有限长的时间而获得正确的结果。
但算法不等于程序， 也不等于计算方法。通常，程序的编制不可能优于算法的设计。 算法的基本特征包括以下几个方面：
（1）可行性（effectiveness）
（2）确定性（definiteness）:是指算法中的每一个步骤都必须是有明确定义的，不允许有模棱两可的解释，也不允许有多义性。
（3）有穷性（finiteness）:是指算法必须能在有限的时间内做完，即算法必须能在执行有限个步骤之后终止。算法的有穷性还应包括合理的执行时间的含义。
（4）拥有足够的情报
综上所述：算法，是一组严谨地定义运算顺序的规则，并且每一个规则都是有效的，且是明确的，此顺序将在有限的次数下终止。
算法的基本要素：
一个算法通常由两种基本要素组成：一是对数据对象的运算与操作，二是算法的控制结构。 计算计算法：是指计算机能处理操作所组成的指令序列。
指令系统：一个计算机系统能执行的所有指令的集合。
基本运算和操作：
（1）算术运算：主要包括加、减、乘、除等运算。
（2）逻辑运算：主要包括“与”、“或”、“非”等运算。
（3）关系运算：主要包括“大于”、“小于”、“等于”、“不等于”等运算。
（4）数据传输：主要包括赋值、输入、输出等操作。
算法的主要特征着重于算法的动态执行，它区别于传统的着重于静态描述或按演绎方式求解问题的过程。
算法的控制结构：是指算法中各操作之间的执行顺序。
描述算法的工具通常有传统的流程图、N-S结构化流程图、算法描述语言等。 一个算法一般都可以用顺序、选择、循环三种基本控制结构组合而成。 计算机算法：是指计算机解题的过程实际上是在实施某种算法。
算法设计的基本方法：
（1）列举法
列举法的基本思想是，根据提出的问题，列举所有可能的情况，并用问题中给定的条件检验哪些是需要的，哪些是不需要的。列举法是计算机算法中的一个基础算法。
（2）归纳法
归纳法的基本思想是，通过列举少量的特殊情况，经过分析，最后找出一般关系。
（3）递推
递推：是指从已知的初始条件出发，逐次推出所要求的各中间结果和最后结果。
（4）递归
递归：一般总是将问题逐层分解，最后归结为一些简单的问题。这种将问题逐层分解的过程， 1
全国计算机等级考试
实际上并没有对问题进行求解，而只是当解决了最后那些简单的问题后，再沿着原来分解的逆过程逐步进行综合。递归分为直接递归和间接递归两种。
（5）减半递推技术
“减半”是指将问题的规模减半。而问题的性质不变；“递推”是指重复“减半”的过程。
（6）回溯法
回溯法：通过对问题的分析，找出一个解决问题的线索，然后沿着这个线索逐步试探，对于每一步的试探，若试探成功，就得到问题的解，若试探失败，就逐步回退，换别的路线再进行试探。
算法的复杂度包括时间复杂度和空间复杂度。
时间复杂度：是指执行算法所需要的计算工程量。
算法的工作量用算法所执行的基本运算的次数来度量，而算法所执行的基本运算次数是问题规模的函数。在同一个问题规模下，如果算法执行所需的基本运算次数取决于某一特定输入时，可以用以下两种方法分析算法的工作量。
（1）平均性态（Average Behavior）
平均性态分析：是指用各种特定输入下的基本运算次数的加权平均值来度量算法的工作量。
（2）最坏情况复杂性：是指在规模为n时，算法所执行的基本运算的最大次数。 算法的空间复杂度：一般是指执行这个算法所需要的内存空间。一个算法所占用的存储空间包括算法程序所占用的空间、输入的初始数据所占用的存储空间以及算法执行过程中所需要的额外空间；其中额外空间包括算法程序执行过程中的工作单元以及某种数据结构所需要的附加存储空间。
1.2数据结构的基本概念
数据结构作为一门学科，主要研究和讨论以下三方面的问题：
（1） 数据集合中各元素之间所固有的逻辑关系，即数据的逻辑结构；
（2） 在对数据进行处理时，各数据元素在计算机中的存储关系，即数据的存储结构；
（3） 对各种数据结构进行运算。
目的在于提高数据处理的效率，效率包括两个方面：一是提高数据处理的速度，二是尽量节省在数据处理过程中所占用的计算机存储空间。
数据处理：是指对数据集合中的各元素以各种方式进行运算，包括插入、删除、查找、更改等运算，也包括对数据元素进行分析。
简单的说数据结构就是指相互之间有关联的数据元素的集合。在数据处理领域中，每一个需要处理的对象都可以抽象成数据元素。一般简称为元素。一般情况下，在具有相同特征的数据元素集合中，各个数据元素之间有某种关系（联系），这种关系反映了该集合中数据元素所固有的一种结构。在数据处理时，通常把数据元素之间这种固有的关系简单的用前后件关系（或直接前驱与直接后继关系）来描述。
所谓的结构实际上就是指数据元素之间的前后件关系。一个数据结构应该包含以下两放慢的信息：
（1）表示数据元素的信息 ；
（2）表示个元素之间的前后件关系。（数据之间的前后件关系是指它们的逻辑关系，而与它们在计算机中的存储位置无关。）
数据处理是计算机应用的一个重要领域，在实际进行数据处理时，被处理的各数据元素总是被存储在计算机的存储空间中，并且，各数据元素在计算机存储空间中的位置关系与它们的逻辑关系不一定是相同的，而且一般也不可能相同。
数据的存储结构：是指数据的逻辑结构在计算机存储空间中的存放形式。
在数据结构的图形表示中，对于数据集合D中的每一个数据元素用中间标有元素值的方框表 2
全国计算机等级考试
示，一般称之为数据结点，并简称为结点。
根结点：没有前件的结点。
终端结点：没有后件的节点。
内部结点：数据结构中除了根结点与终端结点外的其他结点。
通常，一个数据结构中的元素结点可能是在动态变化的。
插入运算：根据需要或在处理过程中，可以在一个数据结构中增加一个新结点。
删除运算：删除数据结构中的某个结点。
插入与删除是对数据结构的两种基本运算。
在数据结构的处理过程中，不仅数据结构中的结点（即数据元素）个数在动态的变化，而且各数据元素之间的关系也有可能在动态变化。
数据结构为空的数据结构：一个数据结构中一个数据元素都没有。
根据数据结构中个数据元素之间的前后件关系的复杂程度，一般讲数据结构分为两大类型：线性结构与非线性结构。如果一个非空的数据结构满足下列两个条件：
（1）有且只有一个根结点。
（2）每一个结点最多有一个前件，也最多有一个后件。
则称该数据结构为线性结构。线性结构又称为线性表。在一个线性结构中插入或删除任何一个结点后还应是线性结构。根据这一点，如果一个数据结构满足上述两个条件，但当在此数据结构中插入或删除任何一个结点后就不满足这两个条件了，则该数据结构不能称为线性结构。线性结构与非线性结构都可以是空的数据结构。
1.3线性表及其顺序存储结构
线性表（Linear List）是最简单、最常用的一种数据结构。
记录：由若干个数据项组成的数据元素。
文件：由多个记录构成的线性表。
线性表是由n(n≥0)个数据元素a1,a2,?,an组成的一个有限序列，表中的每一个数据元素，除了第一个外，有且只有一个前件，除了最后一个外，有且只有一个后件。显然，线性表是一种线性结构。数据元素在线性表中的位置只取决于它们自己的序号，即数据元素之间的相对位置是线性的。非空线性表有如下一些结构特征：
（1）有且只有一个根结点a1,它无前件；
（2）有且只有一个终端结点an,它无后件；
（3）除根结点与终端结点外，其他所有结点有且只有一个前件，也有且只有一个后件。线性表中结点的个数n称为线性表的长度。当n=0时，称为空表。
3
第二篇：C语言程序设计考点知识点
第一章 程序设计基本概念
1.1程序和程序设计
程序：连续执行的一条条指令的集合称为“程序”。
对于计算机来说，它不能识别由高级语言编写的程序，它只能接受和处理由0和1的代码构成的二进制指令或数据。由于这种形式的指令是面向机器的，因此也被称为“机器语言”。所以所有由高级语言编写的程序都要经过编译，编译成二进制代码。这种具有翻译功能的软件称为编译程序。
语言有很多种，我们现在要谈论的就是C语言。为什么计算机会能进行各种各样的操作，就是由不同的指令来实现的。而不是只有C语言才可以实现这样的功能。还有其它很多语言。但是我们一般说C语言是其它语言的母语。会了C语言其它的语言在学习的过程就会感到轻松一些。
1.1.2程序设计
1.确定数据结构
2.确定算法
3.编码
4.在计算机上调试程序
5.整理并写出文档资料
1.2算法
定义：是指为了解决某个特定的问题而采取的确定且有限的步骤。
1. 有穷性
2. 确定性
3. 可行性
4. 有零个或多个输入
5. 有一个或多个输出
1.3结构化程序设计和模块化结构
结构化程序由三种基本结构组成
1. 顺序结构
2. 选择结构
3. 循环结构
12）计算机能直接执行的程序是（B ）。
A）源程序 B）目标程序 C）汇编程序 D）可执行程序
13）以下叙述中正确的是( D )
A）程序设计的任务就是编写程序代码并上机调试
B）程序设计的任务就是确定所用数据结构
C）程序设计的任务就是确定所用算法
D）以上三种说法都不完整
第二章 ：C程序设计的初步知识
2．1 C语言程序的构成和格式
#include <stdio.h>
Main()
{
double a,b,area;
a=1.2,b=3.6; /*将矩形的两条边长分别赋给a和b 变量*/
area=a*b;
printf(“a=%f,b=%f,area=%f\n”,a,b,area);/*输出矩形的两条边长和面积*/
}
#include <stdio.h>:每当写一个程序时，第一条语句永远是这个语句，因为一个程序可以没有输入但必须要有输出，而这个语句就是控制输入输出的。所以任何一个程序都必须由这个语句开始。
Main()：是一个程序的主函数。一个程序是由多个函数组成的，而任何一个程序都要有一个主函数，有且只有一个。任何程序都是由主函数开始执行的。
｛｝：它们两个必须要成对出现，它们中的语句是主函数体。包括定义部分和执行部分。它们中的语句，每一条必须由;结束。；是C语句的一个组成部分而不是一个结束标识。
/**/:注释符一定要成对出现，不允许嵌套。两个符号间的语句不被执行。
例年真题：
#include<stdio.h>
main()
{
Int a;
A=5; /*给A变量赋值5
A+=3; 再赋值后再加3*/
Printf(“%d”,a);
}
（11）以下叙述中正确的是（ C ）。
A）C 程序的基本组成单位是语句 B）C 程序中的每一行只能写一条语句
二级C 语言程序设计试卷）
C）简单C 语句必须以分号结束 D）C 语句必须在一行内写完
（11）以下叙述中正确的是( C )
A)C程序中的注释只能出现在程序的开始位置和语句的后面
B)C程序书写格式严格，要求一行内只能写一个语句
C)C程序书写格式自由，一个语句可以写在多行上
D)用C语言编写的程序只能放在一个程序文件中
第二课：C语言的基础知识
2.2标识符，常量和变量
2.2.1标识符：
定义:由字母，数字和下划线组成，并且第一个字符必须为字母或下划线的。这样的组成就是标识符。
下列合法的是：
else what #$123 34a a34 a_b a-b If
a=3 A=4
注意：在C中大写字母与小字字母被认为是两个不同的字符。
分类：
关键字：在C中已经定义好了的，不能用作它用的。如if double int 等等。
预定义标识符：如printf scanf
用户标识符：用户根据自己的需求来定义的。
（12）以下选项中，能用作用户标识符的是( C )
A）void
B）8_8
C）_0_
D）unsigned
（11）以下选项中合法的标识符是( C )
A） 1-1 B）1—1 C）-11 D）1—
（12）以下选项中不合法的标识符是 ( C )
A)print B)FOR C)&a D)_00
2.2.2常量：
定义：是指在程序的执行的过程中，其值不会被改变的量。
分类：
整型常量：没有小数的常量
如：3 9 1234等等都是。
实型常量：有小数点的常量
如：3.9 3.0 3.
字符常量：由单个字符组成的量
如：’a’ ‘b’ ‘3’
字符串常量：至少由一个字符组成的量
如：“a” “abc” “ beijing”
符号常量：符号常量的值到底是多少，这是由在来定义符号常量时来决定的
?2*pi
（13）以下选项中，能用作数据常量的是 ( D )
A）o115 B） 0118 C）1.5e1.5 D） 115L
（13）以下选项中不能作为C 语言合法常量的是（ A ）。
A）'cd' B）0.1e+6 C）"\a" D）'\011'
(13)以下选项中不属于字符常量的是 ( B )
A)'C' B)"C" C)'\xCC0' D)'\072'
2.3整型常量与实型常量
整型常量的几个表示方法
十进制数:
八进制数:以0开头的数字，由0-7组成。
下列合法的八进制数是
A,0 B,028 C,-077 D,01.0
十六进制数:以0X开头，由0-9和A-F组成。
A,oxff B,0xabc C,0x11 D,0x19
实型常量 123.4
小数形式：123.4
指数形式：1.234e2
1. 字母e和E之前必须要有数字
2.字母e和E之后的数字必须是整数
3.字母e’和数字之间不能有空格。
A，2.607E-1 0.8103E 2 -77.77 456E-2 0.1e+6 1.23E1.2
2.2.4变量：
1.定义：在程序的运行过程中其值可以被改变的量，就叫变量。
2.原则：变量必须先定义后使用。变量定义的过程就是给变量开辟存储单元的过程。
3.分类：
整型变量：用关键字int来表示.
short int 短整型
long int 长整型 在内存中占4个字节 如123L
unsigned 无符号 如有-200U这就是错的。
变量的定义：int a 这是定义了一个整型变量a.
实型变量：用关键字 double 或float来表示。
float 单精度 在内存中占4个字节
double 双精度 在内存中占8个字节。
2.2.5算术表达式
一、基本的算术运算符
+ - * / % 这些是双目运算符（就是指操作对象有两个）
注意：
除%外，其它的运算符的运算对象可以是整型也可以是实型。%的操作对象只能是整型。
如10%3=1 10.7%3 10%4.5 x%3=0
+ - 也可以做为单目运算。-5.4 +4.9
说明：
1.如果双目运算符两边运算数的类型一致，则所得结果的类型与运算数的类型一致。如 1.0/2.0=0.5 1/2=0
2.如果双目运算符两边运算数的类型不一致，则系统会自动进行类型转换，使两边的类型一致后，再进行运算。
1.0/2=0.5
3.所有的单精度数据，在运算过程中都以双精度进行运算。
二、优先级
（） + - * / % + -
由高——————低
如 (5+1)/2=？？？
2.5.3强制类型转换表达式
格式：（类型名） （表达式）
例：（int）3.234=3
(double)10%3=?
（14）表达式：4-(9)%2的值是( B )
A）0
B）3
C）4
D）5
(14)设变量已正确定义并赋值，以下正确的表达式是 ( C )
A)x=y*5=x+z
B)int(15.8%5)
C)x=y+z+5,++y
D)x=25%5.0
2.6赋值表达式
格式：变量名=表达式
注：1.不可以颠倒（左边必须是变量名，右边必须是C语言中合法的表达式）
2.功能就是先求出右边表达式的值，然后把此值赋值给赋值号左边的变量。确切的说是把数据存入以该变量为标识的存储单元中去。a=4 , a=7
3.结合性的优先级仅高于逗号表达式。顺序是自右向左的。如a=2+7/3
4."="是一个赋值号，不是一个等号。
5.x=y。变量的值也是可以传递和赋值的。它的意思就是将变量Y中的值赋值到X中去。同样N=N+1也成立
6.赋值运算符的左侧只能是变量，不能是常量或表达式 a+b=c这就是违法的
7。赋值号的右边也可以是一个赋值表达式。如a=b=7+1；
补充；表达式与语句的区别，
表达式后面加一个分号就是语句。
2.6.2复合赋值表达式
例:
a+=3------a=a+3 同理可得a*=3 /= -=
a+=a-=a+a a 的初值是9
a+=a-=18
a+=(a=a-18)
a+=(a=-9)
a+=a
-18
（15）若有定义语句：int x=10;，则表达式x-=x+x的值为( B )
A）-20
B）-10
C）0
D）10
（14）设有定义：int x=2;，以下表达式中，值不为6的是 ( D )
A） x*=x+1 x=x*(x+1)
B） x++,2*x
C）x*=（1+x）
D）2*x,x+=2
(17)若变量均已正确定义并赋值，以下合法的C语言赋值语句是 (A)
A)x=y==5;
B)x=n%2.5;
C)x+n=I
D)x=5=4+1;
2.7 ++ 和——的讲解
++:自身加1
--：自身减1
如
i=3 i++_______I=i+1 i=4
单目
3++
++I I++
当++在前，先自身加1，然后再干别人让干的事情 。
当++在后，先别人让干的事情然后再干 自身加1。
int i=3;
int a;
a=i++; a=3
a=++I;a=4
第三课：输入和输出语句
3.2输出语句的讲解
一、printf函数的一般调用形式
格式：printf(格式控制，输出项1，输出项2，.......)；
在printf函数的最后面写上;号就是输出语句。
1，给输出项白提供输出格式说明
格式说明符：
作用：就是使数据按格式说明符的要求进行输出。
组成：由%号和紧跟在其后的格式描述符组成。
int--------%d
float或double---%f或e%
char--------%c
2.提供原样输出的文字或字符
在 “ ” 中除了格式说明符之外的内容要全部原样输出。
各个输出项之间要用逗号隔开。
输出项可以是任意合法的常量，变量或表达式。
printf中常用的格式说明
在格式说明符中，每一个格式说明符都必须以%号开头由相应的类型标识字母结束。但在他们之间可以有其它的一个内容：
%c ：输出一个字符
%d：输出一个十进制的数据
%o：以八进制格式输出。
%X：以十六进制输出
%U:无符号十进制输出
%f:以带小数点的数字输出
%e:以指数形式输出
%s：输出一个字符串。
%%：输出一个%号
%4d:输出的数据长度是4个长度，当原来的长度大于4个时会自动突破。小于4个时会填充空格。
%x.yf: x代表数制的宽度（包括小数点）。Y代表小数点后面的小数位数。
注意事项：
1.输出比较自由一些，输出有的各个数之到底是什么，取决于格式说明符之间的内容。
2.格式说明符要与输出项一一对应。
3.输出语句中还可以有 \n \r \t \a
4.尽量不要在输出语句中改变输出变量的值。
5.输出的数据中如果存在变量，一定要定义过的。
习题讲解
（13）阅读以下程序
#include
main()
{ int case; float printF;
printf(“请输入2个数：”);
scanf(“%d %f”,&case,&pjrintF);
printf(“%d %f\n”,case,printF);
}
该程序编译时产生错误，其出错原因是（ A ）
A）定义语句出错，case是关键字，不能用作用户自定义标识符
B）定义语句出错，printF不能用作用户自定义标识符
C）定义语句无错，scanf不能作为输入函数使用
D）定义语句无错，printf不能输出case的值
（16）有以下程序
#include
main()
{ int a=1,b=0;
printf(“%d,”,b=a+b);
printf(“%d\n”,a=2*b);
}
程序运行后的输出结果是 （ D ）
A）0,0
B）1,0
C）3,2
D）1,2
（15）程序段：int x=12;
double y=3.141593; printf（“%d%8.6f”,x,y）；的输出结果是 （ A ）
A）123.141593
B）12
3.141593
C）12，3.141593
D）12 3.141593
#include <stdio.h>
main()
{
double a=123.456;
printf("%6.2f",a);
}
输入语句
格式： scanf(格式控制，输入项1，输入项2，...)；
例如：想通过键盘输入3个数分别给变量a,b,c。并且他们分别为整型，浮点型，双精度型。
输入语句为scanf("%d%f%lf",&k,&a,&y);
说明：
1.格式说明符与输出语句一样。
2.在格式串中，必须含有与输入项一一对应的格式转换说明符。
3.在VC6.0的环境下，要收输入的DOUBLE型数据的格式说明符一定要用%lf，否则数据不能正确的输入
4.由于输入是一个字符流，所以当输入的数据少于输入项时，程序会等待用户输入，直到满足要求。当输入的数据多于输入项时，多余的数据会自动作废。
例题：
int x;
x=11/3;
int y=5;
printf("%%d,%%%d\n",x,y); 结果是：%d,%3
[3.5] 若变量已正确说明为int类型，要给a、b、c输入数据，以下正确的输入语句是( D )
A)read(a,b,c); B)scanf(“ %d%d%d” ,a,b,c);
C)scanf(“ %D%D%D” ,&a,%b,%c); D)scanf(“ %d%d%d”,&a,&b,&c);
[3.6] 若变量已正确说明为float类型，要通过以下赋值语句给a赋予10、b赋予22、c赋予33，以下不正确的输入形式是( A )
A)10 B)10.0,22.0,33.0 C)10.0 D)10 22
22 22.0 33.0 33
33
scanf(“ %f %f %f” ,&a,&b,&c);
复合语句：多个语句被{}括起来，当成一条语句来执行。
空语句：最后的表示只有一个;
程序举例：
1。编写一个程序，从键盘上输入两个数字，让后让他们互换一下。
#include<stdio.h>
main()
{
int a,b;
printf("请输入两个数字：");
scanf("%2d%3d",&a,&b);
printf("qian：%d%d",a,b);
int c;
c=a,a=b,b=c;
printf("后：%d%d",a,b);
}
2。编写程序，对一个double型数据进行四舍五入运算。要求保留两位有效小树。
123.4567
123'4567*100=12345.67
12345.67+0.5=12346.17
(int)(12346.17)=12346
12346/100=123.46
3。编写程序，使从键盘中输入的三位数倒着输出。
选择题
[3.1] 若a、b、c、d、都是int类型变量且初值为0，以下选项中不正确的赋值语句是( C )
A)a=b=c=d=100； B)d++; C)c+b； D)d=(c=22)-(b++);
[3.2] 以下选项中不是C语句的是( C )
A){int i； i++； printf(“%d\n”,i);} B);
C)a=5,c=10 D){ ; }
[3.3] 以下合法的C语言赋值语句是( D )
A)a=b=58 B)k=int(a+b); C)a=58,b=58 D)--i;
[3.4] 以下程序的输出结果是( C )
A)0 B)1 C)3 D)不确定的值
main( )
{ int x=10, y=3;
printf(“%d\n”,y=x/y); }
[3.5] 若变量已正确说明为int类型，要给a、b、c输入数据，以下正确的输入语句是( D )
A)read(a,b,c); B)scanf(“ %d%d%d” ,a,b,c);
C)scanf(“ %D%D%D” ,&a,%b,%c); D)scanf(“ %d%d%d”,&a,&b,&c);
[3.6] 若变量已正确说明为float类型，要通过以下赋值语句给a赋予10、b赋予22、c赋予33，以下不正确的输入形式是（ B ）
A)10 B)10.0,22.0,33.0 C)10.0 D)10 22
22 22.0 33.0 33
33
scanf(“ %f %f %f” ,&a,&b,&c);
[3.7] 若变量已正确定义，要将a和b中的数进行交换，下面不正确的语句组是( C )
A)a=a+b,b=a-b,a=a-b; B)t=a,a=b,b=t;
C)a=t;t=b;b=a; D)t=b;b=a;a=t;
[3.8] 若变量已正确定义，以下程序段的输出结果是( D )
A) 输出格式说明与输出项不区配，输出无定值 B)5.17
C)5.168 D)5.169
X=5.16894;
Printf(“ %f\n”,(int)(x*1000+0.5)/(float)1000);
[3.9] 若有以下程序段，c3中的值是( A )
A)0 B)1/2 C)0.5 D)1
int c1=1,c2=2,c3;
c3=c1/c2;
[3.10] 若有以下程序段，其输出结果是( B )
A)3，0，-10 B)0,0,5 C)-10,3,-10 D)3,0,3
int a=0,b=0,c=0;
c=(a-=a-5),(a=b,b+3);
printf(“ %d,%d,%d\n”,a,b,c);
填空题
[3.21] 若有以下定义，请写出以下程序段中输出语句执行后的输出结果。
（1）-200，2500（2）i=-200,j=500 (3)i=-200 回车 j=2500
int i=-200,j=2500;
printf(“ (1) %d %d”,i,j);
printf(“ (2) i=%d,j=%d\n” ,i,j);
printf(“ (3) i=%d\n j=%d\n”,i,j);
[3.22] 变量i、j、k已定义为int类型并有初值0，用以下语句进行输入时
scanf(“ %d”,&I); scanf(“ %d”,&j); scanf(“ %d” ,&k);
当执行第一个输入语句，从键盘输入：
12.3<CR> <CR>表示Enter键
则变量i、j、k的值分别是____12____、____0___、__0____。
[3.23] 复合语句在语法上被认为是 一条语名。空语句的形式是 ；
[3.24] C语句的最后用 ；结束。
[3.25] 以下程序段，要求通过scanf语句给变量赋值，然后输出变量的值。写出运行时给k输入100，给a输入25.81，给x输入1.89234 时的三种可能的输入形式_____、_____、_____。
int k; float a; double x;
scanf(“ %d%f%lf”,&k,&a,&x);
pirntf(“ k=%d,a=%f,x=%f\n”,k,a,x);
编程题和改错题
[3.29] 以下程序多处有错。要按下面指定的形式输入数据和输出数据时，请对该程序做相应的修改。
main
{double a,b,c,s,v;
printf(input a,b,c:\n);
scanf(“%d%d%d”,a,b,c);
s=a*b; /*计算长方形面积*/
v=a*b*c; /*计算长方体体积*/
printf(“%d %d %d”,a,b,c);
printf(“s=%f\n”,s,”v=%d\n”,v);
}
当程序执行时，屏幕的显示和要求输入形式如下：
input a,b,c:2.0 2.0 3.0 此处的2.0 2.0 3.0是用户输入的数据
a=2.000000,b=2.000000,c=3.000000 此处是要求的输出形式
s=4.000000,v=12.000000
[3.30] 编写程序，把560分钟换算成用小时和分钟表示，然后进行输出。
[3.31] 编写程序，输入两个整数：1500和350，求出它们的商数和余数并进行输出。
[3.32] 编写程序，读入三个双精度数，求它们的平均值并保留此平均值小数后一位数，对小数点后第二位数进行四舍五入，最后输出结果。
[3.33] 编写程序，读入三个整数给a、b、c，然后交换它们中的数，把a中原来的值给b，把b中原来的值给c， 把c中原来的值给 a。
第四课：C语言的程序结构
4-1节、关系运算与逻辑运算
一、简介
关系表达式与逻辑表达式的运算结果都会得到一个逻辑值。就是“真”、“假”
在C语言中0表示“假”，非0（无论是负数还是正数都是真，更多时候用1来代替）表示“真”。
二、几个简单的关系运算符
< <= > >= == !=
注意：
1，由两个字符组成的运算符，中间不能有空格
2，它们都是双目运算符，具有自左至右的结合性。
3，上面的6个运算符中，前4个的优先级要比后2个的优先级要高。
先计算，后判断，最后进行赋值运算。
三、几个简单的逻辑运算符
&& 与 一假则假
|| 或 一真则真
！ 非 非假则真，非真则假
1&&2=1
0&&6=0
int a=4 ,b=7;
a&&7=1
int x=0,y=7;
x++&&y++ ?x= 1 y= 7
++x&&y++ ?x=1 y=8
同样放在||中也是一样的。
4-2、4-3节、 if语句
一、定义：
只有两种结果。要么执行这条语句，要么执行那条语句。
if(条件表达式)
上述条件成立执行的句子
else
上述条件不成立执行的句子
如：
if(成绩>60)
显示及格
else
显示不及格
二、分类
1.不含有else的语句
if(表达式) 语句
if(a<b)
{
t=a;
a=b;
b=t;
}
2.含有else语句
if(条件)
语句1;
else
｛
语句2；
语句3；
｝
注:
1.没有分号
2.控制的是与if或者else紧临的“一条”语句。
if(a<b)
printf("%d",b);
else
printf("%d",a);
if(a%3==0)
yes
else
no
4-4节、结合一个例题来给大家分析if的嵌套
输入一个学生的成绩，评定他的等级。每十分一个等级
if()
elseif()
elseif()
`
else
if(a>=90) printf("a");
elseif(a>=80) printf("b");
elseif(a>=70) printf("c");
elseif(a>=60) printf("d");
else printf("e");
4-5、节
7）设有定义：int a=1,b=2,c=3;，以下语句中执行效果与其它三个不同的是 （ C ）
A）if(a>b) c=a,a=b,b=c;
B）if(a>b) {c=a,a=b,b=c;}
C）if(a>b) c=a;a=b;b=c;
D）if(a>b) {c=a;a=b;b=c;}
（18）有以下程序应该选（ B ）
#include <stdio.h>
main（）
{int x;
scanf（“%d”,&x）;
if（x<=3 ; else
if（x!=10）
printf（“%d\n”,x）;
}
程序运行时，输入的值在哪个范围才会有输出结果
A）不等于10的整数
B）大于3且不等于10的整数
C）大于3或等于10的整数
D）小于3的整数
（19）有以下程序 （ C）
#include<stdio.h>
Main（）
{
int a=1,b=2,c=3,d=0;
if（a= =1 &&b++= =2）
if（b!=2 || c--!=3）
printf（“%d,%d,%d\n”,a,b,c）;
else printf（“%d,%d,%d\n”,a,b,c）;
else printf（“%d,%d,%d\n”,a,b,c）;
}
程序运行后的输出结果是
A）1,2,3
B）1,3,2
C）1,3,3
D）3,2,1
4-6节、条件表达式
是C语言中唯一的一个三目运算。
格式 ：表达式1？表达式2：表达式3
当1成立（非零时）时，表达 式的值就是2的值，否则就是3的值。
如：
1.1<2?4:5
2.printf("%d",x<0?(-1)*++x:x++); (假定X的值为-3)
3.++X>3?(x<3?a:b):b
4-7节、switch语句（一）
switch(表达式)
{
case 常量表达 式1：语句1
case 常量表达 式2：语句2
case 常量表达 式3：语句3
case 常量表达 式4：语句4
case 常量表达 式5：语句5
。。。
case 常量表达 式N：语句N
}
4-8节、switch语句（二）
switch(A/10)
{
case 10:printf("A");
case 9:printf("A");
case 8;printf("b");
case 7;printf("c");
case 6;printf("d");
default :printf("e");
}
4-9节-------4-15节、选择题
[4.1] 下列运算符中优先级最高的运算符是（ A ）
A）！ B）% C)-= D)&&
[4.2] 下列运算符中优先级最低的运算符是 （ A ）
A)|| B)!= C) <= D)+
[4.3] 为表示关系x>=y>=z, 应使用的C语言表达式是 （ A ）
A) (x>=y)&&(y>=z) B) (x>=y)AND (y>=z)
C) (x>=y>=z) D) (x>=y)&(y>=z)
[4.4] 设 a、b 和c 都是int 型变量，且a =3，b=4， c=5；则以下的表达式中，值为0的表达式是 （ D ）
A) a&&b B)a<=b C)a||b+c&&b-c D)!((a<b)&&!c||1)
[4.5] 以下程序的输出结果是：（ C ）
A) 0 B)1 C)2 D)3
main()
{ int a=2,b=-1,c=2;
if (a<b)
if (b<0)
c=0;
else c+=1;
printf(“%d\n”,c);
}
[4.6] 以下程序的输出结果是:（ A ）
A) 1 B) 2 C) 3 D) 4
main()
{ int w=4,x=3,y=2,z=1;
printf(“%d\n”,(w<x?w:z<y?z:x));
}
[4.7] 若执行以下程序时从键盘上输入3和4，则输出结果是（ B ）
A)14 B)16 C)18 D)20
main()
{ int a, b,s;
scanf(“%d%d”,&a,&b);
s=a;
if (a<b) s=b;
s*=s;
printf(“%d\n”,s);
}
[4.9] 运行以下程序后，输出（ D ）
A)#### B)&&&&
C)####&&&& D)有语法错误不能通过编译
main()
{ int k=-3;
if (k<=0) printf(“****\n”);
else printf(“&&&&\n”);
}
[4.10] 若a和b均是正整数型变量，以下正确的switch语句是 （ A ）
A) switch ( pow(a,2)+pow(b,2)) (注：调用求幂的数学函数)
{ case 1: case 3: y=a+b; break ;
case 0: case 5: y=a-b;
}
B) switch (a*a+b*b);
{ case 3:
case 1: y=a+b; break ;
case 0: y=b-a; break;
}
C) switch ()a
{ default : x=a+b;
case 10 : y=a-b;break;
case 11 : y=a*d; break;
}
D) switch(a+b)
{ case 10: x=a+b; break;
case11: y=a-b; break;
}
二、 填空题
[4.11] C语言中用 非0 表示逻辑值“真”，用 0 表示逻辑值“假”。
[4.12] C语言中的关系运算符按优先级别是（！= <=） _!= 、 <=
[4.13] C语言中的逻辑运算符按优先级别是(|| && !)
[4.14] C语言中的关系运算符和逻辑运算符的优先级别是(== &&)
[4.15] C语言中逻辑运算符 ! 的优先级高于算术运算符。
[4.16] 将下列数学式改写成C语言的关系表达式或逻辑表达式A) a=b||a<c 和 B) x>4||x<-4
A) a=b 或 a<c B) |x|>4
[4.17] 请写出以下程序的输出结果 1 。
main()
{ int a=100;
if (a>100) printf(“%d\n”,a>100);
else printf(“%d\n”,a<=100);
}
[4.18] 请写出与以下表达式等价的表达式A) X<=0 B) 1
A) !(x>0) B) !0
[4.19] 当a=1，b=2，c=3时，以下if 语句执行后，a 、b 、c 中的值分别为 3 、2 、2
if (a>c)
b=a;
a=c;
c=b;
[4.20] 若变量巳正确定义，以下语句段的输出结果是 *#
x=0,y=2,z=3;
switch(x)
{ case 0: switch (y==2)
{ case 1: printf(“*”); break;
case 2: printf(“%”); break;
}
case 1: switch(z)
{ case 1: printf(“$”);
case 2: printf(“*”);break;
default: printf(“#”);
}
}
三、 编程题
[4.21] 请将以下语句改写成switch语句。
if ( a<30) m=1;
else if (a<40) m=2;
else if (a<50) m=3;
else if (a<60) m=4;
else m=5;
[4.22] 编写程序，输入一位学生的生日（年：y0、月:m0、日:d0）； 并输入当前的日期（年： y1、月：m1、日：d1）； 输出该生的实足年龄。
[4.23] 编写程序，输入一个整数，打印出它是奇数还是偶数。
[4.24] 编写程序，输入 a、b 、c 三个数，打印出最大者。
[4.25] 有一函数：
x (-5<x<0)
y= x-1 (x=0)
x+1 (0<x<10)
编写一程序，要求输入x 的值，输出y 的值。
分别用 （1）不嵌套的if 语句（2）嵌套的if 语句 （3）if-else语句 （4）switch 语句
第五课：循环结构
5-1、5-2节、while 语句
一、格式 ：
while(表达式)
循环体
注：1：
2：
3：一条
while(a<3)1
{ a+=s;2
s=a;3}
1.......100
int i=1,sum=0;
while(i<101)
sum=sum+i++;
printf("%d",sum);
丛1开始加到哪个数时他们的和将超过1000？
int i=1,sum=0;
while(sum<1000)
{sum+=i;999 +42=1041
i++;}42 43
printf("%d",--i);
5-3节、do-while语句
do while()
格式：
do
循环体
while(表达式)
1 2 3 5 8 13
do
{
a3=a1+a2;
a1=a2;
a2=a3;
}while(a3<=1000);
1:1
2:;
5-4节、for语句（1）
for语句和for语句构成的循环结构
一、格式：
for(表达式1;表达式2;表达式3)
循环体
相当于while语句的
表达式1；
while(表达式2)
｛
循环体；
表达式3；
｝
k=0
for(;k<=10;)
｛printf("*");
k++；
｝
int k=0;
while(k<10)
{
printf("*");
k++;
}
注：
1：表达式可以省略，但分号不可以。
2：表达式可以是任意有效的C语言表达式
第六课、字符型数据
6-1节、字符型常量
格式：’a’ ‘A’ ‘ ’
要求：
1,单引号中的大写字母和小写字母代表不同的字符常量。
2.单引号中的空格也是一个字符常量，但不能是两个连续的单引号
3．字符常量只能用单引号括起来，不能用双引号。
转义字符
\n代表回车
\’代表一个单引号 ‘
\\代表一个\
\”代表一个双引号
注意：
1． 转义字符常量，如’\141’只代表一个字符
2． 反斜线后的8进制数可以不用0开头。如1中所讲的141就是一个8进制数。0141
3． 反斜线后的16进制数只可以用x开头，不可以用X开头。
字符串常量
格式：由双引号括起来的一串字符。
同时也要知道“A”和’A’是不一样的。
“A” ‘A’
ACSII码
A 65 a 97
‘a’-‘A’= 32
6.2节、字符变量
格式：char a=’s’
6.3字符的输入和输出
Printf和scanf函数输出和输入字符
对于字符型数据的格式说明符是%c
Char c=’a’;
Printf(“%c”,c);
Char a,b,c,d;
Scanf(“%c%c%c”,&a, &b, &c);
6-3节、程序举例
写出26个大写字母和他们的ASCII代码要求每行输出两组数据。
#include <stdio.h>
Main()
{
Char ch; int I;
For(i=0;i<26:i++)
{
Ch=i+65;
If(i%2= =0)
Printf(“\n”);
Printf(“c=%c,ASCII=%d”,ch,ch);
}
}
在上面的程序中有对于字符的输入与输出，在C语言中也有另外的输入输出字符的语句。
输入：变量名=getchar()
输出：putchar(变量名)
第七章 函数
7-1节、库函数
1.调用C语言标准库函数时要求的include命令行
Include命令行必须以#开头，系统提供的头文件以.h作为文件的后缀，文件名用一对双引号或一对尖括号（需要注意include命令行不是C语句，因此不能在最后加分号）
2.标准库函数的调用
函数名（参数表）
如：putchar(ch)
（1） 出现在表达式中的 ------ch=getchar()
（2） 做为单独的语句完成某种操作。-----printf(“********”);
7.2函数的定义和返回值
由于C语言中的定义的函数不能完成用户所有的要求，所以用户可以为自己定义函数实现相应的功能。
7.2.1函数定义的语法
1：格式：
函数返回值的类型名 函数名（类型名 形式参数1，类型名 形式参数2……）
{
说明部分
语句部分
}
2：函数名和形式参数都是用户命名的标识符。在同一个程序中，函数名必须唯一，形式参数名只要在同一函数中唯一即可，可以与其他函数中的变量同名。
3：C语言规定，不能在函数的内部定义函数。
4：若在函数的首部省略了函数返回值的类型名，则说明该函数的返回值是int类型
5：除了返回值类型为int类型的函数外，函数必须先定义后调用。
6：当没有函数返回值，则必须把函数定义成void类型。
例：编写求两个双精度数之和的函数。
double add(double a, double b )
{
double s;
s=a+b;
return s;
}
7-2节、函数的返回值
函数的值通过return语句返回，
return 表达式；
此表达式的值必须与函数首部所说明的类型一致，若类型不一致，则以函数值的类型为准。需要注意的是，无论函数体中有多少个return语句，只能执行一次。
函数体内可以没有return语句，这时也必须定义函数为 viod类型。
7-3节、函数的调用
7.3.1函数的两种调用方式
格式为：
函数名（实在参数表）
当实参的个数多于一个时，各实参用逗号隔开。实参的个数必须与调用函数中形参的个数相周，类型一一对应匹配。
如没有形参，则形式为 函数名（） 注意后面的小括号不能丢。
如题：
#include<stdio.h>
double add(double ,double);
main()
{
double m,n,z;
scanf(“%lf %lf”,m,n);
z=add(m,n);
printf(“%lf”,z);\
}
double add(double a, double b )
{
double s;
s=a+b;
return s;
}
7．3.2 函数调用时的语法要求
1.调用函数时，函数名必须与所调用的函数名字完全一致。
2.实参的个数必须与形参的个数一致。
3.C语言中规定，函数必须先定义后使用。
4.C语言中，函数可以直接或间接的自己调用自己。称为递归调用
fac(n)=fac(n-1)*n
7-4节、函数的说明
在C语言中凡是未在调用前定义的函数，C编译程序都默认函数的返回值为int 型。对于返回值是其它类型的，若把函数的定义放在调用之后，应该在调用之前对函数进行说明。
说明的格式：
类型名 函数名（参数类型1，参数类型2.。。。。）
也可以用以下格式
类型名 函数名（参数类型1 参数名1，参数类型2 参数名2，……）
函数说明的位置：
一般为了让程序早点识别出程序中的定义好了的函数，一般将其放在程序的开始部分
7-5节、调用函数和被调用函数之间的数据传递
一：三种格式进行传递
1． 实在参数和形式参数之间进行数据传递
2． 通过return语句把函数值返回调用函数
3． 能过全局变量，但这不是一种好的方式，通常不提倡使用。
通过一个程序来看一下数据到底是怎样传递的。
#include <stdio.h>
viod try(int ,int ,int );
main()
{
int x=2,y=3,z=0;
printf(“(1)x=%d y=%d z=%d\n”,x,y,z);
try(x,y,z);
printf(“(4) x=%d y=%d z=%d\n”,x,y,z);
}
void try(int x,int y,int z)
{
printf(“(2) x=%d y=%d z=%d\n”,x,y,z);
z=x+y;
x=x*x;
y=y*y;
printf(“(3) x=%d y=%d z=%d\n”,x,y,z”);
}
屏幕上的结果是：
(1) x=2 y=3 z=0
(2) x=2 y=3 z=0
(3) x=4 y=9 z=5
(4) x=2 y=3 z=0
再来一个程序
#include<stdio.h>
viod swap(int ,int);
main()
{
int x=10,y=20;
printf(“(1)x=%d y=%d\n”,x,y);
swap(x,y);
printf(“(4)x=%d y=%d\n”,x,y);
}
void swap (int a,int b )
{
int t;
printf(“(2) a=%d b=%d\n”,a,b);
t=a;a=b;b=t;
printf(“(3)a=%d b=%d\n”,a,b);
}
程序运行结果
(1) x=10 y=20
(2) a=10 b=20
(3) a=20 b=10
(4) x=10 y=20
7.6程序应用举例
编写一个函数isprime(int a)，用来判断自变量a是否为素数。若是素数，函数返回整数1，否则返回0.
#include <stdio.h>
int isprime(int)
main()
{
int x;
printf(“enter a integer number:”);
scanf(“%d”,&x);
if(isprime(x))
printf(“%dis prime \n”,x);
else
printf(“%dis not prime\n”,x);
}
int isprime(int a)
{
int i;
for(i=2;i<=a/2;i++)
if(a%i==0)
return 0;
return 1;
}
编写函数myupper(ch)，把ch中的小写字母转换成大写字母作为函数值返回，其他字符不变。主函数中不断输入字符，用字符@结束输入，同时不断输出结果。
#include <stdio.h>
#include<ctype.h>
char myupper(char ch)
{
if(ch>=’a’&&ch<=’z’)
ch=ch-32;
return ch;
}
main()
{
char c;
while((c=getchar())!=’@’)
{
c=myupper(c);
putchar(c);
}
}
编写函数统计输入字符的个数，用@字符结束输入，在主函数中调用此函数，输出统计结果。
#include<stdio.h>
long countch();
main()
{
long n;
n=countch();
printf(“n=%ld\n”,n);
}
long countch()
{
long cn;
for(cn=0;getchar()!=’@’;cn++)
;
return cn;
}
7-10----7-13节、课后习题
[7.1] 以下说法中正确的是 C
A)C语言程序总是从第一个定义的函数开始执行
B)在C语言程序中,要调用的函数必须在main函数中定义
C)C语言程序总是从main函数开始执行
D)C语言程序中的main函数必须放在程序的开始部分
[7.2] 以下函数的类型是C
A)与参数x的类型相同
B)void类型
C)int类型
D)无法确定
fff(float x)
{ printf("%d\n",x*x);}
[7.3] 以下函数调用语句中,含有的实参个数是B
A)1 B)2 C)4 D)5
func( (exp1,exp2),(exp3,exp4,exp5));
[7.4] 以下程序的输出结果是C
A)11 B)20 C)21 D)31
func(int a,int b)
{ int c
c=a+b;
return c;
}
main()
{ int x=6,y=7,z=8,r;
r=func((x--,y++,x+y),z--);
printf("%d\n",r);
}
[7.5] 以下程序的输出结果是A
A)-1 B)0 C)1 D)2
main()
{ int i=2,p;
p=f(i,i+1);
printf("%d",p);
}
int f(int a,int b)
{ int c;
c=a;
if(a>b)c=1;
else if(a==b)c=0;
else c=-1;
return(c);
}
[7.6] 以下程序的输出结果是D
A)0 B)1 C)6 D)无定值
fun( int a, int b, int c)
{ c=a*b; }
main()
{ int c;
fun(2,3,c);
printf("%d\n",c);
}
[7.7] 以下程序的输出结果是A
A)5.500000 B)3.000000 C)4.000000 D)8.25
double f(int n)
{ int i; double s;
s=1.0;
for(i=1; i<=n; i++) s+=1.0/i;
return s;
}
main()
{ int i,m=3; float a=0.0;
for(i=0; i<m; i++) a+=f(i);
printf("%f\n",a)L;
}
二、填空题
[7.8] 以下程序的输出结果是____12____.
unsigned fun6(unsigned num)
{ unsigned k=1;
do
{ k*=num%10; num/=10; }
while(num);
return k;
}
main()
{ unsigned n=26;
printf("%d\n",fun6(n);
}
[7.9] 以下程序的输出结果是___9.0_____.
double sub(double x,double y,double z)
{ y-=1.0;
z=z+x;
return z;
}
main()
{ double a=2.5,b=9.0;
printf("%f\n",sub(b-a,a,a));
}
[7.10] 以下程序的输出结果是___4_____.
fun1(int a,int b)
{ int c;
a+=a; b+=b;
c=fun2(a,b);
return c*c;
}
fun2(int a,int b)
{ int c;
c=（a*b）%3;
return c;
}
main()
{ int x=11,y=19;
printf("%d\n",fun1(x,y));
}
[7.11] 下面pi函数的功能是,根据以下公式返回满足精度要求的的值.请填空.
pi/2=1+1/3+1/3*2/5+1/3*2/5*3/7+1/3*2/5*3/7*4/9+...
double pi(double eps)
{ double s=0.0,t=1.0;
int n;
for(__n=1__;t>eps;n++)
{ s+=t;
t=n*t/(2*n+1);
}
return (2.0*__S___);
}
[7.12] 以下函数用以求x的y次方.请填空.
double fun(double x,int y)
{ int i; double z=1;
for(i=1; i___<=y__; i++)
z=___z*x__;
return z;
} n
[7.13] 以下程序的功能是计算S= S K!.请填空.
long f(int n) K=1
{ int i; long s;
s=__1___;
for(i=1; i<=n; i++) s=__s*i___;
return s;
}
main()
{ long s; int k,n;
scanf("%d",&n);
s=__0___;
for(k=0; k<=n; k++)s=s+___f(k)__;
printf("%ld\n",s);
}
三、程序调试和编程题
[7.14] 以下fun函数用以判断n是否是素数,fun函数中有逻辑错,请调试改正.
fun(int n)
{ int k,yes;
for(k=2; k<=n/2; k++)
if(n%k==0)
return yes= 0;
yes=1;
return yes;
}
第八章 : 指针变量
8.1变量的地址和指针：
在最开始的时候，一直给大家强调变量要先定义，后使用。为什么会这个样子？这是因为，每当我们使用一个变量系统就必须要给他开辟一个存储单元。系统要对它的值进行记录。每时每刻的记录。怎样进行记录呢？系统会自动的开辟一个地方将该变量监督起来，观察和记录它的变化。这个地方多大放什么东西？这都要求我们提前和系统说好。所以就有了变量要先定义在使用说法。其实变量定义的过程就是给他开辟存储空间的过程。那么存储空间又是什么东西呢？？
计算机种有一个硬件叫内存条，当我们提起这个硬件的时候往往都会说多大的。1G,2G,4G……这都是在说他的空间大小。计算机中的内存是以字节为单位的一片连续的存储空间，每一个字节都有一个编号，这个编号就称为内存地址。如同旅馆的房间一样，单人间，双人间等等，每个房间都有自己的编号。
内存中的空间是连续的，地址号也是连续的，并且都是用二进制数来表示的。
变量在定义的时候先要说明定义的类型。如：int k; double b; char ch;等等如此的定义。这样是在和电脑系统打招呼，我们是2人要一个两人间。目的就是告诉老板你的房间要是两个人的空间。不能定的是2人间，结果来了3个人住；同时也不能定的2人间，结果就你自己来了（对自己来说多花钱了）。
综上所述：变量的定义就是给变量开辟存储空间的过程。
int a float b
这就是变量定义的时候系统给随机开辟的地址空间。在结合我们在一开始讲的不同类型的变量的大小，其实就是在说变量所占的内存单元的多少。
1012就是整型变量a的首地址，1014就是浮点型变量b 的首地址。
当要用到一个变量时，系统就会迅速的找到这个变量。所以在C程序中还有这样的一个变量的存在，就是指针。
指针就是用来存放一个变量在内存中的地址，当要调用这个变量的时候能迅速的找到。用来存放一个变量地址的变量就叫指针变量。
同时大家也要走出一个误区就是：指针变量之所以叫变量，就是因为它里面所存放的变量的地址也不断的变化的。指针是可以移到的。
8.2指针变量的定义和指针变量的基类型
一：格式：
类型名 *指针变量名1， * 指针变量名2….
如
int *pi,*pj;
与之前不一样的地方就是在变量的前面加了一个*。*是一个说明符，用来说明该变量是指针变量。*号省略的话就和普通的变量一样了。
又如：
int *pi; char * ch; int a; char c;
指针的作用都是一样的，都是用来存放地址的，为什么还要分类型的。原因就是指针变量pi只能存放整型变量的地址，指针变量ch只能存放字符变量的地址。
如何让一个指针存放一个变量的地址呢？
pi=&a; ch=&c;
&叫取址符。*叫指针运算符。
能过以上的讲解在家一定对指针有了更进一步和了解。我们共同的回顾一下；
变量的定义就是给其开辟存储单元的过程。
任何一个变量都有自己的存储地址。
指针就是用来存放变量地址的。
指针也是一个变量。
指针也要一个地址。
那，
有没有能存放指针变量地址的一个对象呢？用该怎么称呼？
有
它是专门用来存放指针的地址的。
它就是指向指针的指针。
int **p ,*s;
p=&s;
**p就是一个指向指针的指针。它里面只能存放同种数据类型的指针的地址。
8.3 给指针变量赋地址值
一个指针变量可以通过不同的方式获得一个确定的地址值，从而指向一个具体的对象。（在以后的课程中，每当一个指针中存放了一个变量的地址的时候，我们就说这个指针指向了这个变量）。
int k=1,*q,*p;
q=&k;
q k
这时可以说：q指向了变量k;
q=&k+1 q=&(k+1) 这是错误的，指针q就是用来存放地址的，前两个例子不是。
同时：
&必须放在运算对象的左边，而且运算对象的类型必须与指针变量的基类型相同。
2，通过指针变量获得地址值
可以通过赋值运算，把一个指针变量中的地址值赋给另一个指针变量，从而使这两个指针指向同一地址。
int k,*p,*q;
q=&k; p=q;
也就是说指针变量p和q都指向了变量k.
注：当进行赋值运算时，赋值号两边指针变量的基类型必须相同。
3.给指针变量赋“空”值；
“ 空”：
null的代码值为0，当执行了以上和赋值语句后，称P为空指针。null的代码值为0.
p=’\0’ p=0;
注意： p并不是指向地址为0 的存储单元，而是一个有确定的值“空”。
8.4对指针变量的操作
C语言提供了一个称作“间接访问运算符”的单目运算符：“*”当指针变量中存放了一个确切的地址值是，就可以用“间接运算预算符”通过指针来引用该地址的存储单元。
int *p,i=10,j;
p=&i;
则这样的赋值语句
j=*p;
上面的这个赋值语句我们可以这样理解：j变量的值是由指针指向的空间中的值赋予的。这里的*p代表指针p中存放的变量i的地址中的值。*不是乘而是用来说明指针的说明符。
j=i~~~~~~~j=*(&i)
如果有这样的表达式代表：
j=*p+1 代表指针p指向的空间中中的值加1后的值给了变量j；
再如
int *p,k=0;
p=&k;
*p=100;
*p+=1;
注意：当*p出现在赋值号左边时，代表的是指针所指的存储单元，当出*p出现在赋值号右边时，代表的是指针所指的存储单元的内容。
如果有：
*p+=1
++*p
(*p)++
这三个表达式有什么不一样吗？
++和*两个运算符的优先级相同。但按自右至左的方向结合。因此++*p相当于++（*p）。而在（*p）++中，一对括号不可以少，（*p）++代表先取里面的值然后再加1。而如果去掉怎成了*p++,根据顺序，先++然后再取值。这样就成了先p++再取值。而P++就是指针先向后移动。
例8，1
用指针指向两个变量，通过指针运算选出值小的那个数。
#include <stdio.h>
main()
{
int a,b,min,*pa,*pb,*pmin;
pa=&a;pb=&b;pmin=&min;
scanf(“%d%d”,pa,pb);
printf(“a=%d, b=%d\n”,a,b);
*pmin=*pa;
if(*pa>*pb)
*pmin=*pb;
printf(“min=%d\n”,min);
}
8.4移动指针
所谓移动指针就是对指针变量加上减去一个整数，或通过赋值运算，使指针变量指向相邻的存储单元。
（因此只有当指针指向一串连续的存储单元时，指针的移动才有意义）
a[0] a[1] a[2] a[3] a[4]
P q
p=&a[0]
q=p+2
q++
q++
q- -
p++
对指针进行加减运算时，数字“1”不再代表十进制数1，而是指一个单位存储单元长度。这个单元到底多长，要看存储数据的类型了。
如果是int则代表1个存储单元长度就是位移4个字节。如果是char类型则代表1个存储单元长度就是位移1个字节。如果变量的类型是double，8个字节为一个单位，而指向它的指针是int，4个字节为一个单位。那么这个时候指针每移动一个单位就代表移动4个字节的长度，这个时候读取数据的时候就会出错。
8．5函数之间地址值的传递
▲形参为指针变量时参数和形参之间的数据传递
若函数的形参为指针类型，调用该函数时，对应的实参必须是基类型相同的地址值或者是已指向某个存储单元的指针变量。
例题：编写函数myadd（int*a ,int *b）,函数中把指针a和b所指的存储单元中的两个值相加，然后将和值作为函数值返回。在主函数中输入两个数给变量，把变量地址做为实参，传给对应的形参。
#include <stdio.h>
int myadd(int *a,int *b)
{
int sum;
sum=*a+*b;
return sum;
}
main()
{
int x,y,z;
int *p,*q;
p=&x,q=&y;
printf(“enter x,y:”);
scanf(“%d%d”,&x,&y);
z=myadd(*p,*q);
printf(“%d+%d=%d”,x,y,z);
}
▲ 通过传送地址值在被调用函数中直接改变调用函数中的变量的值
之前我们已经知道形参值的改变并不能改变对应实参的值，把数据从被调用函数返回到调用函数的唯一途径是通过return语句返回函数值。
例题：调用swap函数，交换主函数中变量x和y中的数据
#include <stdio.h>
void swap(int *,int *)
main()
{
int x=30,y=20;
printf(“(1)x=%d y=%d \n”,x,y);
swap(&x,&y);
printf(“(4)x=%d y=%d\n”,x,y);
}
void swap(int *a,int *b)
{
int t;
printf(“(2)a=%d b=%d\n”,*a,*b);
t=*a;*a=*b;*b=t;
printf(“(3) a=%d b=%d\n”,*a,*b);
}
例题：编写函数order（int *a,int *b）,使用函数中的第一个实参总是存放两个数中较小的数，第二个参数存放两个数中较大的数
#include <stdio.h>
void swap(int *x1,int *x2)
{
int t;
t=*x1;*x1=*x2;*x2=t;
}
void order(int *a,int *b)
{if(*a>*b) swap(a,b);
}
main()
{
int x,y;
printf(“输入x，y:”);
scanf(“%d%d”,&x,&y);
printf(“x=%d y=%d\n”,x,y);
order(&x,&y);
printf(“x=%d y=%d\n”,x,y);
}
8.5函数返回地址值
函数值的类型不仅可以是简单的数据类型，而且可以是指针类型
例：以下函数把主函数中变量i和j中存放较大数的那个地址作为函数值传回。
第九章 数组
之前我们只学过单个变量的定义，而有的时候就需要一片连续的存储单元。单个单个的定义第一，分配的内存空间不一定连续，这样指针就不能移动了。第二，单个单个的定义会费时费力。所以这个时候就需要一个东西来满足用用户这样一个需求。数组就在这样的条件下产生了。
数组：多个相同类型的变量被存储在一片连续的存储单元中。
9.1一维数组的定义和一维数组元素的引用
★一维数组的定义：
当数组中每个元素只带有一个下标时，称这样的数组为一维数组。
格式： 类型名 数组名【整型常量表达式】
如 int a[10]
说明：
1. 定义了一个名为a的一维数组
2. 方括号中的10规定了a数组含有10个元素，它们是（a[0]. a[1]. a[2]. a[3].a[4].a[5]. a[6]. a[7]. a[8]. a[9]）
3. 类型名int规定了a数组中每个元素都是整型，在每个元素中只能存放整形数。
4. 每个元素只有一个下标，C语言规定每个数组第一个元素的下标总为0（称为数组下界），那么最后一个9（称为数组的下标为上界）
5. 在内存中给数组中每个成员开辟了一个存储单元。总计大小：10*4=40字节。这样每当调用数组中的一个成员时就用它们的下标。如 a[*]
注：当同时定义多个数组时彼此之间用，号隔开
如 double w[22],v[100],u[5];
以上定义了三个数组。
需要注意的是，【】中的内容只能是整型常量或整型常量表达式。如int a[11+22]也可以。
★ 一维数组元素的引用
格式： 数组[下标表达式]
其实x[0],x[j],x[i+k]都是对数组中元素的合法引用形式。但是需要注意的是下标表达式的值必须大于或等于0，并且小于数组上界的数。
能过上面知识讲解，大家应该建立以下概念：
1：一个数组元素实质上就是一个变量名，代表内存中一个存储单元。一个数组占有一串连续的存储单元。
2：在C语言中一个数组不能整体引用。不能说用一个数组名就代表整个数组了。这是错误的。因为在C语言中规定数组名是一个地址常量，它代表整个数组的首地址。
int *p ;int a[10] p=a(p=&a[0]) a= =&a[0] a=10
3:数组元素中下标表达式的值必须是整数。在编写程序时保证数组下标不越界是十分重要的。
a[2.5] a[10]=123
★ 一维数组的初始化
一维数组的始化，其实就是给数组元素赋值。
格式： int a[8]={0,1,2, 4,5,6,7}
所赋的值放在等号后的一对花括号中，数值类型必须必须与所说明的类型一致，所赋值之间用逗号隔开。系统会按赋值顺序来自动分配。
当花括号中的值少于数组元素个数时，将自动给数组后面元素赋值0.如
int a[10]={1}这个时候除了a[0]=1外，其它的都是0；
对于字符数组也是一样；
char a[10]={‘!’}
不够的也会赋值‘\0’
通过赋初值定义数组的大小
C语言中规定，可以通过赋初值来定义数组的大小，这时数组说明符的一对方括号中可以不指定数组的大小。
如 int a[]={1,1,1,1,1,1,1,1,1,1}
这样相当于数组中有了10个元素
例题：编写一个程序，通过键盘给数组a中的10个成员赋初值。
#include <stdio.h>
main()
{
int a[10];
int i,*p;
p=a;
for(i=0;i<10;i++)
{scanf(“%d”,p);
printf(“a[i]=%d”,*p);}
}
编写一个程序定义一个含有30个成员的数组。并给其赋值，要求从1这样的奇数开始。当赋值完毕后，按每行10个输出。
include <stdio.h>
#define m 30
main()
{
int a[m];
int i,k=1;
for(i=0;i<m;i++)
{a[i]=k;
k+=2;}
for(i=0;i<m;i++)
{ printf(“a[%d]=%d”,i,a[i]);
if((i+1)%10= =0)
printf(“\n”);}
}
9.2一维数组和指针
★一维数组和数组元素的地址
前言：定义的数组名可以认为是一个存放地址值的指针变量名，其中的地址值是数组第一个元素的地址，也就是数组所占一串连续存储单元的起始地址。重要的是：这个指针变量中的地址值不可改变，也就是说，不可以给数组重新赋值。因此，也可以认为数组名是一个地址常量。
如： float a[10] ,*p,x;
语句a=&x或a++这样的语句都是非法的。因为不能给a重新赋地址值。一旦定义a永远指向a数组的首地址。
虽然不可以改变数组名a中的内容，但可以用对数组名加一个整数的办法，来依次表达该数组中不同元素的地址。
如：int a[10],*p; p=a+4~~~~~~~~~~p=&a[4]
再如：for(k=0;k<10;k++)
p=a+k;
在循环中并没有改变数组名a中的内容，但通过表达式：a+k逐一给出了a数组中每个元素的地址，使p依次指向a数组中和每一个元素。
如果要能过类似上面的语句给数组中的元素赋值，语句为：
for(k=0;k<10;k++)
scanf(“%d”,a+k);
如有p=a或p=&a[0]这两个表达式所要表达的意思是一样的。都是指指针P指向了数组a的首地址。所以当要依次访问数组中的每一个元素时可以用以下的两个形式；
p++；
或a+k(k的值是不断变化的如上面的for语句一样)
★ 通过数组的首地址引用数组元素
a是数组元素的首地址，a（即a+0）的值即等于&a[0]，则用a+1的值等于&a[1].
在以前我们学过“间接访问运算符”----“*”来引用地址所在的存储单元。因此对于数组a[0]，可以用表达式*&a[0]来引用也可以用*（a+0），还可以用a[0]来表示。
但需要注意的是对于*（p+k）这样的表达式不能这样写*p+k，这样写的话就错了。代表指针取值后再加K的值了。
总结：表示数组元素s[i]的表达式应当有
s[i] *(s+i) *(p+i) *p[i]
(但当p=s+2时，p=&a[2].*p[0]就是a[2]的值了)
9.3函数之间对一维数组和数组元素的引用
数组元素作实参
每个数组元素实际上代表内存中的一个存储单元，故和普通变量一样，对应的形参必须是类型相同的变量。数组元素的值可以传送给该变量，在函数中只能对该变量进行操作，而不能直接引用数组元素，更不能在函数中改变对应数组元素中的值。
数组名作实参
数组名也可以作为实参传送，但数组名是一个地址值，因此，对应的形参就应当是一个指针变量，此指针变量的基类型必须与数组的类型一致。这样就可以通过指针变量来引用调用函数中对应的数组元素，从而达到对调用函数中对应的数组元素进行操作而改变其中的值。
例：编写程序，通过一个函数给主函数中定义的数组输入若干大于或等于0的整数，用负数作为输入结束标志，调用另一个函数输出该数组中的数据。
#include <stdio.h>
#define M 100
void arrout(int *,int);
int arrin(int *);
main()
{
int s[M],k;
k=arrin(s);
arrout(s,k);
}
int arrin (int *a)
{
int i,x;
i=0;
scanf(“%d”,&x);
while(x>=0)
{
*(a+i)=x;
i++;
scanf(“%d”,&x);
}
return i;
}
void arrout(int *a,int n)
{
int i;
for(i=0;i<n;i++)
printf(((i+1)%5==0)?”%4d\n”;”%4d”,*(a+i));
printf(“\n”);
}
当数组名作为实参时，对应的形参除了是指针外，还可以用另外两种形式。
在上面的题目中数组名作为实参时，函数的首部用的是指针arrin(int *a),还可以用以下的形式调用：、
arrin(int *a)
arrin(int a[])
arrant(int a[M])
9.3.3数组元素地址作为实参
当用数组元素地址作为实参时，因为是地址值，所以对应的形参也应当是基类型相同的指针变量。
例：编写函数，对具有10个元素的char类型数组，从下标为4的元素开始，全部设置星号“*”；保持前4个元素中的内容不变。
假设数组是c[10]={‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’,‘I’,‘J’ }
根据题意可以知道想要从E开始后面的全变成*
编写一个改变的函数，编写一个输出的函数。
#include <stdio.h>
#define M 10
#define B 4
void setstar(char *,int);
void arrout(char *,int);
main()
{
char c[M]= {‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’,‘I’,‘J’ };
setstar(&c[4],M-B);
arrout(c,M);
}
void setstar(char *a,int n)
{
int i;
for(i=0;i<n;i++)
*(a+i)=’*’;}
void arrout(char *a,int n)
{
int i;
for(i=0;i<n;i++)
printf(“%c”,a[i]);
printf(“\n”);
}
9.4一维数组应用举例
编写程序，定义一个含有15个元素的数组，并编写函数分别完成以下操作。
1， 调用C库函数中的随机函数给所有元素赋以0-49的随机数；
2， 输出数组元素中的值。
3， 按顺序对每隔三个数求一个和数，并传回主函数。
4， 最后输出所有求出的和的值。
#include <stdio.h>
#include “stdlib.h”
#define SIZE 15
#define N 3
void getrand(int *,int);
void getave(int * ,int *,int );
void priarr(int *,int );
main()
{
int x[SIZE],w[SIZE/N]={0};
getrand(x,SIZE);
printf(“output%d random numbers:\n”,SIZE);
priarr(x,SIZE);
getave(x,w,SIZE);
printf(“Output 5 sum numbers :\n”);
priarr(w,SIZE/N);
}
void getrand(int *a,int n)
{
int i;
for(i=0;i<n;i++)
a[i]=rand()%50;
}
void getave(int *a,int *b,int n)
{
int i,j,sum;
for(sum=0,i=0,j=0;i<=n;i++)
{
sum+=a[i];
if((i+1)%3==0)
{
b[j]=sum;
sum=0
j++;
}
}
}
void priarr(int *a,int n)
{
int I;
for(i=0;i<n;i++)
{
printf(“%5d”,a[i]);
if((i+1)%5==0)
printf(“\n”);
}
printf(“\n”);
}
例：将数组中的数按颠倒的顺序重新存放。在操作时，只能借助一个临时存储单元，不得另外开辟数组。
注意：不是按颠倒的顺序打印数据，而是要求按逆序重新放置数组中的内容。
#include <stdio.h>
#define NUM 8
void invert (int *,int);
void priout(int *,int);
main()
{
int a[num]={10,20,30,40,50,60,70,80};
printf(“输出数组中的内容：”);
priout(a,NUM);
invert(a,NUM);
printf(“输出数组中调换后的内容：”)
priout(a,NUM);
}
void priout(int s[],int n)
{
int i;
for(i=0;i<n;i++)
printf(“%4d”,s[i]);
printf(“\n”);
}
void invert(int *a,int n)
{
int i,j,t;
i=0;j=n-1;
while(i<j)
{t=a[i];a[i]=a[j];a[j]=t;
i++;j--;
}
}、
9.5二维数组的定义和二维数组元素的引用
9.5.1二维数组的定义
当数组中的每个元素带有两个下标时，称这样的数组为二维数组。（在逻辑是可以把二维数组看成一个具有行和列的表格或一个矩阵）
定义语句形式如下：
类型名 数组名[常量表达式1][常量表达式2]
二维数组说明符中必须有用两个方括号括起来的常量表达式，常量表达式的值只能是正整数。如果将二维数组当做矩形来看，那么常量表达式1就是代表行数，常量表达式2就代表列数。
如int a[3][4] a[1][2]
1. 定义了一个名为a的二维数组。
2. 数组中的每个元素都是整形
3. a数组中共有3*4个元素。
4. a数组的逻辑结构是一个具有3行4列的矩阵。
第0列 第1列 第2列 第3列
第0行 a[0][0] a[0][1] a[0][2] a[0][3]
第1行 a[1][0] a[1][1] a[1][2] a[1][3]
第2行 a[2][0] a[2][1] a[2][2] a[2][3]
其实对于二维数组来说，我们还可以理解为一个特殊的一维数组。如上，将此二维数组中的第0行可以看为一个名为a[0]的一维数组的几个成员。同理对另外几行也成立。
9.5.2二维数组元素的引用
引用二维数组元素时必须带有两个下标，引用形式如下：
数组名[下标表达式1][下标表达式2]
int a[3][4]在这样定义的二维数组中，
有 a[0][1] a[i][j] a[i+k][j+k]
注意：引用二维数组元素时，一定要把两个下标分别放在两个方括号肉。不可以定成a[0,1] a[I,j] a[i+k,j+k]
9.5.3二维数组的初始化
1.所赋值个数与数组元素的个数相同
int a[4][3]={{1,2,3},{4,5,6},{7,8,9},{10,11,12}};
2.每行所赋值个数与数组中元素的个数不同。
int a[4][3]={{1,2},{4,5},{7},{10}};
3.所赋值行数少于数组行数
int a[4][3]={{1,2},{4,5}};
5. 赋值时省略行花括号对
int a[4][3]={1，2，3，4，5};
9.5.4通过赋值定义二维数组的大小
int a[]={1,3,3,3,3,34}
对于二维数组，只可以省略第一个方括号中的常量表达式，而不能省略第二个方括号中的常量表达式
int a[][3]={{1,2},{4,5},{7},{10}};
当用以下形式赋值时：
int a[][3]={1，4，6，7，23,25,17,18};
一维大小按以下规则决定：
1， 当初值的个数能被第二维的常量表达式的值除尽时，所得商数就是第一维的大小。
2， 当初值的个数不能被第二维的常量表达式的值除尽时。则第一维的大小=所得的商+1
9.5.5 二维数组的定义和数组元素引用举例
通过键盘给2*3的二维数组输入数据，第一行赋值1，2，3，第二行赋值10，20，30然后按行输出此二维数组
#include<stdio.h>
main()
{
int a[2][3],i,j;
printf(“Enter data by line :\n”);
for(i=0;i<2;i++)
for(j=0;j<3;j++)
scanf(“%d”,&a[i][j]);
printf(“Output a 2-dimension array :\n”);
for(j=0;j<2;j++)
{
for(i=0;i<3;i++)
printf(“%4d”,a[i][j]);
printf(“\n”);
}
}
9.6二维数组和指针
9.6.1二维数组和数组元素的地址
先给出以下定义：
int *p,a[3][4];
1. 二维数组a由若干个一维数组组成
像上面定义的数组a，我们可以理解为由a[0]、a[1]、a[2]三个元素组成，而他们又分别是一个一维数组
通过前面我们学过的知识可以知道，数组名是一个地址，其值是第一个元素的地址，此地址的基类型就是数组元素的类型。而在二维数组中同样a[0]、a[1]、a[2]都是一维数组名，同样也代表了一个不可变的地址常量。由于它是一个常量，所以这样就错了：a[0]++。而a[0]+1这就是代表向后移动一个单位长度。
对于有一个指针变量P的基类型与a[i]相同，则p=a[i]这是正确的。
2. 二维数组名也是一个地址常量
二维数组名同样也是一个存放地址常量的指针，其值为二维数组中第一个元素的地址。以上a的值与a[0]的值是相同的。
a[0] a+0 第0行的首地址
a[1] a+1 第1行的首地址
………
像他们这样的，还有一个另外的名称----行地址。所以二维数组名应理解为一个行指针。
inta[3][4] a[0]=a
3. 二维数组元素的地址
用以下的五种方式表示：
&a[i][j]
a[i]+j
*(a+i)+j
&a[0][0]+4*i+j
a[0]+4*i+j
9.6.2通过地址引用二维数组元素
若有以下定义：
int a[3][4]
则a数组元素可以用一下五种表达式来引用：
a[i][j]
*(a[i]+j)
*(*(a+i)+j)
(*(a+i))[j]
*(&a[0][0]+4*i+j)
9.6.3通过建立一个指针数组引用二维数组元素
int *p[3],a[3][2],i,j;
说明符*p[3]中，也遵照运算符的优先级，一对[]的优先级高于*号，因此p首先与[]结合，构成p[3]，说明了P是一个数组名，系统将为它开辟3个连续的存储单元，在它前面的*号则说明了数组p是批针类型，它的每个元素都是基类型为int的指针。
如有：
for(i=0;i<3;i++)
p[i]=a[i]
这就意味着每一个指针都指向了a数组中的每行的开头。
所以对于数组a中的元素，我们也可以通过这样的指针来表示了
9.6.4通过建立一个行指针引用二维数组元素
若有以下定义：
int a[3][2] ,(*prt)[2]
为什么要先加一个（）？这是因为想要*先与prt结合，说明prt是一个指针变量。然后再与[2]结合，说明指针变量prt的基类型是一个包含有两个int元素的数组。
因为prt与a的类型相同，所以prt=a就是一个合法表达式。当prt指向a数组的开头时，可以通过以下形式来引用a[i][j]
*(prt[i]+j)
*(*(prt+i)+j)
(*(prt+i))[j]
prt[i][j]
9.7二维数组名和指针数组作为实参
9.7.1二维数组名作为实参时实参和形参之间的数据传递
当二维数组名作为实参时，对应的形参必须是一个行指针变量。
假设有这样的一个二维数组名作为实参
double a[M][N]
fun(a)
这个时候对应的函数首部应写成以下几种形式
fun(double (*a)[N])
fun(double a[][N])
fun(double a[M][N])
一定要注意列下标不能丢。
9.7.2指针数组作为实参时，实参和形参之间的数据传递
当指针数组名作为实参时，对应的形参应当是一个指向指针的指针
如：
double *ps[M]
fun(ps)
则fun函数的首部应写成以下几种形式
fun(double *a[M])
fun(double *a[ ])
fun(double **a)
9.8二维数组程序举例
编写程序，通过调用随机函数给5*6的二维数组元素赋值10-40内的整数，并求出每行元素的平均值。
#include <stdio.h>
#include <stdlib.h>
#define M 6
#define N 5
void getdata(int (*)[M]);
void lineave(int[][M],float *);
void outdata(int[N][M],float *);
main()
{
int r[N][M];
float ave[N];
getdata(r);
lineave(r,ave);
outdata(r,ave);
}
void gaetdata(int(*sp)[M])
{
int i,j,x;
for(i=0;i<n;i++)
{
j=0;
while(j<m)
{
x=rand()%41;
if(x>10)
{
sp[i][j]=x;
j++;
}
}
}
void lineave(int s[][M],float *a)
{
int i,j;
for(i=0;i<N;i++)
{
ave=0.0;
for(j=0;j<M;j++)
ave=ave+s[i][j];
a[i]=ave/M;
}
}
void outdata(int sp[N][M],float a[])
{
int i,j;
printf(“output the result:\n”);
for(i=0;i<N;i++)
{
for(j=0;j<M;j++)
printf(“%4d”,sp[i][j]);
printf(“:%6.2\n”,a[i]);
}
putchar(“\n”)
}
}
第九章 数组
一、选择题
[9.1] 若已定义：
int a[]={0,1,2,3,4,5,6,7,8,9},*p=a,i;
其中0＜＝i<=9,则对a数组元素的引用不正确的是
A) a[p-a] B) *(&a[i]) C) p[i] D) *(*(a+i))
[9.2] 以下程序段数组所有元素输入数据，应在下划线填入的是
A) a+(i++) B) &a[i+1] C) a+i D) &a[++i]
main()
{ int a[10],i=0;
while(i<10) scanf("%d",＿);
}
[9.3] 以下程序的输出结果是
A) 3 B) 4 C) 1 D) 2
main()
{ int a[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
printf("%d\n",*(p+2)); }
[9.4] 以下程序的输出结果是
A) 不确定的值 B) 3 C) 2 D) 1
main()
{ int n[2]={0},i,j,k=2;
for(i=0;i<k;i++)
for(j=0;i<k;j++)
n[j]=n[i]+1;
printf("%d\n",n[k]);
}
[9.5] 以下程序的输出结果是
A)17 B)18 C)19 D)20
main()
{ int a[]={2,4,6,8,10},y=1,x,*p;
p=&a[1];
for(x=0;x<3;x++) y+=*(p+x);
printf("%d\n",y);
}
[9.6] 以下程序的输出结果是
A) 6 B) 8 C) 4 D) 2
main()
{ int a[]={2,4,6,8},*p=a,i;
for(i=0;i<4;i++) a[i]=*p++;
printf("%d\n",a[2]);
}
[9.7] 以下程序的输出结果是
A) 720 B) 120 C) 24 D) 6
f(int b[],int n)
{ int i,r=1;
for(i=0;i<=n;i++) r=r*b[i];
return r;
}
main()
{ int x,a[]={2,3,4,5,6,7,8,9};
x=f(a,3);
printf("%d\n",x);
}
[9.8] 以下程序中若第一个printf语句输出的是194，则第二个printf语句的输出结果是
A) 212 B) 204 C) 1a4 D) 1a6 12
main()
{ int a[]={1,2,3,4,5,6,7,8,9,0},*p;
p=a;
printf("%x\n",p);
printf("%x\n",p+9); 2*9=18 12
}
[9.9] 以下程序的输出结果是
A) 0987654321 B) 4321098765 C) 5678901234 D) 0987651234
fun(int *s,int n1,int n2)
{ int i,j,t;
i=n1; j=n2;
while(i<j)
{ t=*(s+i); *(s+i)=*(s+j); *(s+j)=t;
i++; j--; }
}
main()
{ int a[10]={1,2,3,4,5,6,7,8,9,0},i,*p=a;
fun(p,0,3); fun(p,4,9); fun(p,0,9);
for(i=0;i<10;i++) printf("%d",*(a+i));
}
[9.10] 以下程序的输出结果是
A) 4 4 B) 2 2 C) 2 4 D) 4 6
main()
{ int a[5]={2,4,6,8,10},*p,**k;
p=a; k=&p;
printf("%d",*(P++));
printf("%d\n",**k);
}
[9.11] 当运行以下程序时输入三行，每行都是在第一列上开始，＜CR＞代表Enter键；
a<CR>
b<CR>
cdef<CR>
则程序的输出结果是
A)abcdef B)a C)a D)a
b b b
c cd cdef
d
f
#include "stdio.h"
#define N 6
main()
{ char c[N]; int i=0;
for(i=0;i<N;i++) c[i]=getchar();
for(i=0;i<N;i++) putchar(c[i]);
}
[9.12] 若有定义和语句：
int c[4][5],(*cp)[5]; cp=c;
则对C数组元素的引用正确的是
A) cp+1 B) *(cp+3) C) *(cp+1)+3 D) *(*cp+2)
[9.13] 若已定义：
int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12},(*prt)[3]=a,*p=a[0];
则能够正确表示数组元素a[1][2]的表达式是
A) *((*prt+1)[2]) B) *(*(p+5)) C) (*prt+1)+2 D) *(*(a+1)+2)
[9.14] 若有定义和语句:
int a[4][3]={1,2,3,4,5,6,7,8,9,10,11,12},(*prt)[3]=a,*p[4],i;
for(i=0;i<4;i++) p[i]=a[i];
则下能够正确表示a数组元素的表达式是
A) a[4][3] B) p[0][0] C) prt[2][2] D)(*(p+1))[1]
[9.15] 以下程序的输出结果是
A) 23 B) 26 C) 33 D) 36
main()
{ int aa[3][3]={{2},{4},{6}},i,*p=&aa[0][0];
for(i=0;i<2;i++)
{ if(i==0) aa[i][i+1]=*P+1;
else ++p;
printf("%d",*p); }
printf("\n");
}
[9.16] 以下程序的输出结果是
A) 60 B) 68 C) 99 D) 108
main()
{ int a[3][4]={1,3,5,7,9,11,13,15,17,19,21,23};
int (*p)[4]=a,i,j,k=0;
for(i=0;i<3;i++)
for(j=0;j<2;j++)
k+=*(*(p+i)+j);
printf("%d\n",k);
}
[9.17] 以下程序的输出结果是
A) 1,5,9, B) 1,4,7, C) 3,5,7, D) 3,6,9,
main()
{ int i,x[3][3]={1,2,3,4,5,6,7,8,9};
for(i=0;i<3;i++) printf("%d,",x[i][2-i]);
}
[9.18] 若有定义语句int (*p)[M]; 其中的标识符是
A)M个指向整型变量的指针
B)指向M个整型变量的函数指针
C)一个指向具有M个整型元素的一维数组指针
D)具有M个指针元素的一维指针数组，每个元素都只能指向整型量
二、填空题
[9.19] 若有以下定义：
double w[10];
则数组元素下标的上限是 9 ，下限是 0 。
[9.20] 以下程序的输出结果是6 。
main()
{ int a[]={2,4,6},*ptr=&a[0],x=8,y,z;
for(y=0;y<3;y++)
z=(*(prt+y)<x)?*(prt+y):x;
printf("%d\n",z);
}
[9.21] 以下程序的输出结果是 12 。
main()
{ int arr[10],i,k=0;
for(i=0;i<10;i++) arr[i]=i;
for(i=0;i<4;i++) k+=arr[i]+i;
printf("%d\n",k);
}
[9.22] 以下程序的输出结果是 3 .
#define N 5
fun(char *s,char a,int n)
{ int j;
*s=a;j=n;
while(a<a[j]) j--;
return j; }
main()
{ char s[N+1]; int k,p;
for(k=1;k<=N;k++) s[k]='A'+k+1;
printf("%d\n"9;
}
[9.23] 若输入3个整数3、2、1，则以下程序的输出结果是 2721 。
void sub(int n,int uu[])
{ int t;
t=uu[n--]; t+=3*uu[n]; n++;
if(t>=10)
{ uu[n++]=t/10; uu[n]=t%10; }
else uu[n]=t; }
main()
{ int i,n,aa[10]={0};
scanf("%d%d%d",&n,&aa[0],&aa[1]);
for(i=1;i<n;i++) sub(i,aa);
for(i=0;i<=n;i++) printf("%d",aa[i]);
printf("\n");
}
[9.24] 以下程序的输出结果是 -850,2,0 .
main()
{ int i,j,row,col,m;
int arr[3][3]={{100,200,300},{28,72,-30},{-850,2,6}};
m=arr[0][0];
for(i=0;i<3;i++)
for(j=0;j<3;j++)
if(arr[i][j]<m)
{m=arr[i][j]; row=i; col=j;}
printf("%d,%d,%d\n",m,row,col);
}
[9.25] 以下findmax返回数组s中最大元素的下标，数组中元素的个数由t传入，请填空。
findmax(int s[],int t)
{ int k,p;
for(p=0,k=p;p<t;p++)
if(s[p]>s[k]) k=p ;
return p;
}
[9.26] 以下程序统计从终端入的字符中每个大写字母的个数，中统计字母的个数，其它依次类推。用＃号结束输入，请填空。
#include "stdip.h"
#include "ctype.h"
main()
{ int num[26]={0},i; char c;
while((c=getchar())!="#")
if(isupper(c)) num[_]+=1;
for(i=0;i<26;i++)
if(num[i]) printf("%c:%d\n",i+'A',num[i]);
}
三、编程题
[9.27] 输入一行数字字符,请用数组元素作为计数器来统计每个数字字符的个数。用下标为0元素统计字符“1”的个数，下标为1的元素统计字符“2”的个数，...。
[9.28] 编写函数，对具有效期0个整数的数组进行如下操作：从第n个元素开始直到最后一个元素，依次向前移动一个位置。输出移动后的结果。
[9.29] 编写函数把数组中所有奇数放在另一个数组中返回。
[9.30] 编写函数对字符数组中的输入字母，按由大到小的字母顺序进行排序。
[9.31] 输入若干有序数放在数组中。然后输入一个数，插入到此有序数列中，插入后，数组中的数仍然有序。请对以下三种情况运行你的程序，以便验证你的程序是否下确。
（1）插在最前 （2）插在最后 （3）插在中间
[9.32] 编写函数把任意十进制下整数转换成二进制数。提示：把十进制数不断被2除余数放在一个一维数组中，直到商数为零。在主函数中进行输出，要求不得按逆序输出。
[9.33] 编写函数调用随机函数产生0到19之间的随机数，在数组中存入15个互不重复的整数。要求在主函数中输出结果。若已定义为类型，调用随机函数步骤如下：
#include "stdlib.h"
x=rand()%20 /*产生0到19的随机数*/
[9.34] 编写程序求任意方阵每行、每列、两对角线一元素之和。
[9.35] 编写程序求两个矩阵的和。
[9.36] 编写程序打印出以下形式的乘法九九表。
** A MULTIPCATION TABLE **
(1) (2) (3) (4) (5) (6) (7) (8) (9)
(1) 1 2 3 4 5 6 7 8 9
(2) 2 4 6 8 10 12 14 16 18
(3) 3 6 9 12 15 18 21 24 27
(4) 4 8 12 16 20 24 28 32 36
(5) 5 10 15 20 25 30 35 40 45
(6) 6 12 18 24 30 36 42 48 54
(7) 7 14 21 28 35 42 49 56 64
(8) 8 16 24 32 40 48 56 64 72
(9) 9 18 27 36 45 54 63 72 81
[9.37] 调用随机函数为5*4的矩阵置100以内的整数，输出该矩阵，求出每行元素之和，并把和值最大的那一行与第一行上的元素对调。若已定义x为int类型，调用随机函数步骤如下：
#include "stdlib.h"
x=rand()%100 /*产生0到100的随机数*/
[9.38] 调用随机函数为55的矩阵置100以内的整数，输出该矩阵，然后逆置该矩阵。即将第一列的元素放在第一行上、第二列的元素放在第二行上、其它依次类推。
第10章 字符串
字符串的存储完全依赖于字符数组，但字符数组又不等于字符串变量
10.1用一维字符数组存放字符串
1.C语言对字符串的约定
字符串是借助于字符型一维数组来存放的，并规定以字符‘\0’作为字符串的结束标志。‘\0’作为标志占用存储空间，但不计入串的实际长度。
2.C语言中表示字符串常量的约定
随让C语言中没有字符串数据类型，但却允许是哟会更‘字符串常量’在第6章中已经介绍过字符串常量是由双引号括起来的一串字符，在表示字符串常量时，不需要人为在其末尾加入‘\0’。
3.C语言中字符串常量给出的是地址值
每个字符串在内存中占用一串连续的存储空间，这些连续的存储空间实际上就是字符型一维数组。不同的字符串在内存中占有不同的存储空间。也就是说在C语言中，字符串常量被隐含处理成一个以‘\0’结尾的无名字符型一维数组。
若有以下定义：
char *sp ,s[10];
则以下赋值是不合法的
s=”hello”;
因为S相当是一维数组的首地址，是一个不可重新赋值的数组名。因此赋值不合法。而以下赋值是合法的。
Sp=”hello”;
这个语句并不是把字符串的内容放入sp中，而只是把字符串中在内存中所占的首地址赋予了char类型的指针变量sp，使指针变量sp指向该字符串。
4．字符数组与字符串的区别
字符数组的每个元素中可存放一个字符，但它并不限定最后一个字符应该是什么。而字符串则要求最后一个必须是’\0’做为结束标识。在字符数组中可以存放字符串，但不能通过赋值语句将字符串常量或其它字符数组中的字符串直接赋给字符串变量。
10．1．1通过赋初值的方式给一维字符数组赋字符串
1．用给一般数组赋初值的相同方式给一维字符数组赋初值
Char str[10]={‘s’,’t’, ’r’,’i’,’n’,’g’,’! ’, ’\0’}；
字符数组str共有10个元素，但str作为字符串，其长度为7.虽然最后一个字符是\0但它并不是结束标识，因为系统会自动的给其分配一个结束标识。
2．在赋值时直接赋字符串常量
char str[10]={“string”};
习惯上省略花括号：
char str[10]=”string!”(这种方式会自动给字符串的末尾添加结束标识，但需要注意的是字符串数组的长度一定要比赋值的长度多一个)
10.1.2在C程序执行过程中给一维字符数组赋字符串
1.不可以用赋值语句给字符数组整体赋一串字符
当作字符串变量使用的字符数组，不能由赋值语句直接赋字符串常量
如：char mark[10];
mark=”C Program”;
以上的赋值是不允许的。
再如：char str1[10]=”computer” ,str2[10];
Str2=str1;
2.给数组元素逐个赋字符值，最后为加入串结束标志
思考一下如何用for语句赋值
char str[10]
for(i=0;i<9;i++)
scanf(“%c”, &str[i]);
str[i]=’\0’;
10.2使指针指向一个字符串
10.2.1通过赋初值的方式使指针指向一个字符串
char *ps1=”form one”;(后面的这个字符串代表的是一个地址)
这里的意思是将把存放字符串常量的无名存储区首地址赋给指针变量ps1，（不要误以为是将字符串赋给了ps1）
10.2.2 通过赋值运算使指针指向一个字符串
char *ps1;
ps1=”form one”;
10.2.3 用字符数组作为字符串和用指针指向的字符串之间的区别
char mak[]=”program”;
char *pmark=”program”;
区别：
Mark代表的是一个固定的存储空间
但指针变量pmark中的地址可以改变而指向另外一个长度不同的字符串，一旦pmark指向新的字符串而没有另一个指针指向原来的字符串，则此字符串将“丢失”，其所占存储空间也将无法引用。
10.3字符串的输入和输出
10.3.1输入和输出字符串时的必要条件
当对字符串进行办出时，输出项既可以是字符串常量或学符数组名，也可以是已指向字符串的字符指针变量。
当对字符串进行输入时，输入项可以是字符数组名，也可以是字符指针变量
10.3.2用格式说明%s进行整串输入和输出
（1）scanf函数
scanf(“%s”,str_adr)
这里str_adr是地址值，它可以是字符数组名，字 符数组元素的地址或字符指针变量。
注意：
1. 用%s格式符输入字符串时，空格和回车符都作为输入数据的分隔符而不能被读入。
2. 若输入字符串的长度超过数组所能容纳的字符个数时，系统并不报错
3. 当输入项是数组元素的地址时，输入的字符将从这一元素开始依次存放在该数组中
4. 当输入项是字符指针变量时，该指针变量必须已指向确定的有足够空间的连续存储单元
（2）在printf函数中使用格式说明%s可以实现字符串的整体输出、
Printf(“%s”,str_adr)
10.3.3调用gets \puts函数在终端输入或输出一行字符串
printf(“%s”,str_adr)
10.4字符串数组
所谓字符串数组就是数组中的每个元素又都是一个存放字符串的一维数组
二维字符数组的第一个下标决定了字符串的个数，第二个下标决定了字符串的最大长度
2.字符串数组也可以在字义的同时赋初值
char ca[3][5]={“A”,”BB”,”CCC”};
也可以写成
Char[][5]={“A”,”BB”,”CCC”};
3.可以定义字符型数组并通过赋初值来构成一个类似的字符串数组
char *pa[3]={“a”,”bb”,”ccc”};
指针数组pa的每个元素指向一个字符串，也就是说，数组pa的每个元素中存方放着一个字符串首地址
10.5用于字符串处理的函数
1.字符串复制函数strcpy
strcpy(s1,s2)
这是用来把S2中的字符串的内容复制到S1所指存储空间中，返回S1的值，即目的的首地址。注意：为保证复制的合法性，S1必须指向下足够容纳S2串的存储空间。
2.字符串连接函数strcat
Strcat(s1,s2);
该函数将s2所指字符串的内容边接到s1所指的字符串后面，并自动覆盖S1串末尾的\0，注意：S1所指的字符串应有足够的空间容纳两中合并后的内容。
3.求字符串长度strlen
strlen(s)
求字符串s的长度，这个长度不包括串尾的结束标志\0
5. 字符串比较函数strcmp
strcmp(s1,s2)
用来比较两个字符串的大小，若串要s1>s2函数值大于0（正数），若串s1=s2函数值等于0，若s1<s2函数值小于0（负数）.
10.6程序举例
例1，编写函数slength(char *s)，函数返回指针s所指字符串的长度，即相当于库函数strlen的功能。
按要求已知：形参s是指向字符串首地址的指针，计算字符串的长度，只需要逐个统计串中的字符个数，直到遇到串结束标志\0为止。
include<stdio.h>
slength(char *s)
{
int n=0;
while(*(s+n)!=’\0’)
n++;
return(n);
}
main()
{
char str[]=”ABCDEF”;int len1,len2;
len1=length(“ ”);len2=length(str);
printf(“len1=%d,len2=%d\n”,len1,len2);
}
例2，编写函数scopy（char *s,char *t）,将指针t所指的字符串复制到指针s所指的存储空间中。
#include<stdio.h>
void scopy(char *s,char *t)
{
int i;
i=0;
while((s[i]=t[i])!=’\0’)
i++;
}
main()
{
char str1[20],str2[]=”ABCDEFGH”;
scopy(str1,str2);
puts(str1);
}
课后习题
第十章 字符串
一.选择题
[10.1] 以下能正确进行字符串赋值、赋初值的语句组是
A) char s[5]={'a'，'e'，'i'，'o'，'u'}; B) char *s; s="good!";
C) char s[5]="good!"; D) char s[5]; s="good";
[10.2] 以下程序的输出结果是
A) 68 B) 0 C) 字符D的地址 D)不能确定的值
char str[ ]="ABCD",*p=str;
printf ("%d\n",*(p+4));
[10.3] 以下程序段的输出结果是
A) 11 B) 10 C) 9 D) 8
printf ("%d\n",strlen("ATS\n012\1\\")) ;
[10.4] 当运行以下程序时输入OPEN THE DOOR<CR>(此处<CR>代表Enter 键),
则输出的结果是
A) opEN tHE dOOR B) open the door
C) OPEN THE DOOR D) Open The Door
#include "stdio.h"
char fun ( char *c )
{ if ( *c < = 'Z' & & *c > = 'A') *c - ='A'-'a';
return *c;
}
main( )
{ char s[81] , *p=s;
gets(s);
while(*p)
{ *p=fun(p); putchar(*p); p++ }
putchar ( “ \n “ );
}
[10.5] 以下程序的输出结果是
A) GFEDCBA B) AGADAGA C) AGAAGAG D) GAGGAGA #include " stdio.h"
#include "string.h"
void fun ( char *w, int m )
{ char s, *p1 , *p2 ;
p1=w; p2=w+m-1;
while(p1<p2)
{ s=*p1++; *p1=*p2-- *p2=s; }
main( )
{ char a[ ]="ABCDEFG";
fun ( a , strlen(a) );
puts(a);
}
[10.6] 以下程序的输出结果是
A) ABCD B) A C) D D) ABCD
BCD B C ABC
CD C B AB
D D A A
main ( )
{ char s[ ]="ABCD", *p;
for( p=s; p<s+4; p++ ) printf("%s\n",p);
}
[10.7] 设有如下定义:
char *aa[2] = { "abcd" , "ABCD" } ;
则以下说法正确的是
A) aa数组元素的值分别是"abcd" 和 "ABCD"
B) aa是指针变量,它指向含有两个数组元素的字符型一维数组
C) aa数组的两个元素分别存放的是含有四个字符的一维数组的首地址
D) aa数组的两个元素中各自存放了字符 'a' 和 'A' 的首地址
[10.8] 以下程序的输出结果是
A) 6385 B) 69825 C) 63825 D) 693825
main( )
{ char ch[2][5] = {"6937","8254"} , *p[2];
int i , j , s = 0 ;
for ( i=0 ; i <2 ; i++ )
p[i]=ch[i];
for ( i=0 ; i<2 ; i++ )
for( j=0 ; p[i][j]>'\0' &&p[i][j]<='9';j+=2)
s=10*s+p[i][j]-'0';
printf("%d\n",s);
}
[10.9] 以下程序的输出结果是
A) ABCDEFGHIJKL B) ABCD C) ABCDEFGHIJKLMNOP D) AEIM
main( )
{ char *alpha[6]= {"ABCD","EFGH","IJKL","MNOP","QRST","UVWX"};
char **P;
int i;
p=alpha;
for( i=0; i<4; i++ ) printf("%s",p[i]);
printf("\n");
}
[10.10] 库函数strcpy用以复制字符串。若有以下定义和语句:
char str1[ ]="string",str2[8],*str3,*str4="string";
则对库函数strcpy的不正确调用是
A) strcpy(str1,"HELLO1"); B) strcpy(str2,"HELLO2");
C) strcpy(str3,"HELLO3"); D) strcpy(str4,"HELLO4");
二.填空题
[10.11] 以下程序的输出结果是___GFEDCB_________。
#include "stdio.h"
main( )
{ char b[ ]="ABCDEFG", *chp=&b[7];
while (--chp>&b[0]) putchar(*chp);
putchar('\n');
}
[10.12] 以下程序的输出结果是____XYZA________。
#include "stdio.h"
void fun(char *a1, char *a2, int n)
{ int k;
for (k=0;k<n;k++)
a2[k]=(a1[k]-'A'-3+26)%26+'A';
a2[n]='\n';
}
main( )
{ char s1[5]="ABCD", s2[5];
fun ( s1 , s2 , 4 );
puts(s2);
}
[10.13] 以下程序的输出结果是____SO________。
main( )
{ char *p[ ]={"BOOL","OPK","H","SP"};
int i;
for (i=3;i>=0;i--,I--) printf("%c",*p[i]);
printf("\n");
}
[10.4] 当运行以下程序时从键盘输入字符串qwerty和abcd,则程序的输出结果是____10________。
#include "stdio.h"
#include "string.h"
strle (char a[ ], char b[ ] )
{ int num=0,n=0;
while (*(a+num)!='\0') num++;
while (b[n]) {*(a+num)=b[n]; num++;n++}
return(num);
}
main( )
{ char str1[81],str2[81],*p1=str1,*p2=str2;
gets(p1); gets(p2);
printf("%d\n",strle(p1,p2));
}
[10.15] 以下程序的输出结果是___Itis_________。
#include "string.h"
#include "ctype.h"
void fun(char str[ ])
{ int i , j ;
for(i=0,j=0; str[i]; i++)
if ( isalpha (str[i]) ) str[j++]=str[i];
str[i]='\0'; }
main( )
{ char ss[80]="It is!";
fun(ss);
printf("%s\n",ss);
}
[10.16] 以下fun函数的功能是将一个字符串的内容颠倒过来，请填空。
#include "string.h"
void fun(char str[ ] )
{ int i , j , k ;
for ( i=0 , j=___strlen(str)-1_____ ; i < j ; i++ , _____j--_______ )
{ k=str[i]; str[i]=str[j]; str[j]=k; }
}
[10.17] 以下程序的输出结果是______3______。
printf("%d\n",strlen("s\n\016\0end") );
[10.18] 以下程序的输出结果是____goodgood!________。
char s[20]="goodgood!",*sp=s;
sp=sp+2;
sp="to";
puts(s);
第十一章 对函数的进一步讨论
11.1传给main函数的参数
在之前我们编写的main函数，其后的一对圆括号中是空的，其实在支持c的环境中，可以在运行c程序时，通过运行c程序的命令行吧参数传给c程序。如
main(int argc, char **argv)
其中argc和argv是两个参数名，可由用户自己命名，但是他们的类型是固定。第一参数argc必须是整形，第二个参数argv是一个指向字符型的指针数组的指针，这个字符型指针数组的每个指针都指向一个字符串。
当我们对包含以上主函数的，名为myc的文件进行编译连接，生成名为myc.exe 的可执行文件后，即可在操做系统提示符下输入以下命令执行该程序。
如： myc ok! good
这个时候会在屏幕上出现整数3。这也就是argc的值，他里面存放的是字符串的个数包括了myc这个文件名。
例题：若以下程序放在myc.c文件中，在编译连接后，生成一个myc.exe文件，输出arge和argv中的数据。
#include<stdio.h>
main(int argc,char *argv[ ])
{
int i;
printf(“argc=%d\n”,argc);
for(i=1;i<argc;i++)
printf(“%s”,argv[i]);
printf(“\n”);
}
若在命令行中输入
myc A COMMAND LINE
程序输出：
argc=4
A COMMAND LINE
这样的程序的功能就是输出刚才输入的字符串的个数，然后把刚才输入的字符串输出。（注意：输出的个数是我们输入的字符串的个数再加上文件名。）
11.2通过实参向函数传递函数名或指向函数的指针变量
1．指向函数指针变量的定义
在C语言中函数名代表该函数的入口地址。
区分指向函数的指针和返回值是指针
类型的函数
double (*fp)(int ,int *)
这说明fp是一个指向函数的指针变量，这个函数必须是double类型。只有同种类型的指针才能指向这个函数。
double *fp(int ,int *)
这说明fp就不是指针变量，而是说明fp是一个函数，该函数的返回值类型是基类型为double的指针类型。
2．函数名或指向函数的指针变量作为实参
函数名或指向函数的指针变量可以作为实参传给函数，这时，对应的形参应当是类型相同的指针变量。
#include<stdio.h>
#include<math.h>
double tran(double (*) (double),double(*)(double),double);
main()
{
double y,v;
v=60*3.1416/180.0;
y=tran(sin,cos,v);
printf(“tan(60)=%10.6\n”,y);
y=tran(cos,sin,v);
printf(“cot(60)=%10.6f\n”,y);
}
double tran(double (*f1)(double),double(*f2)(double),double x)
{return (*f1)(x)/(*f2)(x);}
11.3函数的递归调用。
如何求阶乘？
f(n)=n*f(n-1)
8！=8*7*6*5*4*3*2*1
int f(int a)
{int t;
if(a==0||a==1)
return 1;
else
{t=a*f(a-1);
return t;}
}
main()
{
int i,j;
scanf(“%d”,&i);
j=f(i);
printf(“%d”,j);
}
第十一章 对函数的进一步讨论
一.选择题
[11.1] 以下叙述不正确的是
A) C程序的main函数可以没有参数。
B) C程序的main函数可以有参数。
C) C程序的main函数可若有参数时，第一个参数的值最少是1。
D) main函数的第一个参数必须是整型，其名字必须是argv；第二个参数可以定义成：
char*argv[ ]，名字必须是argv。
[11.2] 若有以下说明和定义，则对fun函数的正确调用语句是
A） a=fun; a(w); B) a=fun; (*a)(&c);
C) b=fun; *b(w); D) fun(b);
main()
{ int (*a)(int*),*b( ),w[10],c;
:
:
}
fun(int *c) {...}
[11.3] 以下叙述正确的是
A）C语言中各函数之间既允许直接递归调用也允许间接递归调用
B) C语言中各函数之间既不允许直接递归调用也不允许间接递归调用
C) C语言中各函数之间既允许直接递归调用不允许间接递归调用
D) C语言中各函数之间既不允许直接递归调用允许间接递归调用
[11.4] 以下程序的输出结果是
A) 8 B) 30 C) 16 D) 2
long fib (int n)
{ if (n>2) return (fib(n-1)+fib(n-2));
else erturn(2);
}
main()
{ printf(“%ld\n”,fit(6) ); }
二.填空题
[11.5] 假定以下程序经过编译和连接后生成可执行文件PROG.EXE,如果在DOS提示符下键入: PROG ABCD EFGH IJKL<CR> (<CR>表示Enter键)
则输出结果是:__IJKLEFGHABCD__________.
main( )(int atgc,char *argv[])
{ while(--argc>0) printf("%s",argv[argc]);
printf("\n");
}
[11.6] 以下程序的输出结果是___7___.
fun(int x)
{int p;
if(x==0||x==1) return(3);
p=x-fun(x-2);
return p;
}
main( )
{ printf("%d\n", fun(9)); }
[11.7] 以下程序的输出结果是_8____.
fun (int n,int *s)
{ int f1,f2;
if (n==1||n==2) *s=1;
else
{ fun(n-1,&fi);
fun(n-2,&f2);
*s=f1+f2;
}
}
main( )
{ int x;
fun(6,&x);
pirntf("%d\n",x);
}
[11.8] 以下程序调用invert函数按逆序重新放置a数组中元素的值,a数组中的值在main函数中读入. 请填空.
#define n 10
void invert (int *s, int i , int j)
{ int t;
if(i<j)
{ t=*(s+i); *(s+i)=_*(s+j)____; *(s+j)=t;
invert (s,_i+1___,j-1);
}
}
main( )
{ int a[N],i;
for(i=0;i<N;i++) scanf("%d",a+_i___);
invert(a,0,N-1);
for(i=0;i<N;i++) printf("%d",a[i]);
printf("\n");
[11.9] 以下程序的输出结果是___17__.
funa(int a, int b)
{ return a+b;}
funb(int a, int b)
{ return a-b;}
sub (int(*t)( ), int x, int y)
{ return(*t)(x,y); }
main( )
{ int x,(*p)(int,int);
p=funa;
x=sub(p,9,3);
x+=sub(funb,8,3);
printf(“%d\n”,x);
}
第12章 C语言中用户标识符的作用域与存储类
12.1局部变量、全局变量和存储分类
局部变量：在函数内部或复合语句内部定义的变量。函数的形参也属于局部变量。
全局变量；在函数外部定义的变量称为全局变量。
有时局部变量也称内部变量，全局变量称外部变量。
局部变量和全局变量的区别就在于他们的作用域不同，
C语言中，有两种存储类别：一种是自动类，一种是静态类。局部变量可以说是自动类，也可以说是静态类。而全局变量只能是静态类。
有几种说明符玉两种存储类别相关：
auto 自动
regisert 寄存器 （这种变量的利用率很高，一般把这样的变量就存放在了CPU中了。）
static 静态 （这种变量占据着永久性的存储单元）
extern 外部
#include <stdio.h>
int f(int n);
main()
{
int a=3,s;
s=f(a);
s=s+f(a);
s=s+f(a);
printf(“%d\n”,s);
}
int f(int n)
{
static int a=1;
n+=3++;
return n;
}
12.2局部变量及其作用域和生存期
局部变量的作用域是从定义的位置期，到函数体结束为止。
局部变量的生存期是整个程序的运行期间。
若全局变量和某个函数中的局部变量同名，则在该函数中，此全局变量被屏蔽，在该函数内，访问的是局部变量，与同名的全局变量不发生任何关系。
第十三章 编译预处理和动态存储分配
13.1 凡是以“#”号开头的行都称为“编译预处理”命令行。
13.1.1 宏替换
不带参数的宏定义
#define 宏名 替换文本
如 #define SIZE 100
上面提到的SIZE就是宏名，它一般情况下都是大写的。
#define PI 3.14
#define ADDPI (PI+1)
#define TWO_ADDPI(2*ADDPI)
程序中如有表达式 x=TWO_ADDPI 则替换后，表达式将成为：X=(2*(3.14+1)/2)
注意：当宏定义在一行中写不下，需要在下一行继续是，只需要在最后一个字符后紧接着加一个反斜线 “\”
如果在\前或在下一行的开头留有许多空格，则在宏替换时也将加入这些空格。
同一个宏名不能重复定义
替换文本不能替换双引号中与宏名相同的字符串
替换文本并不替换用户表示符中的成分
2.带参数的宏定义
格式；
#define 宏名(形参表) 替换文本
#define MU(x,y) ((x)*(y))
A=MU(5,2)=((5)*(2))
B=6/MU(a+3,a)=6/((a+3)*(a))
第十四章 结构体、共用体和用户定义类型
结构体式一种较为复杂但却非常灵活的构造型数据类型。
其实他们是这样发展的，最初我们学习了定义变量，但是一次只能定义一个。后来为了定义一次而是用多次，就出现了数组，但是它里面所能存存放的都是同种类型的。怎么样才能定义一次使用多次，同时他们还不受类型的限制呢。这就出现了结构体。
结构体类型的说明
struct 结构体标识名
{
类型名1 结构成员名表1；
类型名2 结构成员名表2；
…
类型名n 结构成员名表n；
}；
struct 是关键字，是结构体类型的标志。
注意：结构体说明同样要以分号结尾。
如；
struct date
{
int year,month,day;
};
当结构体中有包含结构体式，称为结构体嵌套。
struct student
{
char name[12];
char sex;
struct date birthday;
float sc[4];
};
其中struct date 是一个已说明过的结构体类型。birthday就是这个结构体中的一个成员。
按照上面定义的结构体：
则给成员std复制如下
Std={“Li Ming”,’M’,1962,5,10,88,76,85.5,90}
对结构体变量赋值是，C编译程序按每个成员在结构体中的顺序一一对应赋值，不允跳过前面的成员给后面的成员赋值。但可以只给前面的若干个成员赋值，后面没有赋值的成员，系统将自动为数值型和字符型数据赋值0。
14.2.4引用结构体变量中的数据
1.对结构体成员变量的引用
1）结构体变量名.成员名
2）指针变量名->成员名
3）（*指针变量名）.成员名
则有：
Std.sex=’M’
Std->name[0]=’L’
14.3共用体
1.共用体类型的说明
union 共用体标识名
｛
类型名1 共用体成员名1；
类型名2 共用体成员名2；
。。。
类型名n 共用体成员名n;
｝
Union是关键字，是共用体类型的标志，
结构体与共用体的区别：结构体变量中中每个成员分别占有独立的存储空间，因此结构体变量所占内存字节数是其成员所占字节数的总和。而共用体变量中的所有成员共享一段公共存储区，所以共用体变量所占内存字节数与其成员中占字节数最多的那个成员相等。
由于共用体变量中所有成员共享存储空间，因此变量中的所有成员的首地址相同，而且变量的地址也就是该变量成员的地址。
14.3.2共用体变量的引用
1、共用体变量中成员的引用
共用体变量名.成员名
指针变量名->成员名
(*指针变量名).成员名
第十五章位运算
位运算的对象只能是整形或字符型数据。在VC6.0中int型数据占4个字节
1. 位运算符
运算符 作用
~ 按位求反
<< 左移
>> 右移
& 按位与
^ 按位异或
| 按位或
它们的优先级是从高到低的
2. 位运算符的运算功能
1) 按位取反
~01001101=10110010
2）左移运算
A=00000110(a=6)
B=a<<2=00011000(在最低位添上2个00，从最高位去掉前两位)
3）右移运算
负数：就是从最高位添上两个1，从最低位去掉两位
正数：就是从最高位添上两个0，从最低位去掉两位
4）按位与
把参加运算的两个运算数按对应的二进制位分别进行“与”运算，当两个相应的位都为1时，该位的结果为1，否则为0.
1101010
0100100
5）按位异或
参与运算的两个运算数中相对应的二进制位上，若数相同，则该位的结果为0，若数不同，则该位的结果为1.
001101010
101010010
6）按位或
参加运算的两个运算数中，只要两个相应的二进制位中有一个为1，该位的运算结果即为1；只有当两个相应位的数都为0时，该位的运算结果才为0.
0010101
1101010
第16章 文件
16.2文件指针
文件指针实际上是批向一个结构体类型的指针。
定义：
FILE *指针变量名；
16.3打开文件
fopen(文件名，文件使用方式)；
fopen(“file_a”,”r”);
文件使用方式：
1.r ，为读而打开文本文件。只读，不能写
2.rb ，为读而打开二进制文件。只读，不写
3.w，为写而打开的文本文件，如果指定的文件存在，则从文件的起始位置开始写，文件中原有内容将全部消失。如果指定的文件不存在，则建立一个同名的文件。
4.wb,为写而打开的一个二进制文件。其余功能与w相似
5.a，为在文件后面添加数据而打开文本文件。如果指定的文件存在，则文件中原有内容将保存，新的数据写在原有内容之后。如果指定的文件不存在，则建立一个同名的文件。
6.ab,为在文件后面添加数据而打开一个二进制文件，其余功能与a相同。
7.r+，为读和写而打开文本文件，用这各方式 时，指定的文件 应当已经存在，既可以对该文件进行读，也可对该文件进行写，在读和写操作之间不必关闭文件。只是对文本文件来说，读和写总是从文件的起始位置开始。在写新的数据时，只覆盖新数据所占的空间，其后的老数据并不丢失。
8.rb+,为读和写而打开一个二进制文件。功能与“r+”相同，只是在读和写时，可以由位置函数设置读和 写的起始位置，也就是说不一定从文件的起始位置开始读和写。
9.w+，首先建立一个新文件，进行写操作，随后可以从头开始读。如果指定的文件已存在，则原有的内容将全部消失。
10wb+功能与w+相同，只是在随后读和写时，可以由位置函数设置读和写的起始位置。
11a+。功能与a相同，只是在文件尾部添加新的数据后，可以从头开始读。
12 ab+，功能与a+相同，只是在文件尾部添加新的数据之后，可以由位置函数设置开始读的起始位置。
16.4关闭文件
fclose(文件指针)
将一个文件中的内容输出到屏幕
判断文件结束函数feof
feof(fp)的返回值是1代表文件结束，否则为0.
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE *fpout;
char ch;
fpout=fopen("file_a.dat","r");
ch=fgetc(fpout);
while(ch!=EOF)
{putchar(ch);
ch=getc(fpout);
}
fclose(fpout);
}
16.1题
把从键盘输入的文本按原样输出到名为file_a.dat文件中，用字符@作为键盘输入结束标志。
以上操作的算法步骤十分简单：
1. 打开文件。
2. 从键盘输入一个字符。
3. 判断输入的字符是否是@，若是，结束循环，执行步骤（7）。
4. 把刚输入的字符输出到指定的文件中。
5. 从键盘输入一个字符。
6. 重复步骤（3）和（5）。
7. 关闭文件
8. 程序结束。
程序如下;
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE *fpout;
char ch;
if((fpout=fopen(“file_a.dat”,”w”))==NULL)
{
printf(“Can’t open this file!\n”);exit(0);}
ch=getchar();
while(ch!=’@’)
{
fputc(ch ,fpout);
ch=getchar();
}
fclose(fpout);
}
}
20##年考题
25、下列选项中，能正确定义数组的语句是
A. int num[0..2008] B.int num[]
C.int N=2008; D.#define N 2008
int num[N] int num[N]
35.#include<stdio.h>
#define SUB(a) (a)-(a)
main()
{
int a=2,b=3,c=5,d;
d=sub(a+b)*c; 5-5*5
printf(“%d\n”,d);
}
程序运行后的输出结果是
A 0 B-12 C-20 D10
36.设有定义：
struct complex
{int real,unreal;}datal={1,8},data2;
则以下赋值语句中错误的是
A.data2=data1; B.data2=(2,6);
Cdata2.real=data1.real; D.data2.real=data1.unreal;
37.有以下程序
#include<stdio.h>
#include<string.h>
strict A
{int a;
char b[10];
double c;
};
void f(struct A t);
main()
{
struct A a={1001,”ZhangDa”,1098.0};
f(a);
printf(“%d,%s,%6.1f\n”,a.a,a.b,a.c);}
void f(struct A t)
{t.a=1002;strcpy(t.b,”ChangRong”);t.c=1202.0;}
程序运行后的输出结果是
A1001，ZhangDa,1098.0 B1002,ChangRong,1202.0
C1001,ChangRong,1098.0 D1002,ZhangDa.1202.0
38.有以下定义和语句
strruct workers
{
int num;char name[20];char c;
struct
{int day ;int month;int year;}s;
};
struct workers w，*pw;
pw=&w;
能给W中year成员赋1980的语句是
A*pw.year=1980; Bw.year=1980;
Cpw->year=1980; Dw.s.year=1980;
40.有以下程序
#include<stdio.h>
main()
{
FILE *fp;char str[10];
fp=fopen(“myfile.dat”,”w”);
fputs(“abc”,fp);fclose(fp);
fp=fopen(“myfile.dat”,”a+”);
fprintff(fp,”%d”,28);
rewind(fp);
fscanf(fp,”%s”,str);
puts(str);
fclose(fp);
}
程序运行后的输出结果是
Aabc B28c
C)abc28 D因类型不一致而出错
20##年9月
33设有以下函数
Viod fun(int n,char *s)
{…….}
则下面对函数指针的定义和赋值均正确的是
A void (*fp)(); pf=fun;
Bvoid *pf(); pf=fun;
Cvoid *pf(); *pf=fun;
Dvoid(*pf)(int,char);pf=&fun;
35有以下程序
#include<stdio.h>
#define f(x) x*x*x 3+1*3+1*3+1
main()
{
int a=3,s,t;
s=f(a+1);t=f((a+1));
printf(“%d,%d\n”,s,t);
}
程序运行后的输出结果是
A10,64 B10,10
C64,10 D64,64
36下面结构体的定义语句中，错误的是
Astruct ord{int x;int y;int z;};struct ord a;
Bstruct ord{int x;int y;int z;} struct ord a;
Cstruct ord{int x;int y;int z;} a;
Dstruct {int x;int y;int z;}a;
39若有以下程序段
int r=8;
printf(“%d\n”,r>>1);
输出结果是
A 16 B8 C4 D2
11.有以下程序
#include <stdio.h>
int a=5;
void sun(int b)
{
int a=10;
a+=b;
printf(“%d”,a);
}
main()
{
int c=20;
fun(c);
a+=c;
printf(“%d\n”,a);
}
程序运行后的输出结果是________3025_
12设有定义：
struct person
{int ID;char name[12];}p;
请将scanf(“%d”,_&p.ID__);语句补充完整，使其能够为结构体变量p的成员ID正确读入数据。
14.有以下程序、
#include<stdio.h>
typedef struct
{int num;double s;}REC;
void sunl(REC x)
{x.num=23;x.s=88.5;}
main()
{REC a={16,90.0};
sunl(a);
printf("%d\n",a.num);
}程序运行后的输出结果是__16__
其它相关题目
34.#define PT 5.5
#define S(x) PT*x*x
#include <stdio.h>
main()
{
int a=1,b=2;
printf(“%4.1f\n”,S(a+b));
}
5.5*1+2*1+2
A 49.5 B9.5 C22 D45.0
35.下面程序输出为
#include “stdio.h”
main()
{
printf(“%d\n”,12<<2);}
A 0 B47 C48 D24
36.在C语言中，只有在使用时才占用内存单元的变量，其存储类型是
A auto 和register B.extern和register C auto 和static D static和tegister
38若有以下定义的语句
struct student
{
int age;
int num;
};
struct student stu[3]={{1001,20},{1002,19},{1003,21}};
main()
{
struct student *p;
p=stu;
…}
则以下不正确的引用是
A(p++)->num B p++ C(*p).num Dp=&stu.age
40如果需要打开一个已经存在的非空文件“Demo”进行修改，下面选项中正确的是
A fp=fopen(“Demo”,”r”); Bfp=fopen(“Demo”,”ab+”);
Cfp=fopen(“Demo”,”w+”); Dfp=fopen(“Demo”,”r+”);
14.以下程序的功能是从名为filea.dat的文本中逐个读入字符并显示在屏幕上，请填空。
#include <stdio.h>
main()
{
FILE *fp;
char ch;
vp=fopen(__”filea.dat”,”r”___);
ch=fgetc(fp);
while(!feof(fp))
{
putchar(ch);
ch=fgetc(fp);
}
putchar(‘\n’);
fclose(fp);
}
34以下程序的运行结果是
#define MAX(A,B) (A)>(B)?(A):(B)
#define PRINT(Y) printf(“Y=%d\t”,Y)
main()
{
int a=1,b=2,c=3,d=4,t;
t=MAX(a+b,c+d);
PRINT(t);
}
A :Y=3 B:存在语法错误 C: Y=7 D:Y=0
35以下程序的功能是进行位运算
main()
{
unsigned char a,b;
a=7^3;b=~4&3;
printf(“%d%d\n”,a,b);
}
程序运行后的输出结果是
A 4 3 B 7 3 C 7 0 D 4 0
38.以下scanf函数调用 语句中对结构体变量成员的引用不正确的是
struct pupil
{
char name[20];
int age;
int sex;
}pup[5],*p;
p=pup;
A scanf(“%s”,pup[0].name); Bscanf(“%d”,&pup[0].age);
Cscanf(“%d”,&(p->sex)); Dscanf(“%d”,p->age);
10.以下程序用来输出结构体变量ex所占存储单元的字节数，请填空。
struct st
{
char name[20];double score;
};
main()
{
struct st ex;
printf(“ex size:%d\n”,sizeof(___struct st__))
}
38.在C语言中，变量的隐含存储类别是
A auto B static C extern D 无存储类别