C语言串讲笔记

更新时间：2024-04-10 05:13:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

C语言程序设计串讲笔记

串讲的目的和作用：

1、将相对零散的知识建立一个整体的筐架，形成整体的知识体系。 2、将考核知识点进行提炼

本次串讲的要讲解的重要知识点（共37个） 1、高级语言与Ｃ语言的特点

2、Ｃ语言的基本字符集、转义字符、保留字及其含义和Ｃ语言标识符的构成规则。 3、Ｃ程序的基本结构与书写Ｃ程序的基本规则 4、Ｃ语言中数据类型的分类

5、整型、实型、字符型、字符串常量的书写方法 6、符号常量的应用和宏定义命令的使用

7、整型、实型、字符型变量的定义、初始化方法 8、基本类型数据在内存中的存放方式 9、基本运算符的运算规则、优先级别和结合性

10、掌握算术表达、关系和逻辑表达式、赋值表达式、逗号和条件表达式的构成和运算规则 11、变量赋值及表达式计算时的数据类型转换规则 12、字符输入／输出函数和格式输入／输出函数的使用 13、三条选择语句和三种选择结构的程序设计 14、三条循环语句和三种循环结构的程序设计

15、一维数组的定义、初始化和数组元素的引用方法 16、二维数组的定义、初始化和数组元素的引用方法 17、字符数组的定义、初始化和数组元素的引用方法 18、字符数组中存放的字符串的输入/输出和处理方法 19、字符串处理的常用系统函数及其使用

20、指针变量的定义、初始化、赋值和一般使用形式

21、指向变量的指针变量、指向一维数组元素的指针变量、指向字符串的指针变量的使用方法。 22、指针数组的定义、初始化和引用

23、函数的结构与定义方法，握函数的一般调用方法

24、函数调用时参数的值传递方法、地址传递方法、返回值传递方法和利用全局外部变量在函数间传递数据的方法。

25、变量的存储类型及其定义方法、变量的生存期和作用域。 26、函数嵌套调用和递归函数的特点和设计方法 27、指针型函数的定义方法和调用方法 28、常用系统函数的使用

29、结构型数据的特点和应用及结构型的定义方法 30、结构型变量的定义、初始化和成员引用方法

31、结构型数组的定义、初始化和引用结构型数组元素的成员的方法。

32、结构型指针变量的定义、初始化和利用结构型指针变量引用结构型数据的成员的方法 33、用户自定义类型的定义和使用

34、文件名的组成规则、文件的分类及其特点 36、文件型指针的定义方法

37、缓冲文件系统中各类系统函数的使用

（1）打开/关闭文件函数的使用方法。（2）文件尾测试函数的使用方法。

（3）文件读/写中字符读/写函数的使用方法。（4）文件读/写中字符串读/写函数的使用方法。（5）文件读/写中数据读/写函数的使用方法。

（6）文件定位函数（定位文件头、随机定位）的使用方法。第一章概述

程序：是用某种计算机能理解并执行的计算机语言描述解决问题的方法步骤。

机器语言：采用计算机能直接识别和执行的二进制代码来表示的程序设计语言。

汇编语言：采用文字方式（助记符）表示的程序设计语言，其中大部分指令和机器语言中的指令一一对应，但不能被计算机的硬件直接识别。

汇编程序

汇编语言程序

汇编

机器语言程序执行

结果

机器语言和编语言又称为―面向机器的语言‖或―低级语言‖。

高级语言：是描述算法过程很方便、同时脱离了对机型的要求，能在任何计算机上运行的计算机语言。又称为―面向过程的语言‖。

用高级语言编写的程序称为源程序。高级语言程序的执行有两种：

一种是翻译一句执行一句，称为―解释执行‖方式，完成翻译工作的程序就称为―解释程序‖；一种是全部翻译成二进制程序后再执行，承担翻译工作的程序就称为―编译程序‖，编译后的二进制程序称为―目标程序‖。Ｃ语言的主要特点：

比其它高级语言更接近硬件，比低级语言更容易描述算法，程序易编、易读、易查错、易修改。可以说兼有高级语言和低级语言的优点。C语言既可以用来编写系统软件，也可以用来编写应用软件。

1．编译程序的功能是（） A.将汇编语言程序转换为目标程序 B.将汇编语言程序转换为高级语言程序 C.将高级语言程序转换为目标程序

D.将高级语言程序转换为汇编语言程序答案：C

第二章 C语言的基本知识Ｃ语言的基本词法 1 字符集

Ｃ语言的字符集就是ASCII字符集，主要包含下列几类：（1）大小写英文字母A～Z、a～z（52个）（2）数字0、1、2、…、9（10个）

（3）非字母数字的可显示字符（33个）键盘可输入的字符。字符集的真题

1.C语言不能选用的字母是( ) A.w B.π C.I D.i

答案：B 2.转义字符

在C语言的字符集中，还有一些不可显示的字符，C语言使用所谓的―转义字符‖在程序中表示这些字符。转义字符由―反斜杠字符\\‖开始后跟单个字符或若干个字符组成。 \\n \\t \\v \\b \\r \\f 回车换行符号 Tab符号垂直制表符号左退一格符号回车符号换页符号 \\a \\\\\‘ \\\\ \\ddd \\xhh 响铃符号双引号单引号反斜杠 1～3位8进制数ddd对应的符号 1～2位16进制数hh对应的符号转义字符的有关真题

1.下列不正确的转义字符是( )

A. ′\\\\′ B. ′\\″ C. ′\\086′ D. ′\\0′ 答案：C

2. 下列转义字符中错误的是( ) A′\\000′ B. ′\\14′ C. ′\\x111′ D. ′\\2′ 答案：C 3.保留字 auto break case char continue const default do double else enum 自动中止情况字符继续常量缺省做双否则枚举 extern float for goto int if long register return short signed 外部浮点对于转向整如果长寄存器返回短带符号 sizeof static struct switch typedef union unsigned void volatile while 计算字节数静态结构开关类型定义共用无符号空可变的当说明：

1、所有的保留字均由小写字母组成的，一旦有一个字母大写，其不再是保留字原来的含义。 2、根据关键字的作用，可分其为数据类型关键字、控制语句关键字、存储类型关键字和其它关键字四类。

? 保留字的有关真题

? 1.下列标识符中，不是C语言保留字的是( )

? ? ? ?

char B.while C. min D.default 答案：C

2. 下列不属于C语言保留字的是( )

? char B.while ? C.typedef D.look ? 答案：D

? 3．表示空类型的保留字是。 ? 答案：void （注意一定小写）

? 数据类型关键字(12个)：char, double, enum, float, int, long, short,signed, struct, union, unsigned,

void

? 控制语句关键字(12个)：break, case, continue, default, do, else,for, goto, if, return, switch, while ? 存储类型关键字(4个)：auto, extern, register, static ? 其它关键字(4个)：const, sizeof, typedef, volatile 4.标识符

标识符是用户自定义的字符序列，比如符号常量名、变量名、数组名、函数名等。

Ｃ语言规定，标识符是由字母或下划线开头的字母、数字、下划线组成的字符序列。标识符中的字母是区分大小写的。标识符的有关真题

1. 正确的C语言用户自定义标识符是 ( )

A. print B. float C. when D. random 答案：A

2.可以用作C程序标识符的一组是（） A.print oodb aBc B.i\\am one-half 3pai

C.Pxq line# His.age D.Cpp while pow 答案：A

3.C语言标识符的第一个字符必须为下划线或者。答案：字母

C程序构成的特点：

(１)Ｃ程序是由若干个函数构成的。每个Ｃ程序有且仅有一个主函数，该主函数的函数名规定为main。

(２)每个函数（包括主函数）的定义分为两个部分：函数头和函数体。函数头：返回值的类型函数名(类型形式参数１，．．．) 函数体：{ 数据定义部分

实现函数功能的语句串 }

函数名后面的一对圆括号―()‖是用来写函数的参数的。参数可以有，也可以没有，但圆括号不能省略。

(３)Ｃ程序中的每个语句以―分号‖作为语句的结束，―分号‖是C语句的组成部分，不可以省略。 (４)用―/*‖和―*/‖括住的任意字符序列，称为―注释‖。源程序编译时，注释被忽略。

(５)Ｃ程序的书写格式很灵活，在一行上可以书写多个语句，一个语句也可以写在多行上。在程序清单的任何一处都可以插入空格符号或回车符号。但是，为了程序清单层次分明、便于阅读，通常都采用缩格并对齐的书写方法。

（6）Ｃ程序的执行总是从主函数开始，并在主函数中结束。主函数和其它函数的位置是任意的。其它函数总是通过函数调用语句被执行。

（7）主函数可以调用任何其它函数；任何其它函数都可以相互调用，但不能调用主函数。（8）C语言编译系统区分字母大小写。 C程序构成的真题

1.构成一个C程序的是( )

A.一个主函数和若干个非主函数 B.若干个主函数和若干个非主函数

C.一个主函数和最多一个非主函数 D.若干个主函数和最多一个非主函数答案：A

2．组成C语言程序的是（）

A.过程 B.函数 C.子程序 D.主程序和子程序答案：B

3.一个C程序一般由若干个函数构成，其中至少应包含一个函数。答案：主

4. C语言程序编译时，程序中的注释部分（） A.参加编译，并会出现在目标程序中 B.参加编译，但不会出现在目标程序中 C.不参加编译，但会出现在目标程序中 D.不参加编译，也不会出现在目标程序中答案：D

第三章基本数据类型、运算符和表达式 C语言数据类型及分类关系图

