C语言辅导资料

长春工业大学

C语言程序设计辅导资料

（内部资料）

主讲教师：张春飞 2011年11月12日

1

第一章 概 述

【要点归纳】

1、 C语言的特点

⑴C语言短小精悍，基本组成精炼、简洁。

32个标准关键字，45个标准运算符及9种控制语句。 ⑵C语言运算符丰富，表达能力强。 ⑶C语言数据结构丰富，结构化好。

⑷C语言提供了某些与汇编语言相似的功能，有利于编写系统软件。 ⑸C语言程序可移植性好。

(6)C语言编译后生成的目标代码小，质量高，程序的执行效率高。 2、 C语言标识符

C语言中，允许用作标识符的字符有： ? 26个英文字母（包括大小写） ? 数字0－9 ? 下划线。

C语言的标识符是满足如下条件的字符序列： ? 只能由英文字母、数字和下划线组成。 ? 长度为1－32.

? 必须以英文字母或下划线开头。 C语言的标识符可以分为以下三类：

? 关键字。C语言中规定了一批标识符，它们在程序中都代表着固定的含义，不能另

作他用。

? 预定义标识符。这些标识符在C语言中也都有特定的含义，因此为了避免误解，建

议用户不要把这些预定义标识符另作它用。 ? 用户标识符。 3、 C语言风格

⑴C语言严格区分英文字母大小写。 ⑵C语言用“；”作为语句分隔符。

⑶C语言中“{}”用于标识一组语句，构成复合语句。

⑷C程序书写格式自由，一行内可以写几个语句，一个语句也可以写在几行上。 ⑸注释用来向用户提示或解释程序的意义。（注释部分允许出现在程序的任何位置。编译时，会忽略所有的注释符，即不对他们作任何处理。） 4、 C程序构成

⑴一个C源程序由函数构成（函数是C程序的基本结构单位），其中至少包括一个主函数。

⑵main函数可以放在任意位置，C程序总是从main函数开始执行，在main函数中结束。

⑶C程序中可以包含常量、变量、运算符和标识符。 5、 C程序的结构

C语言是一种结构化的程序设计语言，它提供了3种基本结构： ⑴顺序结构； ⑵选择结构； ⑶循环结构。

2

6、 结构化程序设计

模块化程序设计的思想是：按照自顶向下的原则，把问题逐层分解。即先从总体出发，把问题分成若干个大块，每一大块代表一个大任务；在此基础上，再对每个大块细化，把大任务变成若干个小任务，直到每个小任务都能用基本结构表示为止。在划分模块的过程中，应保证模块的单入口、单出口、完整性和独立性。

从组织结构上看，一个C程序可以由若干个源程序文件组成，一个源文件可以由若干个函数及全局变量声明部分组成，一个函数由数据定义部分和执行语句组成。 7、 C程序设计步骤

8、 C程序的开发过程

几个相关概念：

(1)程序：是一组计算机可以识别和执行的指令，每一条指令使计算机执行特定的操作。 (2)源程序：程序可以用高级语言或汇编语言编写，用高级语言或汇编语言编写的程序称为源程序。

(3)目标程序：源程序经过“编译程序”翻译所得到的二进制代码称为目标程序。

(4)可执行程序：目标程序与库函数连接，形成的完整的可在操作系统下独立执行的程序称为可执行程序。

编辑（生成·c文件） → 编译（生成·obj文件） → 连接（生成·exe文件） → 执行

3

附：C语言中的关键字（32个）

auto break default do float for register return struct switch volatile while 【本节例题选编】

case double goto short typedef char else if signed union const enum int sizeof unsigned continue extern long static void 1、 选择题

【例1.1】一个C语言程序是由

A．一个主程序和若干子程序组成 B．若干函数组成 C．若干过程组成 D．若干子程序组成

【例1.2】C语言规定，在一个源程序中，main函数的位置

A．必须在最开始 B．必须在系统调用的库函数的后面 C．可以任意 D．必须在最后

【例1.3】一个C程序的执行是从

A．本程序的main函数开始，到main函数结束

B．本程序文件的第一个函数开始，到本程序文件的最后一个函数结束 C．本程序的main函数开始，到本程序文件的最后一个函数结束 D．本程序文件的第一个函数开始，到本程序main函数结束

【例1.4】以下 是C程序的基本结构单位

A．文件 B．语句 C．函数 D．表达式

【例1.5】以下 不是C语言的特点。

A．运算符丰富 B．数据结构丰富

C．可以直接访问物理地址 D．C函数包含的语句数目没有限制

【例1.6】下列关于C语言标识符的叙述中正确的是 。

A．标识符中可以出现下划线和中划线（减号） B．标识符中不可以出现中划线，但可以出现下划线

C．标识符中可以出现下划线，但不可以放在标识符的开头

D．标识符中可以出现下划线和数字，它们都可以放在标识符的开头

【例1.7】以下几组选项中，均为不合法标识符的是

A．A，P_0，do B．float，la0，_A C．b-a，goto，int D．_123，temp，INT

【例1.8】以下叙述不正确的是 。

A．一个C源程序可由一个或多个函数组成 B．一个C源程序必须包含一个main函数 C．C程序的基本结构单位是函数

D．在C程序中，注释说明只能位于一条语句的后面

【例1.9】以下叙述正确的是 。

A．在C程序中，main函数必须位于程序的最前面 B．C程序的每行中只能写一条语句 C．C语言本身没有输入输出语句

D．在对一个C程序进行编译的过程中，可发现注释中的拼写错误

4

2、填空题

【例1.10】一个C源程序中至少应包括一个 。

【例1.11】C程序编译后生成 程序，连接后生成 程序。

【例1.12】C语言规定，标识符只能由 、 、 三种字符组成，而且，

第一个字符必须是 或 。

【例1.13】 程序的3种基本控制结构是 结构、 结构和 结构。

第二章 数据类型及其运算符

【要点归纳】

1、 基本数据类型

C语言的数据类型有基本数据类型和非基本数据类型之分。

基本类型

整 型 字符型

单精度型

浮点型

双精度型

枚举类型 数组类型

数据类型

构造类型 结构体类型

共用体类型 指针类型 空类型

2、 变量

所谓变量就是在程序执行过程中，其值可以改变的量。变量有两个要素： ? 变量名。每个变量都必须有一个名称，即变量名，变量名应遵循标识符的命名规则。 ? 变量值。在程序运行过程中，变量的值存储在内存中，不同类型的变量，占用的内

存单元数不同。

C语言是一种强类型语言，它要求在使用数据之前对数据的类型进行说明。也就是说，在C语言中，所有变量必须先定义后使用。在定义的同时也可以进行赋初值操作，即初始化。

定义变量的格式如下：

[存储类型] 数据类型 变量1，变量2，?； 3、 常量

常量又称作常数，是指在程序运行过程中其值不能被改变的量。在C语言中，常量有不同的类型，如整型常量、实型常量和字符串常量等。 ⑴整型常量：可以是十进制、八进制和十六进制表示的数。

? 十进制 其形式是：d

其中，d可以是从0-9的一个或多个十进制数位，第一位不能是0。 ? 八进制 其形式是：0d

5

其中，d可以是一个或多个八进制数（0-7之间），起始0是必须的引导符。 ? 十六进制 其形式是：0xd

其中，d可以是一个或多个十六进制数（从0-9的数字，或是从”a”到”f”的字母）。引导符0是必须的，字母X可以用大写或小写。

整型数据在内存中是以二进制方式存放的，最高位为符号位，并以补码表示。 将一个十进制整数转化为补码表示的方法如下：

? 对于正数，其补码表示与原码相同。

? 对于负数，其补码表示为它的反码加1；负数的反码为其绝对值的所有位（含符号 位）取反得到。

