精华内容
参与话题
问答
  • 二级C语言考试知识点(很全)

    万次阅读 多人点赞 2018-11-30 01:38:14
    二级公共基础知识作为必考内容出现,出题形式为选择题前10道,占考试总分的10%。 考试其它比重: 1、C语言程序的结构 占总分1% 2、数据类型及其运算 占总分4% 3、选择结构程序设计 占比分的3% 4、循环结构 占比分的5...

    二级公共基础知识作为必考内容出现,出题形式为选择题前10道,占考试总分的10%。
    考试其它比重:
    1、C语言程序的结构 占总分1%
    2、数据类型及其运算 占总分4%
    3、选择结构程序设计 占比分的3%
    4、循环结构 占比分的5%
    5、数组的定义和引用 占比分的5%
    6、函数 占比分的5%
    7、编译预处理 占比分1%
    8、指针 占比分的5%
    9、结构体 占比分的3%
    10、位运算 占比分的2%
    11、文件操作 占比分的2%
    考试方式
    上机考试,时长120分钟
    单选题40分(含公共基础10分),操作题60分(包括程序填空题、程序修改题、程序设计题)

    第一部分 C语言知识复习资料

    第一章 C语言基本知识(90分)
    【考点1】C程序
    用C语言编写的程序称为C语言源程序,源程序文件的后缀名为“.c”。源程序经编译后生成后缀名为“.obj”的目标文件,再把目标文件与各种库函数连接起来,生成“.exe”可执行文件。C语言有三种基本结构:顺序结构、选择结构、循环结构。
    【考点2】main函数
    又称主函数,是C程序的入口。main后面跟一对小括号和一对花括号,花括号括起来的部分称为main函数的函数体。一个C程序从main函数开始执行,到main函数体执行完结束,而不论main函数在整个程序中的位置如何。每一个程序有且仅有一个main函数,其他函数都是为main函数服务的。
    【考点3】存储形式
    计算机在电脑中保存数据是采用二进制形式,由0或1构成的二进制称为位(bit),八个位构成一个字节(Byte),1个Byte=8个bit。二进制、八进制、十六进制转化为十进制采用乘法,十进制转化为二进制、八进制、十六进制采用除法。数据的存放位置就是它的地址。
    【考点4】注释
    是对程序的说明,可出现在程序中任意合适的地方,注释从“/”开始到最近一个“/”结束,其间任何内容都不会被计算机执行,注释不可以嵌套。
    【考点5】书写格式
    每条语句的后面必须有一个分号,分号是语句的一部分。一行内可写多条语句,一个语句可写在多行上。
    【考点6】标识符
    是标识名字的有效字符序列,可以理解为C程序中的单词。
    标识符的命名规则是:
    (1)标识符只能由字母、数字和下划线组成,字母区分大小写。
    (2)标识符的第一个字符必须是字母或下划线,不能为数字。
    C语言标识符分如下3类
    (1)关键字。它们在程序中有固定的含义,不能另作他用。如int、for、switch等。
    (2)预定义标识符。预先定义并具有特定含义的标识符。如define、include等。
    (3)用户标识符。用户根据需要定义的标识符,符合命名规则且不与关键字相同。
    【考点7】常量与变量
    常量是指在程序运行过程中,其值不能改变的量。常量分为整型常量、实型常量、字符常量、字符串常量、符号常量5种。在程序运行过程中其值可以改变的量称为变量。C语言中没有字符串变量。存放字符串使用字符数组。
    【考点8】整型数据
    整型常量有十进制、八进制、十六进制三种表示形式,没有二进制形式。八进制整型常量加前导数字0,十六进制常量加前导0X,八进制常量中不会出现8。
    整型变量可分为基本整型(int)、短整型(short)、长整型(long)、和无符号整型(unsigned)。一个基本整型占4个字节。其它类型的整型占用字节数和取值范围详见教材第9页。
    【考点9】实型数据
    实型数据有两种表示形式:小数形式和指数形式。掌握判定指数形式合法性。
    口诀:E前E后必有数,E后必须为整数。
    实型变量分为单精度型(float)和双精度型(double),单精度型占四个字节。
    【考点10】算术运算
    算术运算符一共有+、—、*、/、%这五个。求余运算要求运算对象只能为整型,除法运算符两边运算对象都为整型时,运算结果也为整型即舍掉小数部分。
    【考点11】强制类型转换
    将一个运算对象转换成指定类型,格式为(类型名)表达式,注意小括号位置。
    【考点12】赋值
    赋值运算符为“=”,不同于关系等于“= =”。赋值表达式格式为:变量名=表达式,赋值运算符左边必须为变量,赋值运算是把赋值运算符右边表达式的值赋给左边变量。
    复合赋值运算符是将算术运算符或位运算符与赋值运算符组合在一起组成的运算符,掌握复合赋值表达式转化为赋值表达式的方法。如n+=100可转化为n=n+100。

    【考点13】自加自减运算
    自加运算符“++”与自减运算符“- -”是单目运算符,运算对象必须是变量。自增自减运算分前缀运算和后缀运算,它们所对应的表达式的值是有区别的,如j=i++;等价于j=i;i=i+1;而j=++i;等价于i=i+1;j=i;。
    口诀:加加在前先加后用,加加在后先用后加。
    【考点14】逗号运算
    逗号运算符运算优先级最低,可将多个表达式构成一个新的表达式。
    考试真题:
    1、下列叙述中错误的是( D )——2006年4月选择第44题
    A)C语言源程序经编译后生成后缀为.obj的目标程序
    B)C语言经过编译、连接步骤之后才能形成一个真正可执行的二进制机器指令文件
    C)用C语言编写的程序称为源程序,它以ASCII代码形式存放在一个文本文件中
    D)C语言中的每条可执行语句和非执行语句最终都将被转换成二进制的机器指令

    2、下列叙述中错误的是(B)——2006年4月选择第45题
    A)算法正确的程序最终一定会结束
    B)算法正确的程序可以有零个输出
    C)算法正确的程序可以有零个输入
    D)算法正确的程序对于相同的输入一定有相同的结果

    3、下列叙述中错误的是(A)——2006年9月选择第11题
    A)一个C语言程序只能实现一种算法
    B)C程序可以由多个程序文件组成
    C)C程序可以由一个或多个函数组成
    D)一个C函数可以单独作为一个C程序文件存在

    4、下列叙述中正确的是(D)——2006年9月选择第12题
    A)每个C程序文件中都必须要有一个main()函数 算法正确的程序对于相同的输入一定有相同的结果
    B)在C程序中main()函数的位置是固定的
    C)C程序中所有函数之间都可以相互调用,与函数所处位置无关
    D)在C程序的函数中不能定义另一个函数

    5、在算法中,对需要执行的每一步操作,必须给出清楚、严格的规定,这属于算法的(C)——2007年4月选择第11题
    A)正当性
    B)可行性
    C)确定性
    D)有穷性

    6、下列叙述中错误的是(D)——2007年4月选择第12题
    A)计算机不能直接执行用C语言编写的源程序
    B)C程序经C编译程序编译后,生成后缀为.obj的文件是一个二进制文件
    C)后缀为.obj的文件,经连接程序生成后缀为.exe的文件是一个二进制文件
    D)后缀为.obj和.exe的二进制文件都可以直接运行

    7、下列叙述中错误的是(C)——2007年4月选择第14题
    A)C语言是一种结构化程序设计语言
    B)结构化程序由顺序、分支、循环3种基本结构组成
    C)使用3种基本结构构成的程序只能解决简单问题
    D)结构化程序设计提倡模块化的设计方法

    8、对于一个正常运行的C程序,下列叙述中正确的是(A)—2007年4月选择第15题
    A)程序的执行总是从main函数开始,在main函数结束
    B)程序的执行总是从程序的第一个函数开始,在main函数结束
    C)程序的执行总是从main函数开始,在程序的最后一个函数中结束
    D)程序的执行总是从程序中的第一个函数开始,在程序的最后一个函数结束

    9、C语言源程序名的后缀是(B)——2007年9月选择第11题
    A).exe B).c C).obj D).cp
    10、下列叙述中正确的是(C)——2007年9月选择第14题
    A)C语言程序将从源程序中第一个函数开始执行
    B)可以在程序中由用户指定任意一个函数作为主函数,程序将从此开始执行
    C)C语言规定必须用main作为主函数名,程序将从此开始执行,在此结束
    D)Main可作为用户标识符,用以命名任意一个函数作为主函数

    1. 以下选项中合法的标识符是(2009年3月)(C)
      A)1_1 B)1-1 C)11 D)1 2.
      2、以下选项中不合法的标识符是c(2008年4月)
      A)print B)FOR C)&a D)_00

    2. 可在C程序中用做用户标识符的一组标识符是(2007年9月)
      A)and B)Date C)Hi D)case _2007 y-m-d Dr.Tom Bigl

    3. 按照C语言规定的用户标识符命名规则,不能出现在标识符中的是 (B)(2007年4月)
      A)大写字母 B)连接符 C)数字字符 D)下划线

    4. 以下不合法的用户标识符是(C)(2006年4月)
      A)j2_KEY B)Double C) 4d D) 8

    5. 以下选项中不属于字符常量的是(2008年4月)
      A)‘C’ B)“C” C)’\xCC0’ D)’\072’

    6. 以下合法的字符常量的是 (A)
      A)’\x 13’ B)‟\081‟ C)‘65’ D)”\n”

    7. 已知大写字母A的ASCII码是65,小写字母a的ASCII码是97。下列不能将变量c中
      的大写字母转换为对应小写字母的语句是(2007年4月) (D)
      A)c=(c-„ A‟)%26+‟a‟
      B) B)c=c+32
      C)C)c=c-„A‟ +‟a‟
      D) D)c=(„A‟+c)%26-„a‟

    8. 以下选项中,值为1的表达式________。(2006年9月)
      A)1-„0‟ B)1-„\0‟ C)‟1‟-0 D)‟\0‟-„0‟ 1.

    5.以下选项中,能用作数据常量的是(2009年3月)
    A)o115 B)0118 C)1.5e1.5 D) 115L

    6、以下选项中不能作为C 语言合法常量的是( )。
    A)‘cd’ B)0.1e+6 C)"\a" D)’\011’

    1. 以下不合法的数值常量是 (B)
      A)011 B)lel C)8.0 E0.5 D)0xabcd

    2. C 源程序中不能表示的数制是(A)。(2008年9月)
      A)二进制
      B)八进制
      C)十进制
      D)十六进制

    3. 以下关于long、int和short类型数据占用内存大小的叙述中正确的是(2007年9月) (D)
      A)均占4个字节
      B)根据数据的大小来决定所占内存的字节数
      C)由用户自己定义
      D)由C语言编译系统决定

    4. 以下选项中,合法的一组C语言数值常量是(2007年9月)
      A) 028
      B) 12.
      C) .177
      D) 0x8A
      . 5e-3
      0xa23
      4e1.5

    10,000
    -0xf 4.5e0 0abc 3.e5

    第二章顺序结构

    【考点1】运算符、表达式、语句
    运算对象加运算符构成表达式,表达式加分号构成表达式语句,运算对象可以是表达式、常量、变量。如赋值运算符加运算对象构成赋值表达式,赋值表达式加分号又可构成赋值语句。
    【考点2】运算符的优先级和结合顺序
    运算符按参加运算的对象数目可分为单目运算符、双目运算符和三目运算符。初等运算符的优先级别最高,然后依次是单目运算符、算术运算符、关系运算符、逻辑运算符(除逻辑非!)、条件运算符、赋值运算符、逗号运算符。位运算符优先级介于算术运算符与逻辑运算符之间。结合顺序大多为自左向右,而自右向左的有三个:单目运算符、条件运算符和赋值运算符。
    【考点3】printf函数
    格式为:printf(输出控制,输出列表)。输出控制是用一对双引号括起来的,包含格式说明和原样信息。输出列表包含若干输出项。
    【考点4】printf函数中格式说明
    %d对应整型,%f对应单精度实型,%c对应字符型,%o对应八进制无符号整型,%x对应无符号十六进制整型,%u对应无符号整型,%e对应指数型,%s对应字符串型。可在%和格式字符之间加一个数来控制数据所占的宽度和小数位数。
    【考点5】scanf函数
    输入项要求带取地址符&。当用键盘输入多个数据时,数据之间用分隔符。分隔符包括空格符、制表符和回车符,但不包括逗号。
    【考点】6如何交换两个变量
    要使用中间变量,语句为:t=x; x=y; x=t;。

    第三章 选择结构

    【考点1】关系运算
    C语言用非0表示逻辑真,用0表示逻辑假。关系运算符有6个,分别是>,>=,<,<=,==,!=,前四种优先级高于后两种。关系表达式真时为1,假时为0。注意a<b<c是不可以的,可用(a<b)&&(b<c)来表示。
    【考点2】逻辑运算
    逻辑运算符共有3个:逻辑与(&&),逻辑或(||),逻辑非(!)。注意短路现象,例a++||b++,如果表达式a++的值非零,则表达式b++不再执行。
    【考点3】if语句
    可以单独出现,也可以与else匹配出现。if语句可以嵌套,这时else总是与离它最近的且没有与else匹配的if匹配。
    【考点4】条件运算
    是唯一的三目运算符,格式为:表达式1?表达式2:表达式3。表达式1值为非0时,整个表达式值为表达式2的值,表达式1值为0时,整个表达式值为表达式3的值。
    口诀:真前假后
    【考点5】switch语句
    格式及执行过程详见教材P33,要注意每条case后有没有break语句的区别。还要注意switch后小括号里面的表达式不能为实型,case后表达式不能有变量。
    口诀:switch表不为实,case表不为变。

    第四章 循环结构

    【考点1】三种循环结构
    三种循环结构分别为:while,do-while,for,三种结构的格式及执行顺序详见教材第36、39、40页。注意for循环中的小括号中必须是两个分号;循环一定要有结束条件,否则成了死循环;do-while()循环最后的while();后一定要有分号。
    【考点2】break与continue
    break是终止所在整个循环,而continue是提前结束本轮循环。break语句可出现在循环结构与switch语句中,continue只出现在循环结构中。
    【考点3】循环的嵌套
    就是循环里面还有循环,计算要一层一层分析,一般只考查两层嵌套,循环嵌套通常是处理二维数组。
    【考点4】循环结构的复习
    循环结构是重点,笔试所占分值一般在13分左右,在上机考试中也是必考点,应用性很强。要求学员重点理解并多加练习,领会掌握。

    第五章 字符型数据 位运算

    【考点1】字符常量
    一个字符常量用一对单引号括起来,字符常量只能包括一个字符,’ab’是非法的。空格常用’□’来表示。字符常量可用对应的ASCII码表示,需记住:’0’的ASCII码为48,’A’的ASCII码为65,’a’的ASCII码为97。
    【考点2】转义字符
    一对单引号中以一个反斜线后跟一个特定字符或八进制、十六进制数来构成转义字符。比如’\n’表示换行,’\101’或’\x41’表示ASCII码为65的字符’A’。
    【考点3】字符型数据可以和整型数据相互转换
    如:’0’-0=48 ‘A’+32=’a’ char a=65;printf(“%d%c”,a,a);结果为65A
    【考点4】位运算符
    C语言提供6种位运算符:按位求反~,按位左移<<,按位右移>>,按位与&,按位异或|,按位或^。一般情况下需要先转化进制。异或运算的规则:0异或1得到1,0异或0得到0,1异或1得到0。可记为“相同为0,不同为1”。
    【考点5】putchar与getchar函数
    可用于输出或输入单个字符,这两个函数是stdio.h文件中的库函数,它们是printf与scanf函数的简化。

    第六章 函数

    【考点1】函数的定义
    函数是具有一定功能的一个程序块。函数的首部为:函数类型 函数名(类型1 形参1,类型2 形参2,……)。在函数定义中不可以再定义函数,即不能嵌套定义函数。函数类型默认为int型。
    【考点2】库函数
    调用C语言标准库函数时要包含include命令,include命令行以#开头,后面是””或<>括起来的后缀为”.h”的头文件。以#开头的一行称为编译预处理命令行,编译预处理不是C语言语句,不加分号,不占运行时间。
    【考点3】函数的返回值
    函数通过return语句返回一个值,返回的值类型与函数类型一样。return语句只执行一次,执行完或函数体结束后退出函数。
    【考点4】函数的声明
    函数要“先定义后调用”,或“先声明再调用后定义”。函数的声明一定要有函数名、函数返回值类型、函数参数类型,但不一定要有形参的名称。
    【考点5】函数的调用
    程序从上往下执行,当碰到函数名后,把值传给调用函数,当程序得到了返回值或调用函数结束,再顺序往下执行。
    【考点6】函数的参数及值传递
    形式参数简称形参,是定义函数时函数名后面括号中的参数。实在参数简称实参,是调用函数时函数名后面括号中的参数。实参和形参分别占据不同的存储单元。实参向形参单向传递数值。
    “传值”与“传址”的区别:传数值的话, 形参的变化不会改变实参的变化。传地址的话,形参的变化就有可能改变实参所对应的量。
    【考点7】函数的递归调用
    函数直接或间接地调用自己称为函数的递归调用。递归调用必须有一个明确的结束递归的条件。在做递归题时可把递归的步骤一步步写下来,不要弄颠倒了。
    【考点8】要求掌握的库函数
    sqrt()算术平方根函数,fabs()绝对值函数,pow()幂函数,sin()正弦函数
    第七章 指针
    【考点1】指针变量
    【考点2】指针变量的定义指针变量是用来存储地址的,而一般变量是存储数值的。指针变量可指向任意一种数据类型,但不管它指向的数据占用多少字节,一个指针变量占用四个字节。

    格式为:类型名 *指针变量名。二维指针int **p;可以理解为基类型为(int *)类型。
    【考点3】指针变量的初始化
    指针变量在使用前必须要初始化,把一个具体的地址赋给它,否则引用时会有副作用,如果不指向任何数据就赋“空值”NULL。
    【考点4】指针变量的引用
    &是取地址符,*是间接访问运算符,它们是互逆的两个运算符。在指针变量名前加间接访问运算符就等价它所指向的量。
    【考点5】指针的运算
    *p++和(*p)++之间的差别:*p++是地址变化,(*p)++是指针变量所指的数据变化。一个指针变量加一个整数不是简单的数学相加,而是连续移动若干地址。当两个指针指向同一数组时,它们可以比较大小进行减法运算。

    第八章 数组

    【考点1】数组的定义
    数组是一组具有相同类型的数据的集合,这些数据称为数组元素。格式为:类型名 数组名[常量表达式]。数组的所占字节数为元素个数与基类型所占字节数的乘积。
    【考点2】数组的初始化
    第一维长度可以不写,其它维必须写。int a[]={1,2};合法,int a[][3]={2,3,4};合法,int a[2][]={2,3,4};非法。数组初始化元素值默认为0,没有初始化元素值为随机。如在int a[5]={0,1,2};中,元素a[4]值为0;而在int a[5];中,元素a[4]值为一个不确定的随机数。
    【考点3】元素的引用
    数组元素的下标从0开始,到数组长度减1结束。所以int a[5];中数组最后一个元素是a[4]。要把数组元素看作一个整体,可以把a[4]当作一个整型变量。
    【考点4】二维数组
    数组a[2][3]={1,2,3,4,5,6};中含6个元素,有2行3列。第一行为a[0]行,第2行为a[1]行,a[0]、a[1]叫行首地址,是地址常量。(a[0]+1)是第一行第一个元素往后跳一列,即元素a[0][1]值为2,(a[0]+3)是第一行第一个元素往后跳三个,即元素a[1][0]值为4。
    【考点5】行指针
    是一个指针变量,占四个字节,行指针指向一行连续数据,形式为:int (p)[2];,p只能存放含有两个整型元素的一维数组的首地址。注意(p)两边的小括号不能省略,否则就成了指针数组,是若干指针元素的集合。
    【考点6】数组名
    数组名是数组的首地址。数组名不能单独引用,不能通过一个数组名代表全部元素。数组名是地址常量,不能对数组名赋值,所以a++是错误的。但数组名可以作为地址与一个整数相加得到一个新地址。
    【考点7】元素形式的转换
    助记:“脱衣服法则”a[2]变成
    (a+2),a[2][3]变成
    (a+2)[3]再可变成*(*(a+2)+3)。

    第九章 字符串

    【考点1】字符串常量及表示
    字符串常量是由双引号括起来的一串字符,如”ABC”。在存储字符串时,系统会自动在其尾部加上一个空值’\0’,空值也要占用一个字节,也就是字符串”ABC”需要占四个字节。
    【考点2】字符数组
    C语言没有字符串变量,只能采用字符数组来存储字符串。数组的大小应该比它将要实际存放的最长字符串多一个元素,从而存放’\0’。
    【考点3】字符串赋值
    可以用下面的形式进行赋值:char str[]=”Hello!”;或char *p;p=”Hello!”;,但不能用下面的形式:char str[10];str=”Hello”;因为str是一个地址常量,不能进行赋值操作。
    【考点4】字符串的输入与输出
    可以用scanf和printf函数,如scanf(”%s”,str);,也可用专门处理字符串的两个函数gets和puts函数,还可以对字符数组逐个元素进行赋值,但一定要在最后赋一个’\0’。使用gets函数可以接收空格,使用puts函数在最后输出一个换行。
    【考点5】字符串函数
    要掌握的四个字符串函数:字符串拷贝函数strcpy(),求字符串长度函数strlen(),字符串链接函数strcat(),字符串比较函数strcmp()。使用这些函数需在预处理部分包含头文件”string.h”。
    字符串长度要小于字符数组的长度,例:char str[10]=”Hello”;sizeof(str)的值为10(数组长度),strlen(str)的值为5(字符串长度)。这些函数是考试常用到的函数,大家一定要熟练应用这几个函数。

    第十章 结构体与共用体

    【考点1】结构体类型的说明
    结构体是若干个类型数据的集合,结构体类型说明格式如下:struct 类型名 {类型1 成员名1;类型2 成员名2;……};,以上整个部分是一个数据类型,与整型的int是同样地位。可用typedef把结构体类型替换成一个只有几个字母的简短标识符。
    【考点2】结构体变量的定义
    结构体变量是用说明的结构体类型所定义的一个变量,与结构体类型不是一回事。一个结构体变量所占字节数为其所有成员所占字节数之和。如struct stu{char name[10];int age;} a,b;则表明定义了两个结构体变量a,b,每个变量占4个字节。a,b与int i,j;中的变量i,j是同样地位。
    【考点3】结构体成员的引用
    引用成员可用以下3种方式:(1结构体变量名.成员名;(2)指针变量名->成员名:(3)(*指针变量名).成员名。点(.)称为成员运算符,箭头(->)称为结构指向运)
    【考点4】链表
    链表是由一个个结点构成的,一个结点就是一个结构体变量。每个结点可以分为数据域与指针域两个部分,数据域用来存放要存储的数据,指针域用来指向下一个结点。链表是考试中的难点,在C语言和公共基础部分都会考到,要领悟掌握。
    【考点5】共用体
    共用体的使用格式与结构体相似,共用体定义的关键字为union,共用体所占字节数是所有成员中字节数最大的那个。

    第十一章 文件

    【考点1】文件类型指针
    文件指针是一个指向结构体类型的指针,定义格式为:FILE *指针变量名。在使用文件时,都需要先定义文件指针。
    【考点2】文本文件与二进制文件
    文本形式存放的是字符的ASCII码,二进制形式存放的是数据的二进制。例如“100”如果是文本形式就是存储’1’、 ’0’、 ’0’三个字符的ASCII码(00110001 00110000 00110000),如果是二进制形式就把100转化成二进制(01100100)。
    【考点3】打开文件
    文件的打开形式如下:FILE *fp; fp=fopen(“c:\lab.c”,”rb”);。fopen函数的前面一部分为文件名,后面一部分为文件的使用方式。打开方式详见教材第127页,其中r代表读,w代表写,a代表添加,b代表二进制位的。
    【考点4】文件函数
    判断文件结束feof函数,调用形式为:feof(FILE fp); //文件指针,如果文件结束,则函数返回1,否则返回0
    fseek用来设置文件的位置,接着的读或写操作将从此位置开始。函数的调用形式如下:
    fseek(文件指针,位移量,移动起始点);
    eg。FILE
    fp=fopen(“C:\xiaoyu.c”,”rb”);
    fseek(fp,12,SEEK_SET); //表示将文件fp的位置移动到文件起始位置后面的第12个字节的位置上
    或者 fseek(fp,12,0);

    fseek(fp,-12,SEEK_END; //表示将文件fp的位置移动到文件末尾位置前面的第12个字节的位置上
    或者 fseek(fp,12,2);

    如果是
    fseek(fp,12,SEEK_CUR); //表示将文件fp的位置从当前位置移动后面的第12个字节的位置上
    或者 fseek(fp,12,1);

    ftell用来获得文件当前的位置,函数给出当前位置相对于文件开头的字节数。函数调用形式如下:
    ftell(FILE *fp) //给出当前闻之相对于开头的字节数 ,出错时,返回-1L

    文件位置移到开头rewind函数功能等价于 fseek(fp,0,SEEK_SET)
    文件字符输入输出ch=fgetc(FILE *fp)函数用于从fp指定的文件中读入一个字符并把它作为函数值返回
    fputc(char ch,FILE *fp),将字符ch写到文件指针fp所指的文件中去,输出成功,则返回输出的字符,失败,则返回一个EOF值
    文件输入输出fscanf函数和fprintf函数,一般形式fscanf(文件指针,格式控制字符串,输入项表或输入项表)
    文件字符串输入输出fgets函数(fgets(str,n,fp),功能是从fp所指文件中读入n-1个字符放入str为起始地址的空间内)和fputs函数( fputs(str,fp) )
    读写二进制文件fread函数和fwrite函数。

    以上函数要求知道格式会用,清楚是用于二进制文件还是文本文件,要把教材文件这章仔细复习下,不要在考试的时候把这些文件函数搞混了。
    典型例题:
    给定程序中,函数fun的功能是将形参给定的字符串、整数、浮点数写到文本 文件中,再用字符方式从此文本文件中逐个读入并显示在终端屏幕上。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。
    注意:源程序存放在考生文件夹下的BLANK1.C中。
    不得增行或删行,也不得更改程序的结构!
    给定源程序:
    #include <stdio.h>
    void fun(char *s, int a, double f)
    {
    1 fp;
    char ch;
    fp = fopen(“file1.txt”, “w”);
    fprintf(fp, “%s %d %f\n”, s, a, f);
    fclose(fp);
    fp = fopen(“file1.txt”, “r”);
    printf("\nThe result :\n\n");
    ch = fgetc(fp);
    while (!feof(2)) {
    putchar(3); ch = fgetc(fp); }
    putchar(’\n’);
    fclose(fp);
    }
    main()
    { char a[10]=“Hello!”; int b=12345;
    double c= 98.76;
    fun(a,b,c);
    }

    第十二章 深入讨论
    【考点1】编译预处理
    凡以#开头的这一行,都是编译预处理命令行,编译预处理不加分号,不占运行时间。宏替换仅是简单的文本替换,如#define f(x) (x)(x)和#define f(x) xx替换f(2+2)时就有区别,前者展开为(2+2)(2+2),后者为2+22+2。
    如果源文件f2.c中有#include”f1.c”可以理解为把源文件f1.c原样包含到f2.c中,使f1.c和f2.c融合到一起成为一个C程序编译。所以一个C程序必有主函数,但一个C源文件未必有主函数。

    【考点2】标识符作用域
    局部变量是在函数内或复合语句内定义的变量,作用域为定义它的函数内。局部变量有三种类型:自动auto,寄存器register和静态static。
    自动变量随着函数的使用与否创建消失;寄存器变量分配在cpu中,没有内存地址;静态变量占用固定存储单元,在程序执行过程不释放,直到程序运行结束。
    全局变量是在函数外定义的变量,作用域从定义它的位置到整个源文件结束为止,生存期为整个程序运行期间。全局变量都是静态变量。
    eg
    .#include<stdio.h>
    int fun()
    {
    static int x = 1;
    x*=2;
    return x;
    }
    main()
    {
    int i,s=1;
    for(i=1;i<=3;i++)
    s*=fun();//i=1 S=2 i=2 S=8
    printf(“%d\n”,s);
    } 64
    【考点3】动态存储分配
    malloc(size)用来创建连续size个字节存储区,返回值类型为void *型。malloc函数常用于动态创建链表结点,如int *p; p=(int *)malloc(sizeof(int));。
    calloc(n,size)创建n个同一类型的存储空间,可以理解为n个malloc。
    free§释放动态分配的存储单元。

    第二部分 公共基础知识资料
    第一章 数据结构与算法
    【考点1】算法的基本概念
    算法:是指一组有穷的指令集,是解题方案的准确而完整的描述。算法不等于程序,也不等于计算方法。
    算法的基本特征:
    确定性,算法中每一步骤都必须有明确定义,不允许有多义性;
    有穷性,算法必须能在有限的时间内做完,即能在执行有限个步骤后终止;
    可行性,算法原则上能够精确地执行;
    拥有足够的情报。
    算法的组成要素:一个算法由数据对象的运算和操作以及其控制结构这两部分组成。
    算法的基本运算和操作:算术运算,逻辑运算,关系运算,数据传输。
    算法的基本控制结构:顺序,选择,循环。
    算法基本设计方法:列举法、归纳法、递推、递归、减半递推技术。
    【考点2】算法的复杂度
    算法效率的度量——算法的复杂度:时间复杂度和空间复杂度。
    算法时间复杂度:指执行算法所需要的计算工作量。通常,一个算法所用的时间包括编译时间和运行时间。
    算法空间复杂度:指执行这个算法所需要的内存空间。包括算法程序所占的空间,输入的初始数据所占的空间,算法执行过程中所需的额外空间。
    空间复杂度和时间复杂度并不相关。
    【考点3】数据结构的基本概念
    数据:数据是客观事物的符号表示,是能输入到计算机中并被计算程序识别和处理的符号的总称,如文档,声音,视频等。
    数据元素:数据元素是数据的基本单位。
    数据对象:数据对象是性质相同的数据元素的集合。
    数据结构:是指由某一数据对象中所有数据成员之间的关系组成的集合。
    【考点4】逻辑结构和存储结构
    数据结构可分为数据的逻辑结构和存储结构。
    数据的逻辑结构是对数据元素之间的逻辑关系的描述,与数据的存储无关,是面向问题的,是独立于计算机的。它包括数据对象和数据对象之间的关系。
    数据的存储结构也称为数据的物理结构,是数据在计算机中的存放的方式,是面向计算机的,它包括数据元素的存储方式和关系的存储方式。
    数据结构和逻辑结构的关系:一种数据的逻辑结构可以表示成多种存储结构即数据的逻辑结构和存储结构不一定一一对应。
    常见的存储结构有:顺序,链接,索引等。采用不同的存储结构其数据处理的效率是不同的。
    【考点5】线性结构和非线性结构
    线性结构的条件(一个非空数据结构):(1)有且只有一个根结点;(2)每一个结点最多有一个前件,也最多有一个后件。
    非线性结构:不满足线性结构条件的数据结构。
    栈、队列、双向链表是线性结构,树、二叉树为非线性结构。
    【考点6】线性表及其顺序存储结构
    线性表是由一组数据元素构成,数据元素的位置只取决于自己的序号,元素之间的相对位置是线性的。
    在复杂线性表中,由若干项数据元素组成的数据元素称为记录;由多个记录构成的线性表称为文件。
    非空线性表的结构特征:
    (1)有且只有一个根结点a1,它无前件;
    (2)有且只有一个终端结点an,它无后件;
    (3)除根结点与终端结点外,其他所有结点有且只有一个前件,也有且只有一个后件。
    结点个数n称为线性表的长度,当n=0时,称为空表。
    线性表的顺序存储结构具有以下两个基本特点:
    (1)线性表中所有元素所占的存储空间是连续的;
    (2)线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
    元素ai的存储地址为:ADR(ai)=ADR(a1)+(i-1)*k,ADR(a1)为第一个元素的地址,k代表每个元素占的字节数。
    顺序表的运算:查找、插入、删除。
    【考点7】线性链表
    线性链表是线性表的链式存储结构,数据结构中的每一个结点对应于一个存储单元,这种存储单元称为存储结点,简称结点。结点由两部分组成:(1) 用于存储数据元素值,称为数据域;(2) 用于存放指针,称为指针域,用于指向前一个或后一个结点。
    在链式存储结构中,存储数据结构的存储空间可以不连续,各数据结点的存储顺序与数据元素之间的逻辑关系可以不一致,而数据元素之间的逻辑关系是由指针域来确定的。
    链式存储方式既可用于表示线性结构,也可用于表示非线性结构。
    线性单链表中,HEAD称为头指针,HEAD=NULL(或0)称为空表。

    双向链表有两个指针:左指针(Llink)指向前件结点,右指针(Rlink)指向后件结点。

    循环链表:循环链表与单链表的不同的是它的最后一个结点的指针域存放的事指向第一个结点的指针而单链表存放的是空指针。

    线性链表的基本运算:查找、插入、删除。
    【考点8】栈
    1、栈的基本概念
    栈是一种特殊的线性表,只允许在表的一端进行插入和删除的线性表;插入,删除的一端为栈顶,另一端为栈底;当表中没有元素时为空栈。
    栈是一种后进先出(或先进后出Last In First Out)的线性表。栈具有记忆功能。栈的实例:火车调度,子弹夹。
    2、栈的存储结构
    顺序存储结构:用一组地址连续的存储单元即一维数组来存储;
    链式存储:用线性链表来存储;
    3、栈的基本运算
    (1) 入栈运算,在栈顶位置插入元素;
    (2) 退栈运算,删除元素(取出栈顶元素并赋给一个指定的变量);
    (3) 读栈顶元素,将栈顶元素赋给一个指定的变量,此时指针无变化。
    【考点9】队列
    1.队列的基本概念
    队列是一种特殊的线性表,只允许在表的一端插入,在另一端删除,允许插入的一端是队尾(rear),允许删除的一端为队头(front);当表中没有元素是空队列;队列是一种先进先出的线性表。(FIFO)
    2、队列的存储结构
    顺序存储:一维数组。
    链式存储:线性链表。队尾插;队头删
    3、队列的运算:
    (1) 入队运算:从队尾插入一个元素; (2) 退队运算:从队头删除一个元素。
    队列的顺序存储结构一般采用循环队列的形式。循环队列s=0表示队列为空;s=1且front=rear表示队满。
    计算循环队列的元素个数:“尾指针减头指针”,若为负数,再加其容量即可。
    【考点10】树的基本概念
    树是一种非线性结构,是n个结点的有限集。当n=0 时为空树,n>0时为非空树。结点的度:结点所拥有的子树的个数。
    叶子结点:度为0的结点。
    分支结点:除叶子结点以外的结点。
    结点的层次:根结点在第一层,同一层上左右结点的子结点在下一层。
    树的深度:所处层次最大的那个结点的层次。
    树的度:树中所有结点的度的最大值。
    【考点11】二叉树及其基本性质
    1、二叉树的概念
    二叉树是一种特殊的树形结构,每个结点最多只有两棵子树,且有左右之分不能互换,因此,二叉树有五种不同的形态,见教材12页。
    2、二叉树的性质
    性质1 在二叉树的第k层上,最多有2k-1(k≥1)个结点。
    性质2 深度为m的二叉树最多有2m-1个结点。
    性质3 在任意一棵二叉树中,度为0的结点(叶子结点)总是比度为2的结点多一个。
    性质4 具有n个结点的二叉树,其深度不小于[log2n]+1,其中[log2n]表示为log2n的整数部分。
    3、二叉树的存储结构:详见教材第13-14页。
    【考点12】满二叉树与完全二叉树
    满二叉树:除最后一层外,每一层上的所有结点都有两个子结点。在满二叉树中,每一层上的结点数都达到最大值,即在满二叉树的第k层上有2k-1个结点,且深度为m的满二叉树有2m-1个结点。
    完全二叉树是指这样的二叉树:除最后一层外,每一层上的结点数均达到最大值;在最后一层上只缺少右边的若干结点。
    满二叉树是完全二叉树,而完全二叉树一般不是满二叉树。
    【考点13】完全二叉树的性质
    性质1 具有n个结点的完全二叉树的深度为[log2n]+1。
    性质2 完全二叉树中度为1的结点数为0或1。
    【考点14】二叉树的遍历
    前序遍历:先访问根结点、然后遍历左子树,最后遍历右子树;并且,在遍历左、右子树时,仍然先访问根结点,然后遍历左子树,最后遍历右子树。
    前序遍历图5可得:ABCDFHEG。
    中序遍历:先遍历左子树、然后访问根结点,最后遍历右子树;并且,在遍历左、右子树时,仍然先遍历左子树,然后访问根结点,最后遍历右子树。
    中序遍历图5可得:BAFHDCGE。
    后序遍历:先遍历左子树、然后遍历右子树,最后访问根结点;并且,在遍历左、右子树时,仍然先遍历左子树,然后遍历右子树,最后访问根结点。
    后序遍历图5可得:BHFDGECA。

    【考点15】顺序查找
    顺序查找是从表的一端开始,依次扫描表中的各个元素,并与所要查找的数进行比较。
    在下列两种情况下也只能采用顺序查找:
    (1)如果线性表为无序表,则不管是顺序存储结构还是链式存储结构,只能用顺序查找。
    (2)即使是有序线性表,如果采用链式存储结构,也只能用顺序查找。
    【考点16】二分查找
    二分查找的条件:(1)用顺序存储结构 (2)线性表是有序表。
    查找的步骤:详见教材第16页。
    对于长度为n的有序线性表,在最坏情况下,二分法查找只需比较log2n次,而顺序查找需要比较n次。
    【考点17】排序
    1、交换排序
    (1)冒泡排序法,在最坏的情况下,冒泡排序需要比较次数为n(n-1)/2。
    (2)快速排序法 ,在最坏的情况下,快速排序需要比较次数为n(n-1)/2。
    2、插入类排序法:
    (1)简单插入排序法,最坏情况需要n(n-1)/2次比较;
    (2)希尔排序法,最坏情况需要O(n1.5)次比较。(大写O是算法复杂度的表示方法)
    3、选择类排序法:
    (1)简单选择排序法,最坏情况需要n(n-1)/2次比较;
    (2)堆排序法,最坏情况需要O(nlog2n)次比较。
    相比以上几种(除希尔排序法外),堆排序法的时间复杂度最小。
    第二章 程序设计基础
    【考点1】程序设计方法与风格
    形成良好的程序设计风格需注意:(详见教材第19页)。
    1、源程序文档化; 2、数据说明的方法; 3、语句的结构; 4、输入和输出。
    注释分序言性注释和功能性注释。
    语句结构清晰第一、效率第二。
    【考点2】结构化程序设计方法的四条原则
    1、自顶向下; 2、逐步求精; 3、模块化; 4、限制使用goto语句。
    【考点3】结构化程序的基本结构
    顺序结构:是最基本、最普通的结构形式,按照程序中的语句行的先后顺序逐条执行。
    选择结构:又称为分支结构,它包括简单选择和多分支选择结构。
    循环结构:根据给定的条件,判断是否要重复执行某一相同的或类似的程序段。循环结构对应两类循环语句:先判断后执行的循环体称为当型循环结构;先执行循环体后判断的称为直到型循环结构。
    【考点4】面向对象的程序设计及面向对象方法的优点
    面向对象的程序设计以对象为核心,强调对象的抽象性,封装性,继承性和多态性。
    面向对象方法的优点
    (1)人类习惯的思维方法一致; (2)稳定性好; (3)可重用性好;
    (4)易于开发大型软件产品; (5)可维护性好。
    【考点5】对象及其特点
    对象(object):面向对象方法中最基本的概念,可以用来表示客观世界中的任何实体,对象是实体的抽象。
    对象的基本特点:
    (1)标识惟一性; (2)分类性; (3)多态性; (4)封装性; (5)模块独立性好。
    【考点6】属性,类和实例
    属性:即对象所包含的信息,它在设计对象时确定,一般只能通过执行对象的操作来改变。
    类:是具有相似属性与操作的一组对象。类是关于对象性质的描述。类是对象的抽象,对象是其对应类的一个实例。
    【考点7】消息及其组成
    消息:是一个实例与另一个实例之间传递的信息。对象间的通信靠消息传递。它请求对象执行某一处理或回答某一要求的信息,它统一了数据流和控制流。
    消息的组成包括:
    (1)接收消息的对象的名称; (2)消息标识符,也称消息名; (3)零个或多个参数。
    【考点8】继承和多态
    继承:是使用已有的类定义作为基础建立新类的定义技术,广义指能够直接获得已有的性质和特征,而不必重复定义他们。
    继承具有传递性,一个类实际上继承了它上层的全部基类的特性。
    继承分单继承和多重继承。单继承指一个类只允许有一个父类,即类等级为树形结构;多重继承指一个类允许有多个父类。
    多态性:是指同样的消息被不同的对象接受时可导致完全不同的行动的现象
    第三章 软件工程基础
    【考点1】软件定义与软件特点
    软件指的是计算机系统中与硬件相互依存的另一部分,包括程序、数据和相关文档的完整集合。
    名称 描述
    程序 软件开发人员根据用户需求开发的、用程序设计语言描述的、适合计算机执行的指令序列
    数据 使程序能正常操纵信息的数据结构
    文档 与程序的开发、维护和使用有关的图文资料
    软件的特点:
    软件是一种逻辑实体,具有抽象性;
    软件的生产与硬件不同,它没有明显的制作过程;
    软件在运行、使用期间不存在磨损、老化问题;
    软件的开发、运行对计算机系统具有依赖性,受计算机系统的限制,这导致了软件移植的问题;
    软件复杂性高,成本昂贵;
    软件开发涉及诸多的社会因素。
    根据应用目标的不同,软件可分应用软件、系统软件和支撑软件(或工具软件)。
    名称 描述
    应用软件 为解决特定领域的应用而开发的软件,如办公自动化软件
    系统软件 计算机管理自身资源,提高计算机使用效率并为计算机用户提供各种服务的软件,如操作系统
    支撑软件(或工具软件) 支撑软件是介于两者之间,协助用户开发软件的工具性软件。
    【考点2】软件的生命周期
    软件生命周期是指软件产品从提出、实现、使用维护到停止使用退役的整个过程。可分为软件定义,软件开发及软件维护3个阶段。软件生命周期中,能够准确确定软件系统必须做什么和必须具备哪些功能的阶段是:需求分析。

    定义阶段 开发阶段 维护阶段
    【考点3】软件危机和软件工程的概念
    软件危机泛指在计算机软件的开发和维护过程中遇到的一系列严重的问题,集中表现在成本,质量。生产效率等几个方面。
    所谓软件工程是指采用工程的概念、原理、技术和方法指导软件的开发与维护。是建立并使用完善的工程化原则,以较经济的手段获得,能在实际机器上有效运行的可靠软件的一系列方法;软件工程的主要思想强调在软件开发过程中需要应用工程化原则。软件工程的核心思想是把软件当作一个工程产品来处理。
    软件工程包括3个要素:方法,工具和过程
    名称 描述
    方法 方法是完成软件工程项目的技术手段
    工具 工具支持软件的开发、管理、文档生成
    过程 过程支持软件开发的各个环节的控制、管理
    【考点4】软件工程过程
    软件工程过程是把软件转化为输出的一组彼此相关的资源活动,包含4种基本活动:
    (1)P(plan)——软件规格说明; (2)D(do)——软件开发;
    (3)C(check)——软件确认; (4)A(action)——软件演进。
    【考点5】软件开发技术和软件工程管理
    软件工程的理论和技术性研究的内容主要包括软件开发技术和软件工程管理。
    软件开发技术包括软件开发方法学、开发过程、开发工具和软件工程环境,其主体内容是软件开发方法学。
    软件开发方法包括分析方法,设计方法和程序设计方法。
    软件工程管理包括软件管理学,软件工程经济学,软件心理学等。
    软件管理学包括人员组织,进度安排,质量保证,配置管理,项目计划等。
    软件工程经济学是研究软件开发中成本的估算,成本效益的方法和技术。
    【考点6】软件工程的原则
    软件工程的原则:抽象,信息隐蔽,模块化,局部化,确定性,一致性,完备性,可验证性(详细见教材第28-29页)。
    【考点7】需求分析概述
    需求分析阶段的工作:需求获取,需求分析,编写需求规格说明书,需求评审。
    需求分析方法有:
    (1)结构化需求分析方法;
    ①面向数据结构的Jackson方法(ISD);
    ②面向数据流的结构化分析方法(SA);
    ③面向数据结构的结构化数据系统开发方法(DSSD);
    (2)面向对象的分析的方法(OOA)。
    从需求分析建立的模型的特性来分:静态分析和动态分析。
    【考点8】结构化方法和结构化分析方法
    1、结构化方法包括结构化分析方法,结构化设计方法,结构化编程方法。
    结构化方法中,软件功能分解属于总体设计阶段。
    2、结构化分析方法的概念
    结构化分析方法是面向数据流自顶而下逐步求精进行需求分析的方法。
    结构化分析方法在软件需求分析阶段的应用。
    3、结构化分析的常用工具
    数据流图(DFD-Data Flow Diagram):是结构化分析方法中用于系统逻辑模型的一种工具。它以图形的方式描绘在系统中流动和处理的过程。
    数据流图中四种基本的符号。
    箭头:表示数据流,数据流是数据在系统中传播的路径。
    圆或椭圆:表示加工,加工又称为数据处理,是对数据流进行某些操作或变换。
    双横:表示数据存储(数据源)。数据存储又称为文件,指暂时保存的数据,它可以是数据库文件或任何形式的数据组织。
    方框:源、潭。表示数据的源点或终点。它是软件系统外部环境中的实体,统称外部实体
    数据字典(DD):它是结构分析方法的核心,是用来描述系统中所用到的全部数据和文件的文档,作用是对DFD中出现的被命名的图形元素进行确切解释。
    数据字典由以下4类元素组成
    (1)数据流 (2)数据流分量 (3)数据存储 (4)处理
    判定树(决策树):是一种描述加工的图形工具,适合描述时候处理中具有多个判断,而且每个决策与若干条件有关。
    判定表:与判定树类似,也是一种描述加工的图形工具。如果一个加工逻辑有多个条件、多个操作,并且在不同的条件组合下执行不同的操作,那么可以使用判定表来描述。
    【考点9】软件需求规格说明书
    软件需求规格说明书(SRS,Software Requirement Specification)是需求分析阶段得出的最主要的文档。软件需求规格说明书的特点:有正确性、无歧义性、完整性、可验证性、一致性、可理解性、可修改性和可追踪性。其中最重要的是无歧义性。
    【考点10】软件设计的基本概念
    软件设计是确定系统的物理模型。
    软件设计是开发阶段最重要的步骤,是将需求准确地转化为完整的软件产品或系统的唯一途径。
    从技术观点上看,软件设计包括软件结构设计、数据设计、接口设计、过程设计。
    (1)结构设计定义软件系统各主要部件之间的关系;
    (2)数据设计将分析时创建的模型转化为数据结构的定义;
    (3)接口设计是描述软件内部、软件和协作系统之间以及软件与人之间如何通信;
    (4)过程设计则是把系统结构部件转换为软件的过程性描述。
    从工程管理角度来看,软件设计分两步完成:概要设计和详细设计。
    (1)概要设计将软件需求转化为软件体系结构、确定系统级接口、全局数据结构或数据库模式;
    (2)详细设计确立每个模块的实现算法和局部数据结构,用适当方法表示算法和数据结构的细节。
    【考点11】软件设计的基本原理
    1、软件设计中应该遵循的基本原理和与软件设计有关的概念:
    模块化:把程序划分成独立命名且可独立访问的模块,每个模块完成一个子功能。
    抽象化:抽出事物的本质特性而暂时不考虑它们的细节。
    信息隐藏和局部化:信息隐蔽是指在一个模块内包含的信息(过程或数据),对于不需要这些信息的其他模块来说是不能访问的,实现信息隐蔽依靠对象的封装。
    模块独立性:模块独立性是指每个模块只完成系统要求的独立的子功能,并且与其他模块的联系最少且接口简单。模块的独立程度是评价设计好坏的重要度量标准。
    【考点12】耦合性和内聚性
    衡量软件的模块独立性是用耦合性和内聚性两个定性的度量标准。
    耦合性:是对一个软件结构内不同模块之间互联程度的度量。耦合性的强弱取决于模块间接口的复杂程度。
    内聚性:是一个模块内部各个元素间彼此结合的紧密程度的度量。
    一个模块的内聚性越强则该模块的模块独立性越强。一个模块与其他模块的耦合性越强则该模块的模块独立性越弱。
    在结构程序设计中,模块划分的原则是模块内具有高内聚度,模块间具有低耦合度。
    耦合和内聚的种类(详见教材第35页)。
    耦合度由低到高:非直接耦合,数据耦合,标记耦合,控制耦合,外部耦合,公共耦合,内容耦合。
    内聚性由强到弱:功能内聚,顺序内聚,通信内聚,过程内聚,时间内聚,逻辑内聚,偶然内聚。
    【考点13】结构化设计方法
    结构化分析方法是面向数据流自顶而下,逐步求精进行需求分析的方法,基本思想将软件设计成由相对独立,单一功能的模块组成的结构,与结构分析方法衔接使用,以数据流图为基础得到软件的模块结构,适用于变换型结构和事物型结构的目标系统。
    1、概要设计的任务:(1)划分出组成系统的物理元素 (2)设计软件的结构
    2、概要设计的工具:
    结构图(SC-Structure Chart)也称程序结构图,在结构图中,模块用一个矩形表示,箭头表示模块间的调用关系。可以用带注释的箭头表示模块调用过程中来回传递的信息。还可用带实心圆的箭头表示传递的是控制信息,空心圆箭心表示传递的是数据。
    结构图的基本形式:基本形式、顺序形式、重复形式、选择形式。
    结构图有四种模块类型:传入模块、传出模块、变换模块和协调模块。
    程序结构图中的专业术语:
    名称 描述
    深度 表示控制的层数
    上级模块,从属模块 上,下两层模块a和b,且有a调用b,则a是上级模块,b是从属模块
    宽度 整体控制跨度(最大模块的层)的表示
    扇入 调用该模块的模块个数
    扇出 一个模块直接调用的其他模块数
    原子模块 树中位于叶子节点的模块
    3、面向数据流的设计方法
    任何软件系统都可以用数据流图表示,典型的数据流类型有两种:变换型和事务型。
    变换型系统结构图由输入、中心变换、输出三部分组成。
    4、设计的准则
    (1)提高模块独立性。
    (2)模块规模适中。
    (3)深度,宽度,扇出和扇入适当。如果深度过大,则说明有的控制模块可能简单了,如果宽度过大,则说明系统的控制过于集中,扇出过大说明模块过分复杂,需要控制和协调过多的下级模块,应适当加中间层次,扇出过小可以把模块进一步分解成若干小模块,或合并到上级模块中,扇入越大则共享该模块的上级数目越多。好的软件设计结构通常顶层高扇出,中间扇出较少,底层高扇入。
    (4)使模块的作用域在该模块的控制域内。
    (5)减少模块的接口和界面的复杂性。
    (6)设计成单入口,单出口的模块。
    (7)设计功能可预测的模块。
    详细设计常用的设计工具(工程设计工具):图形工具,表格工具和语言工具。
    图形工具:
    程序流程图:箭头表示控制流,方框表示加工步骤,菱形表示逻辑条件。
    N-S图:有五种基本图形。
    PAD图:问题分析图,有五种基本图型。
    表格工具:判定表。
    语言工具:PDL——过程设计语言(结构化的英语和伪码)。
    【考点14】软件测试的目标和准则
    软件测试的目标:发现程序中的错误。
    软件测试的准则:
    (1)所有测试都是应追溯到需求。
    (2)严格执行测试计划,排除测试的随意性。
    (3)充分注意测试中的群集表现。程序中存在错误的概率与该程序中已发现的错误数成正比。
    (4)程序员应避免检查自己的程序。
    (5)穷举测试不可能。穷举测试是把程序所有可能的执行路径都进行检查,即使小规模的程序的执行路径数也相当大,不可能穷尽,说明测试只能证明程序有错,不能证明程序中无错。
    (6)妥善保存测试计划,测试用例出错统计和最终分析报告。
    【考点15】软件测试方法
    从是否需要执行被测软件的角度分为静态测试和动态测试;按功能分为白盒测试和黑盒测试
    1、静态测试和动态测试
    静态测试包括代码检查、静态结构分析、代码质量度量。不实际运行软件,主要通过人工进行。
    动态测试是通过运行软件来检验软件中的动态行为和运行结果的正确性。动态测试的关键是使用设计高效、合理的测试用例。测试用例就是为测试设计的数据,由测试输入数据(输入值集)和预期的输出结果(输出值集)两部份组成。测试用例的设计方法一般分为两类:黑盒测试方法和白盒测试方法。
    2、白盒测试和黑盒测试
    (1)白盒测试
    白盒测试也称为结构测试或逻辑测试,是把程序看成装在一只透明的白盒子里,测试者完全了解程序的结构和处理过程。它根据程序的内部逻辑来设计测试用例,检查程序中的逻辑通路是否都按预定的要求正确地工作。
    白盒测试的基本原则:
    (1)保证所测模块中每一独立路径至少执行一次。
    (2)保证所测模块所有判断的每一分支至少执行一次。
    (3)保证所测模块每一循环都在边界条件和一般条件下至少各执行一次。
    (4)验证所有内部数据结构的有效性。
    (5)按照白盒测试的基本原则,“白盒”法是穷举路径测试。
    白盒测试的方法:逻辑覆盖,基本路经测试。
    (2)黑盒测试
    黑盒测试也称功能测试或数据驱动测试,是把程序看成一只黑盒子,测试者完全不了解,或不考虑程序的结构和处理过程。它根据规格说明书的功能来设计测试用例,检查程序的功能是否符合规格说明的要求。
    黑盒测试的方法:等价划分法,边界值分析法,错误推测法。
    【考点16】软件测试的实施
    软件测试过程分4个步骤,即单元测试、集成测试、验收测试和系统测试。
    单元测试是对软件设计的最小单位——模块进行正确性检验的测试,单元测试的根据是源程序和详细设计说明书,单元测试的技术可以采用静态分析和动态测试。
    单元测试期间对模块进行的测试:模块接口,局部数据结构,重要的执行通路,出错处理通路,边界条件。
    驱动模块相当于被测模块的主程序,它接收测试数据,并传给所测模块,输出实际测试结果
    桩模块通常用于代替被测模块调用的其他模块,其作用仅做少量的数据操作,是一个模拟子程序。
    集成测试是测试和组装软件的系统化技术,主要目的是发现与接口有关的错误,集成测试的依据是概要设计说明书。
    集成测试的方法:非增量方式组装和增量方法组装。
    增量方式包括自顶而下的增量方式,自底而上的增量方式和混合增量方式。
    确认测试的任务是验证软件的功能和性能,确认测试的实施首先运用黑盒测试方法,对软件进行有效性测试,即验证被测软件是否满足需求规格说明确认的标准。
    检查软件产品是否符合需求定义的过程是:确认测试。
    系统测试是通过测试确认的软件,作为整个基于计算机系统的一个元素,与计算机硬件、外设、支撑软件、数据和人员等其他系统元素组合在一起,在实际运行(使用)环境下对计算机系统进行一系列的集成测试和确认测试。
    系统测试的具体实施一般包括:功能测试、性能测试、操作测试、配置测试、外部接口测试、安全性测试等。
    【考点17】程序调试
    在对程序进行了成功的测试之后将进入程序调试(通常称Debug,即排错)。
    程序的调试任务是诊断和改正程序中的错误。
    程序调试和软件测试的区别:
    (1)软件测试是尽可能多地发现软件中的错误,而程序调试先要发现软件的错误,然后借助于一定的调试工具去执行找出软件错误的具体位置。
    (2)软件测试贯穿整个软件生命期,调试主要在开发阶段。
    程序调试的基本步骤:
    (1)错误定位。从错误的外部表现形式入手,研究有关部分的程序,确定程序中出错位置,找出错误的内在原因;
    (2)修改设计和代码,以排除错误;
    (3)进行回归测试,防止引进新的错误。
    软件调试可分为静态调试和动态调试。静态调试主要是指通过人的思维来分析源程序代码和排错,是主要的设计手段,而动态调试是辅助静态调试的。
    主要的调试方法有:
    (1)强行排错法; (2)回溯法; (3)原因排除法,包括演绎法,归纳法和二分法。
    第四章 数据库设计基础
    【考点1】数据库的基本概念
    数据(Data)是数据库存储的基本对象,是描述事物的符号记录。
    数据库(DB)是长期储存在计算机内、有组织的、可共享的大量数据的集合,它具有统一的结构形式并存放于统一的存储介质内,是多种应用数据的集成,并可被各个应用程序所共享,所以数据库技术的根本目标是解决数据共享问题。
    数据库管理系统(DBMS)是数据库的管理机构,负责数据库中的数据组织、数据操纵、数据维护、控制及保护和数据服务等。数据库管理系统是数据库系统的核心。数据库系统包含数据库和数据库管理系统。
    数据库管理系统的功能:
    (1)数据模式定义:即为数据库构建其数据框架;
    (2)数据存取的物理构建:为数据模式的物理存取与构建提供有效的存取方法与手段;
    (3)数据操纵:为用户使用数据库的数据提供方便,如查询、插入、修改、删除等以及简单的算术运算及统计;
    (4)数据的完整性、安全性定义与检查;
    (5)数据库的并发控制与故障恢复;
    (6)数据的服务:如拷贝、转存、重组、性能监测、分析等。
    为完成数据库管理系统的功能,数据库管理系统提供相应的数据语言:
    数据定义语言(DDL):负责数据模式定义和数据物理存取构建。
    数据操纵语言(DML):负责数据的操纵。
    数据控制语言(DCL):负责数据完整性,安全性的定义与检查以及并发控制,故障恢复等功能。
    数据语言按使用方式具有两个结构形式:交互式命令语言(自含型和自主型语言)和宿主型语言。
    数据库管理员(DBA)的工作:数据库设计,数据库维护,改善系统性能,提高系统效率。
    数据库系统(DBS)是指在计算机系统中引入数据库后的系统,一般由数据库、数据库管理系统、应用系统、数据库管理员和用户构成。
    数据库应用系统(DBAS)是数据库系统再加上应用软件及应用界面这三者所组成,具体包括:数据库、数据库管理系统、数据库管理员、硬件平台、软件平台、应用软件、应用界面。
    【考点2】数据管理的发展和基本特点
    数据管理技术的发展经历了三个阶段:人工管理阶段、文件系统阶段和数据库系统阶段,数据独立性最高的阶段是数据库系统阶段。
    人工管理阶段特点:(1)计算机系统不提供对用户数据的管理功能(2)数据不能共享(3)不单独保存数据。
    文件系统阶段的缺陷:(1)数据冗余(2)不一致性(3)数据联系弱。
    数据库系统的发展阶段:第一代的网状、层次数据库系统;第二代的关系数据库系统;第三代的以面向对象模型为主要特征的数据库系统。
    数据库系统的基本特点:
    (1)数据的高集成性 (2)数据的高共享性和低冗余性 (3)数据高独立性 (4)数据统一管理与控制。
    数据独立性是数据与程序间的互不依赖性,即数据库中的数据独立于应用程序而不依赖于应用程序。
    数据的独立性一般分为物理独立性与逻辑独立性两种。
    (1)物理独立性:当数据的物理结构(包括存储结构、存取方式等)改变时,其逻辑结构,应用程序都不用改变。
    (2)逻辑独立性:数据的逻辑结构改变了,如修改数据模式、增加新的数据类型、改变数据间联系等,用户的应用程序可以不变。
    【考点3】数据系统的内部结构体系
    1、数据统系统的三级模式:
    (1)概念模式,也称逻辑模式,是对数据库系统中全局数据逻辑结构的描述,是全体用户公共数据视图。一个数据库只有一个概念模式。
    (2)外模式,外模式也称子模式,它是数据库用户能够看见和使用的局部数据的逻辑结构和特征的描述,一个概念模式可以有若干个外模式。
    (3)内模式,内模式又称物理模式,它给出了数据库物理存储结构与物理存取方法。一个数据库只有一个内模式。
    内模式处于最底层,它反映了数据在计算机物理结构中的实际存储形式,概念模式处于中间层,它反映了设计者的数据全局逻辑要求,而外模式处于最外层,它反映了用户对数据的要求。
    2、数据库系统的两级映射 (详见教材第55页)
    两级映射保证了数据库系统中数据的独立性。
    (1)概念模式到内模式的映射。该映射给出了概念模式中数据的全局逻辑结构到数据的物理存储结构间的对应关系;
    (2)外模式到概念模式的映射。概念模式是一个全局模式而外模式是用户的局部模式。一个概念模式中可以定义多个外模式,而每个外模式是概念模式的一个基本视图。
    【考点4】数据模型的基本概念
    数据模型按不同的应用层次分为:
    概念数据模型:简称概念模型,是一种面向客观世界,面向用户的模型,不涉及具体的硬件环境和平台也与具体的软件环境无关的模式,它是整个数据模型的基础。
    逻辑数据模型:又称数据模型,它是一种面向数据库的模型。分为层次模型,网状模型,关系模型和面向对象模型,其中层次模型和网状模型统称为非关系模型。层次模型用树型结构表示实体之间联系的模型。
    物理数据模型:又称物理模型,它是一种面向计算机物理表示的模型。
    【考点5】E—R模型
    1、E-R模型的基本概念
    (1)实体:现实世界中的事物可以抽象成为实体,实体是概念世界中的基本单位,它们是客观存在的且又能相互区别的事物。
    (2)属性:现实世界中事物均有一些特性,这些特性可以用属性来表示。
    (3)码:唯一标识实体的属性集称为码。
    (4)域:属性的取值范围称为该属性的域。
    (5)联系:在现实世界中事物间的关联称为联系。
    两个实体集间的联系实际上是实体集间的函数关系,这种函数关系可以有下面几种:一对一的联系、一对多或多对一联系、多对多。
    2、E-R模型的的图示法
    E-R模型用E-R图来表示,E-R图包含了表示实体集、属性和联系的方法。
    (1)实体的表示:用矩形表示实体集,在矩形内写上该实体集的名字。
    (2)属性的表示:用椭圆形表示属性,在椭圆形内写上该属性的名称。
    (3)联系的表示:用菱形表示联系,菱形内写上联系名。
    【考点6】层次模型和网状模型
    层次模型是有根的定向有序树,是数据库系统中最早出现的数据模型。网状模型对应的是有向图。
    层次模型和网状模型各自应满足的条件
    模型名称 满足的条件
    层次模型 (1)有且只有一个结点没有双亲结点,这个结点称为根结点
    (2)根以外的其他结点有且只有一个双亲结点
    网状模型 (1)允许一个以上的结点无双亲
    (2)一个结点可以有多于一个的双亲
    【考点7】关系模型及相关概念
    关系模式采用二维表来表示,由关系数据结构,关系操纵和关系完整性约束3部分组成,在关系数据库中,用来表示实体间联系的是关系。
    关系:一个关系对应一张二维表。一个关系就是一个二维表,但是一个二维表不一定是一个关系。
    元组:表中的一行即为一个元组。
    属性:表中的一列即为一个属性,给每一个属性起一个名称即属性名。
    分量:元组中的一个属性值,是不可分割的基本数据项。
    域:属性的取值范围。
    在二维表中惟一标识元组的最小属性值称为该表的键或码。二维表中可能有若干个健,它们称为表的候选码或候选健。从二维表的所有候选键选取一个作为用户使用的键称为主键或主码。表A中的某属性集是某表B的键,则称该属性值为A的外键或外码。
    关系操纵:数据查询、数据的删除、数据插入、数据修改。
    关系模型允许定义三类数据约束,它们是实体完整性约束、参照完整性约束以及用户定义的完整性约束。其中实体完整性约束、参照完整性约束必须满足的完整性约束条件。参照完整性约束不允许关系应用不存在的元组。实体完整性约束要求关系的主键中属性值不能为空,这是数据库完整性的最基本要求。
    【考点8】关系代数
    关系代数是一种抽象的查询语言,关系代数的运算对象是关系,运算结果也是关系。运算对象,运算符和运算结果是运算的三大要素。集合运算符,专门的运算符,算术比较符和逻辑运算符。
    关系模型的基本运算:(1)插入 (2)删除 (3)修改 (4)查询(包括投影、选择、笛卡尔积运算)还有扩充运算交、除、连接及自然连接运算。
    关系代数的5个基本操作中并,差,交,笛卡尔积是二目运算。
    设关系R和S具有相同的关系模式
    1、并:R和S的并是由属于R或属于S的所有元组构成的集合。
    2、差:R和S的差是由属于R但是不属于S的元组构成的集合
    3、笛卡尔积:设R和S的元数分别为r和s,R和S的笛卡尔积是一个(r+s)元的元组集合,每个元组的前r个分量来自R的一个元组,后s个分量来自S的一个元组。运算后得到的新表的元组数是R*S,属性是r+s。
    4、交:属于R又属于S的元组构成的集合。
    5、投影:一元运算,对一个关系进行垂直切割,消去某些列,并重新按排列的顺序。
    6、选择:一元运算,根据某些条件对关系进行水平分割。即选择符合条件的元组。
    7、除:给定关系R(X,Y)和S(Y,Z),其中X,Y,Z是属性组,R中的Y和S中Y可以有不同的属性名,但必须出自相同的域集。
    8、连接:也称θ连接运算,是一种二元运算,它的操作是从两个关系的笛卡尔积中选取属性间满足一定条件的元组,以合并成一个大关系。连接运算包括等值连接和不等值连接。连接运算后得到的新表的属性是运算前表中属性相加。即多于原来关系中属性的个数。
    9、自然连接:自然连接满足的条件是(1)两关系间有公共域(2)通过公共域的相等值进行连接。
    【考点9】数据库设计和管理
    数据库设计中有两种方法,面向数据的方法和面向过程的方法。
    面向数据的方法是以信息需求为主,兼顾处理需求;面向过程的方法是以处理需求为主,兼顾信息需求。由于数据在系统中稳定性高,数据已成为系统的核心,因此面向数据的设计方法已成为主流。
    数据库设计目前一般采用生命周期法,即将整个数据库应用系统的开发分解成目标独立的若干阶段。它们是:需求分析阶段、概念设计阶段、逻辑设计阶段、物理设计阶段。
    一个低一级范式的关系模式,通过模式分解可以转化为若干个高一级范式的关系模式的集合,这种过程就叫规范化。
    概念结构设计是将需求分析阶段得到的用户需求抽象为信息结构即概念模型的过程,它是整个数据库设计的关键。
    逻辑结构设计的任务是将E—R图转换成关系数据模型的过程。
    数据库的物理结构是指数据库在物理设备上的存储结构和存取方法。它依赖于给定的计算机系统。
    常用的存取方法:索引方法,聚簇方法和HASH方法。
    数据库管理的内容:
    (1)数据库的建立,它是数据库管理的核心,包括数据模式的建立和数据加载。
    (2)数据库的重组。
    (3)数据库安全性控制。
    (4)数据库的完整性控制,数据库的完整性是指数据的正确性和相容性。
    (5)数据库的故障恢复。
    (6)数据库监
    输入输出
    有以下程序段
    int j;
    float y;
    char name[50];
    scanf(“%2d%f%s”,&j,&y,name);
    若从键盘上输入55 566 7777qbc后,y的值为(566.0)

    循环
    #include<stdio.h>
    main()
    {
    int x =8;
    for(;x>0;x–)
    {
    if(x%3) 8 5 4 2
    {
    printf(“%d”,x–);
    continue;
    }
    printf(“%d”,–x);
    }
    }
    函数
    void f(int v,int w)
    {
    int t;
    t=v;
    v=w;
    w=t;
    }
    main()
    {
    int c=1,y=3,z=2;
    if(x>y)
    f(x,y);
    else if(y>z)
    f(y,z);
    else
    f(x,z);
    printf(“%d,%d,%d\n”,x,y,z);
    }

    字符串的操作
    #include<stdio.h>
    main()
    {
    char s[]=”012xy\08s34f4w2”;
    int i,n=0;
    for(i=0;s[i]!=0;i++)
    if(s[i]>=’0’ &&s[i]<=’9’) n++;
    printf(“%d\n”,n);
    }
    (3)

    指针基本操作
    #include<stdio.h>
    #include<stdlib.h>
    main()
    {
    int *a,*b,*c;
    a = b = c=(int *)malloc(sizeof(int));
    *a = 1;*b=2,*c = 3;
    a=b;
    printf(“%d,%d,%d\n”,*a,*b,*c);
    }
    (3,3,3)
    b = *p++;//指针变量p会先与++结合,相当于先取指针变量p所指向的存储单元中的值赋给变量b,然后使指针变量p自增1
    指针数组:一般定义形式如下: 类型名 指针数组名[常量表达式]
    如,int p[3]; //因为[]的优先级高于号,因此,p首先与【】结合,构成p【3】,说明了p是一个数组名,在它前面的
    号说明数组p中的每个元素只能存放指针

                                                        a[0][0]
      P[0]                                              
                                                        a[0][1]
      P[1]                                                 
                                                        a[1][0]
      P[2]
    

    数组及指针
    #include<stdio.h>
    main()
    {
    int x[3][2]={0},i;
    for(i=0;i<3;i++)
    scanf(“%d”,x[i]);
    printf(“%3d%3d%3d\n”,x[0][0],x[0][1],x[1][0]);
    } 若运行时输入:2 4 6<回车>,则输出结果是(2 0 4)

    结构体知识点补充:
    struct student
    {
    char name[10];
    char sex;
    int age;
    float score;
    };
    Struct student s1,*ps,stu[3];
    eg.
    struct S
    {
    int a;
    int b;
    }data[2]={10,100,20,200};

    main()
    {
    sturct s p =data[1];
    printf(“%d\n”,(++p.a));
    }
    (21)

    链表:
    结构体中含有指向本结构体类型的指针成员,例如下面
    #include “stdio.h”
    #include"stdlib.h"
    struct link
    {
    char data;
    struct link *next;
    };
    typedef struct link LINK;
    LINK *create_list()
    {
    char ch;
    LINK *h,s,r;
    h = (LINK
    )malloc(sizeof(LINK));
    r = h;
    printf(“请输入一些字母(空格也被认为是字母,回车结束)”);
    ch = getchar();
    while(ch !=’\n’)
    {
    s = (LINK
    )malloc(sizeof(LINK));
    s->data=ch;
    printf("%c",ch);
    r->next=s;
    r = s;
    ch=getchar();
    }
    r->next = NULL;
    return h;
    }
    void print_list(LINK *h)
    {
    LINK *p;
    p = h->next;
    if(p==NULL)
    printf(“The List is NULL\n”);
    else
    while(p!= NULL)
    {
    printf("%c",p->data);
    p=p->next;
    }
    printf("\n\n");
    }

    int add_node_at_front(LINK *head,char newData)
    {
    LINK *p;
    p =(LINK *)malloc(sizeof(LINK));
    p->data = newData;
    if(headNULL)
    {
    head = p;
    p->next = NULL;
    }
    else
    {
    p->next = head;
    head ->next = p;
    }
    return 1;
    }
    void del_node(LINK *head,char dataToDel)
    {
    LINK *p = head,*pPre=head;
    if(p
    NULL)
    return;
    printf(“come to del_node,head->data is %c,deldata is %c\n”,head->data,dataToDel);
    while(p!=NULL)
    {
    if(p->data == dataToDel)
    {

    if(p==head)
    {
    printf(“come to del_node 1\n”);
    free§;
    head = pPre=p=NULL;
    if(head == NULL)
    printf("head is null ");
    else
    printf(“head is %d”,head);
    }
    else
    {
    pPre->next = p->next;
    free§;
    p=NULL;
    }
    break;
    }
    pPre=p;
    p = p->next;
    }
    }
    LINK *find_node(LINK *head,char dataToFind)
    {
    LINK *p = head;
    while(p!= NULL)
    {
    if(p->data == dataToFind)
    {
    return p;
    }
    p = p->next;
    }
    return NULL;
    }

    int modify_node(LINK *head,char oldData,char newData)
    {
    LINK *p = head;
    p = find_node(head,oldData);
    if(p != NULL)
    {
    p->data = newData;
    return 1;
    }
    return 0;
    }
    main()
    {
    char c,cNew;
    LINK *head,*p;
    head = create_list();
    printf("%d",head);
    print_list(head);
    c = getchar();
    del_node(head,c);

    print_list(head);	
    

    }
    冒泡排序
    冒泡排序每一趟排序把最大的放在最右边。
    比如:
    87 12 56 45 78
    87和12交换:12 87 56 45 78
    87和56交换: 56 87 45 78
    87和45交换: 45 87 78
    87和78交换: 78 87
    到此第一趟排序结束,接下来的每一趟排序都是这样。

    #include<stdio.h>
    void Print(int *num, int n)
    {
    int i;
    for(i = 0; i < n; i++)
    printf("%d “, num[i]);
    puts(”\n");
    return;
    }
    void Bubble_Sort(int *num, int n)
    {
    int i, j;
    for(i = 0; i < n; i++)
    {
    for(j = 0; i + j < n - 1; j++)
    {
    if(num[j] > num[j + 1])
    {
    int temp = num[j];
    num[j] = num[j + 1];
    num[j + 1] = temp;
    }
    Print(num, n);
    }
    }
    return;
    }
    int main()
    {
    int num[8] = {87, 12, 56, 45, 78};
    Bubble_Sort(num, 5);
    return 0;
    }

    快速排序:
    1.一、假设我们给一个int数组进行排序,数组中数字初始序列为int a[9]={3,6,5,9,7,1,8,2,4}

    2.2
    二、分析快速排序的原理前,我们先声明一些东西,首先设置一个临时变量用来存放随机取出数组中的一个数,一般我们取数组的第一个元素也就是说temp=a[0],同时设置两个游标分别指向数组第一个元素和最后一个元素。

    3.3
    三、算法的基本运算步骤为:1、依次比较数组的后游标所指与temp的大小,如果temp<a[j],则j–,直到遇到第一个temp>a[j],则停止移动,将a[j]赋值给a[i]
    4.4
    四、算法的基本运算步骤为:2、依次比较数组的前游标所指与temp的大小,如果temp>a[i],则i++,直到遇到第一个temp<a[i],则停止移动,将a[i]赋值给a[j]
    5.5
    五、算法运算步骤为:3、判断i是否等于j,如果不相等则循环1、2步,直到i等于j,则完成一次快速排序。

    展开全文
  • 全国计算机等级考试 二级C语言考前复习资料(笔试)

    全国计算机等级考试

    二级C语言考前复习资料(笔试)

    第一课C语言程序设计基础

    本课主要知识点:

    1.知识点:C程序基础

    l  C语言是一种结构化程序设计语言。三种基本结构:顺序、选择、循环

    例1:(2010-09-11)以下关于结构化程序设计的叙述中正确的是(C)

    A)一个结构化程序必须同时由顺序、分支、循环三种结构组成

    B) 结构化程序使用goto语句会很便捷

    C) 在C语言中,程序的模块化是利用函数实现的

    D)由三种基本结构构成的程序只能解决小规模的问题

    2:(2011-03-26)计算机高级语言程序的运行方法有编译执行和解释执行两种,以下叙述中正确的是(A)

    A)C语言程序仅可以编译执行

    B)C语言程序仅可以解释执行

    C)C语言程序既可以编译执行又可以解释执行

    D)以上说法都不对

    【解析】计算机不能直接理解高级语言,只能直接理解机器语言,所以必须要把高级语言翻译成机器语言,计算机才能执行高级语言编写的程序。翻译的方式有两种,一个是编译,一个是解释。C语言程序仅可以编译。

    3:(2011-03-26)以下叙述中错误的是( D)

    A)C语言的可执行程序是由一系列机器指令构成的

    B)用C语言编写的源程序不能直接在计算机上运行

    C)通过编译得到的二进制目标程序需要连接才可以运行

    D)在没有安装C语言集成开发环境的机器上不能运行C源程序生成的.exe文件

    【解析】C程序开发过程:编辑—>(.c)编译—>(.obj)链接—>可执行文件(.exe)

    2.知识点:C语言程序的构成

    C程序是由函数构成的,一个C程序有且仅有一个main函数。一个函数由两部分组成:函数的首部和函数体。函数体包括声明部分和执行部分。一个C程序总是从main函数开始执行(即程序的入口),由main函数结束,(即程序的出口)。

    例1:(2010-03-12)以下叙述正确的是(B)

    A)C语言程序是由过程和函数组成的

    B) C语言函数可以嵌套调用,例如:fun(fun(x))

    C) C语言函数不可以单独编译

    D)C语言中除了main函数,其他函数不可作为单独文件形式存在

    2:(2011-09-11)以下叙述中错误的是 (C)             

    A.C语言编写的函数源程序,其文件名后缀可以是C

    B.C语言编写的函数都可以作为一个独立的源程序文件

    C.C语言编写的每个函数都可以进行独立的编译并执行

    D.一个C语言程序只能有一个主函数

    3.知识点:标识符

    命名规则:

    ①标识符中只能包含字母(a-z,A-Z),数字(0-9),下划线(_)。

    ②第一个字符必须是字母或下划线。

    分类

         ③用户自定义的标识符 ⅰ格式合法,ⅱ不能使用关键字,ⅲ见名知意

    例1:(2010-03-13)以下C语言用户标识符中,不合法的是(D)

    A)_1          B)AaBc            C)a_b             D)a-b

    4.知识点:数据类型

    例1:(2010-03-16)以下关于C语言数据类型使用的叙述中错误的是(D)

    A)若要准确无误差的表示自然数,应使用整数类型

    B)若要保存带有多位小数的数据,应使用双精度类型

    C)若要处理如“人员信息”等含有不同类型的相关数据,应自定义结构体类型

    D)若只处理“真”和“假”两种逻辑值,应使用逻辑类型

    【解析】结构数据类型是根据已定义的一个或多个数据类型用构造的方法来定义的,一个结构类型的值可以分解成若干个“成员”或“元素”,每个“成员”都是一个基本数据类型或又是一个构造类型,C项正确。C语言没有逻辑类型,故D项错误。

    例2:(2011-03-26)定义无符号整数类为UInt,下面可以作为类UInt实例化值的是(B)

    A)-369     B)369     C)0.369       D)整数集合{1,2,3,4,5}

    【解析】无符号整数类型为只有正整数和0,所有选择B。

    5.知识点:常量

    l      整型常量

    十进制整常数:没有前缀,其数码为0-9。例如65535,-568

    八进制整常数:以0开头,其数码为0-7。例如015

    十六进制整常数:以0X或0x开头,其数码为0-9,A-F或a-f。例如0x2A

    长整型数:整型常数后缀为L或l。例如358000L

    无符号数:整型常数后缀为U或u。例如158u

    l   实型常量的形式

    小数形式:必须有小数点,小数点前后不能同时没有数字。

    指数形式:aEn(其中a表示十进制数,E阶码标志,n阶码)。E前E后必须有数字,E后必为整数,可以带符号。例如2.1E-3、5E8

    1:(2011-09-13以下选项中关于C语言常量的叙述错误的是:D

    A.所谓常量,是指在程序运行过程中,其值不能被改变的量      

    B.常量分为整型常量、实型常量、字符常量和字符串常量

    C.常量可分为数值型常量和非数值型常量

    D.经常被使用的变量可定义成常量

    【解析】根据常量的基本概念,则不难判断A、B、C均正确。

    例1:(2009-04-13)以下选项中,能用作数据常量的是(D)

    A)o115        B)0118        C)1.5e1.5        D)115L

    【解析】八进制整常数以0开头,A项错误;八进制整常数的数码味0-7,B项错误;实型常量的指数形式E后必为整数,故C项错误;长整型数后缀为L或l,故D项正确。

    2(2010-03-26)以下选项中可用作C程序合法实数的是( A)

      A).1e0       B)3.0e0.2       C)E9          D)9.12E

    【解析】实型指数表示方式“E前E后比有数,E后必须是整数”,故选A

    l      字符常量:用单引号‘’括起来的一个字符。包括普通字符常量和转义字符。

    普通字符常量:如‘a’、‘A’、‘1’。

    转义字符:由一对单引号引起来的以\开头的若干字符的组合。如‘\n’表示回车换行、‘\\’表示反斜线符、‘\’’表示单引号符、‘\”’表示双引号、‘\ddd’表示八进制数、‘\xhh’表示十六进制数。

    例3:(2010-09-15)以下选项中能表示合法常量的是(C)

    A)整数:1,200      B)实数:1.5E2.0     C)字符斜杠:‘\\’    D)字符串:“\007”

    【解析】表示整常量不能用逗号分隔,A项错误;实型常量的指数形式E后必为整数,故B项错误;’\007’是转义字符,只能用单引号括起来,不能用双引号或其他括号,故D项错误。4(2010-03-26)以下选项中不能用作C程序合法常量的是( B)

      A)1,234      B)'\123'         C)123         D)"\x7G"

    【解析】A中的‘,’在编译时会出错的,直接写成1234即可,B是一个三位八进制数代表的字符,C是一个数字常量,D是一个字符串,其中\x7是一个一位十六进制数代表的字符,也即D中的字符串是两个字符,如果sizeof的话是3,如果strlen的话是2。

    6.知识点:变量

    l      整型变量和实型变量

    以考试标准Viusal c++6.0为例,说明各类型变量所占的位数。

    类型

    所占

    位数

    所占

    字节数

     

    类型

    所占

    位数

    所占

    字节数

    short

    16

    2

    unsigned int

    32

    4

    int

    32

    4

    unsigned long

    32

    4

    long

    32

    4

    float

    32

    4

    unsigned short

    16

    2

    double

    64

    8

    例1:(2010-09-38)有以下程序

    #include <stdio.h>

    main(0)

    {int s,t,A=100;double B=6;

    s=sizeof(A); t=sizeof(B);

    printf(“%d,%d\n”,s,t);

    }

    在VC6平台上编译运行,程序运行后的输出结果是(C)

    A)2,4    B)4,4    C)4,8     D)10,6

    【解析】在VC6平台上,int型占4个字节,double型占8个字节,故答案是C。

    l  字符变量:一个字符变量只能存放一个字符。字符串不能存放在字符变量中,只能用字符数组或指针存放字符串。

    例1:(2009-09-22)有以下定义语句,编译时会出现编译错误的是(C)

    A)char a=’a’;    B)char a=‘\n’;      C)char a=‘aa’;      D)char a=‘\x2d’;

    【解析】一个字符变量只能存放一个字符,A项字符变量存放的是普通字符常量;B、D项字符变量存放的转义字符;字符常量只能是单个字符,不能是字符串,’aa’不是单个字符,故C项错误。

    7.知识点:ASCII码

    l      ‘0’的ASCII码值为48;‘A’的ASCII码值为65;‘a’的ASCII码值为97。

    l      大写字母与小写字母的ASCII码值相差32。

    例1:(2009-09-23)有以下程序

    #include <stdio.h>

    main()

    {char c1,c2;

    c1=’A’+’8’-‘4’;

    c2=’A’+’8’-‘5’;

    printf(“%c,%d\n”,c1,c2);

    }

    已知字母A的ASCII码为65,程序运行后的输出结果是(A)

    A)E,68          B)D,69       C)E,D           D)输出无定值

    【解析】’A’的ASCII码值为65,’8’的ASCII码值为56,’4’的ASCII码值为52,65+56-52=69,对应于字符’E’。’5’的ASCII码值为53,65+56-53=68,对应于字符’D’。字符变量c1以%c格式输出,即’E’。字符变量c2以%d格式输出,即68。故答案是A。

    8.知识点:进制转换

    l  十进制转换成二进制、八进制、十六进制:将十进制的数字除以2(8、16),得到的商数继续除以2,直到商为0,然后将各次相除所得的余数从后往前排列。

    l  二进制、八进制、十六进制转换成十进制:将二(八、十六)进制数的每一位数从高位到低位乘以2的n-1次幂,n为该位所在的位数。

    l      二进制与八进制之间的转换:每个八进制数字转换成3位二进制数字。

    l      二进制与十六进制之间的转换:每个十六进制数字转换成4位二进制数字。

    例1:(2010-09)以下程序运行后的输出结果是    2008   

    #include <stdio.h>

    main()

    {int a=200,b=010;

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

    }

    【解析】八进制数010转换成十进制数为8,按“%d%d”格式分别输出a、b,即2008。

    9.知识点:运算符的优先级

    级别由大到小:(逻辑)非 >算(术运算符) >关(系运算符) >(逻辑)与 >(逻辑)或 >条(件运算符) >赋(值运算符)

    10.知识点:强制类型转换运算符

    l  一般形式:(类型说明符)(表达式)

    l  功能:把表达式的运算结果强制转换成类型说明符所表示的类型

    例1:(2009-04-06)表达式(int)((double)(5/2)+2.5)的值是4。

    【解析】(int)((double)(5/2)+2.5)→(int)((double)2)+2.5)→(int)(2.000000+2.5)→(int)(4.500000) →4。

    2:以下程序运行后的输出结果是() 。

    main()

    {     int a;

    a=(int)((double)(3/2)+0.5+(int)1.99*2);

    printf("%d\n",a);

    }

    答案:3

    【解析】(3/2)=1,(double)(3/2)+0.5=1.5,(int)1.99*2=2,所以(double)(3/2)+0.5+(int)1.99*2=3.5,故a=3。

    11.知识点:算术运算符: +、—、*、/、%

    %:参与运算的量均为整型

    /:当除号左右两边都是整数的时候,商也要是整数,如果不是整数则舍弃小数部分。当参与运算量有一个为实型,则商为double型。

    1:(2011-09-14)若有定义语句:inta=10;double b=3.14;,则表达式‘A+a+b值得类型是C

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

    【解析】各种类型数据混合运算时,最终结果的类型可依据以下转换规律:

    char ->short -> int -> long -> float -> double

    1:(2011-09-15)如有定义语句:intx=12,y=8,z;,在其后执行语句z=0.9+x/y,z的值为B

           A.1.9      B.1             C.2              D.2.4

    【解析】x,y,z均为整型变量,因此x/y结果为1,即z=0.9+1=1.9,z最终结果为1

    例1:(2010-09-14)有以下定义:int a;long b;double x,y;则以下选项中正确的表达式是(A)

    A)a%(int)(x-y)      B)a=x!=y;       C) (a*y)%b         D)y=x+y=x

    【解析】参与%运算的左右操作数均为整型,故A项正确,C项错误。B项是赋值语句,不是表达式。赋值运算符左边必须是变量,而不是表达式,而D项中x+y=x,错误。

    12.知识点:逗号表达式

    l  一般形式:表达式1,表达式2……表达式n

    l  求值过程:自左向右依次求解,最后一个表达式的值为整个逗号表达式的值。

    例1:(2009-04-14)设有定义:int x=2;以下表达式中,值不为6的是(D)

    A)x*=x+1         B)x++,2*x       C)x*=(1+x)       D)2*x,x+=2

    【解析】A项x=x*(x+1)=2*(2+1)=6;B项x++后,x的值为3,2*x的值为6,整个逗号表达式的值为6;C项x=x*(1+x)=2*3=6;D项x=x+2=2+2=4,整个逗号表达式的值为4。故答案是D。

    13.知识点:自增自减运算符

    ++i   i自加1后再参与运算

    i++   i参与运算后再自加1

    --i   i自减1后再参与运算

    i--   i参与运算后再自减1

    ++和- -的运算对象只能为变量,不能是常量或表达式。

    例1:(2009-09-06)若有定义语句:int a=5;则表达式:a++的值是   5  

    【解析】表达式a++的值是a未加1之前的值,即5。.

    ++printf语句结合时,若++/--x的形式,则先自增/自减,然后输出;若x++/--的形式,则先输出x原值,在进行自增/自减操作。

    2:(2011-03-26有以下程序

      #include

      main()

    {     int x=011;

             printf("%d\n",++x);

      }            

      程序运行后的输出结果是(C)

      A)12         B)11          C)10          D)9

    【解析】011是一个八进制的数,转为十进制则为1*8+1=9;++x是x先自增1再参与其他运算,所以先x自增1为10再输出即为10,故选C。

    14.知识点:赋值表达式

    l  一般形式:变量名=表达式

    赋值运算符左边必须是变量,而不是表达式。

    例1:(2010-03-14)若有定义:double a=22;int i=0,k=18;则不符合C语言规定的赋值语句是( C)

    A)a=a++,i++;  B)i=(a+k)<=(i+k);   C)i=a%11;      D)i=!a;

    【解析】a为double型,参与%运算的操作数均为整型,故C项错误。

    2(2011-03-26)若有定义语句:int a=3,b=2,c=1;,以下选项中错误的赋值表达式是(A)

      A)a=(b=4)=3;     B)a=b=c+1;       C)a=(b=4)+c;      D)a=1+(b=c=4);

    【解析】赋值表达式的左边必须是变量不能是表达式。而答案A中,(b=4)是一个赋值表达式。

    l  复合赋值运算符和表达式

    +=、—=、*=、/=、%=、<<=、>>=、 &=、 ^=、 |=

    例2:(2010-09-16)表达式a+=a-=a=9的值是(D)

    A)9      B)-9        C)18         D)0

    【解析】赋值运算符的结合性是从右到左,a=9→a=a-9=0→a=a+0=0+0=0。故答案是D。

    15.知识点:位运算

    l  按位与运算&

    规则:0&0=0     0&1=0     1&0=0       1&1=1

    l  按位或运算|

    规则:0|0=0    0|1=1     1|0=1      1|1=1

    l  按位异或运算∧

    规则:0∧0=0   0∧1=1      1∧0=1       1∧1=0

    l  求反运算~

    规则:~0=1     ~1=0

    l  左移运算<<

    规则:把<<左边的运算数的各二进位全部左移若干位,高位丢弃,低位补0。左移一位相当于该数乘以2。左移n位相当于该数乘以2n。

    例1:(2010-09-40)有以下程序

    #include <stdio.h>

    main()

    {short c=124;

    c=c____D____;

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

    }

    若要使程序的运行结果为248,应在下划线处填入的是

    A)>>2         B)|248           C)&0248            D)<<1

    【解析】左移一位相当于该数乘以2,124>>1相当于124乘以2,等于248。故答案是D。

    例2:(2009-04-39)有以下程序

    #include <stdio.h>

    main()

    {int a=5,b=1,t;

    t=(a<<2)|b;

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

    }

    程序运行后的输出结果是(A)

    A)21     B)11     C)6     D)1

    【解析】左移2位相当于该数乘以22。5<<2相当于5乘以4等于20。20|1=21。故答案是A。

    l  右移运算>>

    把>>左边的运算数的各二进位全部右移若干位。高位补0,低位丢弃。右移一位相当于该数除以2。右移n位相当于除以2n。

    例3:(2009-09-39)若有以下程序段

    int r=8;

    printf(“%d\n”,r>>1);

    输出结果是(C)

    A)16     B)8       C)4      D)2

    【解析】右移一位相当于该数除以2。8>>1相当于除以2,等于4,故答案是C。

    16.知识点:关系运算符和表达式

    例1:(2010-09-08)在C语言中,当表达式值为0时表示逻辑值“假”,当表达式值为    

    非0      时表示逻辑值“真”。

    例2:(2010-03-06)设x为int型变量,请写出一个关系表达式     (x%3==0)&&(x%7==0)     ,用以判断x同时为3和7的倍数时,关系表达式的值为真。

    17.知识点:逻辑运算符和表达式

    l  逻辑运算符优先级从高到低:!、&&、||

    l  逻辑运算的真值表

    a

    b

    a&&b

    a||b

    !a

    l  进行逻辑运算时,若&&左边的值为0,则不再对右边的运算对象进行运算,整个表达式的值为0。

    1(2011-09-17)若有定义语句:int k1=10,k2=20;,执行表达式(k1=k1>k2)&&(k2=k2>k1)后,k1和k2的值分别为 (B)

    A.    0和1            B.0和20                     C.10和1       D.    10和20

    【解析】k1>k2为假,因此k1= k1>k2结果0,逻辑与左边表达式为假,右边表达式不再处理,因此k1结果为0,k2不变,仍为20

    例2:int a=2;则表达式(!a==1)&&(a++==2)的值为0,a的值为2。

    【解析】!a为0,!a==1的值为0,&&左边的值为0,则不再对右边的运算对象进行运算,所以a的值为2。

    若||左边的运算对象的值为1,则不再对右边的运算对象进行运算,整个表达式的值为1。

    例2:(2010-03-17)若a是数值类型,则逻辑表达式(a==1)||(a!=1)的值是(A)

    A)1        B)0         C)2          D)不知道a的值,不能确定

    【解析】a的值有两种情况:a等于1或a不等于1。故逻辑表达式(a==1)||(a!=1)的值为1。

    18.知识点:格式输入函数printf()

    (1)一般形式:printf(“格式控制字符串”,输出列表);

    (2)遇到控制字符,按照控制字符的规定输出,遇到非格式字符串按原样输出

    例1:(2009-04-07)若变量x,y已定义为int类型且x的值为99,y的值为9,请将输出语句printf(“  x/y=%d  ”,x/y);补充完整,使其输出的计算结果形式为:x/y=11。

    例2:(2009-04-15)程序段:int x=12;double y=3.141593;printf(“%d%8.6f”,x,y);的输出结果是(A)

    A)123.141593     B)123.141593    C)12,3.141593      D)123.1415930

    【解析】以%8.6f格式输出,即输出的总宽度为8,小数的位数为6。

    19.知识点:格式输入函数scanf()

    (1)一般形式:scanf(“格式控制字符串”,地址列表);

    (2)若格式控制字符串中有非格式字符串,则按原样输入。若格式控制字符串中没有非格式字符作输入数据之间的间隔,则可用空格、Tab、回车作间隔。

    1(2011-09-16)若有定义:inta,b;,通过语句scanf(%d;%d,&a,&b);,能把整数3赋给变量a,5付给变量b的输入数据是            

           A.3  5    B.3,5      C.35    D.35

    解析】scanf格式字符串中两个%d之间带有非格式字符分号,运行时应原样输入。

    例1:(2005-04-19)有以下程序

    main()

    {int m,n,p;

    scanf(“m=%dn=%dp=%d”,&m,&n,&p);

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

    }若想从键盘上输入数据,使变量m中的值为123,n中的值为456,p中的值为789,则正确的输入是(A)

    A)m=123n=456p=789             B)m=123  n=456  p=789

    C)m=123,n=456,p=789            D)123  456  789

    【解析】scanf(“m=%dn=%dp=%d”,&m,&n,&p);格式控制字符串中有非格式字符串,则按原样输入,故答案是A。

    2(2011-03-26)有以下程序段

    char name[20];

    int num;

    scanf("name=%snum=%d",name;&num);

    当执行上述程序,并从键盘输入:name=Lili num=1001<回车>后,name的值(A)

    A)Lili      B)name=Lili   C)Lili num=   D)name=Lili num=1001

    解析】scanf中格式字符串的非格式字符串原样输入,如其中的‘name=’和‘num=’,所以接受到的name值是后面的Lili,num值为1001。故选A。

    (3)在输入字符数据时,若格式控制字符串中无非格式字符,则认为所有输入的字符均为有效字符。空格会被当作字符赋值给变量。

    例3:(2009-04-23)有以下程序

    #include <stdio.h>

    main()

    {int a1,a2;  char c1,c2;

    scanf(“%d%c%d%c”,&a1,&c1,&a2,&c2);

    printf(“%d,%c,%d,%c”,a1,c1,a2,c2);

    }若想通过键盘输入,使得a1的值为12,a2的值为34,c1的值为字符a,c2的值为字符b,程序输出结果是:12,a,34,b则正确的输入格式是(以下_代表空格,<CR>代表回车)

    A)12a34b<CR> B)12_a_34_b<CR> C)12,a,34,b<CR>    D)12_a34_b<CR>

    【解析】空格会被当作字符赋值给变量,故B、D错误;C项中逗号会被当作字符赋值给变量,故C项错误。

    (4)格式字符串

    l  一般形式:%[*][输入数据宽度][长度]类型

    l  *表示该输入项,读入后不赋予相应的变量。

    l  输入数据宽度:用十进制数指定输入的字符数。

    例4:(2010-09-07)有以下程序

    #include <stdio.h>

    main()

    {int x,y;

    scanf(“%2d%ld”,&x,&y); printf(“%d\n”x+y);

    }程序运行时输入:1234567程序的运行结果是    34579     

    【解析】%2d输入的数据宽度为2,x的值为12,y的值为34567,x+y=34579。

    例5:(2009-04-16)若有定义语句:double x,y,*px,*py;执行了px=&x;py=&y;之后,正确的输入语句是(C)

    A)    scanf(“%f%f”,x,y);               B)scanf(“%f%f”,&x,&y);

    C)scanf(“%lf%le”,px,py);            D)scanf(“%lf%lf”,x,y);

    【解析】A、D项地址列表,应为&x,&y;x、y为double型,格式控制字符串不是%f%f,故B项错误。

    当定义的变量类型和scanf中“格式符”类型不一致时(这里只限定在字符型和整型两种类型,其他数据类型不可以。)整型和字符型之间通过ASCALL可以相互转化。

    6(2011-03-12)有以下程序   (说明:字符0的ASCII码值为48)

    main()

    {     charc1,c2;

    scanf("%d",&c1);

    c2=c1+9;

    printf("%c%c\n",c1,c2);

    }若程序运行时从键盘输入48<回车>,则输出结果为 (09)。

    【解析】输入48,则c1=48,c2=48+9,以字符输出c1和c2,则为输出ASCII码为48和57对应的字符,分别为0和9。

    20.知识点:字符输出函数putchar()

    一般形式:putchar(‘a’);putchar(‘\101’);

    21.知识点:字符输入函数getchar()

    一般形式:getchar();或ch=getchar();

    例1:(2010-03-15)有以下程序

    #include <stdio.h>

    main()

    {char a,b,c,d;

    scanf(“%c%c”,&a,&b);

    c=getchar();  d=getchar();

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

    }当执行程序时,按下列方式输入数据(从第1列开始,<CR>代表回车,注意:回车也是一个字符)

    12<CR>

    34<CR>

    则输出结果是(B)

    A)1234      B)12        C)12            D)12

                  3           34

    【解析】以%c格式读取一个字符,以getchar()形式也是读取一个字符。空格会被当作字符赋值给变量。所以,a=’1’,b=’2‘,c=’\n’,d=’3‘。

    getchar经常作为while循环条件,判断输入哪一个字符时,循环结束。例如,输入字符串,直到输入‘0’,程序结束,则可写成while( getchar()!='0')

    2(2011-03-26)有以下程序段

    main()

    {     …

    while( getchar()!='\n');

    }以下叙述中正确的是(C)

    A)此while语句将无限循环

    B) getchar()不可以出现在while语句的条件表达式中

    C)当执行此while语句时,只有按回车键程序才能继续执行

    D)当执行此while语句时,按任意键程序就能继续执行

    【解析】while条件表达式getchar()!='\n'只要输入的字符不是回车,就一直执行循环,而循环内是一个空语句,所以按回车键程序才能继续执行,选择C。

    第二课 选择结构与循环结构

    本课重要知识点:

    1.知识点:if语句

    l  if(表达式),其中表达式可以是任意合法的C语言表达式。

    1:(2011-09-19)下列条件语句中输出结果与其他语句不同的是(D

    A.ifa printf(%d\n,x);  else printf(%d\n,y);

    B.ifa==0 printf(%d\n,y);  else printf(%d\n,x); 

    C.ifa!=0 printf(%d\n,x);  else printf(%d\n,y);  

    D.ifa==0 printf(%d\n,x);  else printf(%d\n,y); 

    【解析】作为if语句的条件,a等价于a!=0,因此 A和C是等价的。

    2(2011-03-26)if语句的基本形式是:if(表达式)语句,以下关于“表达式”值的叙述中正确的是(D)

    A)必须是逻辑值  B)必须是整数值  C)必须是正数  D)可以是任意合法的数值

    【解析】表达式不限于关系表达式、逻辑表达式,也可以是任意的数值类型,其中非0为真,0为假。故选D。

    l  对于单个if语句,其后跟随的受if控制的只能是1个语句或者是1个复合语句。

    例1:(2009-09-17)设有定义: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;}

    【解析】对于单个if语句,其后跟随的受if控制的只能是1个语句或者是1个复合语句。故C项,if(a>b)条件成立时,语句c=a;才被执行,而无论if(a>b)条件成立与否,语句a=b;b=c;都会被执行。A、B、D项,只有if(a>b)条件成立时,语句c=a; a=b;b=c; 才被执行。

    2(2011-03-26)以下程序运行后的输出结果是     200  

    main()

    {     int x=10,y=20,t=0;

    if(x==y)t=x;x=y;y=t;

    printf("%d %d\n",x,y);

    }

    【解析】x=10,y=20,所以x==y为false,t=x;不执行,直接执行x=y;y=t;x为20,y为0。注意和if(x==y){t=x;x=y;y=t;}区别。

    当多个if(表达式)单分支形式并行出现时,其执行顺序是:先判断第一if单分支的条件,如果为真,执行其后面的语句,执行完后,继续向下执行。判断第二个if单分支语句,依次类推。如果第一个if表达式的值为假,则不执行其后的语句,而去判断第二个if单分支条件。

    1(2011-03-26)有以下程序

    main()

    {     int x;

    scanf("%d",&x);

    if(x>15) printf("%d",x-5);

    if(x>10) printf("%d",x);

    if(x>5) printf("%d\n",x+5);

    }若程序运行时从键盘输入12<回车>,则输出结果为   1217   

    【解析】输入12,比较不大于15所以不执行if(x>15)内的语句;大于10执行printf("%d",x);输出12;大于5执行printf("%d",x+5);输出17。

    2.知识点:if语句的嵌套

    l  内嵌结构中,else总是与前面最近的且未曾配对的if语句配对,组成一对if-else语句。

    例2:(2010-09-18)有以下程序

    #include <stdio.h>

    main()

    {int a=1,b=0;

    if(!a) b++;

    else if(a==0)  if(a) b+=2;

    else b+=3;

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

    }程序运行后的输出结果是(A)

    A)0       B)1     C) 2          D)3

    【解析】else总是与前面最近的且未曾配对的if语句配对,组成一对if-else语句。即else b+=3;

    与if(a) b+=2;配对。if(!a)不成立,不执行b++;else if(a==0)不成立,不执行if(a) b+=2;

    else b+=3;故直接执行printf(“%d\n”,b);,输出结果为0。

    3.知识点:条件表达式

    l  一般形式:表达式1?表达式2:表达式3

    l  执行过程:表达式1的值为真,条件表达式取表达式2的值;表达式1的值为假,条件表达式取表达式3的值。

    例1:(2009-09-19)以下程序段中,与语句:k=a>b?(b>c?1:0):0;功能相同的是(A)

    A)if((a>b)&&(b>c)) k=1;                       B)if((a>b)||(b>c)) k=1;

    else k=0;                                     else k=0;

    C) if(a<=b) k=0;                               D) if(a>b)k=1;

    else if(b<=c) k=1;                             else if(b>c) k=1;

    else k=0;

    【解析】条件运算符的结合性是从右至左。当b>c时,b>c?1:0的值为1,k=a>b?1:0,同时当a>b时,a>b?1:0的值为1,此时k=1。否则k=0。故答案为A。

    4.知识点:switch语句

    l  switch语句的圆括号中的表达式的值必须是整型或字符型,不能为实型。

    l  case后的表达式可以是求得整型和字符型的常量表达式,但不能含有变量。

    l  default的位置对程序的执行没有影响。

    例1:(2010-09-19)若有定义语句int a,b;double x;则下列选项中没有错误是(C)

    A)switch(x%2)                          B) switch((int)x%2.0)

    {case 0:a++;break;                           {case 0:a++;break;

     case 1:b++;break;                            case 1:b++;break;

     default:a++;b++;                             default:a++;b++;

    }                                           }

    C)switch((int)x%2)                        D)switch((int)(x)%2)

    {case 0:a++;break;                           {case 0.0:a++;break;

     case 1:b++;break;                            case 1.0:b++;break;

     default:a++;b++;                            default:a++;b++;

    }                                          }

    【解析】switch语句的圆括号中的表达式的值必须是整型或字符型,不能为实型。x是double型,x%2不合法,A项错误。(int)x%2.0不合法,B项错误。(int)x%2值为整型,故C项正确。case后面的表达式可以是求得整型量和字符型量的常量表达式,故D项错误。

    例2:(2009-09-18)有以下程序

    #include <stdio.h> 

    main()

    {int c=0,k;

    for(k=1;k<3;k++)

    switch(k)

    {default:c+=k;

    case 2:c++;break;

    case 4:c+=2;break;

    }

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

    }程序运行后的输出结果是(A)

    A)3        B)5          C)7              D)9

    【解析】当k=1时,没有匹配的case,执行default语句,c=c+k=0+1=1。继续往下执行case 2后边的语句,c++,c变为2,遇到break语句,于是退出内层switch结构。当k=2时,找到匹配的case 2,执行c++; c变为3,遇到break语句,于是退出内层switch结构。执行外层循环for结构的k++,k变为3,k<3不成立,跳出for语句。最后输出结果为3。

    l  当switch语句和循环语句(for、while)时,要注意switch里面的break语句退出的位置。解决这一问题的方法是:首先划分结构,确定循环的语句体包括哪些语句。然后,在继续划分循环体内的语句,如果循环体内的语句只有一条switch语句,其内部出现了break,遇到break,要结束当前switch语句的执行,继续执行下一次循环

    例1:(2011-03-26)有以下程序

      main()

      {     int s;

             scanf("%d",&s);

             while(s>0)

             { switch(s)

                    {case1:printf("%d",s+5);

                    case2:printf("%d",s+4);break;

                    case3:printf("%d",s+3);

                    default:printf("%d",s+1);break;

                    }

                    scanf("%d",&s);

             }

      }  运行时,若输入1 2 3 4 5 0<回车>,则输出结果是(A)

    A)6566456         B)66656        C)66666         D)6666656

    【解析】while循环s<=0时退出循环,输入1 2 3 4 5 0,只有当输入0时退出循环,switch中当s=1时,执行case 1,case 2,由于case 1后面没有break,会继续执行case 2,遇到break,退出switch;当s=2时,执行case 2,退出switch;当s=3时,执行case 3,default,由于case 3后面没有break,会继续执行default,遇到break,退出switch;当s=4和5时,执行default,退出switch。所以输入1时,输出65;输入2时,输出6;输入3时,输出64;输入4时,输出5;输入5时,输出6。故选择A。

    5.知识点:while,do-while,for三种循环结构

    1:(2011-09-20有以下程序:

    #include <stdio.h>

    main()

    {  inta=7;

     while(a--);

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

    }程序运行后的输出结果是 (B)

        A.- 1  B.0       C.1      D.7

    【解析】此类题一定要注意标点符号的位置,while(a--);该行末尾的分号即为一条空语句,来作为while的循环体。

    例1:(2010-09-20)有以下程序

    #include <stdio.h>                       

    main()

    {int a=1,b=2;

    while(a<6) {b+=a;a+=2;b%=10;}

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

    }程序运行后的输出结果是(B)

    A)5,11            B)7,1           C)7,11             D)6,1

    例2:(2011-03)有以下程序段

    main()

    {     …

    while( getchar()!='\n');

    }以下叙述中正确的是(C)

    A)此while语句将无限循环

    B) getchar()不可以出现在while语句的条件表达式中

    C)当执行此while语句时,只有按回车键程序才能继续执行

    D)当执行此while语句时,按任意键程序就能继续执行

    【解析】while条件表达式getchar()!='\n'只要输入的字符不是回车,就一直执行循环,而循环内是一个空语句,所以按回车键程序才能继续执行,选择C。

    循环体部分可以只有一条空语句,不做任何操作。

    例3:(2010-09-21)有以下程序

    #include <stdio.h>                       

    main()

    {int y=10;

    while(y--);

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

    }程序执行后的输出结果是(B)

    A)y=0         B)y=-1        C)y=1         D)while构成无限循环

    【解析】while(y--)后面的分号是一个空语句,当y--不等于0时执行空语句,当y—等于0时,执行printf函数输出y值,当y—等于0时退出循环,此时y值变成-1。

    l  如果第一次判断表达式的值为0,则循环一次也不执行。即while循环体最少执行0次。

    例4:(2011-03)当执行下列程序时,输入1234567890<CR>,则其中while循环体将执行     0    次。

    #include <stdio.h>                       

    main()

    {char ch;

    while((ch=getchar()==’0’))  printf(‘#’);

    }

    【解析】ch=getchar(),ch第一次读入的值为’1’,故while((ch=getchar()==’0’))不成立,循环一次也不执行。

    while循环与switch结构

    例5、(2011-03)有以下程序

      main()

      {     int s;

             scanf("%d",&s);

             while(s>0)

             { switch(s)

                    {case1:printf("%d",s+5);

                    case2:printf("%d",s+4);break;

                    case3:printf("%d",s+3);

                    default:printf("%d",s+1);break;

                    }

                    scanf("%d",&s);

             }

      } 运行时,若输入1 2 3 4 5 0<回车>,则输出结果是(A)

    A)6566456          B)66656        C)66666         D)6666656

    【解析】:while循环s<=0时退出循环,输入1 2 3 4 5 0,只有当输入0时退出循环,switch中当s=1时,执行case 1,case 2,由于case 1后面没有break,会继续执行case 2,遇到break,退出switch;当s=2时,执行case 2,退出switch;当s=3时,执行case 3,default,由于case 3后面没有break,会继续执行default,遇到break,退出switch;当s=4和5时,执行default,退出switch。所以输入1时,输出65;输入2时,输出6;输入3时,输出64;输入4时,输出5;输入5时,输出6。故选择A。

    6.知识点:do-while语句

    例1:(2009-09-09)以下程序运行后的输出结果是     5    

    #include <stdio.h>                       

    main()

    {int a=1,b=7;

    do{

    b=b/2; a+=b;

    }while(b>1);

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

    l  do-while循环体最少执行1次。

    例2:(2007-09)若变量已正确定义,有以下程序段

    i=0;

    do printf(“%d,”,i); while(i++);

    printf(“%d\n”,i);    其输出结果是 (B)

    A)0,0         B)0,1        C)1,1           D)程序进入无限循环

    【解析】执行do-while循环,输出i的值为0,接着判断循环条件i++,i++的值为0,i的值为1,故答案是B。

    7.知识点:for语句

    例1:(2011-03)有以下程序

      main()

      {     char b,c; int i;

             b='a'; c='A';

             for(i=0;i<6;i++)

             {     if(i%2)  putchar(i+b);

                    else  putchar(i+c);

             }

    printf("\n");

      }  程序运行后的输出结果是(B)

    A)ABCDEF      B)AbCdEf        C)aBcDeF        D)abcdef

    【解析】:for循环执行6次,每次判断i能否被2整除,如果不能,则输出i+b,如果可以则输出i+c,注意if(i%2)是求表达式i%2是否为true,即其结果是不是非0。所以i为0时,输出0+A=A,i为1时,输出1+a=b,i为2时,输出2+A=C,i为3时,输出3+a=d,i为4时,输出4+A=E,i为5时,输出5+a=f。故选B。

    l  表达式1、表达式2、表达式3可以缺省,但两个分号不能省略。

    表达式1省略的情况如下:

    例2:(2010-03-21)有以下程序

    #include <stdio.h>

    main()

    {int a=1,b=2;

    for(;a<8;a++) {b+=a;a+=2;}

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

    }程序运行后的输出结果是(D)

    A)9,18     B)8,11     C)7,11          D)10,14

    表达式1和表达式3也可以是逗号表达式。

    例3:(2009-04-20)以下程序段中的变量已正确定义

    for(i=0;i<4;i++,i++)

    for(k=1;k<3;k++) printf(“*”);程序段的输出结果是 (B)

    A)********      B)****           C)**             D)*

    【解析】外层for循环,表达式3是逗号表达式,即i自加2。.

    for循环与switch结构

    例4:(2009-09-29)有以下程序

    #include <stdio.h>

    main()

    {int a[]={2,3,5,4},i;

    for(i=0;i<4;i++)

    switch(i%2)

    {case 0:switch(a[i]%2)

           {case 0:a[i]++;break;

            case 1:a[i]--;

           }break;

    case 1:a[i]=0;

    }

    for(i=0;i<4;i++)  printf(“%d”,a[i]);  printf(”\n”);

    }程序运行后的输出结果是(C)

    A)3 3 4 4    B) 2 0 5 0     C)3 0 40      C)0 3 0 4

    例5、(2011-03)有以下程序段

      int i,n;

      for(i=0;i<8;i++)

    {     n=rand()%5;

             switch (n)

             {     case1:

                    case 3:printf("%d\n",n);break;

                    case 2:

                    case 4:printf("%d\n",n);continue;

                    case 0:exit(0);

             }

    printf("%d\n",n);

      }  以下关于程序段执行情况的叙述,正确的是(D)

    A)for循环语句固定执行8次

    B)当产生的随机数n为4时结束循环操作

    C)当产生的随机数n为1和2时不做任何操作

    D)当产生的随机数n为0时结束程序运行

    【解析】:rand()是随机产生一个整数,rand()%5即随机得到0-4这五个数字,for循环控制随机产生8次,当得到1,3时执行printf("%d\n",n)并退出switch,当得到2,4时执行printf("%d\n",n)并继续循环,当得到0时,exit(0)正常结束程序。所以循环不一定执行8次,故选择D。

    for循环与数组

    例6:(2010-09-09)有以下程序

    #include <stdio.h>

    main()

    {int i,n[]={0,0,0,0,0};

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

    {n[i]=n[i-1]*3+1; printf(“%d ”,n[i]);}

    }程序运行后的输出结果是    1 4 13 40   

    注意区 赋值语句和判断语句

    例 7:(2011-03)若i和k都是int类型变量,有以下for语句

      for(i=0,k=-1;k=1;k++)  printf("*****\n");

      下面关于语句执行情况的叙述中正确的是 (D)

      A)循环体执行两次               B)循环体执行一次

    C)循环体一次也不执行           D)构成无限循环

    【解析】:for循环的表达式1和表达式3可以是一个简单的表达式也可以是逗号表达式,本题表达式1是一个逗号表达式,i赋值为0,同时k赋值为-1。所以判断表达式2:k=1是k赋值为1,故无限循环,选择D。

    8.知识点:循环嵌套

    例1:(2010-03-20)有以下程序

    #include <stdio.h>

    main()

    {int i,j,m=1;

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

    {  for(j=3;j>0;j--)

       {if(i*j>3)  break;

         m*=i*j;

    }

    }

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

    }程序运行后的输出结果是 (A)

    A)m=6        B)m=2          C)m=4       D)m=5

    例2:(2011-03)有以下程序

    main()

    {     int x=1,y=0;

    if(!x) y++;

    else if(x==0)

    if (x) y+=2;

    else y+=3;

    printf("%d\n",y);

    }程序运行后的输出结果是(D)

    A)3                B)2           C)1             D) 0

    【解析】:if-else的嵌套,注意else总是与前面最近的且未配对的if语句配对组合。if(!x)中x为1,!x为0为false,即if(!x) 后的语句不执行,else if(x==0),x为1也不等于0,也不成立,故else if内的语句也不执行,而if (x) y+=2;else y+=3;均为else if内的语句。所以直接输出y为0,故选D。

    9.知识点:break语句

    功能:跳出整个switch语句;跳出循环体,防止死循环。

    break语句只能出现在switchwhiledo-whilefor循环中,不能出现在其他地方。

    作用范围:所在循环体从属的最内层循环,而不是外层的某个循环。

    6.知识点:continue语句

    功能:结束本次循环,接着判断是否继续下一次循环。

    continue语句只能出现在whiledo-whilefor循环中。

    作用范围:所在循环体从属的最内层循环,而不是外层的某个循环。

    例1:(2009-04-09)以下程序运行后的输出结果是      s=0      

    #include <stdio.h>

    main()

    {int k=1,s=0;

    do{

         if((k%2)!=0)    continue;

    s+=k; k++;

    }while(k>10);

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

    }

    【解析】k=1,if((k%2)!=0)条件成立,执行continue语句,结束本次循环,判断表达式k>10,值为0,故跳出do-while循环,执行printf(“s=%d\n”,s);则输出结果为s=0。

    第三课 数组

    本课重要知识点:

    1.知识点:一维数组的定义

    例1:(2010-03-25)下列选项中,能正确定义数组的语句是(D)

    A)int num[0…2008];                   B)int num[];

    C)int N=2008;                          D)#define N 2008

    int num[N];                             int num[N];

    【解析】数组的长度必须是一个整型常量、整型常量表达式,故A项错误。定义数组时,不能省略数组长度,B项错误。数组的长度不能是变量,C项错误。数组的长度可以是符号常量,D项正确。

    例2:(2010-09-28)若要定义一个具有5个元素的整型数组,以下错误的定义语句是(D)

    A)int a[5]={0};               B)int b[]={0,0,0,0,0};

    C)int c[2+3];                 D)int i=5,d[i];

    【解析】可以只给数组的前面一部分元素设定初值,A项正确。对全部数组元素赋初值时,可以不指定数组元素的个数,B项正确。数组的长度可以是一个整型常量表达式,C项正确。数组的长度不能是变量,D项错误。

    2.知识点:一维数组元素的引用

    例1:(2008-09-21)若有定义语句:int m[]={5,4,3,2,1},i=4;则下面对m数组元素的引用中错误的是 (C)

    A)m[--i]         B)m[2*2]             C)m[m[0]]           D)m[m[i]]

    【解析】m数组元素的引用的下限为0,上限为4。i=4,--i的值为3,A项正确。B项没有越界,正确。m[0]=5,超过上限,已经越界,故C项错误。m[4]=1,没有越界,故D项正确。

    例2:(2011-03)以下程序运行后的输出结果是  13715  

    main()

    {     int i,n[5]={0};

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

    { n[i]==n[i-1]*2+1; printf("%d",n[i]); }

    printf("\n");

    }

    【解析】:n[1]=1,n[2]=1*2+1=3,n[3]=3*2+1=7,n[4]=7*2+1=15

    3.知识点:一维数组的初始化

    l  顺序列出数组元素的全部初值,例如inta[5]={1,2,3,4,5};

    l  只给数组的前面一部分元素设定初值,未赋初值的元素自动取0值。例如,int a[5]={1,2};

    l  对全部数组元素赋初值时,可以不指定数组元素的个数。例如,inta[]={1,2,3,4,5};

    4.知识点:二维数组的初始化

    l  按行分段给二维数组赋初值

    l  按行连续赋值

    l  对部分元素赋初值,未赋初值的元素自动取0值

    l  若对全部元素赋初值,则第一维的长度可以不指定

    例1:(2006-04-16)以下数组定义中错误的是(B)

    A)    int x[][3]={0};

    B)    intx[2][3]={{1,2},{3,4},{5,6}};

    C)    int x[][3]={{1,2,3},{4,5,6}};

    D)    int x[2][3]={1,2,3,4,5,6};

    【解析】若对全部元素赋初值,则第一维的长度可以不指定,C项正确。二维数组的初始化可以按行连续赋值,D项正确。C项二维数组的初始化超过第一维度长度,故错误。

    5.知识点:二维数组和for语句

    例1:(2010-03-09)有以下程序

    #include <stdio.h>

    main()

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

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

    for(j=i;j<3;j++)  printf(“%d”,a[i][j]);

    printf(“\n”);

    }程序运行后的输出结果是     123569    

    6.知识点:字符串

    定义:由“”引起来的,由若干个字符所组成的序列。

    字符串的结束标志:’\0’

    如字符串“china”,在内存中存储形式是

    c

    h

    i

    n

    a

    \0

    该字符串的长度为5字节,所占的存储空间为6字节。

    7.知识点:字符数组的定义及初始化

    l  字符数组名是地址常量,不能赋值给数组名。

    例1:(2009-04-32)以下选项中正确的语句组是(D)

    A)char s[];s=”BOOK!”;               B)char *s;s={“BOOK!”};

    C)char s[10];s=”BOOK!”;             D)char *s;s=”BOOK!”;

    【解析】字符数组名是地址常量,不能赋值给数组名,故A、C项错误,D项指针s是个变量,将字符串常量赋值给s,是正确的。B项中给s赋值时不能用花括号将字符串括起来。

    例2:(2009-09-31)下面是有关C语言字符数组的描述,其中错误的是(D)

    A)不可以用赋值语句给字符数组名赋字符串

    B)可以用输入语句把字符串整体输入给字符数组

    C)字符数组中的内容不一定是字符串

    D)字符数组只能存放字符串

    8.知识点:字符数组的输入与输出

    例1:(2009-09-13)有以下程序

    #include <stdio.h>

    main()

    {char a[20]=”How are you?”,b[20];

    scanf(“%s”,b);printf(“%s %s\n”,a,b);

    }程序运行时从键盘输入:Howare you?<回车>

    则输出结果为How are you? How

    【解析】scanf函数输入,以空格作为字符串输入结束的标志,故字符数组b只接收到字符串”How”。

    例2:(2011-03)有以下程序

    main()

    {     char a[30],b[30];

    scanf("%s",a);

    gets(b);

    printf("%s\n%s\n",a,b);

    }程序运行时若输入:howare you? I am fine<回车>则输出结果是(B)

    A)how are you?           B)how

    I amfine                    are you?I am fine

    C)how are you? I am fine   D)row are you?

    【解析】:scanf以空格作为字符串输入结束的标志,而gets(s)不会。所以a得到的是“how”,b得到的是剩下的“are you? I am fine”。故选择B。

    例3:(2011-03)有以下程序

      main()

      {     chars[]="012xy\08s34f4w2";

             inti, n=0;

             for(i=0;s[i]!=0;i++)

                    if(s[i]>='0'&&s[i]<='9')  n++;

             printf("%d\n",n);

      }  程序运行后的输出结果是 (B)

      A)0          B)3         C)7                D)8

    【解析】:for循环读取字符数组s中的字符,当读到0时退出循环,注意0和‘0’的区别,字符‘0’的ASCII码为48,‘\0’的ASCII 码才是0,所以读取的字符为“012xy”中的字符,for循环读取到字符后判断是不是数字字符,如果是n自增1,“012xy”中的数字字符只有三个,所以选择B。

    9.知识点:字符串处理函数

    1(2011-09-32)有以下程序:

    #include<stdio.h>

    #include<string.h>

    main()

    { chara[5][10]={“china”,”beijing”,”you”,”tiananmen”,”welcome”};

    int i,j; char t[10];

    for(i=0;i<4;i++)

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

       if(strcmp(a[i],a[j])>0)

       { strcpy(t,a[i]);  strcpy(a[i],a[j]);  strcpy(a[i],t);}

     puts(a[3]);

    }程序运行后的输出结果是  (C)

    A.beijing      B.china        C.welcome          D.tiananmen

    【解析】双层for循环部分是典型的排序方法,通过strcmp比较两个字符串的大小,然后借助t数组作为中转数组,通过strcpy函数完成a[i]a[j]两个字符串的交换,使a数组按从小到大排序,即{”beijing” , “china” , ”tiananmen”,”welcome”,”you” }

    例1:(2010-09-23)有以下程序

    #include <stdio.h>

    #include <string.h>

    main()

    {char x[]=”STRING”;

    x[0]=0;x[1]=’\0’;x[2]=’0’;

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

    }程序运行后的输出结果是(B)

    A)6 1    B)7 0      C)6 3    D)7 1

    【解析】经过x[0]=0;x[1]=’\0’;x[2]=’0’;后,x[]=”0\00ING”。strlen测字符串的实际长度,不含字符串结束标志’\0’,故strlen(x)为0。sizeof测字符串所占的存储空间,包含字符串结束标志,故sizeof(x)为7。

    例2:(2010-09-33)有以下程序

    #include <stdio.h>

    #include <string.h>

    main()

    {char a[20]=”ABCD\0EFG\0”,b[]=”IJK”;

    strcat(a,b);  printf(“%s\n”,a);

    }程序运行后的输出结果是(B)

    A)ABCDE\0FG\0IJK  B)ABCDIJK    C)IJK            D)EFGIJK

    【解析】把字符数组b中的字符串连接到字符数组a中字符串的后面,并删去字符串a后的第一个字符串结束标志’\0’。故输出结果为ABCDIJK。

    例3: (2010-09-31)下列选项中,能够满足“若字符串s1等于字符串s2,则执行ST”要求的是 (A)

    A)if(strcmp(s2,s1)==0)ST;                       B)if(s1==s2)ST;

    C)if(strcpy(s1,s2)==1)ST;                        D)if(s1-s2==0)ST;

    【解析】若字符串s1等于字符串s2,strcmp(s2,s1)==0,故答案是A。

    第四课 指针

    本课重要知识点:

    1.知识点:指针的概念与指针变量

    指针就是地址指针变量是用来存储地址,而一般变量是用来存储数值

    例1.(09-09-26)有如下程序输出结果为   1,2,2,1     

    #include <stdio.h>

    main()

    {     int m=1,n=2,*p=&m,*q=&n,*r;

           r=p ;p=q ;q=r ;

           printf(“%d,%d,%d,%d\n”,m,n,*p,*q) ;

    }

    【解析】p、q为指针,初始化时p指向m,q指向n。执行r=p ;p=q ;q=r ;p和q的值交换,从而p指向n,q指向m。指针的改变不会应用m、n的值,最后输出*p和*q的值分别为n、m的值。

    2.知识点:指针的引用

    l  指针的引用是通过两个运算符实现&”和“*实现的

      &是取地址符号,它的一半格式是:&变量名。例如:int  i ; &i表示取i的地址。

      *是取值运算符,它的一般格式:*指针变量名。例如:inti=10,*p=&i; *p表示取i的值10

    1.(2011-09-25)若定义语句:intyear=2009,*p=&year;,以下不能使变量year中的值增至2010的语句是  D 

           A.*p+=1;                            B.(*p)++;                            C.++(*p);                     D.*p++;

    【解析】*++同级别,按自左向右的结合方向,因此D选项可转变为*p++),从而只是使指针发生移动,而不能将p所指变量增1

    例2.(06—04—24)若有说明语句:double *p,a;则能通过scanf语句正确给输入项读入数据的程序段是 (D)

        A)*p=&a; scanf("%lf",p);

        B)*p=&a; scanf("%f",p);

        C)p=&a; scanf("%lf",*p);

        D)p=&a; scanf("%lf",p);

        【解析】对于scanf函数,输入数据列表必须是合法地址表达式(可以使地

    址常量、指针),A选项、B选项*使用错误。

    例3.(09-03-16)若有定义语句 doule x,y,*px,*py;执行了px=&x;py=&y;之后,正确的输入语句是(C)

           A) scanf("%f%f",x,y);         B) scanf("%f%f"&x,&y);

           C)scanf("%f%le",px,py);     D) scanf("%lf%lf",x,y);

    【解析】A,D选项中的x,y缺少取地址符,B项中&x之前缺少逗号,格式不正确。

    3.知识点:指针变量的初始化

    l  指针变量在使用前必须要初始化,把一个具体的地址赋给它,否则引用时会出错,如果不指向任何数据就赋“空值”NULL。

    l  指针变量两种初始化方法:方法一:int a=2,*p=&a;(定义的同时初始化)

                                   方法二:int a=2,*p;p=&a;(先定义后初始化)

    例1.(07—04—29)设已有定义:float x;则以下对指针变量P进行定义且赋初值的语句中正确的是 (D)

    A)float *p=1034;  B)int *p=(float)x; C)float p=&x;  D)float *p=&x;

    【解析】可以给一个指针赋值的只能是一个与该指针同类型的指针(或地址值);故A、B选项错误;C选项声明指针出错,P前面的指针说明符*不能省略。

    4.知识点:指针的运算

    *p++和(*p)++之间的差别:*p++是地址变化,(*p)++是指针变量所指的数据变化。一个指针变量加一个整数不是简单的数学相加,而是连续移动若干地址。当两个指针指向同一数组时,它们可以比较大小进行减法运算。

    例如:int a[10],*p; p=a; p++;表示p移动一个存储单元,p指向a[1],只有当指着指向数组元素时,指针的运动才有意义。

    5:知识点:指针与数组

    l  指针与一维数组

    数组名代表数组的首地址。一维数组中,第一个元素的地址即为该数组的起始地址。建立指针变量与一维数组的联系:

    例如:    inta[6],*pa;    pa=a;或pa=&a[0];

    说明:①数组名a代表该数组的首地址,也即a[0]的地址。

             ② pa=a;或pa=&a[0];使pa保存了数组a的首地址,pa,a,&a[0]都指向一个地址。

             ③以上操作可等价于 int a[6],*pa=a;

             ④如果pa=&a[3];表示*pa的值就是a[3]的地址。

    注意:数组a是一个地址常量,它永远指向数组的首地址,不能重新赋值。因此  a=&i;或a++都是错误的。

    例1.(08—04—23)有以下程序

        #include<stdio.h>

        main()

        {int a[]={1,2,3,4),y,*p=&a[3];

        --p;y=*p;printf("y=%d\n",y);

        }   程序的运行结果是(D)

        A)y=0    B)y=l   C)y=2    D)y=3

    【解析】程序中定义一个一维数组,并初始化,再一定义了一变量和一个指针(将指针指向数组下标为3的一个元素),执行--p;(注意,当指针指一个元素后,指针变量加上“*”时,表示引用的是元素的值,当不加“*“时表示引用的是地址),向前移动一个位置,指向a[2],y=+p;(将p指针指向的值3赋给变量y),输出y的值为3。

    例2.(11-03-24)设有定义:double x[10],*p=x;,以下能给数组x下标为6的元素读入数据的正确语句是( C )

      A)scanf("%f",&x[6]);           B)scanf("%lf",*(x+6));

      C)scanf("%lf",p+6);            D)scanf("%lf",p[6]);

    【解析】数组名是数组的首地址,p=x,指针p指向数组的首地址,要表示数组x下标为6的元素的地址可以有&x[6],x+6,p+6,&p[6],scanf后面的参数列表必须是地址列表,B中*(x+6)D中p[6]都是取数组x下标为6的元素的值,A中格式控制符%f与double类型不匹配,所以选C。

    6.知识点:用指针访问数组元素

    l  通过指针引用数组元素

    例如:int*p,a[5];         p=&a[0];

    说明:①指针变量p指向了数组元素a[0],可以使用访问运算符“*”来引用变量a[0];

             例:*p=18;等价于a[0]=18; 

             ②*(p+1)表示a[1]    p+1表示&a[1]

    l  通过数组的首地址引用数组元素

    例如:int a[5];

    说明:①a是数组名,表示收地址,可以把a当做一个指针常量。

    ②*a等价与a[0],*(a+1)等价与a[1];a等价于&a[0],a+1等价与&a[1];

    l  用带下标的指针变量引用一维数组元素

    例如:int*p,a[5];  p=a;

    说明:①p[0]表示p指针指向的内存单元,p[1]表示p指向的内存单元

             ②a[i]的等价引用方法:a[i]、p[i]、*(a+i)、*(p+i)

         ③a[i]的地址等价引用方法:&a[i]、&p[i]、a+i、p+i

    例1.(09-03—29)若有以下定义

        int x[10],*pt=x;   

        则对x数组元素的正确应用是     B     

        A)*&x[10]    B)*(x+3)   C)*(pt+10)    D)pt+3

    【解析】引用数组元素时,注意取地址运算符&与指针运算符t的作用;指针运算符+用来取得指针变量所指存储空间的内容,取地址运算符&用来取得变量的地址值;A选项数组下标越界;B选项中+(x+3)等价于元素X[3];C选项中。(pt+10)等价于x[10],数组下标越界;D选项pt+3是元素x[3]的地址,与&x[3]等价;故正确答案是B。正确答案:B

    1.(2011-09-27)有以下程序

    #include <stdio.h>

    void fun(int *p)

    {printf(“%d\n”,p[5]);}

    main()

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

     fun(&a[3]);

    }程序运行后的输出结果是  D

           A.5                B.6          C.8                D.9

    【解析】fun函数被调用时将&a[3]通过传递付给了形参指针变量p,此时可用*pp[0]来表示a[3],因此p[5]亦可表示a[8],所以输出结果为9

    7.知识点:指针与二维数组

    l  任何一个二维数组均由若干个一维数组组成,a[0]、a[1]和a[2]是一维数组名,数组名代表数组的首地址,因此a[0]就代表数组元素a[0][0]的地址,也即&a[0][0]。

    注意:a的值与a[0]相同,但它们的基类型不同,a可以等价于一个二维指针,而a[0]是一维指针。因此 int a[3][4],*p=a;错误

           取数组元素a[i][j]的地址的几种方法:&a[i][j];a[i]+j; *(a+i)+j;

    l  指针数组的定义方式:

    *指针数组名[常量表达式];如:int *p[3];

    l  行指针的一般定义形式如下:

    类型名(*指针数组名)[常量表达式];    如:int (*p)[2];

    指针数组与行指针的区别

    1、int *p[3];定义的是指针数组,表示一个数组,含有3个元素p[0]、p[1]、p[2],且这3个元素只能存放整型元素的地址

     2、int (*p)[3];定义的是行指针,表示一个指针变量,它仅有一个存储空间,只能存放一个长度为2的一维数组指针。

    例1.(06—09—33)若有定义语句:int k[2][3],*pk[3];则以下语句正确的是(B)

        A)pk=k; B)pk[0]=&k[1][2];  C)pk=k[0]; D)pk[1]=k;

    【解析】题目中定义了一个二维数组和一个指针数组,pk是指针数组名,不能被赋值,指针数组pk中的元素是指针,并且二维数组名是指向一维数组的指针常量,相当于行指针,二者不可转换,所以A、C、D选项均有误,本题答案选B。

    例2.(09-09-27) 若有定义语句: int a[4][10],*p,*q[4];且0<=i<4,则错误的赋值是 (A)

    A)p=a           B)q[i]=a[i]            C)p=a[i]               D)p=&a[2][1]

    【解析】p为基类型为int的指针,指向一个整形数据,也就可以指向一个数组元素,所以D正确。指针数组q的每个数组元素q[i]的基类型也为int,所以p、a[i]、a[i]的基类型一致,选项B、C也是正确的。

    8.知识点:指针与函数

    例1.(08—04—40)设有定义语句int(*f)(int);,则以下叙述正确的是__B_______。

        A)f是基类型为int的指针变量

        B)f是指向函数的指针变量,该函数具有一个int类型的形态

        C)f是指向int类型一维数组的指针变量

        D)f是函数名,该函数的返回值是其类型为int类型的地址

        【解析】在c语言中,函数名代表此函数的入口地址,所因此,可以定义一种指向函数的指针来存放函数的入口地址,定义方式是:函数返回值类型(*函数指针名)(参数类型列表);本题答案选B。

    9.知识点:指针与字符串

    l  可以通过字符指针来处理字符串

    例如:char *p="China"或者char *p;p="China";把字符串赋值给指针p,实质是把保存字符串"China"的那段内存的首地址赋值给指针p,使得指针p指向了字符串,这样就可以通过指针来操作字符串了。

    【注意】char str[10] ; str="China";是错误的!数组名是地址常量,不能进行赋值操作!

    “三名主义”(考试的重点)

     数组名:表示第一个元素的地址。数组名是地址常量名,不能进行赋值和自加(减)等运算。(考了很多次)

       函数名:表示该函数的入口地址。

       字符串常量名:表示第一个字符的地址。

    11.(2011-09-22)有以下程序(注:字符a的ASCII码值为97)

    #include <stdio.h>

    main()

    { char *s={“abc”};

     do

    {printf(“%d”,*s%10);++s;}

    while(*s);

    }程序运行后的输出结果是 (B)

        A.abc       B.789       C.7890      D.979898

    11.(2011-09-30)若有定义语句:char*s1=OK;*s2=ok;,以下选项中,能够输出“OK”的语句是 (D

    A.if(strcmp(s1,s2)==0)   puts(s1);                          

    B.if(strcmp(s1,s2)!=0)   puts(s2);

    C.if(strcmp(s1,s2)==1)   puts(s1);

    D.if(strcmp(s1,s2)!=0)   puts(s1);

    【解析】strcmp函数作为字符串比较函数,当s1等于s2所指字符串时结果为0,当s1大于s2所指字符串时结果为 >0,当s1小于s2所指字符串时结果为 <0

    例11.(07—04—44)有下列程序:

    main()

    {char ch[]=“uvwxyz”,*pc;   

    pc=ch;printf(”%c\n”,*(pc+5));

    } 程序运行后的输出结果是(A)

        A)Z    B)0   C)元素ch[5]的地址 D)字符Y的地址

    【解析】指针P指向了字符数组ch,*(pc+5)-->ch[5]-->’z’,printf函数要求以%c形式输出,故输出字符Z。

    例12.(09-09-37)设有定义:char *c;.以下选项中能够使字符型指针c正确指向一个字符串的是(A)

    A)char str[]=”string”; c=str;                B)scanf(“%s”,c);

    C)c=getchar();                                          D)*c=”string”;
    【解析】选项A为正确用法。先将字符串存于字符数组中,然后将数组名赋给字符指针。选项B为无语法错误,但运行时可能会出现问题。原因是字符指针没有被赋值,是一个不确定的值,指向一个不确定的内存区域,这个区域可能存放有用的指令或数据。在这个不确定的区域重新存放输入的字符串,可能会发生无法预知的错误。选项C错误。getchar()函数输入一个字符给字符型变量,而不应该是字符指针。选项D错误。*c=”string”应该改为c=”string”才是正确的。

    第五课 函数

    本课重要知识点:

    1、知识点:函数的概述

    l C源程序是由函数组成的,函数由函数首部与函数体组成,函数体包括声明部分和执行语句部分组成。

    l C语言程序可以由多个源程序组成,其中一个源程序文件包含main函数,其他函数可以写在另外的源程序文件中,为单独文件,并且可以单独编译

           例1:(10-03-11)以下叙述正确的是(  B )

           A)C语言程序是由过程和函数组成的

           B)C语言函数可以嵌套调用,例如:fun(fun(x))

           C)C语言函数不可以单独编译

           D)C语言中除了main函数,其他函数不可以作为单独文件形式存在

    【解析】选项A错误,C语言中没有过程的概念;选项B正确,C语言可以嵌套调用(此知识点在后面介绍);选项C错误,C语言中可以对包含一个或多个函数的源程序单独编译;选项D错误,C语言函数可以单独存在。

    l C程序的执行总是main函数开始,完成对其它函数的调用后再返回到main函数,最后main函数结束整个程序。main 函数可以调用其它函数,而不允许被其它函数调用一个C源程序必须有,也只能有一个主函数main

           例1:下列叙述中正确的是(  C  )

           A)C语言程序将从源程序中第一个函数开始执行

           B)可以在程序中由用户指定任意一个函数作为主函数,程序将从此开始执行

           C)C语言规定必须用main作为主函数名,程序将从此开始执行,在此结束

           D)main可作为用户标识符,用以命名任意一个函数作为主函数。

    l 在一个函数的函数体内,不能再定义另一个函数,即不能嵌套定义

    例1、下列叙述中正确的是(  D  )

           A)每个C程序文件中都必须要有一个main()函数

           B)在C程序中main ()函数的位置是固定的

           C)C程序中所有函数之间都可以是固定的

           D)在C程序的函数中不能定义另一个函数

    【解析】一个C源程序可以由多个C程序文件,但只能有一个main()函数,并不是每个C程序文件都必须要有一个main(),main()函数可以放在任意位置,且不允许被其他函数调用,因此正确答案是D。

    2、知识点:函数的定义

    例1:以下正确的函数定义形式是:(C)

    A)double  fun(int x,int y);{}                     B) double  fun(int x ;inty){}

    C) double  fun(int x,int y){}            D)  double fun(int x, y);{}

    【解析】在函数中对形参的说明,要求对每个形参都必须说明类型,各参数之间用“,i;le  fun(intx,int y); D)”隔开,函数定义后应无“;”。

    l  函数返回return语句的一般形式:return 表达式;或return  (表达式);

    在函数中允许有多个return语句,但每次只能有一个return语句被执行。

    例1:(10-03-24)以下关于return语句叙述中正确的是( B)

           A)一个自定义函数中必须有一条return语句

           B)一个自定义函数中可以根据不同情况设置多条return语句

           C)定义void类型的函数中可以有带返回值的return语句

           D)没有return语句的自定义函数在执行结束时不能返回到调用处。

    【解析】自定义函数中可以没有return语句(如不需要返回值的函数,常见void类型)),可以有多条return语句(如在分支结构中,可以从不同分支中返回到调用程序,常见if..else);定义成void类型的函数,不允许从该函数取得返回值,也不允许使用return语句。没有return语句的函数在执行到函数的最后一条语句后自动返回达到调用处。

    Ø  函数值的类型与函数定义中函数的类型保持一致,如不一致,以函数类型为准

    例2:(06-04-23)已定义以下函数

     intfun(int *p){return *p;}       fun函数返回值是( B )

     A)不确定的值       B)一个整数 C)形参P中存放的值       D)形参P的地址值

       【解析】函数返回性类型取决于定义函数时函数名称前的类型,fun前是int,表明函数fun执行完毕后返回一个整型数。正确答案:B

    Ø  return 后的表达式可以是常量、变量、表达式,也可以空。

    如:return ;   return 0;    return a;  return (a+b);

    3、知识点:形参和实参及函数调用

    形参出现在函数定义中(即定义函数时函数名后面括号中的参数),实参出现在主调函数中(调用函数时函数名后面括号中的参数)

    形参在本函数体内都可以使用,离开该函数则不能使用。实参在主调函数中内有效,进入被调函数后,实参变量也不能使用。(注:在进行函数调用时,函数必须有确定的值)

    实参向形参单向传递数值,不能将形参的值反向的传送给实参。实参和形参在数据上、类型上、顺序上要一致。在函数调用过程中,形参的变化不会改变实参的变化。

           1、(09-09-24)有以下程序

           #include<stdio.h>

           void fun(int p)

           {     int d=2;          p=d++;printf(“%d”,p);  }

           main()

           {     int a=1;

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

           }     程序运行后的输出结果是( C)

           A)   32           B)12              C)21              D)22

    【解析】此题考点为函数参数的传递。C语言中函数参数的传递是值传递,是把实参的值传给形参,是单向传递,形参的改变不会影响到实参的值。程序中,把实参a的值传给形参p,p=1,然后p=d++,再次赋值后p=2,输出p的值2。返回到主程序中,输出a的值为1。(形参p的改变不会影响到实参a的值,a的值仍为1).因此答案为C.

    l  在传递数值时,形参和实在分别占据不同的存储单元(形参变量只有在被调用时才分配内存单元,调用结束后,即刻释放分配的内存单元)

           例1、(07-04-25)若函数调用时的实参为变量时,以下关于函数形参和实参的叙述中正确的是( D)

        A)函数的实参和其对应的形参共占同一存储单元

        B)形参只是形式上的存在,不占用具体存储单元

    C)同名的实参和形参占同一存储单元 

    D)函数的形参和实参分别占用不同的存储单元

        【解析】本题考点是函数的参数定义,在函数中,主调数中里边的参数叫做实参,而被调函数里边的参数叫做形参,当函数传递时,传递的是值,它们占用的不是同一存储单元,而且在传递中,是单向传的,由实参传向形参。

     “传值”与“传址”的区别:传数值的话,形参的变化不会改变实参的变化。传地址的话,形参的变化就有可能改变实参所对应的量。

           1(10-03-26)有以下程序

           #include <stdio.h>

           void fun(char *c,int d)

           {     *c=*c+1;   d=d+1;

                  printf(“%c,%c”,*c,d);

           }

           main()

           { char b=’a’, a=’A’;

             fun(&b,a);

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

           }     程序运行后的输出结果是(A)

           A) b,B,b,A            B)b,B,B,A             C)a,B,B,a              D)a,B,a,B

    4、知识点:函数调用的一般形式和调用方式

    l  函数调用的一般形式为:函数名(实际参数表)

    实参可以是常数、变量或其他构造类型数据及表达式,也可以没有(当为无参函数时)

    l  函数调用的方式:

           (1)函数表达式:函数作为表达式中的一项出现在表达式中,以函数返回值参与表达式运算。例如:z=max(x,y);

           (2)函数语句函数调用的一般形式上加上分号。例如:printf(“%d\n”,a);

           (3)函数实参:函数作为另一个函数调用的实际参数出现。例如:printf(“%d”,max(x,y));

    l  程序从main函数进入,上往下执行,当碰到函数名后,把值传给调用函数,当程序得到了返回值或调用函数结束,再顺序往下执行,最后到main函数结束。

    5、知识点:函数的声明及其位置

    函数要“先定义后调用”,或“先声明再调用后定义”。函数的声明一定要有函数名、函数返回值类型、函数参数类型,但不一定要有形参的名称。

    一般形式为:

    类型说明符被调函数名(类型形参,类型形参…)

        类型说明符被调函数名(类型,类型…)

    注意:其末尾“;”不能省

    例如int max(int a,int b);       int max(int ,int); 两者功能相同

    例1、(06-09-32)若有以下函数首部

                 int fun(double x[10],int *n)

                 则下面针对此函数声母语句中正确的是(D)

              A)int fun(double x,int *n); B)int fun(double,int);

            C)int fun(double*x,int n); D)int fun(double *,int。);

        【解析】本题考点是对函数的声明,在函数声明的时候,其格式如下:返回值类型函数名(参数类型[参数名],参数类型[参数名]……)其中,参数名可以不写,但是参数类型一定要写全

    省去主调函数中对被调函数的函数说明的几种情况:

    1)被调函数的返回值是整型或字符型时(返回值自动按整型处理)

    2)当被调函数的函数定义在主调函数之前时

    3)在所有函数定义之前,在函数外预先说明了各个函数的类型

    例2:(10-09-24)有以下程序

          #include<stdio.h>

          int f(int x);

          main()

          { int n=1,m;

           m=f(f(f(n)));  printf(“%d\n”,m);

          }

          int f(intx)

          { returnx*2;}

          程序运行的输出结果( D  )

          A) 1        B)2                C)4                D)8

    【解析】f函数定义在main下面,但在外部进行声明int f(int x);因此在main中可直接调用。

    三次调用函数:f(n)=f(1)=2  f(2)=4 f(4)=8 m=f(f(f(n)))=f(f(f(1)))=f(f(2))=f(4)=8

    例3:(11-03-12)有以下程序,请在 【12】处填写正确语句,使程序可正常编译运行。

    【12】;

    main()

    {     doublex,y,(*p)();

    scanf("%lf%lf",&x,&y);

    p=avg;

    printf("%f\n",(*p)(x,y));

    }

    double avg(double a,double b)

    { return((a+b)/2);}

    答案:double avg(double a,doubleb);或double avg(double ,double );

    【解析】当函数定义在调用之后,调用前必须对函数进行申明,申明的形式和函数定义中的函数头部分相同,最后加分号即可。

    6、知识点:函数的嵌套调用

    l  C语言中不允许作嵌套的函数定义,但是允许在一个函数的断定仪中出现对另一个函数的调用,即嵌套调用。

    例1:(06-04-33)有以下程序

        intfunl(double a){return  a*=a;}

        int fun2(double x,double y)

        {double a=0,b=0;

        a=funl(x);b=funl(y);return (int)(a+b);

    }

    main()

       {double w;w=fun2(1.1,2.0);……}

        程序执行后变量w中的值是( C )

                A)5.2l    B)5   C)5.0  D)0.0

    【解析】此题考查函数的嵌套调用。main函数中调用了fun2函数;fun2函数中又调用了如fun1函数w=fun2(1.1,2.0)-->w=(int)(funl(1.1)+funl(2.0))àw=(int)5.21;w值为5,但是w是double类型变量,故将5转换成5.0赋值给变量w

    例2、(09-3-24)有以下程序

    #include<stdio.h>

    int f(int x,int y)

    {return ((y-x)*x);}

    main()

    {     int a=3,b=4,c=5,d;

           d=f(f(a,b),f(a,c));

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

           }     程序运行后的输出结果是(  B )

           A) 10    B)9        C)8         D)7

    【解析】程序的main()函数中,定义了4个变量,前3个分别初始化,D用来接收调用函数后返回的值,主函数一共调用了3次f()函数,第一次传递a,b的值,给形参x,y,返回(y-x)*x的值为3,第二次将a,c的值传递给形参x,y,返回(y-x)*x的值为6,接着将f(a,b),f(a,c)的值3、6传递给形参,执行后返回值9,赋值变量d,最后输出结果为9

    7、知识点:函数的递归调用

    函数直接或间接地调用自己称为函数的递归调用。递归调用必须有一个明确的结束递归的条件。在做递归题时可把递归的步骤一步步写下来,不要弄颠倒了。

    例1、(04-09-37)在函数调用过程中,如果函数funA调用了函数funB,函数funB又调用了函数funA,则 ( B )

        A)称为函数的直接递归调用

        B)称为函数的间接递归调用

        C)称为函数的循环调用

        D)C语言中不允许这样的递归调用

    【解析】此题考查函数递归的基本概念。一个函数直接或间接调用自己称为函数的递归调用;若直接调用了自己,则称为直接递归调用,若间接调用了自己则称为间接递归调用;根据间接递归调用的概念可知,本题中的函数调用为间接递归调用。

    例2、(09-09-15)

    #include <stdio.h>

    fun(int x)

    {     if(x/2>0) fun(x/2);

           printf(“%d  ”,x);

    }

    main()

    {   fun(6);   printf(“\n”);}程序运行后的输出结果是__1  3  6______

    【解析】程序的执行过程是先递推、后递归的过程。当x=1时,条件不成立,递推终止。程序执行流程参照示意图。

    例3:(10-03-33)有以下程序

    #include <stdio.h>

    int f(int t[],intn);

    main()

    { int a[4]={1,2,3,4},s;

     s=f(a,4); printf(“%d\n”,s);

    }

    int f(int t[],int n)

    {     if(n>0)return t=[n-1]+f(t,n-1);

           elsereturn 0;

    }程序运行后的输出结果是( B)

    A) 4        B) 10             C)14       D)6

    【解析】s=f(a,4)=t[3]+f(a,3)=4+f(a,3)=4+t[2]+f(a,2)=4+3+f(a,2)=7+t[1]+f(a,1)

    =7+2+f(a,1)=9+t[0]+f(a,0)=9+1+f(a,0)=10+0=10

    例4:(11-03-32)设有如下函数定义

    int fun(int k)

    {     if(k<1) return 0;

    else if(k==1) return 1;

    else return fun(k-1)+1;

    }若执行调用语句:n=fun(3);,则函数fun总共被调用的次数是( B)

    A)2                B)3             C)4               D)5

    【解析】递归调用,fun(3)—> fun(2)—> fun(1) ;fun(1)—1—> fun(2)—2—> fun(3)—3—>n;所以fun总共被调用的次数是3,最后n为3。

    例5:(11-03-34)有以下程序

    int fun (int x,int y)

    {     if(x!=y) return ((x+y)/2);

    else return (x);

    }

    main()

    {     inta=4,b=5,c=6;

    printf("%d\n",fun(2*a,fun(b,c)));

    }程序运行后的输出结果是( B)

    A)3              B)6              C)8                D)12

    【解析】函数递归调用,fun(8,fun(5,6)),其中fun(5,6)因为5!=6, return ((x+y)/2)为5,所以fun(8,fun(5,6))为fun(8,5),8!=5, return ((x+y)/2)为6

    8、知识点:局部变量和全局变量

    在一个函数内部或复合语句内部定义的变量,它只在本函数范围内有效,也就是说只有在本函数内才能使用它们,在函数以外是不能使用这些变量的。这称为局部变量,局部变量又称为内部变量。函数的形参也属于局部变量。

    在函数外部定义的变量,称为全局变量,又称为外部变量。全局变量可以被本文件的其他函数所共用

    例1、(07-09-40)在一个C语言源程序文件中所定义的全局变量,其作用域为(D)

           A)所在文件的全部范围    B)所在程序的全部范围

           C)所在函数的全部范围    D)由具体定义位置和extem说明来决定范围

    【解析】本题考点是全局变量的作用域,全局变量的作用域是,从变量定义开始,一直到程序程结束为止,当然,也可以在其它文件中用这个以定义的全局变是,但是要通过extern来进行声明,本题答案选D。

    例2、(09-09-11)有以下程序

    #include<stdio.h>

    int a=5;

    void fun(int b)

    {     int a=10; a+=b;

           printf(“%d”,a)

    }

    main()

    {     int c=20;

           fun(c); a+=c;

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

    }程序运行后的输出结果是____3025____

    【解析】全局变量的作用域为定义开始到文件结束。局部变量的作用域为定义其函数内部。当局部变量与全部变量同名时,在局部变量作用域内,全部变量不起作用。

    执行函数fun(c):    实参c 将值传给形参b,即b=20,函数内部定义局部变量a起作用,a=10,a+=b        a=a+b=10+20=30,输出a的值为30

    返回到主函数:    a+=c 此时a为全局变量的值      a=a+c=5+20=25 输出a值25

    注意格式控制符无空格,所以连续输出

    9知识点:变量存储类别(auto变量、register变量、static变量)

    Ø  静态变量(static):

    1在编译时分配存储空间,所占存储单元直到程序结束时才释放,它的值在程序运行过程中一直存在,且变量的初始化只进行一次。

    2static说明符可以用于全局变量,也可用于局部变量autoresgiter不可以定义全局变量)但是,当它说明变量后,只要这个变量还在程序中存在,那么不管用到还是没有用到,它都将会占用内存单元。

    例1:(10-09-36)有以下程序:

    #include <stdio.h>

    int f()

    {     static int x=1;

           x+=1;      return x;

    }

    main()

    {   int i,s=1;

           for(i=1;i<=5;i++)s+=fun();

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

    }     程序运行后的输出结果是( B)

           A)11  B)21    C)6         D)120

    【解析】fun函数被调用了5次,每次调用后的值返回值累加到s上。

    第一次:静态局部变量定义有效,x=2,返回值为2。s=s+fun()=1+2=3;从第2次调用开始,静态局部变量的定义相当于不存在,直接使用x的值。

    第二次:x=3  s=3+3=6              第三次:x=4  s=6+4=10

    第四次:x=5  s=10+5=15          第五次:x=6  s=15+6=21

    例2:(11-03-34)有以下程序

    int fun()

    {     staticint x=1;

    x*=2;

    return x;

    }

    main()

    {     inti,s=1;

    for(i=1;i<=3;i++)s*=fun();

    printf("%d\n",s);

    }程序运行后的输出结果是(D)

    A)0           B)10           C)30           D)64

    【解析】静态变量static类型,在函数执行完后空间并不释放,而且只初始化一次。所以第一次调用后,x的值为2,返回后s的值为2,第二次调用后,x的值为2*2=4,返回后s的值为2*4=8,第三次调用后,x的值为4*2=8,返回后s的值为8*8=64,故选D。

    Ø  自动变量(auto

    1自动变量的存储空间是当程序执行到定义它的函数或语句块时才分配,当函数执行结束后自动释放,变量的值也就不再存在。

    2)局部变量的存储类别默认为auto,可以省略不写,但它不能定义全局变量。

    Ø  寄存器变量(register):

    例1、(08-04-39)在C语言中,只有在使用时才占用内存单元的变量,其存储类型是( A )。

     A)auto和register   B)extern和register  C)auto和static  D)static和register

    【解析】auto变量在进入函数体时,系统为其分配存储单元,退出时自动释放;register是建议编译程序将变量的值保存在cpu的寄存器中,而不是占用内存单元;extern可以对全局变量加以说明,扩展其作用域,在整个程序中都有效,所以会一直占用内存单元;static说明符可以用于全局变量,也可用于局部变量,使变量在整个程序执行期间一直占用内存单元,本题答案选A。

    2:(10-09-34)设函数中有整形变量n,为保证其在未赋初值的情况下初值为0,应该选择的存储类别是( C

           Aauto         B)register              C)static          D)autoregister

    【解析】对于静态局部变量(static),如在定义时不赋初值的话,编译时自动赋初值0(对数值型变量)或空字符(对字符变量)。而对于自动变量(auto或者缺省不写),如果不赋初值则它的值是一个不正确的值。

    10、内部函数与外部函数

    static 进行说明的函数称为静态函数,也叫内部函数。静态函数只能被本编译单元体内的函数调用。一般形式:static 类型标识符函数名(形参表)例如:staticint fun(){…}

    11、知识点:库函数

    l  函数可以分为库函数和用户自定义函数。库函数由C系统提供,用户无须定义,在调用C语言标准库函数时要包含include命令,include命令行#开头

    例1、(07-04-17)若有代数式 (其中e仅代表自然对数的底数,不是变量),则以下能够正确表示该代数式的C语言表达式是( C)

     A)sqrt(abs(nx+ex))                B) sqrt(fbs(pow(n,x)+pow(x,e)))

    C)sqrt(fabs(pow(n,x)+exp(x,e)))     D)sqrt(fabs(pow(x,n)+exp(x)))

    【解析】exp()函数的功能是返回以自然数e为底、函数参数x为幂的指数值ex  ;pow(n,x)函数是计算nx ;fabs()函数的功能是返回函数参数的绝对值;sqrt()用于返回函数参数的平方根。所以正确答案为C。

    例2:以下说法不正确的是(B)

    A)标准库函数按分类在不同的头文件中声明

    B)用户可以重新定义标准库函数

    C)系统不允许用户重新定义标准库函数

    D)用户若需要调用标准库函数,调用前必须使用预编译命令将该函数所在文件包括到用户源文件中

    【解析】对每一类库函数,都有相应的头文件名,调用某个库函数时,用户在源程序中须用include命令包含其头文件名。每一类标准库函数是C语言本身提供的,用户不能重新定义标准库函数。

    12、知识点:数组与函数

    l  数组用作函数参数有两种形式:把数组元素(下标变量)作为实参使用和把数组名作为函数的形参和实参使用。

    数组元素作函数的实参与普通变量并无区别,所进行的传递是形参变量和实参变量占据由编译系统分配的两个不同的内存单元

    数组名作为函数参数时,所进行的传递是地址(相当于把实参数组的首地址赋予形参数组名或指针名),形参数组与实参数组为同一数组,共同拥有一段内存单元

    1:(2011-09-31以下程序的主函数中调用了在其前面定义的fun函数

    #include<stdio.h>

    main()

    {double a[15],k;

    k=fun(a);

    }则以下选项中错误的fun函数首部是  ( D)

    A.double fun(double  a[15])          B.double  fun(double *a)

    C.double fun(double  a[])           D.double  fun(double a)

    【解析】当一维数组名a作为实参时,对应形参有三种表示形式:*aa[ ]a[N]( 注:N为定义a数组时的元素个数)

    例1:(11-03-11)己知a所指的数组中有N个元素。函数fun的功能是,将下标k(k>0)开始的后续元素全部向前移动一个位置。请填空。

    Void fun(int a[N],int k)

    {     inti;

    for(i=k;i<N;i++) a[【11】] = a[i];

    }

    答案:i-1

    【解析】a[i]的值赋给a[i-1]

    例2:(10-09-32)有以下程序

    #include <stdio.h>

    #define N 8

    void fun(int *x,int i)

    {   *x=*(x+i); }

    main()

    {     inta[N]={1,2,3,4,5,6,7,8},i;

           fun(a,2);

           for(i=0;i<N/2;i++)

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

           printf(“\n”);

    }程序运行后的输出结果是(  C )

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

    【解析】数组名代表数组首地址,即a[0]的地址。函数调用:fun(a,2) 参数传递后,形参指针x获得数组首地址,即指向a[0],形参变量i=2;*x即为a[0],*(x+2)即a[2],*x=*(x+2)相当于a[0]=a[2],a[0]变为3,a[2]不变。返回到主程序:循环4次,输出a数组前4个元素:  3 2 3 4

    例3:(10-09-25)有以下程序

    #include <stdio.h>

    void fun(char *s)

    {  while (*s)

           {if (*s%2==0) printf(“%c”,*s);  s++;}

    }

    main()

    {     char a[]={“good”};

           fun(a);printf(“\n”);

    }注意:字母a的ASCII码值为97,程序运行后的输出结果是(  A  )

           A) d        B)go       C)god            D)good

    【解析】调用fun(a)函数,实参字符数组名a传递给形参字符指针s,使s指向字符串“good”;在函数fun中对字符串进行遍历,如果指针s指向字符ASCII码值是偶数则输出该字符。在字符串“good”中,只有“d”的ASCII码值为偶数

    13指针与函数

    函数指针变量是指向函数的指针变量

           定义的一般形式为:  类型说明符(*指针变量名)();      例如: int (*pf)();

           调用函数的一般形式:(*指针变量名)(实参表) 例如:z=(*p)(x,y);

                                                    Ä注: (*指针变量名)中的“()”不能少

    例1:(09-09-33)设有以下函数:

    void fun(int n,char *s){…}   则下面对函数指针的定义和赋值均正确的是( A )

    A)void (*pf)(); pf=fun;            B)void *pf();  pf=fun;

    C)void *pf(); *pf=fun;             D)void (*pf)(int,char);pf=&fun;

    【解析】本题考点为指向函数的指针的用法。函数名代表函数的入口地址,可以赋值给指向函数的指针。指向函数的指针应该定义为void (*pf)().如定义为void *pf(),则表示函数pf返回值为一个基类型为 void的指针。

    函数指针变量不能进行算术运算

    l  指针型函数是指返回指针值的函数。定义的一般形式为:

     类型说明符 *函数名(形参表){…}  例如:int *ap(int x,int y){}

    例1:(10-09-11)有以下程序

    #include <stdio.h >

    int*f(int *p,int *q)  

    main()

    {  int m=1,n=2,*r=&m;

     r=f(r,&n) ; printf(”%d\n”,*r) ;

    }

    int *f(int *p,int *q)

    {     return(*p>*q) ?p :q ;}

    程序运行后的输出结果是______2_____

    【解析】本题中f是个指针型函数,返回值为指针值。如示意图。

    主程序中,指针r指向m,函数调用f(r,&n)时,实参传递给形参,形参指针p指向m,指针q指向n,*p的值为m的值1,*q的值为n的值2,所以函数返回值为q,返回给主程序中的指针r,即指针r指向了n,最后输出*r的值为n的值2.

    例2:(11-03-29)有以下程序

    void fun(char *c)

    {     while(*c)

    {      if(*c>=’a’&&*c<=’z’)*c=*c-(‘a’-‘A’);

    c++;

    }

    }

    main()

    {     chars[81];

    gets(s); fun(s); puts(s):

    }当执行程序时从键盘上输入Hello Beijing<回车>,则程序的输出结果是( C )

    A)hello beijing    B)Hello Beijing    C)HELLO BEIJING    D)hELLO Beijing

    【解析】gets(s)将输入的Hello Beijing赋给了字符数组s,调用fun(s),将字符数组s的首地址传给了c,c指向的即为字符数组的首地址,通过指针变量c取得字符数组中的字符判断是不是小写字母,如果是变成大写字母。*c=*c-(‘a’-‘A’)完成小写换大写的功能。故选C。另外注意gets(s)和scanf(“%s”,s);的区别:scanf以空格作为字符串输入结束的标志,而gets(s)不需要

    第六课 结构体、链表与共用体

    本课重要知识点:

    1.知识点:用typedef定义类型

    l  功能:为已有数据类型取别名

    l  类型定义形式: typedef  旧类型名  新类型名;(例如:typedef  double  D ; )

    注意:

    (1)       定义的新名只是原名的一个别名,并不是建立一个新的数据类型;

    (2)       用新名和原名定义的对象具有相同的性质和效果

      例1:(2010-09-39)若有以下语句

      typedef  struct S

      {int g; charh;}T;

      以下叙述中正确的是 ( B  )

      A)可用S定义结构体变量

      B)可用T定义结构体变量

      C)S是struct类型的变量

    D)T是struct S类型的变量

    【解析】此题中用typedef 说明的新类型名T,与中间部分的结构体类型具有相同的性质和效果

    3. 知识点:结构体变量的定义

     

    具体形式

    实例

    说明

    1

    struct     结构体名

    {

    类型标识符    成员名;

    类型标识符    成员名;

             …………….

    };

    struct  结构体名 变量名表列;

    struct student

    { char   num[20];

    char   name[20];

      char   sex;

    float score[4];

    };

    struct student stu1,stu2;

    特点:先定义类型,后定义变量

    注意:定义变量时,必须以struct  student 开头,缺一不可

    2

    struct     结构体名

    {

      类型标识符    成员名;

      类型标识符    成员名;

             …………….

    }变量名表列;

    struct student

    { char   num[20];

    char   name[20];

      char   sex;

    float score[4];

    } stu1,stu2;

    特点:定义类型的同时定义变量

    注意:之后再定义同类型变量时,也必须必须以struct  student 开头

    形式3

    struct 

    {

    类型标识符    成员名;

    类型标识符    成员名;

             …………….

    }变量名表列;

    struct

    { char   num[20];

    char   name[20];

      char   sex;

    float score[4];

    } stu1,stu2;

    特点:定义类型的同时定义变量

    注意:此形式省略了结构体名,预示着后续程序中将不再定义该类型变量

    形式4

    typedef  struct   结构体名

    {

     类型标识符    成员名;

     类型标识符    成员名;

             …………….

    } STU;

    STU  变量名表列;

    typedef  struct student

    { char   num[20];

    char   name[20];

      char   sex;

    float score[4];

    } STU;

    STU stu1,stu2;

    特点:先定义类型,后定义变量

    注意:用STU或struct  student定义变量具有同等效果,用STU形式简洁方便

    例1:(:2009-09-36)下面结构体的定义语句中,错误的是(  B  )

    A)struct ord {int x;int y;int z;};  struct ord a;

    B)struct ord {int x;int y;int z;}  struct ord a;

    C)struct ord {int x;int y;int z;} n;

    D)struct {int x;int y;int z;} a;

    【解析】遵循先定义类型,再定义该类型变量的原则,类型定义末尾的分号“;”必不可少

    2.知识点: 结构体变量各成员的引用

    l  引用结构体变量的成员的方法是:结构体变量名.成员名  (例如:stu1.sex

    l  结构体指针变量引用成员的方法是:

    形式1:(*指针变量名).成员名  (例如:(*p).num

    形式2: 指针变量名->成员名  (例如:p->num

    l  运算符级别,注意:()和->和 . 同级别,均大于*

    设有:

    structstudent

    {char   num;

    char   name[20];

      struct date {int year,mon,day} birth;

    float score[4];

    };

    struct  student *p,stu1;

    p=&stu1;

    成员类型

    成员

    操作方式

    说明

    普通变量

    例如:引用成员变量num

    直接赋值:stu1.num=201101;

    间接赋值:p->num=201101

    输入:scanf(“%d”,& stu1.num);

    输出:printf(“%d”,stu1.num);

     

    数组

    例如:引用成员数组元素score[0]

    赋值:stu1.score[0]=75;

    间接赋值:p-> score[0]=75;

    输入:scanf(“%f”,& stu1. score[0]);

    输出:printf(“%f”,stu1. score[0]);

     

    字符串

    例如:字符数组成员作为字符串name

    赋值:strcpy(stu1.name,”zhangsan”);

    间接赋值:strcpy(p->.name,”zhangsan”);

    输入:scanf(“%s”, stu1.name);

    输出:printf(“%s”,stu1.name);

    %s作为格式控制时,scanf和printf的输入和输出项均为地址

    结构体嵌套

    例如:引用内嵌结构体变量birth的成员year

    赋值:stu1.birth.year=1989;

    间接赋值:p-> birth.year=1989;

    输入:scanf(“%d”,& stu1. birth.year)

    输出:printf(“%d”,stu1. birth.year)

     

    例1:(2009-9-12)设有定义

    struct person

    { int ID;char name[12];} p;

    请将scanf("%d",     );语句补充完整,使其能够为结构体变量p的成员ID正确读入数据。

    【解析】此题答案是  &p.ID  ,即在成员ID前缀 p. 表示其从属于变量p,操作方式与普通变量和数组没什么不同,只需要在引用时前面标明属于哪个结构体变量。

    例2:(2010-03-38)有以下定义和语句

    struct workers

    {  int  num;

    char name[20];

    char c;

    srruct

    {int  day;int  month;int year;}  s;

    };

    struct workers  w,*pw;

    pw=&w

    能给w中year成员赋1980的语句是 (  D  )

    A)*pw.year=1980;   B)w.year=1980;

    C)pw->year=1980;   D)w.s.year=1980;

    【解析】引用w的内嵌结构体变量s的成员year,应逐级递进。具体方法参考前面表格。

    例3:(2011-03-36)设有定义:struct {char mark[12];intnum1;double num2;} t1,t2;,若变量均已正确赋初值,则以下语句中错误的是(C)

    A)t1=t2;      B)t2.num1=t1.num1;    C)t2.mark=t1.mark;    D)t2.num2=t1.num2;

    【解析】结构体以及结构体成员的赋值,需要类型一致,所有选项都满足,但是mark是结构体中的字符数组的数组名,其数组的首地址,是一个指针常量,只能在初始化的时候赋值,故C错误。

    例4:(2011-03-37)有以下程序

    struct ord

    { int x,y;}dt[2]={1,2,3,4};

    main()

    {

    struct ord *p=dt;

    printf("%d,",++(p->x));printf("%d\n",++(p->y));

    }程序运行后的输出结果是(D)

    A)1,2             B)4,1         C)3,4          D)2,3

    【解析】dt是一个结构体类型的数组,其有两个结构体元素,p是结构体类型指针,其指向dt即指向结构体数组的首地址,p->x和p->y分别是结构体数组第一个元素的x成员和y成员的值,++在前则是先自增1再参与运算,所以输出的是1+1=2,和2+1=3,故选D。

    例5:(2011-03-38)有以下程序

    struct S

    { int a,b;}data[2]={10,100,20,200};

    main()

    {     structS p=data[1];

    printf("%d\n",++(p.a));

    }程序运行后的输出结果是(D)

    A)10             B)11           C)20            D)21

    【解析】结构体变量p赋值为结构体数组第二个元素的值,即p.a=20,p.b=200;所以输出++(p.a)为21,故选D。

    3.知识点: 结构体变量与函数调用

    l  将一个结构体变量的值传递给另一个函数,有3个方法:

      (1)用结构体变量的成员作参数。例如,用stu[1].num作实参,将值传递给形参。用法和用普通变量作实参是一样的,属于“单向值传递”方式。应当注意实参与形参的类型应保持一致。

      (2)用结构体变量作实参。 对应形参也是同类型结构体变量,也属于“单向值传递”方式。

      (3)用指向结构体变量(或数组)的指针作实参,将结构体变量(或数组元素)的地址传给形参。属于“地址传递”方式,应注意在被调用函数中是否对该地址的值有影响。

    例1:(2009-09-14)有以下程序运行后的输出结果是   16  

    typedef struct

    { int num;double s;} REC;

    void fun1(REC x)

    { x.num=23;x.s=88.5; }

    main()

    { REC a={16,90.0};

      fun1(a);

      printf("%d\n",a.num);

    }

    【解析】main函数中的fun1(a); 是将a的值单向传递给了形参x,相当于赋值给了x,因此x的值的变化不会影响到a

    例2:(2009-09-38)有以下程序

    struct A

    { int a;char b[10];double c;};

    struct A f(struct A t);

    main()

    { struct A a={1001,"ZhangDa",1098.0};

      a=f(a); printf("%d,%s,%6.1f\n",a.a,a.b,a.c);

    }

    struct A f(struct A t)

    { t.a=1002;strcpy(t.b,"ChangRong");t.c=1202.0;return t;}

    程序运行后的输出结果是 (  D   )

    A)1001,ZhangDa,1098.0

    B)1002,ZhangDa,1202.0

    C)1001,ChangRong,1098.0

    D)1002,ChangRong,1202.0

    【解析】注意在f函数中的t.a=1002;strcpy(t.b,"ChangRong");t.c=1202.0; 这三条语句。

    4.知识点:链表

    l  当一个结构体中有一个或多个成员的基类型就是本结构体类型时,通常把这种结构体称为可以“引用自身的结构体”,也称为“链表结构

    例如:

    struct  link

    { char ch;

     Struct  link *p;

    }a;  

    在此,p是一个可以指向struct link类型变量的指针成员,因此,a.p=&a是合法的表达式,由此构成的存储结构如图所示。

    对链表进行的操作通常有以下四种:

    1.建立带有头结点的单向链表

    2.顺序访问单向链表各结点数据域的值(即遍历链表)

    struct std

    {

    int data;  /*数据域*/

     struct std * next;  /*指针域*/

    };

    …建立头结点和数个节点,即建立以下链表

    遍历链表:

    p=head;

    while(p!=0)

    {

                  printf("%4d",p->data);

                  p=p->next;

    }

    }

    3.删除单向链表中的某个结点

    删除q指向的节点:

    p->next=q->next;或者p->next=r;

    free(p);

    4.向单向链表中插入结点

    将r指向的节点插入p、q所指的两个结点之间:

    r->next=q;  或者r->next=p->next;

    p->next=r;

    1(2011-09-37)在以下程序

     #include<stdio.h>

    main()

    {struct node{int n;struct node *next;}*p;

     struct node x[3]={{2,x+1},{4,x+2},{6,NULL}};

    p=x;

    printf(“%d,”,p->n);

    printf(“%d\n”,p->next->n);

    }程序运行后的输出结果是  B

    A.2,3    B.2,4   C.3,4    D.4,6

    【解析】通过赋值语句p=x,即p=&x[0],使p指向了x[0],因此p->n等价于x[0].n,输出2p->next等价于x[0].next,即x+1或表示为&x[1]p->next->n也可表示为x[1].n,输出4

    例1:(2009-03-15)以下程序把三个NODETYPE型的变量链接成一个简单的链表,并在while循环中输出链表结点数据域中的数据,请填空

    #include <stdio.h>

    struct node

    {int data; struct node *next;};

    typedef  struct  node  NODETYPE;

    main( )

    {NODETYPE a,b,c,*h,*p;

    a.data=10;b.data=20;c.data=30;h=&a;

    b.next=&b;b.next=&c;c.next=’\0’;

    p=h;

    while(p){printf(“%d”,p->data);  p=p->next  ;}

    }

    【解析】while就是用来遍历链表的,为了能遍历每个结点,每执行一次循环,就要使变量p指向下一个结点,所以空白处应填p=p->next

    5.知识点:共用体类型定义

    l  共用体是一种构造数据类型(遵循先定义类型,再定义该类型变量的原则

    l  用途:使几个不同类型的变量共占一段内存(相互覆盖)

    l  与结构体结构体与共用体

    1.区别: 存储方式不同,

    结构体变量占用的内存单元,是其所有成员占内存单元的总和,而共用体变量是其所有成员中占用空间最大的成员的内存单元

    2.联系: 类型定义、变量定义、成员引用等操作方式相同,两种类型可相互嵌套

    例1.(06-04—41)有以下程序

    main()

    {union

     {char ch [2];

       int d;

       }s;

      s.d=0x4321;

     printf(“%x,%x\n”,s.ch[0],s.ch[1]);

    } 在16位编译系统上,程序执行后的输出结果是___ A __

    A)21,43    B)43,21    C)43,00    D)21,00 

    【解析】此题考查整形数据在内存中存放形式以及共用体内存分配。对于共用体而言,字符数组ch与整型变量d共用2个字节的存储空问;存储器存储数据原则是:低地址存放低字节,高地址存放高字节;于是0x4321中2l存放在低字节中,43存放在高字节中,故输出时s.ch[0]输出21,s.ch[1]输出43。

    第七课 编译预处理、文件

     

     

    本课重要知识点:

    1.知识点:main()函数的参数

    l  定义形式:main(int argc,char *argv[])

                  {…

                   }

    l  int argc是命令行中的字符串数,char *argv[]是指向字符串的指针数组,系统使用空格把各个字符串隔开。

    2.知识点:不带参数的宏定义

    l  一般形式:#define 宏名 字符串(或数值)

    即用字符串或数值取代宏名。

    l  宏名一般采用大写字母表示,以与变量名区别,也可用小写字母。

    宏定义不是C语句,不必在行末加分号

    例1:(2009-04-36)有以下程序

    #include<stdio.h>

    #define PT 3.5;

    #define S(x) PT*x*x;

    main()

    {int a=l,b=2;printf("%4.1f\n",S(a+b));}

    程序运行后输出的结果是(D)

    A)14.0          B)31.5         C)7.5        D)程序有错无输出结果

    【解析】此题考查宏的定义形式。由于宏定义并不是语句,故#define后面不能有分号,故该程序有错无法输出结果,所以,正确答案:D。

    例2:(2011-03-30)以下函数的功能是:通过键盘输入数据,为数组中的所有元素赋值。

    #define N 10

    void fun(int x[N])

    {     inti=0;

    while(i<N)scanf(“%d”,_________);

    }在程序中下划线处应填入的是

    A)x+i       B)&x[i+1]         C)x+(i++)         D)&x[++i]

    答案:C

    【解析】要求给每个元素赋值,while循环的变量i必须不断增加,所以A、B显然不行,i++是先参与运算在自增1,++i是先自增1再参与运算,所以D会出现x[0]未赋值的情况,故选C。

    l 对程序中用“”括起来的字符串内的字符,即使与宏名相同,也不进行置换。

    l  宏定义可以嵌套使用,例如:

    #define R 3.0

    #define PI 3.14159

    #define L L*PI*R

    3.知识点:带参数的宏定义

    l  一般形式:#define 宏名(参数表) 字符串

    l  带参数的宏不占运行时间,只占编译时间;只是简单、机械字符替换;宏名无类型。

    要注意有括号和没括号的区别

    例1:(2009-09-35)有以下程序

    #include <stdio.h>

    #define f(x) x*x*x

    main()

    {int a=3,s,t;

    s=f(a+1);    t=f((a+1));

    printf(“%d,%d\n”,s,t);

    }程序运行后的输出结果是(A)

    A)10,64      B)10,10          C)64,10         D)64,64

    【解析】本题考点为带参数的宏定义,宏定义中的参数没有类型,仅为字符序列,不能当作表达式运算。宏展开时,把实参字符串原样写在替换文本中。s=f(a+1)=a+1*a1*a+1=10;t=f((a+1))= (a+1)* (a+1)* (a+1)=64

    例2:(2011-03-35)有以下程序

    #define S(x) 4*(x)*x+1

    main()

    {     intk=5,j=2;

    printf("%d\n",S(k+j));

    }程序运行后的输出结果是(B)

    A)197             B)143          C)33            D)28

    【解析】#define宏定义,只是机械简单的置换S(k+j)=S(5+2)=4*(5+2)*5+2+1=143

    4.知识点:文件包含

    l  一般形式:#include <文件名>或者#include “文件名”

    l  < >与” ”的区别:<>即系统到存放C库函数头文件的目录中寻找要包含的文件;” ”即系统先在用户当前目录中寻找,若找不到,再到存放C库函数头文件的目录中寻找。

    l  文件包含可以嵌套。

    l  凡是以“#”开头的行都是预处理命令行。

    5.知识点:calloc()函数

    l  函数原型:void *calloc(unsigned n,unsigned size);

    l  功能:分配n个数据项的内存连续空间,每个数据项的大小为size

    6.知识点:free()函数

    l  函数原型:void free(void *p);

    l  功能:释放p所指的内存区

    7.知识点:malloc()函数

    l  函数原型:void *malloc(unsigned size);

    l  功能:分配size字节的存储区

    例1:(2011-03-14)以下程序运行后的输出结果是   emoclew  

    main()

    {     char *p; int i;

    p=(char *)malloc(sizeof(char)*20);

    strcpy(p,"welcome");

    for(i=6;i>=0;i--) putchar(*(p+i));

    printf("\n"); free(p);

    }

    【解析】(char*)malloc(sizeof(char)*20)申请一个20个字符大小的空间,首地址赋给字符指针变量p,strcpy(p,"welcome");将字符串"welcome"赋值给p所指向的空间,for循环实现从后往前输出这个字符串,free(p)为释放申请的空间。

    8.知识点:文件的概念和文件指针

    l  在C程序中文件可以用顺序方式存取,可以用随机方式存取。

    l  C程序把文件分为ASCII文件(文本文件)和二进制文件。

    例1:(2009-09-40)下列关于C语言文件的叙述中正确的是(C)

    A)文件由一系列数据依次排列组成,只能构成二进制文件

    B)文件由结构序列组成,可以构成二进制文件或文本文件

    C)文件由数据序列组成,可以构成二进制文件或文本文件

    D)文件由字符序列组成,其类型只能是文本文件

    【解析】本题考点为文件的基本概念。正确答案为C。C语言中根据数据的组织形式,分为二进制文件和ASCII码文件。一个C文件时一个字节序列或者二进制序列,而不是一个记录(结构)序列。

    l  文件类型指针:FILE *fp;fp是一个指向FILE类型结构体的指针变量,通过文件指针变量找到与它相关的文件。

    例2:(2010-09-15)以下程序打开新文件f.txt,并调用字符输出函数将a数组中的字符写入其中,请填空。

    #include <stdio.h>

    main()

    {  FILE   *fp;

    char a[5]={‘1’,’2’,’3’,’4’,’5’},i;

    fp=fopen(“f.txt”,”w”);

    for(i=0;i<5;i++)fputc(a[i],fp);

    fclose(fp);

    }

    9.知识点:fopen()函数和fclose()函数

    (1)fopen函数

    l  调用方式:fp=fopen(“file1”,”r”);

    l  使用文件方式:如”r”只读打开一个文本文;”w”只写打开或建立一个文本文件;”a”追加打开一个文本文件,在文件末尾添加数据。

    例1:(2011-03-40)设fp已定义,执行语句fp=fopen("file","w");后,以下针对文本文件file操作叙述的选项中正确的是(B)

    A)写操作结束后可以从头开始读          B)只能写不能读

    C)可以在原有内容后追加写              D)可以随意读和写

    【解析】文件打开方式,‘w’只能向该文件写入,如打开的文件不存在则以指定的文件名建立文件,如存在,则先删除再重建一个文件。故选B。

    若不能实现打开任务,fopen函数将带回一个空指针值NULL。

    例1:(2009-04-13)以下程序用来判断指定文件是否能正常打开,请填空。

    #include <stdio.h>

    main()

    {FILE *fp;

    if(((fp=fopen(“test.txt”,”r”))==      NULL     ))

    printf(“未能打开文件!\n);

    else

    printf(“文件打开成功!\n”);

    }

    【解析】考查文件打开操作。打开文件使用fopen函数,正常打开时返回指向该文件的文件指针,否则返回值为NULL;题目中当if条件表达式成立时,输出“未能打开文件!”,故fopen函数返回值为NULL。正确答案:NULL。

    (2)fclose()函数

    l  调用方式:fclose(fp);

    l  顺利完成关闭操作,返回值为0,否则返回EOF(-1)。

    10.知识点:fputc()函数和fgetc()函数

    l  fgetc()函数的调用形式:ch=fgetc(fp);从打开的文件fp中读取一个字符。

    l  fputc()函数的调用形式:fputc(ch,fp);将字符输出到fp所指向的文件中去。

    11.知识点:fread()函数和fwrite()函数

    l  fread()函数的调用形式:fread(buffer,size,count,fp);其中buffer是一个指针,size是每个数据块的字节数,count是每次读入数据块的个数,fp是文件指针。

    例1:structstud

         {char name[10];

          int num;

         }stu[40];

    假设学生的数据已存放在磁盘文件中,如何读入40个学生的数据?

    for(i=0;i<40;i++)

    fread(    &stu[i]   ,  sizeof(struct stur)    ,1,fp);

    l  fwrite()函数的调用形式:fread(buffer,size,count,fp);其中buffer是输出数据的首地址。

    12.知识点:fscanf()函数和fprintf()函数

    l  fscanf(文件指针,格式控制字符串,输入列表);

    l  fprintf(文件指针,格式控制字符串,输出列表);

    例1:(2011-09-40)有以下程序

    #include<stdio.h>

    main()

    {FILE  *fp;

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

    fp=fopen(“d2.dat”,”w”);

    for(i=0;i<6;i++)fprintf(fp,”%d\n”,a[i]);

    fclose(fp);

    fp=fopen(“d2.dat”,”r”);

    for(i=0;i<3;i++)  fscanf(fp,”%d%d”,&k,&n);

    fclose(fp);

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

    }程序运行后的输出结果是   (C)

    A.1,2   B.3,4  C.5,6    D.123,456

    【解析】第一次fp=fopen(“d2.dat”,”w”);以写方式打开,通过循环将a数组全部写入文件中,并且每行写一个;第二次fp=fopen(“d2.dat”,”r”); 以写方式打开,然后通过循环每次读取两个数字给k和n,第三次k和n分别得到5和6

    例1:(2009-04-40)有以下程序

    #include <stdio.h>

    main()

    {FILE *f;

    f=fopen(“filea.txt”,”w”);

    fprintf(f,”abc”);

    fclose(f);

    }若文本文件filea.txt中原有内容为:hello,则运行以上程序后,文件filea.txt的内容为(C)

    A)helloabc           B)abclo          C)abc           D)abchello

    【解析】程序中定义了一个文件指针,然后用fopen()函数,以写的方式打开文件“filea.txt”,并让指针f指向它,执着调用fprintf()函数,将“abc”写到指针所指向的文件中。由于filea.txt里原来的内容”hello”被”abc”覆盖掉,所以文件“filea.txt”里,最后的内容为”abc”,本题答案选C。

    13.知识点:fgets()函数和fputs()函数

    l  fgets(str,n,fp);从fp指向的文件输入n-1个字符,在最后加一个’\0’,得到字符串共有n个字符,把它们放到字符数组str中。

    l  fputs(“China”,fp);把字符串”China”输出到fp指向的文件,字符串末尾’\0’不输出。

    (2010-03-40)有以下程序

    #include <stdio.h>

    main()

    {FILE *fp;char str[10];

    fp=fopen(“myfile.dat”,”w”);

    fputs(“abc”,fp);fclose(fp);

    fp=fopen(“myfile,data”,”a+”);

    fprintf(fp,”%d”,28);

    rewind(fp);

    fscanf(fp,”%s”,str);puts(str);

    fclose(fp);

    }程序运行后的输出结果是(C)

    A)abc            B)28c          C)abc28          D)因类型不一致而出错

    【解析】以“a+”方式打开一个已存在的文件,原有文件内容不被删除,位置指针移到文件末尾,可作添加和读操作。fputs(“abc”,fp);把字符串”abc”输出到fp指向的文件。

    14.知识点:rewind()函数

    l  调用形式:rewind(fp);

    l  功能:使位置指针重新返回文件的开头。

    15.知识点:fseek()函数

    l  功能:改变文件的位置指针

    l  调用形式:fseek(fp,100L,0);将位置指针移到离文件头100个字节处。

    l  文件首 SEEK_SET 0         文件当前位置 SEEK_CUR 1       

    文件末尾 SEEK_END 2

    16.知识点:ftell()函数

    l  ftell(fp);

    l  功能:得到流式文件中的当前位置。

    17.知识点:feof()函数

    l  feof(fp);

    l  判断文件是否结束,结束,返回值为1,否则为0。

    例1(2011-03-15)以下程序运行后的输出结果是 【15】 。

    main()

    {     FILE *fp; int x[6]={1,2,3,4,5,6},i;

    fp=fopen("test.dat","wb");

    fwrite(x,sizeof(int),3,fp);

    rewind(fp);

    fread(x,sizeof(int),3,fp);

             for(i=0;i<6;i++)printf("%d",x[i]);

             printf("\n");

             fclose(fp);

    }

    答案:123456

    【解析】fwrite(x,sizeof(int),3,fp);将数组内的前三个元素即1,2,3输出到文件中去,rewind(fp);文件回到开头,fread(x,sizeof(int),3,fp);将文件的内容读出并存到x数组的前三个元素中,把1,2,3写到数组的前三个元素中去,所有数组中的元素值均没变。

     

    展开全文
  • 计算机二级C语言上机题库及答案(100套)
  • 计算机二级C语言怎么过

    万次阅读 多人点赞 2018-07-27 11:45:25
     计算机二级公共知识(二级语言都考察的内容,大概有10分左右,很多题都是背下来就能秒选的)密码:9ch6  C语言基础知识(基础,不多说了,有不懂的地方多看看)密码:61pi   dev :非常小的一个编译器,对...

    资料: 模拟上机软件 密码:q9d2(抽一一段时间,像高考模拟考试一样,看看自己能得多少分,只能用电脑运行。)

             计算机二级公共知识(二级语言都考察的内容,大概有10分左右,很多题都是背下来就能秒选的)密码:9ch6

             C语言基础知识(基础,不多说了,有不懂的地方多看看)密码:61pi 

            dev  :非常小的一个编译器,对配置要求很小。使用方法

    前言(扯扯谈)

             这份指南是某人而写的,不过都写了,顺便写全一点,大家觉得好的话素质随手三连一波吧(点赞收藏评论)。让我博客排名涨涨。

    做了几套题之后感觉这个考试的知识点和题型很固定,而将这些知识点和做法概括总结出来可以帮助以后考试的同学。

    对于没有相应基础的绝大多数同学,如果想考过二级,首先要克服见到陌生复杂题目的恐惧感。话说回来,其实这些题没有哪一道是真正需要动脑进行复杂思考的,只是知识点没见过,做题的方法不清楚,一旦知道了就能写对。这个考试没有什么含金量,一周的练习基本上足够了。

    另外,需要强调一下,本文档以应试为目的指在帮助你通过考试,而非掌握C语言(这考试真的很水,编程也不是这样学的)。

    如果发现有错误或者有其他建议请与我联系,多谢。也可以在评论下留言给我啦。

    忘啦介绍一下自己了:某计算机专业一名学生,ACMer(不懂百度哦)。

    我的邮箱:1006255603@qq.com

    后续补充:我发现有很多人不知道这个证书有什么用,我根据和学长老师的聊天以及社会经验跟大家聊聊。首先这个等级考试是面向非计算机专业的(没有什么含金量),面向计算机专业有个叫软考(计算机技术与软件专业技术资格(水平)考试)的(这个金量就高了,我正在备考中)。当然这没有规定一定要是计算机专业才能考,像我们学院,因为领导脑门一闪,突然号召全体大一学生报名,我本来是不打算考。。。被逼无奈考了。

                                                      

    虽然含金量不高,但是也是很有用的,有些文职工作要求有这个证书,特别某政府部门,有这个证书你可以吹一波自己会计算机(去到那里只需要会重装系统,会一些office软件的操作就好了,并不需要你编程),有好多这样的政府部门的计算机方面的职务都是空缺的,为啥,因为学计算机有点上进心的都去互联网公司做开发了,当程序员,当然这个比较难,要学的东西很多。

    要不要考三四级?

    计算机等级考试基本是给非计算机专业设置的考试,所以本来就没什么含金量,我没有考。还想考计算机方面的证,可以去考软考[计算机技术与软件专业技术资格(水平)考试]。

    听说计算机等级考试四级比二级还简单,也是买题做题就行了。考考考,给自己大学生活找点事情做。都考了二级,为啥不考三四级呢。

    考试大纲:

    全国计算机等级考试二级c语言程序设计考试大纲(2018 年版)(这部分看看就好,看看自己有哪些知识点不会的,)

    基本要求

    1.熟悉 Visual C++集成开发环境。

    2.掌握结构化程序设计的方法,具有良好的程序设计风格。

    3. 掌握程序设计中简单的数据结构和算法并能阅读简单的程序。

    4. 在 Visual C++集成环境下,能够编写简单的 C 程序,并具有基本的纠错和调试程序的能力。

    考试内容

    一、C 语言程序的结构

    1. 程序的构成,main 函数和其他函数。

    2. 头文件,数据说明,函数的开始和结束标志以及程序中的注释。

    3. 源程序的书写格式。

    4. C 语言的风格。

    二、数据类型及其运算

    1.C 的数据类型(基本类型,构造类型,指针类型,无值类型)及其定义方法。

    2. C 运算符的种类、运算优先级和结合性。

    3. 不同类型数据间的转换与运算。

    4. C 表达式类型(赋值表达式,算术表达式,关系表达式,逻辑表达式,条件表达式,逗号表达式)和求值规则。

    三、基本语句

    1. 表达式语句,空语句,复合语句。

    2. 输入输出函数的调用,正确输入数据并正确设计输出格式。

    四、选择结构程序设计

    1. 用 if 语句实现选择结构。

    2. 用 switch 语句实现多分支选择结构。

    3. 选择结构的嵌套。

    五、循环结构程序设计

    1. for 循环结构。

    2. while 和 do-while 循环结构。

    3. continue 语句和 break 语句。

    4. 循环的嵌套。

    六、数组的定义和引用

    1. 一维数组和二维数组的定义、初始化和数组元素的引用。

    2. 字符串与字符数组。

    七、函数

    1. 库函数的正确调用。

    2. 函数的定义方法。

    3. 函数的类型和返回值。

    4. 形式参数与实际参数,参数值的传递。

    5. 函数的正确调用,嵌套调用,递归调用。

    6. 局部变量和全局变量。

    7. 变量的存储类别(自动,静态,寄存器,外部),变量的作用域和生存期。

    八、编译预处理

    1. 宏定义和调用(不带参数的宏,带参数的宏)。

    2. “文件包含”处理。

    九、指针

    1. 地址与指针变量的概念,地址运算符与间址运算符。

    2. 一维、二维数组和字符串的地址以及指向变量、数组、字符串、函数、结构体的指针变量的定义。通过指针引用以上各类型数据。

    3. 用指针作函数参数。

    4. 返回地址值的函数。

    5. 指针数组,指向指针的指针。

    十、结构体(即“结构”)与共同体(即“联合”)

    1. 用 typedef 说明一个新类型。

    2. 结构体和共用体类型数据的定义和成员的引用。

    3. 通过结构体构成链表,单向链表的建立,结点数据的输出、删除与插入。

    十一、位运算

    1. 位运算符的含义和使用。

    2. 简单的位运算。

    十二、文件操作

    只要求缓冲文件系统(即高级磁盘 I / O 系统),对非标准缓冲文件系统(即低级磁盘 I / O 系统)不要求。

    1. 文件类型指针(FILE 类型指针)。

    2. 文件的打开与关闭(fopen,fclose)。

    3. 文件的读写(fputc,fgetc,fputs,fgets,fread,fwrite,fprintf,fscanf 函数的应用),文件的定位(rewind,fse

    ek 函数的应用)。

    考试方式

    上机考试,考试时长 120 分钟,满分 100 分。

    1. 题型及分值

    单项选择题 40 分(含公共基础知识部分 10 分)。 操作题 60 分(包括程序填空题、程序修改题及程序设计题)。

    2.考试环境

    操作系统:中文版 Windows 7。 开发环境:Microsoft Visual C++ 2010 学习版

    准备:

             去淘宝买一套未来教育的二级书,好像领劵之后才19块钱

             下载未来教育的模拟软件,找个时间自己上机模拟考试一次(把手机关机哦)。里面好像还有视频,可以看一下啦。

    上面资料要认真看看,会的话可以不看了,下面体现这份指南的优越性了。真题讲解

                                                                     

    下列叙述中正确的是
    A)程序可以作为算法的一种表达方式
    B)算法的有穷性是指算法的规模不能太大
    C)算法的复杂度用于衡量算法的控制结构
    D)算法的效率与数据的存储结构无关

    解析:算法是计算机科学非常重要的一部分,例如一个很简单的例子,计算1加到100,最暴力的方法是一个个慢慢加。但我想出一个方法,1+100 = 2+99 = 2+98。。。然后50*101 = 5050 。这个方法就算一种算法。这个很简单

    算法这种东西只有你们深入学习才会知道有多难,天天被算法折磨的我,脑壳疼。

    回归题目,这道题用排除法吧。首先看A,好像没什么错误,看B,算法的有穷性是指算法必须在一段时间内终止,这个很好理解,你不能永远都算不出来吧,那要你何用?C.算法的复杂度用来衡量算法所占用的资源的,分为时间复杂度和空间复杂度(扩展一下,因为不可能只考这到题,把这个题解看懂,别的题你也会了)。空间复杂度是指占用内存大小,那肯定是越少越好了,不过算法有一条很经典的思想,用空间换时间,意思是用程序占用更大的空间我不管,我只要更快就好了。

    时间复杂度,就是程序运行所需要的时间,为了方便计算,时间复杂度在计算是求极限的,忽略常数。时间复杂度常用大O符号表述,不包括这个函数的低阶项和首项系数。

    D选项 计算机有句话,程序 = 算法 +数据结构。所以两者关系大着呢,可以说是密不可分的。所以选A。

    顺序表的长度为40,对该表进行冒泡排序。在最坏的情况下需要比较的次数为()。
    
    A.820                B.780             C.40    D.41 

           

    解析:这题考的算法时间复杂度分析。

    首先我当你是小白,我们一个个词分析。顺序表,就是一种存储结构,你不懂没关系,(顺序表的长度为40)这句话的意思就是告诉你有40个元素。冒泡排序,就是一种排序方法冒泡排序的基本思想是:每次比较两个相邻的元素,如果它们的顺序错误就把它们交换过来。例如我们需要将(12  35   99  18    76)这5 个数进行从大到小的排序。既然是从大到小排序,
    也就是说越小的越靠后,你是不是觉得我在说废话,但是这句话很关键(∩_ ∩)。 首先比较第1 位和第2 位的大小,现在第 1 位是12 ,第 2 位是35。发现 12比35要小。因为我们希望越小越靠后嘛,因此需要交换这两个数的位置。交换之后这5 个数的顺序是
    35 12 99 18 76 。 按照刚才的方法,继续比较第2 位和第 3 位的大小,第 2 位是12,第 3 位是 99 。12 比99要小,因此需要交换这两个数的位置。交换之后这 5 个数的顺序是 35 99  12 18 76 。 根据刚才的规则,继续比较第 3 位和第 4 位的大小,如果第 3 位比第4 位小,则交换位置。交换之后这5 个数的顺序是 35 99 18  12 76。 最后,比较第4 位和第5 位。4 次比较之后 5 个数的顺序是 35 99 18 76  12。 经过4 次比较后我们发现最小的一个数已经就位(已经在最后一位,请注意 12这个数的移动过程),是不是很神奇。现在再来回忆一下刚才比较的过程。每次都是比较相邻的两个数,如果后面的数比前面的数大,则交换这两个数的位置。一直比较下去直到最后两个数比较完毕后,最小的数就在最后一个了。就如同是一个气泡,一步一步往后“滚”,直到最后一位。所以这个排序的方法有一个很好听的名字“冒泡排序”。 

    上面可以不看。 算法有上界和下界之分。上界就是排序的数就是已经排好了,这样一次遍历就可以完成排序了。时间是O(n).

    下界就是最坏的情况,如从小到大排序,但这组数刚刚是完全从大到小的,这样就需要O(n^2)的时间复杂度。这题就是

    40*(40-39)= 1560 次操作。但是这题有个点啊啊。问的是比较的次数,排序有两个操作:1是比较,2是交换。

    所以就是1560/2 = 780次操作了

    对长度为n的线性表排序,在最坏情况下,比较次数不是n(n-1)2的排序方法是()
    A)快速排序
    B)冒泡排序
    c)直接插入排序
    d)堆排序

    选d堆排序 。这个解释有点复杂,你只要记住快速 ,选择,冒泡,插入在最坏的情况下排序都是要比较n(n-1)/2就行了。

    堆排序不是。

    展开全文
  • 二级考试完整复习资料,包含计算机二级C语言历年真题、上机模拟软件、知识点总结
  • 2019年全国计算机考试二级C语言——公共基础(全) 教你过二级
  • 今天,想给大家介绍一下计算机二级考试的相关问题,碍于本人写作水平有限,还望各位大佬指点。 教育招生考试院的官网上在12月10日已经发布了明年3月份计算机等级考试的通告。 传送门如下:...

    今天,想给大家介绍一下计算机二级考试的相关问题,碍于本人写作水平有限,还望各位大佬指点。

    教育招生考试院的官网上在12月10日已经发布了明年3月份计算机等级考试的通告。

    传送门如下:http://www.sdzs.gov.cn/zsks/2018/1211/26ef3e3ac20a491696d12537c624d573.shtm(山东省的,其他省的可以百度**省教育招生考试院)

    一、公告查询操作流程:

    1、进入官网首页

     

    2、点击上图红色圆圈中的“证书考试”,跳转到下一界面

    3、便进入下图的界面,找到红色方框的计算机等级考试一栏,点击最新的考试事项公告

    4、剩下的便是仔细读公告内容了。

    其实内容对于我们这些参加过多次考试的人来说,都是些老生常谈的问题。

    重点需要注意一下几点内容:

    ①注意考试报名的时间,报名为线上报名(具体的报名、缴费流程,我会在接下来的模块里详细介绍),一定要看准时间,及时报名,不要以为报名时间很长,过几天报名也可以。根据往年的经历,到后来我们本校的考场满了,你就只能大老远地往其他学校跑,甚至周围学校都满了,你连报名的报不上。

    ②考试报名分为集体报名和个人报名,我们一般选择个人报名就可以了。

    ③报名费为72元/人,也不便宜啊,大家一定要好好准备啊!

    ④考试结果可以在50个工作日后进行查询。成绩没有具体分数,只分为优秀,良好,及格三个等级。

    二、网上报名,缴费,打印准考,查询成绩一条龙流程:

    1、网上报名的链接其实就在上面那幅图的左下角(下图蓝色圆圈的地方)

    2、勾选已阅读重要说明,进入报名页面

    3、然后需要注册一个账号,注册流程与各种账号的注册大致相同,就不详细叙述了。需要注意的是,密码的格式要求较高,需要同时具有大小写字母,数字和符号。

    4、登陆后,点击左侧的当前考次,勾选同意,进入填写详细信息页面。

    选择考场尽量选择本校的,如果本校考场已满,可以考虑报临近学校的考场。对于缴费,使用支付宝就可以了。

    打印准考证的时间一般是在开考前的半个多月的这段时间里(今年是在3月10号开始)

    于考后的50个工作日进行成绩查询。网站:http://chaxun.neea.edu.cn

    三、计算机二级考试的简介以及C语言的试题分析

    1、计算机二级考试是全国计算机等级考试(National Computer Rank Examination,简称NCRE)四个等级中的一个等级,考核计算机基础知识和使用一种高级计算机语言编写程序以及上机调试的基本技能。计算机二级考试采用全国统一命题、统一考试的形式。

    计算机二级考试包含:程序设计/办公软件高级应用级,考核内容包括计算机语言与基础程序设计能力,要求参试者掌握一门计算机语言,可选类别有高级语言程序设计类、数据库程序设计类等;办公软件高级应用能力,要求参试者具有计算机应用知识及MS Office办公软件的高级应用能力,能够在实际办公环境中开展具体应用。从2013年开始全国计算机等级考试已从传统的笔试和上机考试改革成无纸化考试,二级Delphi科目从2013年上半年开始停考。

    从 2018 年 3 月开始,将实施 2018 版考试大纲,并按新体系开考各个考试级别。 [1] 

    二级取消“Visual FoxPro 数据库程序设计”科目(代码:27),2017年 12 月是其最后一次组考。新增“Python 语言程序设计”科目(代码:66),考试时长:120 分钟,2018 年 9 月首次开考。

    NCRE二级科目设置体系

    考试等级 考试科目 科目代码 考试时间 考试方式 备注

    二级

    C语言程序设计

    24

    120分钟

    无纸化

     

    VB语言程序设计

    26

    120分钟

    无纸化

     

    VFP数据库程序设计

    27

    120分钟

    无纸化

    2018年3月停考

    Java语言程序设计

    28

    120分钟

    无纸化

     

    Access数据库程序设计

    29

    120分钟

    无纸化

     

    C++语言程序设计

    61

    120分钟

    无纸化

     

    MySQL数据库程序设计

    63

    120分钟

    无纸化

     

    Web程序设计

    64

    120分钟

    无纸化

     
    MS Office高级应用

    65

    120分钟

    无纸化

     
    Python语言程序设计 66 120分钟 无纸化 2018年9月开考

     

                                                                                                                                          ——以上内容来源于百度百科

    2、C语言考试试题内容包括选择题和操作题两部分。

    选择题一共有40个,每个一分。前10个选择题为二级公共基础知识,主要内容涉及数据结构,软件工程的一些相关内容。说实话,如果想去深入了解和学习,其实是挺难的,需要下很大的功夫,但如果是为了通过考试,建议大家这部分可以去刷一下题,这十分基本就能够拿到。

    剩下的三十个选择题,就是C语言的相关知识点了,从变量,基础语句到指针,结构体和文件等相关知识点都有涉及,这部分主要是考查大家对C语言的基础知识的掌握情况,难度适中。

    操作题一共有3个,分为程序填空题(18分),程序改错题(18分)和编程题(24分)。

    填空题和改错题相对简单,是必拿的分值。由于程序改错题已将程序的错误位置标出了,大大降低了题目的难度。

    至于编程题,一般是要求考生编写一个函数来实现相应的功能(其余的程序框架已经给出)。

    这部分就要考验考生的能力了,大家尽量去写,题目应该是有过程分的。

    四、对于考试感想

     

    其实吧,我觉得计算机二级考试挺水的,它的含金量虽然不高,但也是现阶段作为一名非计算机专业的大学生能力的证明,同时也是进一步三级,四级考试的叩门砖。
    就算不说那些有的没的,德育分还总是有的嘛。

    这种考试对于你们这些经历过高考这种大风大浪的同学来说,简直是小菜一碟。我认为只要用心去准备就一定能够通过。对于网上流传通过率低的问题,大部分原因还是源于考生自身,自身的自律能力较差。很多同学报名的时候随大流也跟着报名,然后就没有然后了……
    等到考试的时候,裸考或者临时抱佛脚,就已经晚了。

    其实对于c语言的学习,它锻炼的是一个人的逻辑性思维能力。
    兴趣是最好的老师。编程的学习本是枯燥的,但如果能够以兴趣为佐料,那它便会成为罕见的佳肴。

    就拿我的例子来说吧,以前的我挺讨厌数学的,整天的作题没啥意思,最重要的是还不会做。但是就在最近的一段时间里,我读了一些大佬的文章,顿时感觉很受启发。比如说,原来我已经学习了余数,哈希函数,散列的知识,但是零散的,学习的时候只是为了学习而学习,并没有去了解它们之间的联系和应用。但当我看到大佬文章中写到其实取余操作本身就是一个哈希函数时,我顿时恍然大悟。可不是嘛!虽然只是一个简单的联系,但顿时让我觉得原来数学还可以这样玩,顿时就来了兴趣。有些时候当你对做某件事不感兴趣时,不妨去换个角度看待,去了解它的应用或是它的历史,说不定当你对它的了解更多时,你的态度也会因此改观。同时,我认为学习的过程应该善于去抓住事物之间的联系,在自己脑海中有清晰的结构层次,将会让你对其的理解更加深入。

    学习的过程不要去盲从,学会自我思考,自我反省,敢于去将自己的想法表达出来。 

    曾经听说过这样一个故事,一个技术高超的渔夫有两个儿子,他想让两个儿子去继承自己的衣钵,就将其毕生所学传授给两个儿子,但无论他怎么努力,他儿子的技术还是很一般,远远不及他。这时,一个智者便出现说:“你的技术,是你亲身去锻炼实践出来的,而你儿子只是听你说,没有自己的思考,技术永远得不到真正的提高”。人就是这样,只有自己亲身经历,吃过亏,才会印象深刻。这也是为什么老师、家长苦口婆心地劝说要好好学习,但仍然有一部分同学仍然无动于衷的原因。

    道理咋们都懂,但能否真正做到还要看自己的努力。

    归根结底,还是希望大家多去练习,学会思考,培养兴趣,在兴趣中快乐学习。

    平时我在这些方面也做得不是很好,愿今后的路上我们一起努力,让自己去造就自己的未来。

    五、学习资料的推荐

    建议大家去淘宝上买一本二级书,里面有各种知识和题库,推荐华研的书。其实买书还有一个重要的目的,就是它会赠送电脑端的二级考试模拟软件和手机app(刷选择题用)。

    然后再给大家介绍一个小技巧,就是买书的时候不要直接在淘宝下单,先去一些发放内部优惠券的qq群或是网站等等(有的还自己做了app),去搜一下优惠券,这种书一般都有大额优惠券,一般二三十的书几块钱就拿下了。我的二级书就花了几块钱,四级书花了五块八,也算是减少了一部分开支。

     

     

     

    展开全文
  • 全国计算机等级优秀老师主讲,非常细致,适合的新手学习,也加强大佬的知识,学好这个,C语言选择题大题准过。
  • 题型分值分布: ...二级公共基础知识在各科考试选择题中体现。程序设计部分,主要考查考生对程序设计语言使用和编程调试等基本能力,在选择题和操作题中加以体现。 扩展资料: 考试要求: 1、熟悉Visual C++...
  • C语言复习知识点汇总5--计算机二级C语言

    千次阅读 多人点赞 2018-01-08 17:33:04
    感谢众多小伙伴关注,特此提供此文档word版完整版下载链接:https://download.csdn.net/download/qq_41451521/10231099 第四章 1)三种循环结构: a)for() ; while();do- while()三种。...
  • 该文档为计算机二级C语言考试的程序填空题部分,该文档内的程序填空题均为计算机二级C语言题库中题目,本人与同学合作亲自从计算机二级C语言题库中截屏所得,该文档内容包括三部分:程序填空题的题目、程序(含空)...
  • 安徽省计算机二级C语言考试系统

    热门讨论 2010-12-11 23:04:07
    安徽省计算机二级C语言考试系统 运行文件夹里的spks.exe文件即可进入系统
  • 包括了计算机二级C语言的教材、上机考试题库、历年真题等
  • 国家计算机二级C语言模拟软件,国二刷题软件,过等考,小意思!
  • 计算机二级C语言题库,未来教育官方题库!计算机二级C语言题库,未来教育官方题库!
  • 浙江省历年计算机二级c语言真题及答案,06年之前的与现在的考试内容变化很大,没必要看了
  • C语言是目前流行的通用程序设计语言,是许多计算机专业人员和计算机的爱好者学习程序设计语言的首选。 <br> 本书共10章,分别介绍了C语言的算法基础、基本概念和如何利用C语言进行程序设计。通过大量的实例介绍了...
  • 国家计算机二级c语言考试模拟软件,考前刷题专用,多刷几遍肯定过
  • 该文档为计算机二级C语言考试的程序设计题部分,该文档内的程序设计题均为计算机二级C语言题库中题目,本人与同学合作亲自从计算机二级C语言题库中截屏所得,该文档内容包括三部分:程序设计题的题目、程序(含空)...
  • 这是一份非常详细的二级c资源,适合于计算机等级考试或者研究生复试上机的复习。(是2010年的,而且只有2010.2009.2008的)
  • 本软件按照较新《全国计算机等级考试二级C语言程序设计考试大纲》研发而成。软件具有自动计时、随机抽题、全真模拟、精选习题、详尽解析等功能。软件中包含近年历次考试真题。题库软件下载地址:...
  • 该文档为计算机二级C语言考试的程序修改题部分,该文档内的程序修改题均为计算机二级C语言题库中题目,本人与同学合作亲自从计算机二级C语言题库中截屏所得,该文档内容包括三部分:程序修改题的题目、程序(含空)...
  • 快毕业了,赶紧补一下江苏计算机二级的证,江苏计算机二级C语言除了选择题是常识题,跟C语言没关系,其他题目还好,题目很简单,但是当时最后一题卡了一会,考完试才看出来是循环和判断出了问题,在此记录一下。...
  • 江苏省计算机二级C语言 2011(春季)笔试 试题与答案
  • 全国计算机二级C语言程序设计题库;全国计算机二级C语言程序设计题库
  • 1、把考试软件下载到桌面 2、双击打开,为如下界面 3选择红色矩形框的部分,解压到桌面 4、解压到桌面如下图所示 5、打开文件,找到如图中矩形框所示的文件,点打开 6、打开后如下图所示 ...
  • 国家计算机二级C语言编程大题C语言BUG做法,就是进入到提交文件把结果改掉,本人亲测。
  • 全国计算机等级考试二级C语言,考试刷题课配套文档。内容包括考试注意事项,VC2010下载地址等。适用于考前准备。
  • 一、C语言概述 C语言的简介 C语言的特点 Hello,word书写 1.1)C语言的简介 C语言是一种功能强大、引用广泛的编程语言,目前很多应用软件及操作系统均由C语言程序设计开发; C语言虽然是高级语言,但它也可以...
  • 计算机二级C语言学习笔记(一)

    千次阅读 多人点赞 2019-07-24 17:45:55
    老实看知识点,认真刷题

空空如也

1 2 3 4 5 ... 20
收藏数 145,859
精华内容 58,343
关键字:

计算机二级c语言

c语言 订阅