┌ 带符号整型 ┌ 带符号整型┼ 带符号短整型 │ └ 带符号长整型 ┌ 整型┤ ┌ 无符号整型 │ └ 无符号整型┼ 无符号短整型 │ └ 无符号长整型 ┌ 基本类型┤ ┌ 单精度型 │ ├ 实型┤

│ │ └ 双精度型 │ └ 字符型数据类型┤ ┌ 数组型 ├ 构造类型┤

│ └ 结构型 ├ 指针型

└ 空类型( void) C语言数据类型的真题

1.属于C语言基本数据类型的是( ) A.指针型 B.无符号整型 C.数组型 D.结构型答案：B 常量整型常量

在Ｃ语言中，整型常量有三种书写形式:

(１)十进制整数:由数字0-9和正负号表示。如:0、-111、+15、21等。（２）八进制整数(在前面0)。例如00、-0111、+015、021。

（３）十六进制整数(在前面0x)。例如 0x0 、-0x111、+0xff、0x2d。

整型常量在一般微型机中占用2个字节，数值范围都是十进制的-32768+32767。长整型常量（在整数的末尾字母―L‖）：长整型常量在计算机中占用4个字节。

10和10L是不同的整型常量，虽然它们有相同的数值，但它们在内存中占用不同数量的字节。常量的真题

1、C语言的长整型数值在计算机中占用的字节个数是( ) A.1 B.2 C.3 D.4 答案：D

2、在C语言中，整型常量的书写形式包括：八进制、十进制和进制。答案：十六实型常量

实型常量只使用十进制，它的书写形式有两种:

1、十进制数形式：(必须有小数点）如0.123, .123, 123.0, 0.0, 123. 2、指数形式：（e或E之前必须有数字；指数必须为整数）如: 12.3e3 ,123E2, 1.23e4 , e-5 , 1.2E-3.5 说明：

1、实型常量在一般的微型机中占用4个字节数。 2、实型常量有效数字是7位。实型常量的真题

1．C语言中，错误的int类型的常数是（）

A．1E5 B．0 C．037 D．0xaf 答案：A

2、在C语言中，一个双精度数-5.88在二进制文件里占用的字节数是。答案：8 字符常量

字符常量用两个单引号(‘)前后括住的单个字符来表示。例如，‘a‘、‘1‘、 ‘%‘ 、‘A‘、 ‘\\n‘、‘\\101‘。说明：

1、C语言规定，字母是区分大小写的。

2、在内存中，每个字符常量都占用一个字节，具体存放的是该字符对应的ASCII代码值。 3、在C语言中，一个字符常量也可以看成是―整型常量‖，其值就是该字符的ASCII代码值。例如，‘a‘ ，可以看作是97。

4、如果其值在0～127之间，整型常量也可以将其看成一个字符型常量.例如97,可以当成字符常量‘a‘来使用。字符常量真题

1. 设 char x =′a′；则printf(″x = ﹪c, y = ﹪c \\ n″，x，97)；的输出是（） A. x = a，y = 97 B. x = 97，y = a C. x = 97，y = 97 D. x = a，y = a 答案：D

2.设char a=?\\70‘；则变量a中（）

A.包含1个字符 B.包含2个字符 C.包含3个字符 D.是非法表示答案：A 字符串常量

字符串常量简称为―字符串‖。字符串就是用两个双引号（\）前后括住的一串字符。空字符串:没有字符的字符串称为―空字符串‖。例如，\。

字符串的长度:一个字符串中所有字符的个数称为该字符串的长度

例如，―‖的长度为0； ―ab12c‖ 的长度为5； \的长度为5

说明：1、空串与空格串是不同的。空串前者不含任何字符，长度为0；空格串是包含若干空格字符的字符串其长度为所含空格字符的个数。

2、每个字符串在内存中占用的字节数等于字符串的长度+1。其中最后一个字节存放的字符为―空字符‖，其值为0 ，书写时常用转义字符―\\0‖来表示，称为字符串结束标记。字符串常量真题

1.下列数据中，不是C语言常量的是( ) A. ′\\n′ B. ″a″ C. e-2 D. 012 答案：C

2.字符串″ABCD\\t\\\\\\123″的长度是。答案：7 符号常量

符号常量的定义方法如下: #define 符号常量常量【例】#define PI 3.14159 说明： 1、符号常量标识符的规则构成，建议用大写英文字母组成。其中的常量可以是任何类型的常量。 2、符号常量的定义一般放在程序的开头，每个定义必须独占一行，其后不跟分号。宏定义命令

宏定义命令的一般格式如下：#define 宏名一串符号说明：

1、其中的―#‖表示这是一条预处理命令。凡是以―#‖开头的均为预处理命令。―define‖为宏定义命令。 ―一串符号‖可以是常数、表达式、格式串等。

2、当对源程序清单进行编译之前，将把所有的―宏名‖替换成对应的―一串符号‖，切不可自行添加其它符号。

3、宏可以嵌套宏定义宏定义的真题

1.下列叙述中，正确的是（）

A.引用带参的宏时，实际参数的类型应与宏定义时的形式参数类型相一致 B.宏名必须用大写字母表示

C.宏替换不占用运行时间，只占编译时间

D.在程序的一行上可以出现多个有效的宏定义答案：C

2.在下列有关宏替换的叙述中，正确的说法是( ) A.宏替换占用运行时间 B.宏名有类型

C.带参数的宏替换和函数等价 D.宏替换只是字符替换答案：D

3.下列程序的运行结果是( ) # define A 5 # define B A+1 main( ) {int a;

a=B;

printf(″%d\\n″a--); }

A.6 B.5 C.4 D.出错答案：A 变量

变量的概念

在程序运行过程中，其值可以被改变的量称为变量。变量的四个要素

(1)变量名。每个变量都必须有一个名字──变量名，变量命名遵循标识符命名规则。 (2)变量值。在程序运行过程中，变量值存储在内存中。 (3)变量类型:int char float 等

(4)变量的存储类型：aoto register static exit 变量的数据类型及其定义数据类型数据类型符占用字节数数值范围整型短整型长整型无符号整型 int short long 2(或4) 2 4 同短整型(或长整型) -32768～+32767 (-215～215-1) -2147483648～+2147483647 (-231～231-1) 同无符号短整型(或长整型) 0～65535 (0～216-1) 0～4294967295 (0～232-1) -1038～1038（保留7位有效数字） -10308～10308（保留11位有效数字） -128～+127 unsigned [int] 2(或4) 无符号短整型 unsigned short 2 无符号长整型 unsigned long 4 单精度实型双精度实型字符型 float double char 4 8 1 有名常量的定义定义方法如下：

const 数据类型符变量名1=初值1,变量名2=初值1,...;

说明：有名常量的值是通过赋初值的方式获得，不能用赋值方式获得值。而且，获得初值后，程序中将不能改变其值。

【例】定义有名常量举例。

const char char_y=‘Y‘,char_n=‘N‘;

/* 定义字符型有名常量char_y和char_n，其值分别为字符Y和N */ 运算符

算术运算符 (+、-；+、-、*、/、%) 说明：

（1）除运算(/)和运算对象的数据类型有关。

例如，14/5=2 1/2=0 1/2.0=0.5 1.0/2=0.5。

（2）模运算(%)的对象必须是整型数据，结果是整除后的余数，运算结果的符号必须与被除数相同。例如，14%5=4 14%-5=4 -14%5=-4 -14%-5=-4。增１、减１运算符（++ --）

注意：增1、减1运算符的运算对象是变量，不能是常量或表达式。关系运算符（>=、>、<=、< ==、!=）和逻辑运算符（&& || !）说明：

（1）关系运算和逻辑运算的结果是整型数据0或1。（2）运算符的优先级如下:

! 优先于双目算术运算符优先于关系运算符优先于 && 优先于 ||

注意：用&&对两个表达式进行计算时，若第一个表达式的值为―假‖，则运算结果与第二个表达式的值无关，结果肯定为―假‖，所以Ｃ语言规定此时第二个表达式将不再计算。同样用||对两个表达式进行计算时，若第一个表达式的值为―真‖，则运算结果与第二个表达式的值无关，结果肯定为―真‖，所以Ｃ语言规定此时第二个表达式也不再计算。赋值运算符（=）

算术自反赋值运算符 (+= -= *= /= %=) 说明：

（1）算术自反赋值运算符和赋值运算符的优先级是相同的，只比逗号运算符高。（2）自反赋值运算符右边的表达式是自动加括号的。

【例】―c%=a-3‖不能理解为―c=c%a-3‖，应理解为―c=c%(a-3)‖。逗号运算符（,）说明：

（1）由逗号运算符组成的式子也是表达式,其值等于右边表达式的值。（2）任何运算符都优先于号运算符。条件运算符（？：）说明：

（1）条件运算符是唯一的三目运算符。

（2）条件运算符的优先级：优先于赋值、算术自反赋值运算符逗号运算符（排倒数第三）长度运算符（sizeof()）

【例】设变量定义如下：int n; 表达式sizeof(n)的值是2。表达式sizeof(long)的值是4。位运算符（~ & | ^）

位运算的对象只能是整型数据（包括字符型）。运算结果仍是整型数据。 a 0 0 1 1 b 0 1 0 1 a&b 0 0 0 1 a|b 0 1 1 1 a^b 0 1 1 0 位移位运算符 ( << 左移， >> 右移)

运算符真题

1.下列表达式的值为0的是（）

A. 3﹪5 B. 3/5.0 C. 3/5 D. 3<5 答案：C

2.设int a = 3；则表达式a<1&& - - a>1的运算结果和a的值分别是（）