对于用补码表示的数据，还原为原码的方法如下： ? 对于正数（补码表示的符号位为0），原码与补码相同。

? 对于负数，原码一定为负数，其绝对值为除符号位以外所有位取反后加1。 ⑵实型常量

实型常量又称浮点型常量，是一个用十进制表示的符号实数。实型常量表示形式有以下两种：

? 十进制小数表示方式 ? 指数表示方式

注：e之前必须有数字，e后面的指数必须为整数。 ⑶字符常量

字符常量又分为字符型常量、字符串常量、转义字符和符号常量四种类型。 ? 字符型常量

字符型常量是指用一对单引号括起来的一个字符。 ? 字符串常量

字符串常量是指用一对双引号括起来的一串字符。 ? 转义字符

转义字符是C语言中一种特殊形式的字符。

例：\\ddd 三位八进制

\\xhh 二位十六进制 ? 符号常量

6

C语言允许将程序中的常量定义为一个标识符，称为符号常量。 例：#define PI 3.1415926 4、 运算符

运算符：狭义的运算符是表示各种运算的符号。

表达式：使用运算符将常量、变量、函数连接起来，构成表达式。 ⑴算术运算符

+、－、*、/、% 注：“％”运算符的操作数只能是整数。“/”运算符的运算结果根据操作数的类型而定。 ⑵自增和自减运算符

++、――

注：自增和自减运算符只适用于单个变量，而不能用于表达式或常量。 ⑶赋值运算符

＝

⑷复合的赋值运算符

+＝、－＝、*＝、/＝、%＝

注：复合的赋值运算符只能是双目运算符。 ⑸关系运算符

<、<=、>、>=、==、!= ⑹逻辑运算符

！、&&、|| ⑺逗号运算符

表达式1，表达式2，? ⑻条件运算符

c ? e1 : e2 ⑼长度运算符

sizeof() ⑽位运算符

~、&、|、^、>>、<< 5、 类型转换

⑴数据的混合运算和类型自动转换

C语言允许不同类型的数据混合运算，但此时要遵循一定的规则，将运算符两边的操作数转换成共同的类型，具体转换原则是将运算符两边的数据转换成为它们之中数据最长的数据类型，以保证运算的精度不会低。

⑵强制类型转换

（类型名称）（表达式）

注：(1)类型说明和表达式都需要加括号（单个变量可以不加括号）；

(2)无论隐式转换，强制转换都是临时转换，不改变数据本身的类型和值。

7

6、 C语言语句

一个C程序应包括数据描述（由数据声明部分来实现）和数据操作（由执行语句来实现）两部分。C语句分为以下五类：

? 控制语句（9种） ? 函数调用语句 ? 表达式语句 ? 空语句 ? 复合语句 7、数据输出

在C语言中可以使用printf( )、putchart( )、puts( )等函数进行数据输出。 注：在printf ()语句中，是从右向左计算输出表达式的值。 8、数据输入

在C语言中可以使用scanf( )、getchar( )、gets( )等函数进行数据输入。 注：

⑴scanf（）函数中没有精度控制。

⑵gets(str);与scanf(“%s”,str);的差别是：使用gets()函数输入的字符串可以含有空格，而scanf(“%s”,str);不能输入含空格字符的字符串。

【本节例题选编】 1、选择题

【例2.1】若x、i、j和k都是int型变量，则计算下面表达式后，x的值为

x=(i=4,j=16,k=32)

A．4 B．16 C．32 D．52 【例2.2】若有代数式

3ae，则不正确的C语言表达式是 bcA．a/b/c*e*3 B．3*a*e/b/c C．3*a*e/b*c D．a*e/c/b*3

【例2.3】已知各变量的类型说明如下：

int k,a,b;

unsigned long w=5; double x=1.42;

则以下不符合C语法的表达式是

A．x%(-3) B．w+=-2 C．k=(a=2,b=3,a+b) D．a+=a-=(b=4)*(a=3)

【例2.4】以下选项中不属于C语言的类型的是 。

A．signed short int B．unsigned long int C．unsigned int D．long short

【例2.5】下列定义中合法的是 。

A．shor _a=1-.1e-1; B．double b=1+5e2.5; C．long do=0xfdaL; D．float 2_end=1-e-3;

【例2.6】-8在内存中的存储形式是 。

A．11111111 11111000 B．10000000 00001000 C．00000000 00001000 D．11111111 11110111

【例2.7】数值029是一个 。

A．八进制数 B．十六进制数 C．十进制数 D．非法数

【例2.8】在C语言中，要求运算数必须是整型的运算符是

8

A．/ B．++ C．！＝ D．%

【例2.9】以下符合C语言语法的赋值表达式是 。

A．d=9+e+f=d+9 B．d=9+e, f=d+9 C．d=9+e, e++, d+9 D．d=9+e++=d+7

【例2.10】C语言中，关于自增自减运算符使用正确的是 。

A．10++ B．(x+y)-- C．d+++d+++d++ D．++(a-b)

【例2.11】设有int x=11; 则表达式(x++*1/3)的值是 。

A．3 B．4 C．11 D．12

【例2.12】已知：int i=6, j; 则语句j=(++i)+(i++)后的j值是 。

A．4 B．14 C．13 D．15

【例2.13】设x、y、t均为int型变量，则执行语句：x=y=3; t=++x || ++y后，y的值为 C 。

A．不定值 B．4 C．3 D．1

【例2.14】当c的值不为0时，以下能将c的值赋给变量a, b 的是 C 。

A．c=b=a B．(a=c) || (b=c) C．(a=c) && (b=c) D．a=c=b

【例2.15】已有定义：int x=3, y=4, z=5, 则表达式!(x+y)+z-1 && y+z/2的值是 D 。

A．6 B．0 C．2 D．1

【例2.16】下列运算符中，哪个运算符的优先级最高 。

A．<= B．+ C．|| D．>=

【例2.17】在C语言中，int、char和short三种类型数据所占用的内存是 。

A．均为2个字节 B．由用户自己定义 C．由所用机器的机器字长决定的 D．是任意的

【例2.18】若有说明语句：char c=?\\72?;则变量c

A．包含1个字符 B．包含2个字符

C．包含3个字符 D．说明不合法，c的值不确定

【例2.19】若有定义：int a=7; float x=2.5, y=4.7；则表达式x+a%3*(int)(x+y)%2/4的值是 A

A．2.500000 B．2.750000 C．3.500000 D．0.000000

【例2.20】设有说明：char w; int x; float y; double z；则表达式w*x+z-y值的数据类型为

A．float B．char C．int D．double

【例2.21】以下程序的执行结果是 B 。

#include void main() {

int i=2;

printf(“%d,%d\\n”, ++i, --i); }

A．1, 1 B．2, 1 C．1, 2 D．2, 2

【例2.22】当接受用户输入的含空格的字符串时，应使用的函数是 。

A．scanf( ) B．gets( ) C．getchar( ) D．getc( )

【例2.23】下列叙述中正确的是

A．C语言中既有逻辑类型也有集合类型 B．C语言中没有逻辑类型但有集合类型 C．C语言中有逻辑类型但没有集合类型

D．C语言中既没有逻辑类型也没有集合类型

9

【例2.24】以下错误的叙述是 。

A．在C程序中，逗号运算符的优先级最低

B．在C程序中，APH和aph是两个不同的变量

C．若a和b类型相同，在计算了赋值表达式a=b后b中的值将放入a中，而b中的值不变

D．当从键盘输入数据时，对于整型变量只能输入整型数值，对于实型变量只能输入实型数值

【例2.25】长整型long数据在内存中的存储形式是

A．ASCII码 B．原码 C．反码 D．补码

【例2.26】字符型常量在内存中存放的是

A．ASCII码 B．BCD码 C．内部码 D．十进制码

【例2.27】字符串常量“\\\\\\22a,0\\n”的长度是 B

A．8 B．7 C．6 D．5

【例2.28】设int x=1,y=1；表达式（!x||y--）的值是 1

A．0 B．1 C．2 D．－1

【例2.29】已知：int x;则使用逗号表达式(x=4*5, x*5), x+25的结果是 45 ，变量x的值为 20 。

A．20 B．100 C．45 D．表达式不合法

【例2.30】逻辑运算符两侧运算对象的数据类型 。

A．只能是0或1 B．只能是0或非0正数 C．可以是整型或字符型数据 D．可以是任何类型的数据

【例2.31】以下程序的执行结果是 A 。

#include void main() {

printf(“%f\\n”,2.5+1*7%2/4); }

A．2.500000 B．2.750000 C．3.375000 D．3.000000

【例2.32】若给定条件表达式（M）?(a++):(a--)，则其中表达式（M）

A．和（M＝＝0）等价 B．和（M＝＝1）等价 C．和（M！＝0）等价 D．和（M！＝1）等价

【例2.33】有以下程序：

#include void main() {

unsigned char a,b,c; a=0x3; b=a | 0x8; c=b<<1;

printf(“%d %d\\n”, b, c); }

程序运行后的输出结果是 D 。 A．-11 12 B．-6 -13 C．12 24 D．11 22

10

2、填空题

【例2.34】若有以下定义，则计算表达式y+=y-=m*=y后的y值是 -16 。

int m=5,y=2;

【例2.35】已知int x=6;则执行x+=x-=x*x语句后，x的值是 -60 。

【例2.36】若w=1, x=2, y=3, z=4, 则条件表达式w>x?w:y

【例2.37】在C语言中，一个int 型数据在内存中占2个字节，则int型数据的取值范围为 -32768~32767 。

【例2.38】要将一个16位二进制的整型变量的高8位清零，只保其留低8位，可用的方法

是 与0Xff相与 。

【例2.39】若x和n均是int型变量，且x和n的初值均为5，则计算表达式x+=n++后x的

值为 10 ，n的值为 6 。

【例2.40】已知字母a 的ASCII码为十进制数97，且设ch为字符型变量，则表达式

ch=?a?+?8?-?3?的值为 102 。

【例2.41】假设m是一个三位数，从左到右用a,b,c表示各位的数字，则从左到右各个数字

是bac的三位数的表达式是 m0/10*100+ m/100*10+m 。

【例2.42】设y为int型变量，描述“y是奇数”的表达式是 y%2==1 。 【例2.43】在scanf( )函数中格式符x用于输入 16进制的数 。

【例2.44】若有定义：int a=2, b=3; float x=3.5, y=2.5；则下面表达式的值为 3.500000 。

(float）(a+b)/2+(int)x%(int)y

【例2.45】若有定义：int b=7; float a=2.5,c=4.7;则下面表达式的值为 5.500000 。

a+(int)(b/3*(int)(a+c)/2)%4

【例2.46】若有以下程序：执行后的输出结果是 6 , 4 。

#include void main() {

int k=2,i=2,m; m=(k+=i*=k);

printf(“%d,%d\\n”,m,i); }

【例2.47】有以下程序，输入123456789，其输出结果是 12,56,789.000000 。

#include void main() {

int a,b; float f;

scanf(“-%*2d-%f”, &a, &b, &f); printf(“%d,%d,%f\\n”, a,b,f); }

【例2.48】以下程序的执行结果是 2 , 0 , 3 , -1 。

#include void main() {

int a,b,c; a=b=1;

11

c=a++-1;

printf(“%d,%d,”, a, c); c+=-a+++(++b || ++c); printf(“%d,%d\\n”,a,c); }

【例2.49】以下程序的执行结果是 8 , 9 , 10 。

#include void main() {

int i=10;

printf(“%d,%d,%d”,i--,i--,i--); }

【例2.50】以下程序的执行结果是 -32768 , 32767 。

#include void main() {

int a=-32768, b; b=a-1;

printf(“a=%d,b=%d”, a, b); }

【例2.51】以下程序的执行结果是 8 。

#include void main() {

int x=042, y=067, z; z=(x>>2) & (y<<3); printf(“%d\\n”,z); }

【例2.52】以下程序的执行结果是 18 。

#include void main() {

int n=023;

printf(“%d\\n”,--n); }

【例2.53】以下程序的执行结果是 8, 8, 10 。

#include void main() {

int x=10,y=9; int a,b,c;

a=(--x==y++)?--x:++y; b=x++; c=y;

12

printf(“%d,%d,%d\\n”,a,b,c); }

第三章 选择语句和循环语句

【要点归纳】

1、if语句

if语句有三种使用形式 ⑴单分支if语句。

if（条件） 语句； ⑵双分支if语句。

if（条件） 语句1； else 语句2； ⑶多分支if语句。

if（〈条件1〉） 语句1； else if（〈条件2〉）语句2； ?

else if （〈条件n〉）语句n； else 语句n+1;

2、switch（开关）语句

switch语句用于方便地从多个语句中选择一个或多个语句执行。 switch（〈表达式〉） {

case 常量表达式1： 语句1； case 常量表达式2： 语句2； ?

case 常量表达式n： 语句n； default： 语句n+1； }

注：表达式的值一定是整型值，若为其他类型，最后都要转换为整型数。 3、while循环语句

while（条件）语句；

注：先判断条件，后执行语句； 4、do－while循环语句

do 语句；

while（条件）；

注：先执行一次循环体，再判断条件。

While和do-while语句的差别是，后者至少执行“语句”一次，而前者有时一次也不执行语句。

5、for循环语句

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

13

注：省略各个表达式时，应能够知道其意义。

⑴“表达式1”可以省略，此时应在该语句之前给循环变量赋初值。其后的分号不能省略。

⑵“表达式2”可以省略，即无判定条件，循环无终止进行下去。需要在循环体中用break等语句退出循环。

⑶“表达式3”可以省略，这样需要在循环体“语句”中让循环变量变化，以保证循环能正常结束。

⑷“表达式1”和“表达式3”可以同时省略，这样为⑴和⑶两种情况同时出现，需要使用相关语句保证循环结束。

⑸三个表达式都可省略，这样为⑵和⑷两种情况同时出现，需要使用相关语句保证循环结束。

#include void main() {

int i=1,sum=0; for(; ;) {

if(i>100) break; sum+=i; i++; }

printf(“sum=%d”,sum); }

6、 break语句

break语句的使用格式很简单，由关键字break和分号构成，其功能如下：

? 在switch语句中，break用来使程序流程跳出switch语句，继续执行switch后的语

句；

? 在循环语句中，break用来从最近的循环体内跳出来。 7、 continue语句

continue语句只能用于循环语句中，作用为结束本次循环，即跳过循环体中尚末执行的语句，接着进行是否执行下一次循环的判定。

【本节例题选编】 1、选择题

【例3.1】以下语句错误的是

A．if(x>y); B．if(x=y)&&(x!=0) x+=y; C．if(x!=y) scanf(“%d”,&x); esle scanf(“%d”,&y); D．if(x

【例3.2】C语言的if语句中，用作判断的条件表达式为

A．任意表达式 B．逻辑表达式 C．关系表达式 D．算术表达式

【例3.3】为了避免在嵌套的条件语句if-else中产生二义性，C语言规定：else子句总是与 配对。

A．缩排位置相同的if B．同一行上的if C．其之后最近的if D．其之前最近的if

【例3.4】以下程序的输出结果是

14

#include void main() {

int i=1,j=1,k=2;

if((j++ || k++) && i++) printf(“%d,%d,%d\\n”,i,j,k); }

A．1，1，2 B．2，2，1 C．2，2，2 D．2，2，3

【例3.5】已知int x=10,y=20,z=30; 以下语句执行后x,y,z的值是 。