A. 0和2 B. 0和3 C. 1和2 D. 1和3 答案：B

3.设 int m1=5,m2=3；表达式m1>m2?(m1=1):(m2=-1)运算后，m1和m2 的值分别是( )

A.1和-1 B.1和3 C.5和-1 D.5和3 答案：B

4.设float m=4.0,n=4.0;使m为10.0的表达式是( )

A.m-=n*2.5 B.m/=n+9 C.m*=n-6 D.m+=n+2 答案：D

5.表达式5&2||5|2的值是( ) A.0 B.1 C.2 D.3 答案：B

6.设int x=-1;执行表达式++x||++x||++x后，x的值是( )

A.0 B.1 C.2 D.3 答案：B

7.设int x;则执行printf(″%x\\n″,~x^x)；的结果是( ) A.0 B.1 C.ff D.ffff 答案：D

8.C语言中计算a3正确的表达是( )

A.a^3 B.pow(a,3) C.a**3 D.power(a,3) 答案：B

9．不用第三个变量，将变量a和b的值进行互换的操作是（） A.a+=b;b-=a;a-=b; B.a+=b;b=a-b;a-=b; C.b-=a;a-=b;a-=b; D.b-=a;a=b-a;a+=b; 答案：B 10．设int a=1,b=2,c=4;经过表达式（c=a!=b）&&(a= =b)&&(c=b)运算后，a、b和c的值分别是（A.1，2，0 B.1，2，1 C.1，2，2 D.1，2，3

）

答案：B

11.若定义了int a，x，y；，则下列语句中不正确的是( ) A. x=3，y=5； B. ++x； C. x=y+=x*30； D. a=y+x=30；答案：D

12.若定义了x=100；，则表达式x++>100?x+20：x+10的值是( ) A.110 B.111 C.120 D.121 答案：B

13. 执行语句printf(″%x″, -1)；后输出结果是( ) A. -1 B. –ffff C. 1 D. ffff 答案：D

14. 设float a=2, b=4, c=3；，以下C语言表达式与代数式1/2(a+b)c计算结果不一致的是( ) A. (a+b)*c/2 B. (1/2)*(a+b)*c C. (a+b)*c*1/2 D. c/2*(a+b) 答案：B

15. 设int a=10, b=20, c=30;条件表达式a

16. 在位运算中，操作数左移一位，其结果相当于操作数( ) A. 乘以2 B. 除以2 C. 乘以4 D. 除以4 答案：A

1.初始化值是0.618的双精度变量a的定义形式为__________。答案：double a=0.618;

2.表达式 !10! = 1的值是___________。答案：1

3.―2020&&x<=30

4.表达式a=1，a+1，a++ 的值是___________________。答案：1

5.利用运算符--，下列两个语句 b=5+a;a-=1; 的功能可以仅由一个语句实现，这个语句是________。答案：b=5+a--

6.―n是小于整数m的偶数‖的C语言表达式是________。答案 n

7.设int y;执行表达式(y=4)||(y=5)||(y=6)后，y的值是______。答案：4

8.设char ch=′A′;则printf(″%c″,(ch>=′A′&&ch<=′Z′)?ch+32:ch);的值是_____。答案：a

9．设int a, b, c;则执行a=(b=3, c=5, b=10);后变量a的值是__________。答案：10

10.表达式10＜＜3+1的值是。答案：160

11.若定义了int a=1；，则执行printf(″％d\\n″,((a=a+4,a+5),a+6))；语句的输出结果是。答案：11

12. 设int x=2, y=1；则表达式x+++y的值是__________。答案：3

变量赋值及表达式计算时的数据类型转换规则 1、表达式计算中数据类型的自动转换规则

2.运算结果存入变量时数据类型的自动转换规则

先将运算结果的数据类型自动转换成左边变量的数据类型，然后再赋予该变量。 3.运算结果的强制性数据类型转换规则命令格式: (数据类型符)(表达式) 说明：

当被转换的表达式是一个简单表达式时，外面的一对圆括号可以缺省。

强制转换类型得到的是一个所需类型的中间量，原表达式类型并不发生变化。第四章顺序结构、选择结构和循环结构的程序设计字符输入／输出函数

1.字符输入函数getchar()

【功能】从键盘读取单个字符。 2.字符输出函数putchar(ch)

【功能】将参数ch对应的字符输出到显示器上。

注意：若程序中用到上面两个函数，则在程序的开头加 ―#include ―stdio.h‖‖。格式输入／输出函数 1.格式输入函数

【格式】scanf(输入格式字符串,输入变量地址表) 输入格式字符串格式字符 %md %mo %mx %mld %mlo %mlx %mf %me %mlf %mle double float long unsigned long 数据对象的类型输入形式 int short unsigned int unsigned short 十进制整数八进制整数十六进制整数十进制整数八进制整数十六进制整数十进制实数十进制指数十进制实数十进制指数无m 按实际位数输入有m 输入m位,不足m位则跟回车换行键数据输入方法 %mc %ms char 字符串单个字符字符串无m 仅取单个字符有m 输入m位,仅取第一个字符无m 取若干字符直到回车或空格为止有m 仅取前m个字符 2.格式输出函数

【格式】printf(输出格式字符串,输出表达式表)

【功能】先按照自右向左的顺序，依次计算―输出表达式表‖中诸表达式的值。然后按照―输出格式字符串‖中规定的格式顺序，将各个表达式值输出到显示器上显示。格式字符数据对象的类型输出形式数据输出方法 %-md int 十进制整数 %-mo short 八进制整数 %-mx unsigned int 无m 按实际位数输出有m 输出m位 %-mu unsigned short 十六进制整数 char 无符号整数超过m位,按实际位数输出 %-mld 十进制整数不足m位,则用空格补足m位 %-mlo long 八进制整数无-号右对齐(左补空格) %-mlx unsigned long 十六进制整数有-号左对齐(右补空格) %-mlu 无符号整数 %-m.nf 十进制小数无m.n 按实际位数输出 %-m.ne 十进制指数有m.n 输出n位小数,总宽度为m float 超过m位,按实际位数输出 double %g 自动选取f或e中不足m位,用空格补足m位宽度较小的格式无-号右对齐(左补空格) 有-号左对齐(右补空格) 无m 输出单个字符 %-mc char int short 单个字符有m 输出m位, 单个字符和m-1个空格无-号右对齐(左补空格) 有-号左对齐(右补空格) 无m.n 按实际字符数输出全部字符 %-m.ns 字符串一串字符有m.n 仅输出前n个字符,补m-n个空格无-号右对齐(左补空格) 有-号左对齐(右补空格) 输入输出函数真题

1.设int a=7,b=8;则printf(″%d,%d″,(a+b,a),(b,a+b));的输出是( ) A.7，15 B.8，15 C.15，7 D.出错答案：A

2.若定义了unsigned short a=32768；，则执行printf(″a=％d″，a)；语句的输出结果是 ( A. a=-32768 B. a=-1 C. a=32768 D.数据类型不一致，出错答案：A

3. 使用语句scanf(″a=%f, b=%f″, &a, &b) 输入变量a、b的值(□代表空格)，正确的是 ( A. 1.25，2.4 B. 1.25□2.4 C. a=1.25, b=2.4 D. a=1.25□b=2.4 答案：C

) ) 4．设int k=-1；执行printf(″%u″,k)；后输出的值是。答案：65535

5.写出程序的输出结果 main()

{ int a =10,i=1,j=2;

printf(″%d,%o,%x\\n″,a,a,a); printf(″i=%d\\n″,i++);

printf(″%c\\n″,i==j?′A′:′B′); }

答案：10，12，A i=1 A

结构化程序设计方法

结构化程序设计的三种基本结构是：顺序结构、选择结构和循环结构

单分支选择结构: if （表达式）语句；双分支选择结构: if （表达式）语句１；

选择结构 else 语句２；多分支选择结构

使用if语句嵌套实使用switch语句

注意:在设计嵌套的―if语句‖和―if-else语句‖时，要特别注意else是和其前面出现的哪个if配对。【例】 if (c>=‘0‘&&c<=‘9‘) if (c==‘5‘) y=0; else y=1;

多分支结构的switch语句

【格式】switch （表达式）

{ case 常量表达式１：语句组１；break； case 常量表达式２：语句组２；break；．．．

case 常量表达式ｎ：语句组ｎ；break； default：语句组ｎ+１； } 说明：

（1）表达式常用的是字符型或整型表达式。

（2）常量表达式是由常量或符号常量组成的表达式，所有常量表达式值必须互不相同。

（3）break在switch语句中的作用是：执行完某个语句组后，将退出该switch语句。如果省略了break语句，则执行完某个语句组后，将连续执行其后的所有语句组。

（4）default及其后的语句组可以省略。省略时，若表达式的值和n个常量表达式值均不相同，则该语句什么也不做。选择结构真题

1. 与语句if(a>b)if(c>d)x = 1；else x = 2；等价的是( ) A. if(a>b){if(c>d) x = 1；else x = 2；} B. if(a>b){if(c>d) x = 1；} else x = 2； C. if((a>b) && (c>d)) x = 1；else x = 2； D. if(a< =b) x = 2；else if (c>d) x = 1；答案：A

2.执行下列语句 int a=8,b=7,c=6;

if(ac){a=c;c=b;} printf(″%d,%d,%d\\n″,a,b,c); 后输出的结果是( )

A.6，7，7 B.6，7，8 C.8，7，6 D.8，7，8 答案：C

3．下列程序段运行后，x的值是（） a=1;b=2;x=0; if(!(--a))x--;