if(x>y)

z=x; x=y; y=z;

A．x=10,y=20,z=30 B．x=20,y=30,z=30 C．x=20,y=30,z=10 D．x=20,y=30,z=20

【例3.6】以下程序的运行结果是 。

#include void main() {

int m=5;

if(m++>5) printf(“%d\\n”,m); else printf(“%d\\n”,m--); }

A．4 B．5 C．6 D．7

【例3.7】以下程序的输出结果是 。

#include void main() {

int a=100,x=10,y=20,ok1=5,ok2=0; if(x

if(ok2) a=10; a=-1;

printf(“%d\\n”,a); }

A．1 B．0 C．-1 D．值不确定

【例3.8】若a,b均是整型变量，正确的switch语句是

A．switch(a) B．switch(a)

{ {

case 1.0: printf(“i\\n”); case b: printf(“i\\n”); case 2: printf(“you\\n”); case 1: printf(“you\\n”); } }

C．switch(a+b) D．switch(a+b)

15

{ {

case 1: printf(“i\\n”); case 1: printf(“i\\n”); case 2*a: printf(“you\\n”); case 2: printf(“you\\n”); } }

【例3.9】对for（表达式1；；表达式3），可理解为

A．for（表达式1；0；表达式3） B．for（表达式1；表达式3；表达式3） C．for（表达式1；1；表达式3） D．for（表达式1；表达式1；表达式3）

【例3.10】执行以下程序段后，变量a,b,c的值分别是 。

int x=10,y=9; int a,b,c;

a=(--x= =y++)? --x: ++y; b=x++; c=y;

A．a=9,b=9,c=9 B．a=8,b=8,c=10 C．a=9,b=10,c=9 D．a=1,b=11,c=10

【例3.11】有以下程序段：

int n=0, p; do{

scnaf(“%d”,&p); n++;

}while(p!=12345 && n<3);

此处do-while循环的结束条件是 。 A．p的值不等于12345并且n的值小于3 B．的值等于12345并且n的值大于等于3 C．p的值不等于12345或者n的值小于3 D．p的值等于12345或者n的值大于等于3

【例3.12】下面程序中循环体的执行次数是 。

a=10; b=0;

do{ b+=2; a-=2+b; }while(a>=0);

A．1 B．2 C．3 D．4

【例3.13】以下程序段 。

x=-1; do

{ x=x*x; } while(!x);

A．是死循环 B．循环执行二次 C．循环执行一次 D．有语法错误

【例3.14】以下程序的执行结果是

#include void main() {

int a=0, i;

for(i=1; i<5; i++) { switch(i)

16

{

case 0:

case 3: a+=2; case 1:

case 2: a+=3; default: a+=5; } }

printf(“%d\\n”,a); }

A．31 B．13 C．10 D．20

说明：8+8+10+5=31。 【例3.15】下面程序的运行结果是

#include void main() {

int y=10;

do{ y--; } while(--y); printf(“%d\\n”, y--); }

A．-1 B．1 C．8 D．0

【例3.16】下面程序的功能是输出以下金字塔图案的是： * *** ***** *******

#include void main() {

int i, j;

for(i=1; i<=4; i++) {

for(j=1; j<=4-i; j++) printf(“ ”); for(j=1; j<= ; j++) printf(“*”); printf(“\\n”); } }

在下划线处应填入的是

A．i B．2*i-1 C．2*i+1 D．i+2

【例3.17】下面程序段 。

for(t=1;t<=100;t++) {

scanf(“%d”,&x);

17

if(x<0) continue; printf(“=”,t); }

A．当x<0时整个循环结束 B．x>=0时什么也不做

C．printf函数永远也不执行 D．最多允许输出100个非负整数

【例3.18】若w,x,y,z,m均为int 型变量，则执行以下语句后的m值是 。

w=1; x=2; y=3; z=4; m=(w

A．1 B．2 C．3 D．4

【例3.19】请读以下程序：

#include void main() {

int a=5,b=0,c=0; if(a=b+c)

printf(“***\\n”); else

printf(“$$$\\n”); }

以上程序 。

A．有语法错误不能通过编译 B．可以通过编译但不能通过连接 C．输出*** D．输出$$$

【例3.20】下面程序段不是死循环的是 。

A．int i=100;

while(1) {

i=i0+1;

if(i>100) break;

}

B．for( ; ; ); C．int k=0;

do { ++k; } while(k<=0); D．int s=36;

while(s); --s;

【例3.21】有一堆零件（100到200之间），如果分成4个零件一组的若干组，则多2个零件，若分成7个零件一组，则多3个，若分成9个零件一组，则多5个零件，下面程序是求这堆零件总数，请选择填空。

#include void main() {

int i;

18

for(i=100;i<200;i++) if((i-2)%4==0) if(!((i-3)%7))

if( ) printf(“%d”,i); }

A．i%9=5 B．i%9!=5 C．(i-5)%9!=0 D．i%9= =5

【例3.22】下面程序的运行结果是 。

#include void main() {

int i;

for(i=1;i<=5;i++) {

if(i%2)

printf(“*”); else

continue; printf(“#”); }

printf(“$\\n”); }

A ．*#*#*#$ B．#*#*#*$ C．*#*#$ D．#*#*$

【例3.23】下面程序的运行结果是 。

#include void main() {

int i,j,x=0;

for(i=0;i<2;i++) {

x++;

for(j=0;j<=3;j++) {

if(j%2) continue; x++; } x++; }

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

A．x=4 B．x=8 C．x=6

19

D．x=12

2、填空题

【例3.24】C语言中，break语句只能用于 语句和 语句中。 【例3.25】当a=3,b=2,c=1时，表达式f=a>b>c的值是 。

【例3.26】若a=6,b=4,c=2，则表达式!(a-b)+c-1&&b+c/2的值是 。 【例3.27】下列程序计算2~100的偶数的累加和，请填空。

#include void main() {

int i, sum=0;

for( ) sum+=i;

printf(“sum=%d\\n”, sum); }

【例3.28】以下程序的输出结果是

#include void main() {

int x=15;

while(x>10 && x<50) {

x++;

if(x/3) {x++; break;} else continue; }

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

【例3.29】下面程序段是找出整数的所有因子，请填空。

scanf(“%d”, &x); i=1;

for( ; ; ) {

if(x%i= =0) printf(“=”,i); i++; }

【例3.30】下面程序段是从键盘输入的字符中统计数字字符的个数，用换行符结束循环。请填空。

int n=0, c; c=getchar( );

while( ) {

if( ) n++; c=getchar( ); }

【例3.31】等差数列的第一项a=2，公差d=3，下面程序的功能是在前n项和中，输出能被

20

4整除的所有的和。请填空。

#include void main() {

int a,d,sum; a=2; d=3; sum=0; do{

sum+=a; a+=d;

if( ) printf(“%d\\n”,sum); }while(sum<200); }

【例3.32】请读程序：

#include void main() {

int x=1,y=0,a=0,b=0; switch(x) {

case 1:

switch(y) {

case 0:a++; break; case 1:b++; break; } case 2:

a++; b++; break; }

printf(“a=%d,b=%d”,a,b); }

上面程序的运行结果是 。

【例3.33】以下程序对输入的一个小写字母，将字母循环后移5个位置后输出，如‘a’变成‘f’，‘w’变成‘b’。请填空。

#include void main() {

char c;

c=getchar();

if(c>=?a? && c<=?u?) ;

else if(c>=?v? && c<=?z?)

21

; putchar(c); }

【例3.34】下面程序的功能是求出用数字0至9可以组成多少个没有重复的三位偶数。请填空。

#include void main() {

int n,i,j,k; n=0;

for(i=1;i<=9;i++)

for(k=0;k<=8; ) if(k!=i)

for(j=0;j<=9;j++)

if( ) n++; printf(“n=%d\\n”,n); }

【例3.35】下面程序的功能是输出1至100之间每位的乘积大于每位数的和的数。请填空。

#include void main() {

int n,k=1,s=0,m;

for(n=1;n<=100;n++) {

k=1; s=0;

; while( ) {

k*=m; s+=m; ; }

if(k>s)

printf(“%d”,n); } }

【例3.36】下面程序的功能是求1000以内的所有完全数。请填空。 （说明：一个数如果恰好等于它的因子之和（除自身外），则称该数为完全数，例如：6=1+2+3，6为完全数）

#include void main() {

22

int a,i,m;

for(a=1;a<=1000;a++) {

for( ;i<=a/2;i++) if(!(a%i))

; if(m= =a)

printf(“M”,a); } }

【例3.37】下面程序的运行结果是 。

#include void main() {

int i=1;

while(i<=15) if(++i%3!=2) continue; else

printf(“%d”,i); printf(“\\n”); }

【例3.38】下面程序的运行结果是 。

#include void main() {

int i,j,k=19; while(i=k-1) {

k-=3;

if(k%5==0) {

i++;

continue; }

else if(k<5) break; i++; }

printf(“i=%d,k=%d\\n”,i,k); }

【例3.39】下面程序的运行结果是 。

#include void main()

23

{

int y,a; y=2; a=1;

while(y--!=-1) { do{

a*=y; a++; }while(y--); }

printf(“%d,%d”,a,y); }

【例3.40】以下程序的功能是根据公式e=1+

111-6

+++?求e的近似值，精度要求为10.1!2!3!请填空。

#include void main() {

int i;

double e,new; ; new=1.0;

for(i=1; ;i++) {

new/=(double)i; e+=new; }

printf(“e=%f\\n”,e); }

【例3.41】下面程序的功能是打印100以内个位数为6且能被3整除的所有数。请填空。

#include void main() {

int i,j;

for(i=0; ; i++) {

j=i*10+6;

if( ) continue; printf(“%d”,j); } }

【例3.42】下面程序的功能是计算100到1000之间有多少个数其各位数字之和是5.请填空。

24

#include void main() {

int i,s,k,count=0;

for(i=100; i<=1000; i++) {

s=0; k=i;

while( ) {

s+=k; k= ; }

if(s!=5)

; else

count++; }

printf(“%d”, count); }

【例3.43】下面程序的运行结果是 。

#include void main() {

int i=5; do{

switch(i%2) {

case 4: i- -; break; case 6: i- -; continue; }

i- -; i- -; printf(“%d”,i); }while(i>0); }

【例3.44】下面程序的功能是计算一分数数列前20项的和：2/1，3/2，5/3，8/5，13/8，…

#include void main() {

float s=0.0; int i,a,b,t;

for( ;i<=20;i++) {

s+= ; t=a+b; b=a;

25

a=t; }

printf(“s=%.2f”,s); }

第四章 数 组

【要点归纳】

1、一维数组

任何数组在使用之前必须先说明，即指定数组名称，大小和元素类型。一旦说明了一个数组，系统就会为它在内存中分配一个所申请大小的存储空间（sizeof(类型)*长度）。 ⑴一维数组的说明

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

说明：①数组名是一个地址常量，不允许对其值进行修改。 ②“常量表达式”表示该数组拥有多少个元素，即数组的大小，它必须是正数数。 ⑵一维数组元素的引用

数组名[下标]

说明：下标是某个数组元素到数组开始元素的位置偏移量；数组下标从0开始。 ⑶一维数组的初始化

? 对数组的全部元素赋初始值； ? 对数组的部分元素赋初始值； ? 在对数组的全部元素赋初值时，也可以将数组定义为一个不确定长度的数组（形式上的不确定）。 2、二维数组

⑴二维数组的说明

类型说明符 数组名[常量表达式1][常量表达式2]； 注：①二维数组中元素的顺序是：按行优先存放，即在内存中先顺序存放第一行的元素，

再存放第二行的元素，依此类推。

②二维数组可看成是一个特殊的一维数组，它的元素又是一维数组。

⑵二维数组元素的引用

数组名[下标1][下标2] 例：int A[M][N]

其元素A[i][j] 排在第i*N+j+1个存储位置上。 ⑶二维数组的初始化

? 分行给二维数组赋初始值；

? 按数组存储的排列顺序赋初始值；

? 允许省略第一维长度说明来给二维数组赋初始值。 3、字符数组

字符数组是用来存放若干个字符的数组，其定义和引用方式与其它数组相同。 4、字符串数组

字符串数组的每个元素又都是一个字符串。字符串数组是二维数组。 4、字符串处理函数

⑴puts（字符数组） ⑵gets（字符数组）

⑶strcat（字符数组1，字符数组2）

26

⑷strcpy（字符数组1，字符数组2） ⑸strcmp（字符串1，字符串2） ⑹strlen（字符串） ⑺strlwr（字符串） ⑻strupr（字符串）

【本节例题选编】 1、选择题

【例4.1】以下有关C语言中数组的说法正确的是

A．数组元素的数据类型可以不一致

B．数组元素的个数可以不确定，允许随机变动

C．可以使用动态内存分配技术，定义元素个数可变的数组

D．定义一个数组后，就确定了它所容纳的具有相同数据类型元素的个数

【例4.2】若有说明：int a[][3]={0,0}；则下列所述正确的是

A．数组a的每个元素都可得到初值0； B．二维数组a的第一维的大小为4； C．数组a 的行数为2；

D．只有元素a[0][0]和a[0][1]可得到初值0，其余元素均得不到初值

【例4.3】以下对一维数组a的正确说明是 。

A．int a(10); B．int n=10, a[n]; C．int n; D．#define SIZE 10

scanf(“%d”,&n); int a[SIZE]; int a[n];

【例4.4】若有说明：int a[3][4];则对a数组元素的正确引用是 。

A．a[2][4] B．a[1, 3] C．a[1+1][0] D．a(2)(1)

【例4.5】以下错误的语句是

A．static char word[ ]={?C?,?h?,?i?,?n?,?a?}; B．static char word[ ]={“China”}; C．static char word[ ]=”China”; D．static char word[ ]=?China?;

【例4.6】下面程序 （每行程序前面的数字表示行号）

1 main( ) 2 {

3 float a[10]={0.0}; 4 int i;

5 for(i=0; i<3; i++) scanf(“%d”,&a[i]); 6 for(i=1; i<10; i++) a[0]=a[0]+a[i]; 7 printf(“%f\\n”,a[0]); 8 }

A．没有错误 B．第3行有错误 C．第5行有错误 D．第7行有错误

【例4.7】下面程序的运行结果是 。

#include void main() {

27

int a[6], i;

for(i=1; i<6; i++) {

a[i]=9*(i-2+4*(i>3))%5; printf(“-”,a[i]); } }

A．-4 0 4 0 4 B．-4 0 4 0 3 C．-4 0 4 4 3 D．-4 0 4 4 0

【例4.8】以下对C语言字符数组的描述错误的是

A．字符数组可以存放字符串

B．字符数组中的字符串可以进行整体输入输出

C．可以在赋值语句中通过输值运算符“＝”对字符数组整体赋值 D．字符数组的下标从0开始

【例4.9】有下面的程序段

char a[3], b[ ]=”China”; a=b;

printf(“%s”,a);

则 。

A．运行后将输出China B．运行后将输出Ch C．运行后将输出Chi D．编译出错

【例4.10】判断字符串s1是否大于字符串s2，应当使用 。

A．if(s1>s2) B．if(strcmp(s1,s2)) C．if(strcmp(s2,s1)>0) D．if(strcmp(s1,s2)>0)