if(!b)x=7;else ++x;

A.0 B.3 C.6 D.7 答案：A

4．设int x=1,a=9,b=6,c=7,d=8;则执行语句：

if(a>b) if(c>d)x=2;else x=3;后，x的值是（） A.1 B.2 C.3 D.不确定答案：C

5. 写出程序的运行结果 # include ″stdio.h″ main() {char c；

c = getchar()；

if(c> =′a′&&c< =′z′) ‖c> =′X′&&c< =′Z′)c = c - 23； printf(″﹪c \\ n″，c)； }

设从键盘上输入Next 答案：N

6. 写出程序的运行结果 main ( ) { int x=16, y=21, z=0; switch (x%3) {case 0: z++; break; case 1: z++; switch (y%2) {default: z++; case 0: z++; break; }

} printf (″%d\\n″, z); } 答案：3

7. 输入一字符串(换行为结束标志)统计其中数字(0，1，2，…，9不单独统计)、空白和其它字符出现的次数。

# include ″stdio.h″ main() { char c；

int ___________________________； while((c = getchar())! =′\\ n′)

{ if(__________________________)digit + + ； else if(c = =′′‖c = =′\\ t′) ++ blank； else __________________________； }

printf(″digit =﹪d,blank =﹪d,other =﹪d \\ n″,digit,blank,other)； }

答案： digit,blank,other c>=0&&c<=9 other++ 循环结构

循环结构当型循环结构: while （表达式）直到型循环结构: do 语句；

次数型循环结构: for （表达式１；表达式２；表达式３）语句；

注意：

1．do while 循环至少执行1次。

2．for语句主要用来实现次数型循环结构。

（１）表达式１、2、3都可以是任何类型的，都可以省略。但两个分号不可以省略。（２）表达式２省略时，一定是―死循环‖。 break语句和continue语句 1. break语句

【功能】强制结束当前的循环，不再执行循环体中break后面的语句。 2.continue语句

【功能】跳过continue之后的语句，重新判断循环控制条件，决定是否继续循环。多重循环结构的实现

设计多重循环结构时，要注意内层循环语句必须完整地包含在外层循环的循环体中，不得出现

内外层循环体交叉现象。但是允许在外层循环体中包含多个并列的循环语句。 1.对于do-while语句，错误的说法是( ) A.先执行循环体后判断循环条件 B.循环体至少要执行一次 C.循环体有可能一次也不执行 D.循环体中可以包含若干条语句答案：C

2．对do-whie语言错误的说法是（） A.可构成多重循环结构 B.循环次数不可能为0 C.循环次数可能为0 D.先执行后判断答案：C

3.执行语句for(i=1;i++<4;)；后i的值是( )

A. 3 B. 4 C. 5 D. 不确定答案：B

4.设int i = 5；则循环语句while (i > = 1) i - -；执行后，i的值为_______________。答案：0

5.语句for(i=1;i==1;i++);循环的次数是________。答案：1

6．设for(k=0;k<0;k++)++k;则该循环共执行次。答案：0

7.在执行循环结构或switch结构时，能够立即退出该结构的语句是__________。答案：break

8.写出程序的执行结果 main( ) {

int s=0,i; for(i=1;;i++) {

if(s>50)break; if(i%2==0) s+=i; }

printf(″i=%d,s=%d\\n″,i,s); }

答案：i=15,s=56 9.下列程序 int x=3;

do{printf(″%d″,--x);}while(!x); 循环执行的次数是______。答案：1

10.写出程序的执行结果 main( ) ｛ int i；

for(i=0；i<5；i++) switch(i％2)

｛case 0：printf(″1″)；break； case 1：printf(″0″)；｝｝

答案：10101

11. /*设从键盘输入：420<回车> */ #include main( ) { char c;

while ((c=getchar( ) )!=′\\n′) switch(c-′0′) { case 0:

case 1:putchar(c+2);

case 2:putchar(c+3);break; case 3:putchar(c+4);

default:putchar(c+1);break; }

printf(″\\n″); }

答案：5523

12．将一个十进制整数n转变为二进制数。 main( )

{ int i=0,j,n,num[20];

scanf(″%d″, ); /*第一空*/ while(n!=0)

{ num[i++]= ; /*第二空*/ n= ; /*第三空*/ }

for(j=i-1;j>=0;j--)printf(″%d″,num [j]); }

答案：&n n%2 n/2

13. 一个三位整数(100～999)，若各位数的立方和等于该数自身，则称其为―水仙花数‖(如：153=13+53+33), 找出所有的这种数。 main( )

{int n, a, b, c;/*n、a、b和c分别为三位数自身及其个位、十位和百位 */ for(c=1;c<=9;c++) for (b=0; b<=9;b++)

for(______;a++) /*第一空*/ { n=_________; /*第二空*/

if(a*a*a+b*b*b+c*c*c==_________) /*第三空*/ printf(″%d\\n″, n); } }

答案：a=0;a<=9

c*100+b*10+a n

第五章数组一维数组

一维数组的定义格式：

数据类型符数组名1[长度1],数组名2[长度2],...;

说明：长度即数组长度，是一个―整型常量表达式‖，通常是一个整型常量，表示元素的个数。常量表达式中可以包括常量和符号常量，不能包含变量。一维数组元素的引用方法：数组名[下标] 说明：

（1）―下标‖是一个整型表达式，其合法值的范围是0～长度-1。

（2）在C语言中，数组作为一个整体，不能参加数据运算，只能对单个的元素进行处理。（3）当定义了某个一维数组，则要给其所有的元素分配内存单元。单元数目＝数组长度×每个元素占用的字节数，而且，这些内存单元是连续的。并按照元素顺序依次排列。 (4)C语言还规定，数组名是数组的首地址。即a=&a[0] 一维数组

一维数组的初始化说明：

（1）对数组所有元素赋初值，此时数组定义中数组长度可以省略。例如：int a[5]={1,2,3,4,5};或int a[]={1,2,3,4,5}; （2）对数组部分元素赋初值，此时数组长度不能省略。例如：int a[5]={1,2}；

a[0]=1,a[1]=2,其余元素为编译系统指定的默认值0。例如：char c[5]={?a‘,‘b‘}；

c[0]=‘a‘,c[1]=‘b‘,其余元素为编译系统指定的默认值‘\\0‘。（3）对数组的所有元素赋初值0。例如：int a[5]={0}；

注意：如果不进行初始化，如定义int a[5]；那么数组元素的值是随机的，不要指望编译系统为你设置为默认值0。

（4）static int a[5] 不进行初始化，编译系统为你将所有元素设置为默认值0。 static char s[5] 不进行初始化，编译系统为你将所有元素设置为默认值?\\0‘。一维数组真题

1.设char str[100]；int i = 5；则引用数组元素的错误形式是（） A. str[i + 10] B. *(str + i)

C. *(str + i - 1) D. ((str + + ) + i) 答案：D

2.设int a［10］;则对a数组元素的错误引用是( ) A.a［5］ B.*(a+1) C.a［10-10］ D.a(5) 答案：D

3．初始化一维数组a正确的语句是（） A.int a[10]=(0,0,0,0,0); C.int a[ ]={10}; 答案：C

4.在C语言中，数组名除名字的功能之外还代表数组的_______。答案：数组首地址 5. 写出程序的运行结果 # define N 7 main()