【例4.11】已知：char c1[]={“abcd”}; char c2[]={?a?,?b?,?c?,?d?}；则下所述正确的是

A．数组c1和数组c2等价 B．数组c1和数组c2的长度相同 C．数组c1的长度大于数组c2的长度 D．以上都不对

【例4.12】下面程序的运行结果是 。

#include void main( ) {

char str[ ]=”SSSWLIA”, c; int k;

for(k=2; (c=str[k])!=?\\0?; k++) {

switch(c) {

case ?I?: ++k; break; case ?L?: continue;

default: putchar(c); continue; }

putchar(?*?);

28

} }

A．SSW* B．SW* C．SW*A D．SW

【例4.13】已知：char string1[10]=”abcde”, string2[10]=”xyz”；则下列C语句输出结果是

printf(“%d”, strlen(strcpy(string1,string2))); A．3 B．5 C．8 D．9

【例4.14】有以下程序：

#include #include void main() {

char s[]=”\\n123\\\\”;

printf(“%d, %d\\n”, strlen(s), sizeof(s)); }

执行后的输出结果是

A．赋初值的安符串有错 B．6，7 C．5，6 D．6，6

【例4.15】下面程序的功能是将字符串s中所有的字符c删除。请选择填空。

#include void main() {

char s[80]; int i,j; gets(s);

for(i=j=0; s[i]!=?\\0?; i++) if(s[i]!=?c?)

; s[j]=?\\0?; puts(s); }

A．s[j++]=s[i] B．s[++j]=s[i] C．s[j]=s[i]; j++ D．s[j]=s[i]

【例4.16】以下程序的输出结果是

#include void main() {

int b[3][3]={0,1,2,0,1,2,0,1,2}, i, j ,t=0; for(i=0; i<3; i++) for(j=1; j<=i; j++) t=t+b[i][b[j][j]]; printf(“%d\\n”, t); }

A．3 B．4

29

C．1 D．9

【例4.17】有如下程序：

#include void main() {

static int a[3][3]={{1, 2},{3, 4},{5, 6}}, i, j, s=0; for(i=0; i<3; i++) for(j=0; j<=i; j++) s+=a[i][j]; printf(“%d\\n”, s); }

该程序的输出结果是 A．18 B．19 C．20 D．21

【例4.18】有以下程序

#include void main() {

int i;

for(i=0;i<3;i++) switch(i) { case 1: printf(\ case 2: printf(\ default: printf(\ } }

执行后输出结果是 。 A) 011122 B) 012 C) 012020 D) 120

2、填空题 【例4.19】若有定义：static int a[3][4]={{1, 2},{0},{4,6,8,10}}；则初始化后，a[1][2]= ，

a[2][1]= 。

【例4.20】在C语言中，二维数组元素在内存中的存放顺序是 。 【例4.21】若二维数组a有m列，则在a[i][j]前的元素个数为 。 【例4.22】判断字符串a和b是否相等，应当使用 。

【例4.23】以下程序可求出矩阵a的两条对角线上的元素之和，请填空。

#include void main() {

int a[3][3]={1，3，6，7，9，11，14，15，17}，sum1=0, sum2=0, i, j; for(i=0; i<3; i++) for(j=0; j<3; j++) if(i= =j)

sum1=sum1+a[i][j]; for(i=0; i<3; i++)

30

for( ; ; j--) if((i+j)= =2)

sum2=sum2+a[i][j];

printf(“sum1=%d, sum=%d\\n”,sum1, sum2); }

【例4.24】设数组a包括10个整型元素，下面程序的功能是求出a中各相邻两个元素的和，并将这些和存在数组b中，按每行3个元素的形式输出。请填空。

#include void main() {

int a[10], b[10], i; for(i=0; i<10; i++) scanf(“%d”, &a[i]); for( ; i<10; i++) for(i=1; i<10; i++) {

printf(“=”,b[i]);

if( = =0) printf(“\\n”); } }

【例4.25】下面程序中的数组a包括10个整数元素，从a中第二个元素起，分别将后项减前项之差存入数组b，并按每行3个元素输出数组b,请填空。

#include void main() {

int a[10],b[10],i;

for(i=0; ; i++) scanf(“%d”,&a[i]); for(i=1; ;i++) b[i]=a[i]-a[i-1]; for(i=1;i<10;i++) {

printf(“=”,b[i]); if( ) printf(“\\n”); } }

【例4.26】以下程序可求出所有的水仙花数，（提示：所谓水仙花数是指一个三位正整数，其各位数字的立方之和等于该正整数。例如：407＝4*4*4+0*0*0+7*7*7，故407是一个水仙花数）请填空。

#include void main()

31

{

int x,y,z,a[8], m,i=0;

printf(“The special numbers are(in the arrange of 1000:\\n)”); for( ; m++ ) {

x=m/100;

y= ; z=m;

if(x*100+y*10+z==x*x*x+y*y*y+z*z*z) {

; i++; } }

for(x=0; x

【例4.27】下面程序的功能是生成并打印某数列的前20项，该数列第1，2项分别为0和1，以后每个奇数编号的项是前两项之和，偶数编号的项是前两项差的绝对值。生成的20个数存在一维数组x中，并按每行4项的形式输出，请填空。

#include void main() {

int x[21],i; x[1]=0; x[2]=1; i=3; do{

x[i]= ; x[i+1]= ; i= i+2 ; }while(i<=20); for(i=1;i<=20;i++) {

printf(“]”,x[i]); if(i%4= =0) printf(“\\n”); } }

【例4.28】下面程序的功能是输入5个整数，找出最大数和最小数所在的位置，并把二者对调，然后输出调整后的5个数。请填空。

#include void main() {

32

int a[5], max, min,i, j, k; for(i=0;i<5;i++)

scanf(“%d”,&a[i]); min=a[0];

for(i=1;i<5;i++) if(a[i]

min=a[i]; ; }

max=a[0];

for(i=1;i<5;i++) if(a[i]>max) {

max=a[i]; ; }

; printf(“\\nThe position of min is: =\\n”,k); printf(“\\nThe position of max is =\\n”,j); for(i=0;i<5;i++)

printf(“]”, a[i]); }

【例4.29】下面程序的运行结果是

#include void main() {

int i,f[10]; f[0]=f[1]=1;

for(i=2;i<10;i++) f[i]=f[i-2]+f[i-1]; for(i=0;i<10;i++) {

if(i%4= =0) printf(“\\n”); printf(“=”,f[i]); } }

【例4.30】设数组a中的元素均为整数，以下程序是求a中偶数的个数和偶数的平均值。请填空。

#include void main() {

int a[10]={1,2,3,4,5,6,7,8,9,10};

33

int k,s,i; float ave;

for(k=s=i=0; i<10;i++) {

if(a[i]%2!=0) ; s+= ; k++; }

if(k!=0) {

ave=s/k;

printf(“%d,%f\\n”,k,ave); } }

【例4.31】当从键盘输入18并回车后，下面程序的运行结果是 。

#include void main() {

int x,y,i,a[8],j,u; scanf(“%d”,&x); y=x; i=0; do{

u=y/2; a[i]=y%2; i++; y=u;

}while(y>=1); for(j=i-1; j>=0;j--) printf(“%d”,a[j]); }

【例4.32】下面程序的功能是检查一个二维数组是否对称（即：对所有i和j都有a[i][j]=a[j][i]）。请填空。

#include void main() {

int a[4][4]={1,2,3,4,2,2,5,6,3,5,3,7,4,6,7,4}; int i,j,found=0; for(j=0;j<4;j++)

for( ; i<4; i++) if(a[j][i]!=a[i][j]) {

;

34

break; } if(found)

printf(“NO”); else

printf(“YES”); }

【例4.33】以下程序是求矩阵a，b的乘积，结果存入矩阵c中并按矩阵形式输出。请填空。