{int i，j，temp，a[N]={1，2，3，4，5，6，7}； for(i = 0；i

temp = a[i]；a[i]=a[j]；a[j]=temp； }

for(i = 0；i

答案： 7 6 5 4 3 2 1

6. 下列程序的功能是：统计从键盘输入的字符（$作为结束）中每个小写英文字母出现的个数，n[0]、n[1]、???、n[25]分别存放小写字母a、b、???、z。并输出统计结果。 #include″stdio.h″ main( )

{int n[26]={0},k,char c;

while(( )!= ′$′) /*第一空*/ if(c>=′a′&&c<=′z′)

n[c ]+=1; /*第二空*/ for(k=0; ;k++) /*第三空*/ printf(″％c:％d\\n″,k+′a′,n[k] ); }

答案：c=getchar( ) -’a’ k<26

B.int a[10]={ }; D.int a[10]={[10*1]};

7. 先为数组a输满数据，再为x输入一个数据，在数组a中找出第一个与x相等的元素并将其下标输出，若不存在这样的元素，则输出―Not found!‖标志。 main()

{int i，x，a[10]；

for(i = 0；i<10；i ++ )scanf(″﹪d″,___________)； scanf(″﹪d″,&x)；printf(″﹪d″,x)；

for(i = 0；i<10；i ++) if(_________________)break； if (i _________10)printf(″ position:﹪d \\ n″,i)； else printf(″ Not found! \\ n″，x)； } 答案：&a[i] a[i]==x <

8. 将十个整数输入数组，求出其平均值并输出。 main( )

{int i,a[10],sum=0,*p=______; /*第一空*/ for(i=0;i<10;i++) { scanf(″%d″,p++);

sum+=______; /*第二空*/ printf(″%8.2f\\n″,______); /*第三空*/ } 答案：a

a[i]或p[i]或*(a+i)或*(p+i) sum/10.0 二维数组二维数组的定义

【格式】数据类型数组名[行长度][列长度],...; 二维数组元素的引用数组名[行下标][列下标] 说明：

(1)二维数组的存放规律是―按行排列‖，即先顺序存放第一行的元素，再存放第二行，以此类推。（2）一个二维数组可以看成若干个一维数组。二维数组a[3][4]理解为：有三个元素a[0]、a[1]、a[2]，每一个元素是一个包含4个元素的数组。二维数组的初始化

(1)分行给二维数组所有元素赋初值。例如：int a[2][3]={{1,2,3},{4,5,6}}; (2)不分行给多维数组所有元素赋初值。

例如：int a[2][3]={1,2,3,4,5,6}

(3)只对每行的前若干个元素赋初值，此时所有未赋初值的数组元素均获得零值（对整型数组是0；对实型数组是0.0；对字符型数组是‘\\0‘）。例如：int a[2][3]={{1},{4,5}};

(4)只对前若干行的前若干个元素赋初值，此时所有未赋初值的数组元素均获得零值。例如：char a[2][3]={{‘1‘,‘2‘}};

（5）若给所有元素赋初值，行长度可以省略。例如：float a[][3]={{1,2,3},{4,5,6}}; float a[][3]={1,2,3,4,5,6};

注意:允许给出的初值不是列长度的整数倍。此时，行长度＝初值个数整除列长度后再加1。则省略的行长度＝7/3+1=2+1=3。例如：float a[][3]={1,2,3,4,5,6,7};

（6）若分行给所有行的前若干个元素赋初值，行长度可以省略。例如：float a[][3]={{1},{2,3}};

结果：自动认为数组a[][3]的行长度是２。（7）对数组的所有元素赋初值0。例如：int a[5][6]={0}；

注意：如果不进行初始化，如定义int a[5][6]；那么数组元素的值是随机的，不要指望编译系统为你设置为默认值0。

（8）static int a[5][6]不进行初始化，系统将所有元素设置为0。 static char s[5][6]不进行初始化，系统将所有元素设置为?\\0‘。

二维数组真题

1.设int a[][4]={1，2，3，4，5，6，7，8，9}；则数组a的第一维的大小是（） A. 2 B. 3 C. 4 D. 无确定值答案：B 2. 执行下列程序

int a[3][3]={{1}，{2}，{3}}； int b[3][3]={1，2，3}； main()

{printf(″﹪d \\ n″，a[1][0] + b[0][0])；} 后输出的结果是 ( ) A. 0 B. 1 C. 2 D. 3 答案：D

3.设int a[2][3] = {{2}，{3}}；则数组元素_____________的值为3。答案：a[1][0]

4. 设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]); 的输出结果是( )

A.147 B.159 C.357 答案：C

5.设short a[３][４]；如果数组a首地址为2000，则a+1的地址是。答案：2002

6.在C语言中，一个二维数组可以看成若干个______数组。答案：一维

7. 设int a[2][3]=｛ 1, 2, 3, 4, 5, 6};则数组元素a[1][0]的值是__________。答案：4 8. main( )

｛int a[3][3]=｛1，4，17，3，6，19，2，5，18｝，i，s=0； for (i=0；i<=2；i++) s=s+a[i][2-i]； printf(″s=％d\\n″，s)；｝答案：25

字符数组与字符串字符数组

字符数组的定义： char 数组名[长度]={初值表}

D.369

字符数组赋字符串初值【例】 char s1[4]={‖123‖};

char s2[]={‖123‖}; /*省略的数组长度为4*/ char s3[4]=‖123‖; char s4[]=‖123‖;

char s5[4]={?1‘,‘2‘,‘3‘,‘\\0‘}; char s6[]={?1‘,‘2‘,‘3‘,‘\\0‘}; char s7[4]={?1‘,‘2‘,‘3‘ }; 以上七种的赋值结果都是：

字符串处理的常用系统函数