#include void main() {

int a[3][2]={2,-1,-4,0,3,1}; int b[2][2]={7,-9,-8,10}; int i,j,k,s,c[3][2]; for(i=0;i<3;i++) for(j=0;j<2;j++) {

for( ;k<2; k++) s+= ; c[i][j]=s; }

for(i=0;i<3;i++) {

for(j=0;j<2;j++)

printf(“m”,c[i][j]); ; } }

【例4.34】下面程序的功能是求出矩阵x的上三角元素之积，其中矩阵x的行、列数和元素值均由键盘输入，请填空。

#include #define M 10 void main() {

int x[M][M]; int n,i,j; long s=1;

printf(“Enter a integer(<=10):\\n”); scanf(“%d”,&n);

printf(“Enter %d data on each line for the array x\\n”,n); for( ) for(j=0; j

scanf(“%d”,&x[i][j]); for(i=0; i

35

} }

【例4．46】下面程序的运行结果是 。

#include void main() {

int a[6][6],i,j; for(i=1;i<6;i++) for(j=1;j<6;j++) a[i][j]=(i/j)*(j/i); for(i=1;i<6;i++) {

for(j=1;j<6;j++)

printf(“-”,a[i][j]); printf(“\\n”); } }

【例4．47】下面程序的功能是从键盘上输入一个大写字母,要求按字母的顺序打印出3个相邻的字母,指定的字母在中间.若指定的字母为Z,则打印YZA;若指定的字母为A则打印ZAB.请填空.

#include void main() {

char a[3],c; int i;

c=getchar(); a[1]=c; if(c= =?Z?) {

a[2]=?A?;

; }

else if(c= =?A?) {

a[0]=?Z?;

; } else {

; ; }

for(i=0;i<3;i++) putchar(a[i]);

41

}

【例4．48】下面程序的运行结果是 .

#include void main() {

int i,r;

char s1[80]=”bus”; char s2[80]=”book”;

for(i=r=0;s1[i]!=?\\0?&&s2[i]!=?\\0?;i++) if(s1[i]==s2[i]) i++; else {

r=s1[i]-s2[i]; break; }

printf(”%d”,r); }

【例4．49】下面程序的运行结果是 .

#include void main() {

int a[9]={0,6,12,18,42,44,52,67,94}; int x=52,i,m,n=9; i=n/2+1; m=n/2;

while(m!=0) {

if(x

{ i=i-m/2-1; m=m/2; } else if(x>a[i])

{ i=i+m/2+1; m=m/2; } else

break; }

printf(”The index is :%d”,i); }

【例4．50】下面程序的运行结果是 .

#include void main() {

char a[]=”morning”,t; int i,j=0;

for(i=1;i<7;i++)

42

if(a[j]

t=a[j]; a[j]=a[7]; a[7]=t; puts(a); }

【例4．51】下面程序的功能是将二维数组a中每个元素右移一列，最右一列换到最左一列，移后的数组存到另一数组b中，并按矩阵形式输出b。请填空。

#include void main() {

int a[2][3]={4,5,6,1,2,3},b[2][3]; int i,j;

printf(“array a:\\n”); for(i=0;i<=1;i++) for(j=1;j<3;j++) ; for( ; i++) b[i][0]=a[i][2]; printf(“array b:\\n”); for(i=0;i<2;i++) {

for(j=0;j<3;j++)

printf(“]”,b[i][j]); ; } }

【例4．52】从键盘输入一行句子，统计其中单词的个数，补充程序使之完整。

#include void main() {

char s[80]; int i,num=0; ; gets(s);

while(s[i]!=?\\0?) {

if((i==0)&&(s[i]!=? ?)) num++;

else if( && ) num++; i++; }

printf(“num=%d”,num); }

【例4．53】下列count函数用于计算子串substr在母串str中出现的次数。

43

int count(char *str,char *substr) {

int x,y,z; int num=0;

for(x=0;str[x]!= ; x++) for(y= ,z=0; substr[z]= =str[y]; z++,y++) if(substr[ ]= =?\\0?) {

num++; break; }

return( num ); }

【例4．54】下面程序的运行结果是 。

#include void main() {

int i,j;

static int a[10]={1,1,1,1,1,1,1,1,1,1}; for(i=0;i<10;i++) for(j=0;j

第五章 指 针

【要点归纳】

1、 指针变量

在C语言中允许用一个变量来存放指针，这种变量称为指针变量。 在C语言中，提供了两种指针运算符： ? *：取指针目标运算符 ? &：取地址运算符 2、 指针的说明和初始化

指针说明的一般形式如下： 数据类型 *指针名；

说明：与普通变量不同的是，说明指针时指定的数据类型并不是指针变量本身的数据类型，而是其目标的数据类型。无论目标数据类型如何，所有指针都是具有相同格式的地址量，随着机器硬件不同，地址量的数据长度也不同。

44

指针初始化的一般形式如下：

数据类型 *指针名＝初始地址值；

说明：指针初始化的过程是：系统按照给出的数据类型，在一定的存储区域为该指针分配存储空间，同时把初始值置入指针的存储空间内，从而该指针就指向了初始地址值所给定的内存空间。 3、 指针运算

⑴指针与整数的加减运算

C语言的地址计算规定，一个地址量加上或减去一个整数n，其计算结果仍然是一个地址量，它是以运算量为基点的前方或后方第n个数据的地址。

对于目标类型为type的指针p，p+n表示的实际位置的地址值是： p+n*sizeof(type)。 ⑵指针相减

在C语言中，两个地址量相减，并非它们的两个地址值之间直接做减法运算，两个指针相减的结果是整数，表示该两指针所指地址之间的数据个数。 ⑶指针的关系运算

目标类型相同的两个指针之间的关系运算，表示的是它们指向的地址位置之间的关系。 4、 指针和一维数组

在C语言中，指针与数组之间的关系十分密切，它们都可以处理内存中连续存放的一系列数据。数组与指针在访问内存时采用统一的地址计算方法。

C语言中规定，数组名代表数组的首地址，也就是说，可以将数组名（即在内存中存放该数组的首地址）赋给指针。

注：以下四种关系等价

int a[10]，*pa=a；

a[i]，*(a+i)，pa[i]，*(pa+i)。

5、 字符指针和字符串

字符指针变量和字符数组的区别如下：

⑴字符数组由若干个元素组成，每个元素中放一个字符，而字符指针变量中存放的是地址，而不是将字符串放在字符指针变量中。 ⑵赋值方式，对字符数组，只能对各个元素赋值，但不能直接给字符数组进行整体赋值，而对于字符指针，既可以用字符串常量进行初始化，又可以直接用字符串常进行赋值。 ⑶在定义一个数组时，在编译时即已分配内存单元，有确定的地址，而定义一个字符指针变量时，是给指针变量分配内存单元，并在其中可以放一个地址值，也就是说，该指针变量可以指向一个字符型数据，但如果末对它赋一个地址值，则它并末具体指向哪个字符数据。

C语言编译系统提供了动态分配和释放存储单元的函数：

? malloc(size) ：在内存的动态存储区中分配一个长度为size的连续空间，此函数的

返回值是一个指向分配域起始地址的指针。

? calloc(n, size)：在内存的动态存储区中分配n个长度为size的连续空间，此函数的

返回值是一个指向分配域起始地址的指针。 ? free(ptr)：释放由ptr指向的内存区。 6、 指针和二维数组

45

二维数组应区分开行，列指针的概念：

二维数组名和指向一维数组的指针变量是行指针。 以下几种关系等价： int a[10][20];

a[3][2] ，*(*(a+3)+2) ，*(a[3]+2)。 7、 指针数组

当一系列有次序的指针变量集合成数组时，就形成了指针数组。指针数组是指针的集合，它的每个元素都是一个指针变量，并且指向相同的数据类型。

指针数组的说明形式如下：

数据类型 *指针数组名[元素个数]； 8、 多级指针

指向指针的指针称为多级指针。 其说明形式如下：

数据类型 **指针名；

说明：当一个指针指向普通数据时，这样的指针称为一级指针，指向一级指针的指针称为二级指针。指向二级指针的指针称为三级指针，依此类推。 9、 区分开下表中的内容 int a[3][4];

注意：对于a[3][2]来说，a和a[0]的地址值均为a数组在内存中存放的首地址，但二者不等价，因为地址的步进值不同。

10、有关指针的数据类型小结 定 义

46

含 义 int i; int *p; int a[n]; int *p[n]; int (*p)[n]; int f(); int *p(); int (*p)(); int **p;

定义整型变量i p为指向整型数据的指针变量 定义整型数组a，它有n个元素 定义指针数组p，它由n个指向整型数据的指针元素组成 p为指向含n个元素的一维数组的指针变量 f为返回整型函数值的函数 p为返回一个指针的函数，该指针指向整型数据 P为指向函数的指针，该函数返回一个整型值 p是一个指针变量，它指向一个指向整型数据的指针变量 【本节例题选编】 1、选择题

【例5．1】变量的指针，其含义是指该变量的 。

A．值 B．地址 C．名 D．一个标志

【例5．2】若有语句int *point, a=4; 和point=&a; 下面均代表地址的一组选项是 D 。

A．a, point, *&a B．&*a, &a, *point C．*&point, *point, &a D．&a, &*point, point

【例5．3】若已定义a为int型变量，则 A 是对指针p的正确说明和初始化。

A．int *p=a; B．int *p=*a; C．int p=&a; D．int *p=&a;

【例5．4】下面判断正确的是 C 。

A．char *a=”china”; 等价于char *a; *a=”china”;

B．char str[10]={“china”}; 等价于char str[10]; str[]={“china”}; C．char *s=”china”; 等价于char *s; s=”china”;

D．char c[4]=”abc”,d[4]=”abc”; 等价于char c[4]=d[4]=”abc”;

【例5．5】若有以下定义和赋值语句，则对s数组的第i行第j列（假设i,j已正确说明并赋值）元素地址的合法引用为 。

int s[2][3]={0},(*p)[3]; p=s;

A．*(p+i)+j B．*(p[i]+j)

C．(p+i)+j D．(*(p+i))[j]

【例5．6】语句int(*ptr)( ); 的含义是 。

A．ptr是指向一维数组的指针变量 B．ptr是指向int型数据的指针变量

C．ptr是指向函数的指针，该函数返回一个int型数据

D．ptr是一个函数名，该函数的返回值是指向int型数据的指针

【例5．7】下面程序段中，for循环的执行次数是 。

char *s=”\\ta\\018bc”;

for(; *s!=?\\0?;s++) printf(“*”);

A．9 B．5 C．6 D．7

【例5．8】下面程序段的运行结果是 。

char *s=”abcde”; s+=2;

printf(“%d”,s);

47

A．cde B．字符‘c’ C．字符‘c’的地址 D．无确定的输出结果

【例5．9】有以下程序：

#include void main() {

char a,b,c,*d; a=?\\?; b=?\\xbc?; c=?\\xab?; d=”\\017”;

printf(“%c%c%c%c\\n”,a,b,c,*d); }

编译时出现错误，以下所述中正确的是 。

A．程序中只有a=?\\?;语句错误 B．b=?\\xbc?;语句错误

C．d=”\\017”;语句错误 D．a=?\\?;和c=?\\xbc?;语句错误

【例5．10】以下合法的定义是 。

A．static str[ ]={”china”}; B．char *p=”china”;

C．char *p; strcpy(p,”china”); D．char str[13]; str[ ]=”china”;

【例5．11】若有定义：int a[4][6];则能正确表示a数组中任一元素a[i][j](此处0≤i＜4,0≤j＜6)地址的表达式是 。

A．&a[0][0]+6*i+j B．&a[0][0]+4*j+i C．&a[0][0]+4*i+j D．&a[0][0]+6*j+i

【例5．12】若有以下定义，则数值不为3的表达式是 。

int x[10]={0,1,2,3,4,5,6,7,8,9},*p1;

A．x[3] B．p1=x+3, *p1++ C．p1=x+2, *(p1++) D．p1=x+2, *++p1

【例5．13】若有以下说明：int (*p)[3]; 则以下 是正确的叙述。

A．p是一个指针数组

B．p是一个指针，它只能指向一个每行包含3个int类型元素的二维数组 C．p是一个指针，它可以指向一个一维数组中的任一元素 D．(*p)[3]与*p[3]等价

【例5．14】若有说明语句：int x[3][4];则以下关于x,*x,x[0],&x[0][0]的正确描述是 。

A．x,*x,x[0],&x[0][0]均表示元素x[0][0]的地址 B．只有x,x[0],&x[0][0]表示的是元素x[0][0]的地址 C．只有x[0]和&x[0][0]表示的是元素x[0][0]的地址 D．只有&x[0][0]表示的是元素x[0][0]的地址

【例5．15】若有以下说明语句：

static int i, a[2][3]={1, 3, 5, 7, 9,11}; int m, n;

且0≤m≤1，0≤n≤2，则 是对数组元素的正确引用。 A．a[m]+n B．*(a+5) C．*(*(a+m)+3) D．*(*(a+m)+n)

【例5．16】以下程序运行的结果是 。

48

#include void abc(char *p) {

int i,j;

for(i=j=0; *(p+i)!=?\\0?; i++) if(*(p+i)>=?d?) {

*(p+j)=*(p+i); j++; }

*(p+j)=?\\0?; }

void main() {

char str[ ]=”cdalb”; abc(str); puts(str); }

A．dalb B．cd C．dl D．c

【例5．17】下面程序的运行结果是 。

#include void main() {

int x[5]={2,4,6,8,10},*p,**pp; p=x; pp=&p;

printf(“%d”,*(p++)); printf(“%d\\n”,**pp); }

A．4 4 B．2 4 C．2 2 D．4 6

【例5．18】阅读以下程序：

#include void main() {

int a[10]={2,4,6,8,10,12,14,16,18,20},*p; p=a;

printf(“%x\\n”,p); printf(“%x\\n”,p+9); }

若第一个printf语句输出的是ffca，则第二个printf语句输出的是 。 A．ffdd B．ffdc C．ffde D．ffcd

【例5．19】以下程序运行的结果是 。

#include #include

49

void main() {

char *p1,*p2,str[50]=”abc”,st[50]=”abc”; p1=st; p2=”abc”;

strcpy(str+1, strcat(p1,p2)); printf(“%s\\n”,str); }

A．abcabcabc B．bcabcabc C．aabcabc D．cabcabc

【例5．20】以下程序运行的结果是 。

#include sub( int x, int y, int *z) {

*z=y-x; }

void main() {

int a,b,c;

sub(10,5,&a); sub(7,a,&b); sub(a,b,&c);

printf(“M,M,M\\n”,a,b,c); }

A．5， 2， 3 B．-5， -12， -7 C．-5， -12， 7 D．5， -2， -7

【例5．21】执行以下程序后，a的值为【1】 ，b的值为【2】 。

#include void main() {

int a,b,k=4,m=6,*p1=&k,*p2=&m; a=p1= =&m;

b=(-*p1)/(*p2)+7; printf(“a=%d\\n”,a); printf(“b=%d\\n”,b); }

【1】 A．－1 B．1 C．0 D．4 【2】 A．5 B．6 C．7 D．10

【例5．22】下面程序的运行结果是 。

#include void main() {

int b,a=28; char s[10],*p; p=s;

50

本文来源：https://www.bwwdw.com/article/0kba.html