1、字符串输出函数 puts(字符数组）

【功能】输出字符数组中存放的字符串，其中结束标记转换成回车换行符输出。 2、字符串输入函数 gets(字符数组）

【功能】从键盘接受一个字符串（仅以回车换行符为结束标记），存入指定的字符数组中。 3、测试字符串长度函数 strlen(字符串）

【功能】测试指定字符串的长度（除字符串结束标记外的所有字符的个数）。 4、字符串复制函数 strcpy(字符数组,字符串,整型表达式）

【功能】将―字符串‖的前―整型表达式‖个字符组成新的字符串存入―字符数组‖中。若省略―整型表达式‖，则将整个―字符串‖存入字符数组中。 5、字符串比较函数 strcmp(字符串１,字符串２）

【功能】若―字符串１‖小于―字符串２‖，函数返回值为小于0的整数；若―字符串１‖等于―字符串２‖，函数返回值为0；

若―字符串１‖大于―字符串２‖，函数返回值为大于0的整数。 6、字符串连接函数 strcat(字符数组,字符串)

【功能】把―字符串‖连接到―字符数组‖中字符串的最后一个有效字符的后面，组成新的字符串存回―字符数组‖中。

注意：上述前2个函数，应在程序的开头写上命令―#include ‖;后4个函数，应在程序的开头写上命令―#include ‖。字符数组与字符串

【例】用二维数组存放多个字符串 char s4[3][4]={‖123‖,‖AB‖,‖x‖}; 结果： 0

0 ?1‘ 1 ?2‘ 2 ?3‘ 3 ?\\0‘ 1 ?A‘ ?B‘ ?\\0‘ ?\\0‘ 2

?X‘ ?\\0‘ ?\\0‘ ?\\0‘ 字符串的输入输出

逐个字符I/O： %c 整个字符串I/O： %s

1.设char c［5］={′a′,′b′,′\\0′,′c′,′\\0′};则printf(″%s″,c)的输出是( ) A.′a′′b′ B.ab C.abc D.″ab\\0c″ 答案：B

2.设static char x[ ]=″12345″,y[ ]={′1′,′2′,′3′,′4′,′5′,′\\0′}；那么( ) A.x数组的长度等于y数组的长度 B.x数组的长度大于y数组的长度 C.x数组的长度小于y数组的长度 D.x数组与y数组的存储区域相同答案：A

3.执行printf(″％d\\n″，strlen(″t\\″066\\xee\\n″))；语句的输出结果是( A.7 B.12 C.13

D.输出项不合法，无正常输出答案：A

4.字符数组s不能作为字符串使用的是（） A.char s[ ]=＂happy＂; B.char s[ ]={＂happy＂};

C.char s[6]={＇h＇,＇a＇,＇p＇,＇p＇,＇y＇}; D.char s[4]={＇h＇,＇a＇,＇p＇,＇p＇,＇y＇}; 答案：D

5.连接两个字符串的系统函数名是___________________。答案：strcat( )

6.设char string[] =″This_is_a_book!″；则数组的长度应是_________。答案：16

7.# include main( ) { int i=0;

char c,s[]=″SABC″; while(c=s[i]) { switch(c)

)

{

case ′A′:i++;break; case ′B′:++i;

default:putchar(c);i++; }

putchar(′*′); } } 答案：S**B*

8.从键盘输入一个字符串，判断其是否是回文。若是输出―Yes‖，否则输出―No‖。回文是指正向、反向的拼写都一样。例如：ABCBA、aaaa等是回文；china、ABC等不是回文。 #include ″stdio.h″ main( )

｛char string［80］； int i，j，n； gets (string)；

n= ； /*第一空*/ j=n-1；

for (i=0；i

if (string ［i］!=string［j］) ；/*第二空*/ if( )printf(″Yes\\n″)； /*第三空*/ else printf (″No\\n″)；｝

答案：strlen(string) break i>=j 第六章指针指针和指针变量指针变量的定义和初始化

格式：数据类型符 *指针变量名1[=初值1],...; 取地址运算符&与指针运算符*

【例】设有数据定义语句：float a,*p=&a; 则：*&a是正确的。相当于―*(&a)‖，代表变量a。 *&p是正确的。相当于―*(&p)‖，代表p。

&*p是正确的。相当于―&(*p)‖，代表a的地址。

&*a是错误的。相当于―&(*a)‖，因为a不是指针变量，所以*a不正确。指向变量的指针变量的使用

1.给指针变量赋值

格式：指针变量＝地址表达式

注意：不能把一个整数赋给pa,也不能把pa的值赋给整型变量。 2.引用所指向的变量格式： *指针变量

1.设int a,*p；则语句p=&a;中的运算符―&‖的含义是( ) A.位与运算 B.逻辑与运算 C.取指针内容 D.取变量地址答案：D 2.main( )

｛ int x=20，y=40，*p； p=&x；printf(″％d，″,*p)； *p=x+10；

p=&y；printf(″％d\\n″，*p)； *p=y+20；

printf(″％d，％d\\n″，x，y)；｝答案：20，40 30，60

指向一维数组的指针变量的使用

指针变量指向一维数组的方法：

方法一：在数据定义语句中用赋初值的方式 *指针变量=数组名例：short a[10],*pa=a;

方法二：在程序中用赋值方式指针变量=数组名例：short a[10] ,*pa; pa=a;

指针变量指向某一维数组元素的方法：

方法一：在数据定义语句中用赋初值的方式 *指针变量=&数组名[下标] 例：short a[10],*pa=&a[3];

方法二：在程序中用赋值方式指针变量=&数组名[下标] 例：short a[10],*pa; pa=&a[3];

用指向一维数组的指针变量处理数组元素

当指针变量指向一维数组后，对下标为i的数组元素引用一共有下列四种方法：*(数组名+i) 指针变量[i] 数组名[i]

*(指针变量+i) 例：short a[10],*p=a;

a[i] p[i] *(p+i) *(a+i) 指向一维数组的指针变量的运算 (1)指针变量和整数的算术运算运算规则如下：

指针变量+整数指针变量-整数 ++指针变量 --指针变量指针变量++ 指针变量-- (2)指针变量和指针变量的减法运算

指针变量1－指针变量2 结果为它们所指向的数组元素下标相差的整数 (3)指针变量的关系运算

指针变量1 关系运算符指针变量2

1.设int x[] = {1，2，3，4，5，6}，*p=x；则值为3的表达式是（） A. p+=2, *++p B. p+=2, *p++ C. p+=3, *p D. p+=2, ++*p 答案：B

2.设int b[ ]={1,2,3,4}，y,*p=b;则执行语句y=*p++；之后，变量y的值为( ) A.1 B.2 C.3 D.4

答案：A

3.设int a[10],*p=a；则对数组元素的正确引用是（） A.a[p] B.p[a] C.*(p+2) D.p+2 答案：C

4.设int x［］={1, 2, 3, 4, 5, 6, 7, 8, 9, 0}, *p=x, k;且0≤k<10, 则对数组元素x［k］的错误引用是( A. p+k B. *(x+k) C. x［p-x+k］ D. *(&x［k］) 答案：A

指向字符串的指针变量的使用 1.如何将指针变量指向字符串常量

方法一：在数据定义语句中用赋初值的方式 *指针变量=字符串常量例如 char *p=\

方法二：在程序中用赋值的方式指针变量=字符串常量例如 char *p; p=\

说明: 不允许将字符串常量用赋值方式赋予字符型数组。 char a[10];

a=‖abcd‖; /* 这个语句出错 */ 2.指向字符串常量的指针变量的使用 (1)处理整个字符串

) 输出字符串 printf(\指针变量); 输入新的字符串代替原字符串 scanf(\指针变量); (2)处理字符串中的单个字符

第i个字符的表示方法 *(指针变量+i) 3.指向存放字符串的字符数组的指针变量的使用

处理方法和前面介绍的处理一维数组元素的方法完全相同，唯一需要注意的是，数组元素的类型是字符型。

1.设char *s=″china″;则printf(″%s,%c,%c\\n″,s,*s,s［3］);的输出是( ) A.china, c,n B.china,china,i C.c,c,n D.china,china,n 答案：A

2.若定义了char ch［］=｛″abc\\0def″｝，*p=ch；则执行printf(″%c″,*p+4)；语句的输出结果是( ) A. def 答案：C

3. 设char s［10］, *p=s;, 下列语句中错误的是( ) A. p=s+5； B. s=p+s； C. s［2］=p［4］; D. *p=s［0］；答案：B

4. 下列错误的是( ) A. char s［］=″China″; B. char s［10］={″China″}; C. char s［10］; s=″China″; D. char s［10］={′C′,′h′,′i′, n′,′a′}; 答案：C

5. 若定义了int a［10］，*p；，将数组元素a［8］的地址赋给指针变量p的赋值语句是。答案：p=&a[8] 6. 已知程序段：

char *p=″abcdefgh″;p+=4; printf(″%c\\n″,*p++); 运行结果为。答案：e

7. 写出程序的运行结果 main()

{ int k; char a［］=″LANGUAGE″,b［］=″PROGRAM″; char *p=a,*q=b; for(k=0;k<=5;k++)

if(*(p+k)==*(q+k)) printf(″%c″,*(q+k));

B. d C. e

D. 0

} 答案：GA 指针数组

指针数组的定义

格式:数据类型 *指针数组名 [长度],... 【例】int *p[3];

定义了一个名为p、用来指向整型数据的指针型数组，有3个元素：p[0]、p[1]、p[2]。指针数组元素的使用

1.对其赋值指针数组名[下标]＝地址表达式 2.引用所指向的变量或数组元素 *指针数组名[下标] 参加运算（算术运算）指针数组名[下标]＋整数指针数组名[下标]－整数 ++指针数组名[下标] --指针数组名[下标] 指针数组名[下标]++ 指针数组名[下标]--

（关系运算）指针数组名[下标1] 关系运算符指针数组名[下标2] 1.设double * p［6］;则( ) A.p是指向double型变量的指针 B.p是double型数组

C.p是指针数组，其元素是指向double型变量的指针 D.p是数组指针，指向double型数组答案：C

2. 执行下列程序段，则结果是（）。 int a[]={1,2,3,4,5},*b[2]; b[0]=a+1,b[1]=a+2; printf(‖%d,%d‖,*b[0],*b[1]);

A. 语句错误 B. 1,2 C. 1,3 D. 2,3 答案：D

3.阅读下列程序，写出程序运行的输出结果。 void main()

{ char *a[6]={‖AB‖,‖CD‖,‖EF‖,‖GH‖,‖IJ‖,‖KL‖}; int i;

for (i=0;i<4;i++) printf(‖%s‖,a[i]); printf(‖\\n‖); }

答案：ABCDEFGH

【说明】puts()函数和使用―%s‖格式的printf()函数都可以输出字符串，但输出时有区别：对于printf()函数，―字符串结束标记符‖不输出；对于puts()函数，―字符串结束标记符‖转换成―回车换行符‖输出。

第七章函数

函数的概念和模块化程序设计方法函数的概念

函数是一个可以反复使用的程序段，从其它的程序段中均可以通过函数调用语句来执行这段程序，完成既定的功能。 C语言中的函数的分类 (1)从定义的角度来分

用户函数：程序设计人员在程序中自己定义的函数。系统函数：Ｃ语言自身定义好的函数。（2）从形式上来分

有参函数：定义函数时有参数的函数。无参函数。定义函数时无参数的函数。（3）从返回值的角度来分

有返回值函数：调用后将回带一个值的函数无返回值函数：调用后不回带值的函数。（4）从函数起作用的范围来分

外部函数：可以被任何编译单位调用的内部函数：只能在本编译单位中被调用函数的定义

1.函数的一般定义格式

存储类型符数据类型符函数名（形式参数表） { 数据定义语句序列；执行语句序列； } 存储类型符

extern 定义的函数叫做外部函数，它可以被其它编译单位中的函数调用。 static 定义的的函数叫做内部函数，它只能被本编译单位中的函数调用存储类型说明符可以省略，省略时，默认为外部函数。数据类型符规定了本函数返回值的数据类型。

注意：

（1）当函数返回值是整型或字符型时，数据类型符可以省略。（2）数据类型符是―void‖，它表示本函数是无返回值的。函数的定义形式参数表

格式：数据类型符形式参数1, 数据类型符形式参数2,... 注意：

（1）max(int x,int y) { …… }不能写成max(int x,y) { …… } 但可以写成：max(x, y) int x,y; { …… }

（2）当形式参数是数组时，一维数组的长度、二维数组的行长度可以省略。 1.下面函数定义有错误的是( ) A.f1(x1,x2) B.f1(x1,x2) int x1,x2; int x1;int x2; {函数体} {函数体} C.f1(int x1,x2) D.f1(int x1,int x2) {函数体} {函数体} 答案：C 函数的调用

1．函数调用的一般格式

（1）表达式方式：函数名(实际参数表) 作为表达式的一部分只有有返回值的函数才能用这种格式调用。例：y=x+max3(x1,x2,x3); （2）语句方式：函数名(实际参数表);

无返回值的函数通常用这种方式调用，但是，有返回值的函数也可以使用这种形式调用，此时，函数仍然有返回值，但没有被使用。例：printstar( ); 注意:

（1）被调函数出现在主调函数之前，声明可以省略。

（2）若被调函数书写顺序调整到主调函数的后面，由于被调函数是有返回值的，并且返回值是整型或字符型，声明也可以省略。

（3）若被调函数在主调函数之后，并且是无返回值或返回植不是的整型或字符型的函数，所以需要声明。

函数调用时的数据传递方法

Ｃ语言规定在函数间传递数据有四种方式：值传递方式、地址传递方式、返回值方式、全局变量传递方式。

1、利用形参与实参传递数据的值传递方式

形式参数：定义函数时函数名后面括号中的变量名实际参数：调用函数时函数名后面括号中的表达式说明：

（1）实参必须有确定的值（2）形参必须指定类型

（3）形参与实参类型一致，个数相同

（4）若形参与实参类型不一致，自动按形参类型转换———函数调用转换

（5）形参在函数被调用前不占内存;函数调用时为形参分配内存；调用结束，内存释放值传递方式的特点：

（1）函数调用时,为形参分配单元,并将实参的值复制到形参中；调用结束，形参单元被释放，实参单元仍保留并维持原值——单向传递

（2）形参与实参占用不同的内存单元 2、利用形参与实参传递数据的地址传递方式地址传递方式特点：

（1）函数调用时，将数据的存储地址作为参数传递给形参

（2）形参与实参占用同样的存储单元

（3）―双向‖传递，形参和实参的数据实际上并没有传递，其实质是数据的共享（4）实参和形参必须是地址常量或变量当形参是数组时的数据传递方式

数组名做形参，由于数组名代表数组首地址，属于地址传递。当形参是指针变量时的数据传递方式形参是指针变量的结论：

（1）形参是指针变量，实参必须是地址表达式。（2）属于地址传递方式。

（3）在被调函数中，由于形参对应的指针变量已经指向主调函数的某个变量（也可以是数组元素或数组），就可以使用形参对应的指针变量来使用或修改主调函数中的变量或数组元素的值。回到主调函数，可以直接使用―变量‖或―数组元素‖获得在被调函数中修改的值。利用参数进行数据传递的方法给出下列总结:

（1）如果要从主调函数将数据传递给被调函数，可以使用形参是变量，实参是表达式的值传递方式。若有n个不相关的数据要传递，则要设置n个形参。

（2）如果要在主调函数和被调函数之间共享一批相关的数据，可以使用形参是数组，实参是地址（数组名、数组元素地址、指向数组的指针变量）的地址传递方式。

（3）如果要在主调函数和被调函数之间共享单个数据，可以使用形参是指针变量，实参是数据地址的传递方式。如果有多个这样的数据要相互传递，需要设置多个指针变量形式的形参。 3、利用返回值的数据传递方式返回语句

形式：return(表达式)；或return 表达式; 或return;

功能：使程序控制从被调用函数返回到调用函数中，同时把返回值带给调用函数说明：

(1)函数中可有多个return语句，但每调用一次该函数，只能执行到一个return语句。

若无return语句，遇函数的最后一个}时，自动返回调用函数

若函数类型与return语句中表达式值的类型不一致，按前者为准，自动转换------函数调用转换函数调用的真题

1.调用函数时，若实参是一个数组名，则向函数对应的形参传送的是( ) A.数组的长度答案：B

2.在C语言中，函数返回值的类型是由( ) A.定义的函数类型决定

B.return语句中表达式的类型决定 C.调用该函数的主调函数类型决定 D.调用该函数时系统状态决定答案：A

3.在C语言中，有值函数的数据类型是指( )

A. 函数形式参数的数据类型 B. 函数返回值的数据类型

C. 调用该函数时的实参的数据类型 D. 任意指定的数据类型答案：B

1.在C语言中，当定义一个函数的类型为void时，说明执行该函数后。答案：无返回值

2.函数调用时，若形参是一个变量，而对应的实参是一个有确定值的表达式，则函数参数的传递方式是__________传递。答案：值 3.若函数定义为 int data( ) { float x=9.9; return(x); }

则函数返回的值是______。答案：9

B.数组的首地址

C. 数组第一个元素的值 D. 整个数组元素的值

变量的存储类型与作用域变量的存储类型存储类型自动型寄存器型静态型存储类型符 auto register static 存储区域内存的堆栈区 CPU的通用寄存器内存的数据区外部参照型 extern 1.自动型

自动型变量，函数被调用时，给该变量分配内存用于存放变量的值。当函数调用结束时，Ｃ语言就释放该变量

当定义变量时，省略了存储类型符，系统将默认为自动型变量。 2.寄存器型

寄存器型变量是分配在CPU的通用寄存器中,一般以2个左右为宜,且只能定义为整型或字符型。寄存器型变量一般是在函数中定义的，退出该函数后就释放它所占用的寄存器。 3.静态型

静态型变量是在程序开始运行时就分配了固定的内存，在程序运行过程中不释放。只有程序运行结束后，才释放所占用的内存。 4.外部参照型

外部参照型变量是专用于多个编译单位之间传递数据用的。变量的初始化和变量的存储类型的关系

（1）外部参照型(extern)变量不允许初始化。

（2）自动型(auto)变量和寄存器型(register)变量如果进行初始化，则每次进入所定义的函数或复合语句都随着重新定义而重新初始化。自动型 ( auto) 变量和寄存器型(register)变量如果不进行初始化，变量值将不确定。因此，必须用其它赋值方式为其赋值后方能参与运算。

（３）静态型(static)变量如果进行初始化，只有第一次执行定义语句时随着分配内存赋于初值，当退出所定义的函数或复合语句时，将保留分配给它的内存和其中的值。再次进入所定义的函数或复合语句时，不再重新分配内存，也不进行初始化。此时，该变量值是上次离开时的值。静态型(static)变量如果不进行初始化，Ｃ语言编译系统将自动为其赋予―零值‖：对数值型变量赋0，对字符型变量赋空字符‘\\0‘（空字符的ASCII代码值为0）。变量的生存期与作用域 1、内部变量与外部变量

内部变量:在函数（或某个复合语句）内定义的变量；只在本函数内（或本复合语句内）有效。外部变量:在函数外定义的变量。它的有效范围是从定义它的地方开始，到整个程序结束的任何地方。

2．变量的生存期

变量从开始分配内存单元（或寄存器）到分配的内存单元（或寄存器）被收回的期间称为变量的生存期。

3．全局变量和局部变量

局部变量：生存期只覆盖某个函数（或某个复合语句）的变量称为具有局部寿命的变量。说明：

（1） main中定义的变量只在main中有效（2）不同函数中同名变量，占不同内存单元（3）形参属于局部变量

（4）可定义在复合语句中有效的变量

（5）局部变量可用存储类型：auto register static （默认为auto）全局变量：生存期覆盖了定义点到整个程序结束的变量称为具有全局寿命的变量。说明：

（1）外部变量可用存储类型：缺省或 static

（2）若外部变量与局部变量同名，则外部变量被屏蔽（3）应尽量少使用全局变量。关于变量生存期和作用域的总结变量外部变量允许的存储类型省略(称无存储类型) static 省略(默认为auto) 内部变量 auto register static 变量的存储类型与作用域的真题

1.在函数内，定义变量时存储类型符可省略的是 ( ) A. auto B. static C. extern D. register 答案：A

2.全局变量的存储类型可以定义为( ) A.auto或static B.extern或register C.auto或extern D.extern或static 答案：D

3.若函数能被其它编译单位引用，那么函数定义时的存储类型应选用( ) A.auto B.static C.extern D.register 答案：C

4.自动型变量分配在（） A.内存的数据区中 C.内存的程序区中

B.CPU的通用寄存器中 D.内存的堆栈区中

全局变量局部变量定义该变量的函数或复合语句内部生存期全局变量作用域定义点到程序结束答案：D

5.若函数中局部变量的值经函数调用后仍保留，则该局部变量定义为（） A.自动变量 C.外部变量答案：D 6.对于程序段 float f1(int a) {int b；……} main( ) { int m,n; m=f1(n);……} char f2(int x,int y) {int a;……}

变量m,n的作用范围是（） A.整个程序段答案：B

7. 静态型外部变量的作用域是__________。答案：定义点到程序结束 8. 写出程序的运行结果 fun(int x) {int y=0; static int z=3; z++;++y; return(x+y+z); } main( ) {int i,x=2; for(i=0;i<2;i++) printf(″]″,fun(x++)); }

答案： 7 9 9. 写出程序的执行结果 f( ) { int x=1; return x++; } g( )

B.main函数

D.mian函数和f1函数

C.main函数和f2函数

B.内部变量 D.静态变量

{ static int x=1; return x++; } main() { int i,a=0,b=0; for(i=0;i<5;i++) { a+=f(); b+=g(); }

printf(″a=%d\\nb=%d\\n″,a,b); } 答案：a=5 b=15

10. 写出程序的执行结果 int a = 200； main() { int i；

for(i = 1；i< = 5；i + +) { a + + ；

printf(″﹪d，″，a)； s( ); } } s( )

{static int a = 20； a + + ；

printf(″﹪d \\ n″，a)； }

答案：201，21 202，22 203，23 204，24 205，25

11. 写出程序的执行结果 int x=30,y=50; sub(int x, int y) { y=x>y? x:y; return y; } main( )

{

{ int x=100;

printf(″%d\\n″,sub(x,y)); }

printf(″%d,%d\\n,x,y); } 答案：100 30，50

12. 写出程序的执行结果 int a1=300,a2=400; main( )

{int a3=100,a4=200; sub1(a3,a4); sub1(a1,a2);

printf(″%d,%d,%d,%d\\n″,a1,a2,a3,a4); }

sub1(int x,int y) { a1=x; x=y; y=a1; }

答案：100,400,100,200

13. 写出程序的执行结果,设从键盘输入282 sub(int n) {int s=1; do

{ s*=n;n/=10;} while(n); return s; } main( ) { int n;

scanf (″%d″,&n); n=sub(n); printf(″%d\\n″,n); } 答案：32

14. 写出程序的执行结果 int f(int a) { int b=4； static int c=4； b++； c++； return(a+b+c)； } main( ) {int a=4,i； for(i=0;i<3;i++) printf(″％4d″,f(a))； }

答案： 14 15 16 15. 写出程序的执行结果 mian( ) { int i;

for(i=1;i<3;i++) f(i); } f(int j)

{ static int a=100; int k=1; ++k;

printf(″%d\\n″, j+a+k); a-=2; } 答案：103 102

16. 写出程序的执行结果 void LE(int*a, int b) {

int x=*a;

printf(″%d\\t%d\\n″, *a, b); *a=b;b=x; } main( )

{

int x=10, y=25; LE(&x, y);

printf(″%d\\t%d\\n″, x, y); }

答案：10 25 25 25 17. 填空程序

根据对n的输入，求1+2+3+…+n的和。 float sum(int x) { int i; float s;

________; /* 第一空 */ for (i=1;i<=x;i++) s+=i;

________; /* 第二空 */ } main() {int n;

scanf(″%d″,________); /* 第三空 */ printf(″%f\\n″,sum(n)); } 答案：s=0 return s &n

函数的嵌套调用和递归调用函数的嵌套调用

C规定：函数定义不可嵌套，但可以嵌套调用函数

函数的递归调用

定义：函数直接或间接的调用自身叫函数的递归调用

递归过程必须解决两个问题：一是递归计算的公式，二是递归结束的条件和此时函数返回值。递归计算公式 p(n)=n*p(n-1) 递归结束条件 p(1)=1 在程序设计实现：

if (递归结束条件) return (递归结束条件中的返回值); else return (递归计算公式); 函数的嵌套调用和递归调用的真题 1. 写出程序运行的结果 gcd(int m,int n) { if(m==n)return m;

else if(m>n) return gcd(m-n,n); else return gcd(m,n-m); } main( ) {

printf(″Gcd=%d\\n″,gcd(24,36)); } 答案：12

2. 写出程序运行的结果 sum(int n) {

if(n= =1) return(1); else return n+sum(n-1); } main( ) {

printf(″%d\\n″,sum(10)); } 答案：55

3. 写出程序运行的结果 #include long fun(int n) { long s; if(n<=2)s=2; else s=n+fun(n-1); printf(″%d\\t″, s); return s;

} main( ) { fun(5); printf(″\\n″); } 答案：14

指针型函数及其调用

所谓指针型函数，是指该函数的返回值是指针型的，也就是说，这类函数的返回值必须是地址值；调用该类函数时，接受返回值的必须是指针变量、指针数组元素等能存放地址值的对象。指针型函数的定义

定义格式: 存储类型符数据类型符 *函数名（形式参数表）指针型函数的调用

指针型函数的调用和一般函数的调用方法完全相同，唯一需要注意的是只能用指针变量或指针型数组元素来接受指针型函数的返回值，不能使用数组名来接受指针型函数的返回值，因为数组名是地址常量，不是地址型变量，不能接受地址型数据。文件包含命令与多文件程序文件包含命令

文件包含命令的格式如下。【格式1】#include <文件名> 【格式2】#include \文件名\

【功能】在编译预处理时，用指定―文件名‖中的文本内容替代该语句，使文件的全部内容成为本程序清单的一部分。【说明】

（1）用格式1，系统仅按规定的路径搜索文件。建议:系统函数的头文件用格式1。

（2）用格式2，系统先在本程序清单文件所在的磁盘和路径下寻找文件；若找不到，再按系统规定的路径搜索文件。建议: 用户函数的头文件用格式1。多文件程序的处理

多文件程序：若一个大型程序被分散在多个源程序文件中，就称为多文件程序。对这种程序的调试，首先要将多个源程序清单拼接成一个完整的程序清单，然后再对其进行编译和调试。常用系统函数常用的数学处理函数

下面是部分常用的数学处理类系统函数，它们均包含在头文件―math.h‖中。 1．求整型绝对值函数 abs(int x) 2．求长整型绝对值函数 labs(long x) 3．求实型绝对值函数 fabs(double x) 4．求正平方根函数 sqrt(double x) 5．求指数函数 exp(double x)

6．求10的x次方函数 pow10(int x)

7．求x的y次方函数 pow(double x,double y) 常用的字符处理函数

下面是部分常用的字符类系统函数，它们均包含在头文件―ctype.h‖中。 1．判断是否英文小写字母函数 islower(int x)

【返回值】若参数x中存放的字符是英文小写字母，返回非0（真）；否则，返回0（假）。 2．判断是否英文大写字母函数isupper(int x)

【返回值】若参数x中存放的字符是英文大写字母，返回非0（真）；否则，返回0（假）。 3．将大写字母转换为小写字母函数 tolower(int x)

【返回值】若参数x中存放的字符是大写字母，则返回值是对应的小写字母。如果参数x中存放的字符不是大写字母，则返回值等于x的原来值。 4．将小写字母转换为大写字母函数 toupper(int x)

【返回值】若参数x中存放的的字符是小写字母，则返回值是对应的大写字母。如果参数x中存放的字符不是小写字母，则返回值等于x的原来值。 5. 产生一个从0到num-1之间的随机整数random(int num) 第八章结构型与自定义类型结构型的定义

结构型是用户在程序中自己定义的一种来存放类型不同的数据的数据类型，又称―结构体型‖。结构型的定义：

【例】定义嵌套结构型的例子。姓名性别出生日期年月日工资 struct birthday /* 定义含有三个整型成员的birthday结构型 */ { int year; /* 出生日期中的年份 */ int month; /* 出生日期中的月份 */ int day; /* 出生日期中的日 */

};

struct person1 /* 定义含有4个成员的person1结构型 */ { char name[10]; /* 姓名 */ char sex; /* 性别 */ struct birthday bir; /* 出生日期，*/ float wage; /* 工资 */

};

注意，名为―birthday‖的结构型定义必须在结构型―person1‖的定义之前进行定义，否则，结构型―person1‖定义时，会出现―birthday结构型未定义‖的错误。结构型定义的真题 1.设 struct { short a; char b; float c; }cs;

则sizeof(cs)的值是( )

A. 4 B. 5 C. 6 D. 7 答案：D 2．设

struct student

{ int no;char name[12]; char sex;float score[4]; }stu1;

在程序执行时，系统为stu1分配个字节的内存空间。答案：31

结构型变量的定义和成员的引用结构型变量的定义和初始化定义结构型变量的方法有三种。

1、先定义结构型，后定义变量（较常用的一种方法）【例】struct student { long number; char name[10]; char sex; float score[3]; }; ...

struct student x1,y1;

...

struct student x2={100001L,‖zhao1‖,‘f‘,{89,94,86}}, y2={100002L,‖zhao2‖,‘m‘,{78,86,92}}; /*在定义结构型的变量x2和y2的同时，对其所有成员赋初值*/ ２．定义结构型的同时定义变量【例】 struct student { long number; char name[10]; char sex; float score[3];

} x={100001L,‖zhao1‖,‘f‘,{89,94,86}}; ...

struct student y={100002L,‖zhao2‖,‘m‘,{78,86,92}}; ３．定义无名称的结构型的同时定义变量

【例】struct /* 定义无名称的结构型 */ { long number; char name[10]; char sex; float score[3];

} x={100001L,‖zhao1‖,‘f‘,{89,94,86}}, y={100002L,‖zhao2‖,‘m‘,{78,86,92}}; 注意：以后将无法使用这种结构型来定义其它变量。结构型变量成员的引用 1、结构型变量成员的引用方法结构型变量名.成员名嵌套型结构型变量的引用方法：

外层结构型变量.外层结构型成员名.内层成员名

注意，这种嵌套结构型数据，外层结构型变量的结构型成员一般是不能单独引用的。结构型变量成员的引用

2、结构型变量成员地址的引用方法

成员是变量形式的变量地址： &结构型变量名.成员名成员是数组形式的数组首地址：结构型变量名.成员名

成员是数组，其数组元素的地址：&结构型变量名.成员数组[下标] 3、结构型变量地址的引用方法 &结构型变量名 1. #include″string.h″

struct worker {char name[15]; int age; float pay; }; main( ) {struct worket x; char *t=″Lilei″; int d=20;float f=100; strcpy(x.name,t); x.age=d*2;x.pay=f*d;

printf(″％s\\t％d\\t％.0f\\n″,x.name, x.age,x.pay); }

答案： Lilei 40 2000

结构型数组的定义和数组元素成员的引用结构型数组的定义和初始化结构型数组的定义也有三种方法

1、先定义结构型，然后再定义结构型数组并赋初值。【例】struct student { long number; char name[10]; char sex; float score[3]; }; ...

struct student s[3]={{200001L,‖qian2‖,‘m‘,{78,86,92}},

{200002L,‖sun3‖,‘f‘,{85,69,82}}, {200003L,‖li4‖,‘m‘,{84,88,96}}};

2、定义结构型的同时定义数组并赋初值。【例】 struct student { long number;

char name[10]; char sex; float score[3];

} s[3]={{200001L,‖qian2‖,‘m‘,{78,86,92}}, {200002L,‖sun3‖,‘f‘,{85,69,82}}, {200003L,‖li4‖,‘m‘,{84,88,96}}}; 3、定义无名称的结构型的同时定义数组并赋初值。【例】 struct { long number; char name[10]; char sex; float score[3];

} s[3]={{200001L,‖qian2‖,‘m‘,{78,86,92}}, {200002L,‖sun3‖,‘f‘,{85,69,82}}, {200003L,‖li4‖,‘m‘,{84,88,96}}}; 注意：以后将无法使用这种结构型来定义其它变量。结构型数组元素成员的引用

1.结构型数组元素成员的引用方法结构型数组名[下标]．成员名 2.结构型数组元素成员地址的引用方法 &结构型数组名[下标].成员名 3.结构型数组元素地址的引用方法 &结构型数组名[下标] 4.结构型数组首地址的引用方法结构型数组名 1.设有定义语句 struct

{int a；float b；} d[3]={{1，4}，{2，5}，{6，7}}；则printf(″﹪3.1f \\ n″，d[2]. a * d[2]. b/d[1]. b)；的输出是( A. 2.5 B. 2.0 C. 8.0 D. 8.4 答案：D 2. struct porb {char * name； int count；

}x[]={″Li ning″,19,″Lang ping″,21,″Zhu jian hua″,20}； main() {int i；

) for(i = 0；i<3；i + + )

printf(″﹪s: ﹪d \\ n″,x[i].name，x[i].count)； }

答案： Li ning:19 Lang ping:21 Zhu jian hua:20

指向结构型数据的指针变量的定义和使用指向结构型变量的指针变量

定义指向结构型变量的指针变量和定义结构型变量的方法基本相同，唯一的区别是在结构型指针变量名的前面加一个―*‖。

引用该结构型变量的成员的方式：

(*指针变量).成员名指针变量->成员名变量.成员名指向结构型数组的指针变量

1、指针变量指向数组元素对成员的引用

(*指针变量).成员名指针变量->成员名数组名[k].成员名。２、指针变量指向数组对成员的引用

(*(指针变量+k)).成员名 (指针变量+k)->成员名数组名[k].成员名

1.设有定义struct ru{long x;float y;} time,*timep=&time;则对time中成员x的正确引用是( ) A.ru.time.x B.timep.x C.(* timep).x D.time->x 答案：C 2.设