2．作用于函数：
使用static用于函数定义时，对函数的连接方式产生影响，使得函数只在本文件内部有效，对其他文件是不可见的。这样的函数又叫作静态函数。使用静态函数的好处是，不用担心与其他文件的同名函数产生干扰，另外也是对函数本身的一种保护机制。

如果想要其他文件可以引用本地函数，则要在函数定义时使用关键字extern，表示该函数是外部函数，可供其他文件调用。另外在要引用别的文件中定义的外部函数的文件中，使用extern声明要用的外部函数即可。

参考资料：

①《 C程序设计（第二版） 》，谭浩强

②《 Pointers on C 》，Kenneth A.Reek

void和void指针

void的含义
    void即“无类型”，void *则为“无类型指针”，可以指向任何数据类型。

void指针使用规范
    ①void指针可以指向任意类型的数据，亦即可用任意数据类型的指针对void指针赋值。例如：
    int *pint;
    void *pvoid;
    pvoid = pint;   /* 不过不能 pint = pvoid; */
    如果要将pvoid赋给其他类型指针，则需要强制类型转换如：pint = (int *)pvoid;
   
    ②在ANSI C标准中，不允许对void指针进行算术运算如pvoid++或pvoid+=1等，而在GNU中则允许，因为在缺省情况下，GNU认为void *与char *一样。sizeof( *pvoid )== sizeof( char ).
  
void的作用
    ①对函数返回的限定。
    ②对函数参数的限定。
    当函数不需要返回值时，必须使用void限定。例如： void func(int, int);
    当函数不允许接受参数时，必须使用void限定。例如： int func(void)。

    由于void指针可以指向任意类型的数据，亦即可用任意数据类型的指针对void指针赋值，因此还可以用void指针来作为函数形参，这样函数就可以接受任意数据类型的指针作为参数。例如：
    void * memcpy( void *dest, const void *src, size_t len );
    void * memset( void * buffer, int c, size_t num );

   
参考资料：《 C/C++语言void及void指针深层探索 》，宋宝华

函数指针

函数指针是什么？
    先来看函数调用是怎么回事。一个函数占用一段连续内存。当调用一个函数时，实际上是跳转到函数入口地址，执行函数体的代码，完成后返回。如何找到对应的入口地址？这是由函数名来标记的，实际上，函数名就是函数的入口地址。
    函数指针是一种特殊类型的指针，它指向一个函数的入口地址。

    注意：除了void类型指针是无类型的指针外，其他所有指针都是有对应类型的，例如int *pint、struct studentdata *psdata等，只有指明了指针所指的数据类型，编译器才能为指针分配或预计分配相应大小的存储空间，指针的算术运算如pint++等才是有意义的。因此，定义了某种类型的指针之后，除非使用强制类型转换，那么它只能指向相应数据类型的变量或常量，不同类型的指针或数据之间不可混用。所以指针的类型实际上是一种身份标志的作用。

   函数指针如何表明自己的身份呢？为了避免混乱，必须也要作出相应规定，不同函数的函数指针不能混用。例如，int func1(int arg11, char arg12)与int func2(char arg)的函数指针就不能混用，要定义可以指向func1的函数指针应该这样：
    int (*pfunc1)(int, char) = func1；
定义可以指向func2的函数指针则该如下：
    int (*pfunc2)(char) = func2;
    从函数指针的定义可以看出，函数指针的类型实际上是由函数签名决定的。函数签名就象是函数的身份证，一个函数的函数签名是独一无二的，具有相同函数签名的函数实际上就是同一函数。函数签名包括函数名、函数形参类型的有序列表和函数返回值类型。

    一个函数指针的定义规定了它只能指向特定类型的函数。如果两个函数的形参列表和返回值类型相同，只有函数名和函数体不同，则可以使用相同类型的函数指针。例如，如果还有一个函数int func3(char arg)，则上面定义的可以指向函数func2的函数指针也可以用于指向func3，即：
    pfunc2 = func3;
    再使用pfunc2(char ARG)就可以调用函数func3，这时指令计数器（PC）指向函数入口，从此开始执行函数体代码。
    注意：对函数指针进行算术运算也是没有意义的。

如何使用函数指针？
    ①定义合适类型的函数指针变量；
       int (*pfunc)(int, int);
    ②给函数指针变量赋值，使它指向某个函数入口；
       int example(int, int);
       pfunc = example;          /*将函数入口地址赋给函数指针变量*/
       或者：pfunc = &example;    /*函数名总是被编译器转换为函数指针（入口地址）来使用，因此与上面一句等价 */
    ③使用函数指针来调用相应的函数；
       retval = pfunc(10, 16);
       或者：retval = (*pfunc)(10, 16);
       上面两句都与retval = example(10, 16);等价。
    理解：一个指针变量p实际上也和普通的变量一样，要占存储空间（通常与平台的虚拟地址一样宽），也有其自身的存储地址&p；不同的是，在指针变量p的值有特殊的意义，它是另外一个变量或常量的地址值，也就是说，在地址为&p的存储单元上存放着另外一个数据的地址。因此，*p实际上是将p看作它指向的数据的地址来使用，*操作符是引用相应地址中的数据，也就是对地址为p的存储单元中存放的数据进行操作。
    一个函数指针变量则更为特殊。比如上面的例子，pfunc变量本身的值是函数example()的入口地址。因此pfunc可以代替其所指函数的函数名来使用。至于*pfunc，如果按照上面的理解，它实际上是地址pfunc的内容，也即函数example()的入口地址的内容，就有点含糊了。不过，从另一方面来理解，如果使用pfunc = &example来初始化pfunc，则*pfunc == *(&example) == example，又与pfunc等价。因此，就有了两种使用函数指针来调用相应函数的形式。
    值得注意的是，不可用*pfunc来对pfunc的值初始化。即*pfunc = example的写法是错误的。

为什么要使用函数指针？
    前面介绍了函数指针的基本知识和使用规范。下面介绍函数指针的实际用途。不过首先要对前面的知识再做一个补充，因为下面的应用很可能用到这一特性。前面指出，除函数名之外的函数签名内容（函数返回值类型和形参列表）决定了函数指针的类型。实际上还有一种特殊的或说通用的函数指针，在定义这类函数指针时，只需要指定函数返回值类型，而留空形参列表，这样就可以指向返回值类型相同的所有函数。例如：
    int (*pfunc)();
    这样定义的pfunc就可以指向前面提到的func1和func2，因为他们都返回整型值。
    注意： int (*pfunc)()与int (*pfunc)(void)不是一回事，后者不允许接受任何参数。

    函数指针最常见的三个用途是：
    ①作为参数传递给其他函数。
    这样可以把多个函数用一个函数体封装起来，得到一个具有多个函数功能的新函数，根据传递的函数指针变量值的不同，执行不同的函数功能。这是函数嵌套调用难以实现的。参数的传递可以由程序员设定，也可以由用户输入读取，因此具有较大的灵活性和交互性。
    另外还可以用于回调函数。使用void配合，还可以将对不同数据类型的数据进行相同处理的多个函数封装为一个函数，增强函数的生命力。

    ②用于散转程序。
    这种程序首先建立一个函数表（实际上是一个函数指针数组），表中存放了各个函数的入口地址（或函数名），根据条件的设定来查表选择执行相应的函数。这样也可以将多个函数封装为一个函数或者程序，散转分支条件可以由程序员设定，也可以由用户输入读取，甚至是外设的某种特定状态（这种状态可以是不受人为控制的）。

    ③实现C的面向对象的类的封装。
    C语言中的struct与C++中的class有很大不同，除了缺省的成员属性外（struct的成员缺省为public的，可随意使用，而class成员缺省为private的），struct还很难实现类成员函数的封装。struct的成员一般都是数据成员，而非函数成员。因此，为了在C语言中，为某个struct定义一套自己的函数对结构数据成员进行操作，可以在struct结构体中增加函数指针变量成员，在初始化时使它指向特定函数即可。

    应用举例：
    ①假设定义了四个函数：add(int, int)、sub(int, int)、mul(int, int)、div(int, int)，可以将其封装为一个四则运算计算器函数:
    double calculator(int x, int y, int (*pfunc)(int, int)) {
       double result;
       result = pfunc(x, y);
       return result;
    }
    又例如，在一个链表查询程序中，要通过比较节点的特征值来查询节点，不同类型的数据的比较方式不一样，整型等可以直接比较，字符串却要用专门的字符串操作函数，为了使代码可重用性更高，可以使用一个比较函数来代替各种不同数据类型的直接比较代码，同时，比较函数也必然是数据类型相关的，因此要使用void指针和函数指针来转换为类型无关的比较函数，根据相应的数据类型，调用相应的函数（传递相应的函数指针）。一个实例是：
    int (*compare)(void const *, void const *);
    这个函数指针可以接受任意类型的数据的指针参数，同时返回int值作为比较结果标志。一个比较整型数据的比较函数是：
    int compare_ints(void const *a, void const *b) {
       if( *(int *)a == *(int *)b )
          return 0;
       else
          return 1;
    }

    ②散转程序。通过一个转移表（函数指针数组）来实现。还是上面定义的四个四则运算函数，可以建立这样一个转移表（注意初始化该转移表的语句前面应有add等相应函数原型声明或定义）：
    double (*calculator[])(int, int) = {
       add, sub, mul, div
    };
    这样，calculator[0] == add, calculator[1] == sub, ...
    使用result = calculator[oper](x, y);就可以代替下面整个switch语句：
    switch( oper ) {
       case 0: result = add(x, y); break;
       case 1: result = sub(x, y); break;
       ...
    }

    ③C的面向对象化。一个对象包括数据和对数据的操作。C语言中的struct只有数据成员，因此要增加一些“伪数据成员”即函数指针来实现对数据的操作。例如：
    #ifndef C_Class
    #define C_Class struct
    #endif
    C_Class student{
       C_Class student *student_this
       char name;
       int height;
       int gender;
       int classnum;
       ...
       void (*Oper)( C_Class student *student_this );
       ...
    }

参考资料：
①《 Pointers on C 》，Kenneth A.Reek
②《 C程序设计（第二版）》，谭浩强
③《 C语言嵌入式系统编程修炼之道 》

errno与错误处理

errno是什么?
在/usr/include/errno.h中,include了<sys/errno.h>,在该文件中定义了不同的errno的值(错误类型编号)所对应的宏以及错误类型.

基本使用:
#include <errno.h>
extern int errno;

1.使用perror( const char *msg )函数来将错误类型所对应的错误信息以字符串形式打印到终端.
  首先输出用户自定义的字符串msg(可以为空,即""),然后打印错误信息.

2.使用stderr( int errnum )将错误信息转换为字符串.

3.注意,必须在函数表明操作失败后立刻对errno的值进行检查以找出对应错误.在使用它之前必须总是先将其值copy到另外一个变量保存起来,因为很多函数(象fprintf之类)自身就可能会改变errno的值.
  func( );
  errortype = errno;
  printf( "%d\n", errortype );
或者：
  if( errortype == ... ) {
     do ...
  }
  else {
     do ....
  }

C语言中的函数指针

函数在内存中有一个物理位置，而这个位置是可以赋给一个指针的。一零点函数的地址就是该函数的入口点。因此，函数指针可被用来调用一个函数。函数的地址是用不带任何括号或参数的函数名来得到的。（这很类似于数组地址的得到方法，即，在只有数组名而无下标是就得到数组地址。）

怎样说明一个函数指针变量呢 ?
为了说明一个变量 fn_pointer 的类型是"返回值为 int 的函数指针", 你可以使用下面的说明语句:
int (*fn_pointer) ();
为了让编译器能正确地解释这句语句, *fn_pointer 必须用括号围起来。若漏了这对括号, 则:
int *fn_pointer ();
的意思完全不同了。fn_pointer 将是一个函数名, 其返回值为 int 类型的指针。

函数指针变量  

　　在Ｃ语言中规定，一个函数总是占用一段连续的内存区，   而函数名就是该函数所占内存区的首地址。   我们可以把函数的这个首地址 ( 或称入口地址 ) 赋予一个指针变量，   使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。   我们把这种指向函数的指针变量称为 " 函数指针变量 " 。  
函数指针变量定义的一般形式为：  
类型说明符  (* 指针变量名 )();  
其中 " 类型说明符 " 表示被指函数的返回值的类型。 "(*  指针变量名 )" 表示 "*" 后面的变量是定义的指针变量。   最后的空括号表示指针变量所指的是一个函数。  
例如：  int (*pf)(); 
表示 pf 是一个指向函数入口的指针变量，该函数的返回值 ( 函数值 ) 是整型。  
下面通过例子来说明用指针形式实现对函数调用的方法。  
int max(int a,int b){ 
if(a>b)return a; 
else return b; 
} 
main(){ 
int max(int a,int b); 
int(*pmax)(); 
int x,y,z; 
pmax=max; 
printf("input two numbers:\n"); 
scanf("%d%d",&x,&y); 
z=(*pmax)(x,y); 
printf("maxmum=%d",z); 
} 
　　从上述程序可以看出用，函数指针变量形式调用函数的步骤如下：

1.  先定义函数指针变量，如后一程序中第 9 行  int (*pmax)(); 定义 pmax 为函数指针变量。  

2.  把被调函数的入口地址 ( 函数名 ) 赋予该函数指针变量，如程序中第 11 行  pmax=max; 

3.  用函数指针变量形式调用函数，如程序第 14 行  z=(*pmax)(x,y); 　调用函数的一般形式为：  (* 指针变量名 ) ( 实参表 ) 使用函数指针变量还应注意以下两点：  

a.  函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。  

b.  函数调用中 "(* 指针变量名 )" 的两边的括号不可少，其中的 * 不应该理解为求值运算，在此处它只是一种表示符号。  

指针型函数  

前面我们介绍过，所谓函数类型是指函数返回值的类型。   在Ｃ语言中允许一个函数的返回值是一个指针 ( 即地址 ) ，   这种返回指针值的函数称为指针型函数。  
定义指针型函数的一般形式为：   
类型说明符  * 函数名 ( 形参表 )  
{  
...... /* 函数体 */ 
}  
其中函数名之前加了 "*" 号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。  
如：  
int *ap(int x,int y) 
{ 
...... /* 函数体 */ 
} 
　　表示 ap 是一个返回指针值的指针型函数，   它返回的指针指向一个整型变量。下例中定义了一个指针型函数  day_name ，它的返回值指向一个字符串。该函数中定义了一个静态指针数组 name 。 name  数组初始化赋值为八个字符串，分别表示各个星期名及出错提示。形参 n 表示与星期名所对应的整数。在主函数中，   把输入的整数 i 作为实参，   在 printf 语句中调用 day_name 函数并把 i 值传送给形参  n 。 day_name 函数中的 return 语句包含一个条件表达式，  n  值若大于 7 或小于 1 则把 name[0]  指针返回主函数输出出错提示字符串 "Illegal day" 。否则返回主函数输出对应的星期名。主函数中的第 7 行是个条件语句，其语义是，如输入为负数 (i<0) 则中止程序运行退出程序。 exit 是一个库函数， exit(1) 表示发生错误后退出程序，  exit(0) 表示正常退出。  

　　应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如 int(*p)() 和 int *p() 是两个完全不同的量。 int(*p)() 是一个变量说明，说明 p  是一个指向函数入口的指针变量，该函数的返回值是整型量， (*p) 的两边的括号不能少。 int *p()  则不是变量说明而是函数说明，说明 p 是一个指针型函数，其返回值是一个指向整型量的指针， *p 两边没有括号。作为函数说明，   在括号内最好写入形式参数，这样便于与变量说明区别。   对于指针型函数定义， int *p() 只是函数头部分，一般还应该有函数体部分。  
main(){ 
int i; 
char *day_name(int n);  
printf("input Day No:\n"); 
scanf("%d",&i); 
if(i<0) exit(1); 
printf("Day No:%2d-->%s\n",i,day_name(i)); 
} 
char *day_n

ame(int n){ 
static char *name[]={ "Illegal day", 
"Monday", 
"Tuesday", 
"Wednesday", 
"Thursday", 
"Friday", 
"Saturday", 
"Sunday"}; 
return((n<1||n>7) ? name[0] : name[n]); 
} 
　　本程序是通过指针函数，输入一个 1 ～ 7 之间的整数，   输出对应的星期名。指针数组的说明与使用一个数组的元素值为指针则是指针数组。   指针数组是一组有序的指针的集合。   指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。  
　　指针数组说明的一般形式为：   类型说明符 * 数组名 [ 数组长度 ]  
　　其中类型说明符为指针值所指向的变量的类型。例如：  int *pa[3]  表示 pa 是一个指针数组，它有三个数组元素，   每个元素值都是一个指针，指向整型变量。通常可用一个指针数组来指向一个二维数组。   指针数组中的每个元素被赋予二维数组每一行的首地址，   因此也可理解为指向一个一维数组。图 6—6 表示了这种关系。  
int a[3][3]={1,2,3,4,5,6,7,8,9}; 
int *pa[3]={a[0],a[1],a[2]}; 
int *p=a[0]; 
main(){ 
int i; 
for(i=0;i<3;i++) 
printf("%d,%d,%d\n",a[i][2-i],*a[i],*(*(a+i)+i)); 
for(i=0;i<3;i++) 
printf("%d,%d,%d\n",*pa[i],p[i],*(p+i)); 
} 
　　本例程序中， pa 是一个指针数组，三个元素分别指向二维数组 a 的各行。然后用循环语句输出指定的数组元素。其中 *a[i] 表示 i 行 0 列元素值； *(*(a+i)+i) 表示 i 行 i 列的元素值； *pa[i] 表示 i 行 0 列元素值；由于 p 与 a[0] 相同，故 p[i] 表示 0 行 i 列的值； *(p+i) 表示 0 行 i 列的值。读者可仔细领会元素值的各种不同的表示方法。   应该注意指针数组和二维数组指针变量的区别。   这两者虽然都可用来表示二维数组，但是其表示方法和意义是不同的

Question 1. (单选)
在顺序表(3,6,8,10,12,15,16,18,21,25,30)中,用二分法查找关键码值11,所需的关键码比
较次数为(3)

 1. 2
2. 3
3. 4
4. 5

Question 2. (单选)
设散列表的存储空间大小为19,所用散列函数为h(key)=key mod 19,用开地址线性探查法解
决碰撞。散列表的当前

状态如下:0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 190 194 768 559 582 39
3 208.现要将关键码

值75插入到该散列表中,其地址应为 (1)

 1. 1
2. 11
3. 5
4. 15

Question 3. (单选)
作业管理的主要任务包括作业输入、作业处理和作业输出。其中作业处理的工作是Ⅰ.作业
调度 Ⅱ.作业控制 Ⅲ.

作业后备 (3)

 1. 只有Ⅰ
2. 只有Ⅱ
3. Ⅰ和Ⅱ
4. 都是

Question 4. (单选)
系统为了管理文件,设置了专门的数据结构----文件控制块(FC。FCB是在执行下列哪一个系
统调用时建立的? (1)

 1. create
2. open
3. read
4. write

Question 5. (单选)
下面关于通道的叙述中,正确的是Ⅰ.通道相当于一个功能简单的处理机Ⅱ.通道完成数据输
入输出工作Ⅲ.通道与

CPU共用一个内存 (4)

 1. Ⅰ和Ⅱ
2. Ⅰ和Ⅲ
3. Ⅱ和Ⅲ
4. 都是

Question 6. (单选)
互操作性是指在不同环境下的应用程序可以相互操作,交换信息。要使采用不同数据格式的
各种计算机之间能够相

互理解,这一功能是由下面哪一层来实现的? (2)

 1. 应用层
2. 表示层
3. 会话层
4. 传输层

Question 7. (单选)
在UNIX的Shell程序中,可以使用位置变量。若要指明Shell引用的最近后台进程的号码,可
以使用位置变量 (2)

 1. $$
2. $!
3. $#
4. $-

Question 8. (单选)
设二叉树根结点的层次为0，一棵深度(高度)为k的满二叉树和同样深度的完全二叉树各有
f个结点和c个结点，下列

关系式不正确的是： (2)

 1. f>＝c
2. c>f
3. f=2k+1-1
4. C>2k-1

Question 9. (单选)
单链表的每个结点中包括一个指针link，它指向该结点的后继结点。现要将指针q指向的新
结点插入到指针p指向的

单链表结点之后，下面的操作序列中哪一个是正确的？ (3)

 1. q:=p^.link; p^.link:=q^.link
2. p^.link:=q^.link; q:=P^.link
3. q^.link:=p^.link; p^.link:=q;
4. p^.link:=q; q^.link:=p^,link

Question 10. (单选)
某二叉树结点的对称序序列为A、B、C、D、E、F、G，后序序列为B、D、C、A、F、G、E。
该二叉树结点的前序序

列为  (2)

 1. E、G、F、A、C、D、B
2. E、A、C、B、D、G、F
3. E、A、G、C、F、B、D
4. E、G、A、C、D、F、B

Question 11. (单选)
某二叉树结点的对称序序列为A、B、C、D、E、F、G，后序序列为B、D、C、A、F、G、E。
该二叉树对应的树林包

括多少棵树？ (2)

 1. 1
2. 2
3. 3
4. 4

Question 12. (单选)
某二叉树结点的对称序序列为A、B、C、D、E、F、G，后序序列为B、D、C、A、F、G、E。
该二叉树对应的树林结

点的层次次序序列为  (1)

 1. E、G、F、A、C、D、B
2. E、A、C、B、D、G、F
3. E、A、G、C、F、B、D
4. E、G、A、C、D、F、B

Question 13. (单选)
假设就绪队列中有10个进程，系统将时间片设为200ms， CPU进行进程切换要花费10ms。则
系统开销所占的比率约

为  (2)

 1. 1%
2. 5%
3. 10%
4. 20%

Question 14. (单选)
长度相同但格式不同的2种浮点数，假设前者阶码长、尾数短，后者阶码短、尾数长，其它
规定均相同，则它们可

表示的数的范围和精度为： (2)

 1. 两者可表示的数的范围和精度相同
2. 前者可表示的数的范围大但精度低
3. 后者可表示的数的范围大且精度高
4. 前者可表示的数的范围大且精度高

Question 15. (单选)
所谓“变号操作”是指将一个整数变成绝对值相同但符号相反的另一个整数。假设使用补
码表示的8位整数

X=10010101，则经过变号操作后结果为：(4)

 1. 1101010
2. 10101
3. 11101010
4. 1101011

Question 16. (单选)
设有一个用数组Q[1..m」表示的环形队列，约定f为当前队头元素在数组中的位置，r为队
尾元素的后一位置(按顺

时针方向)，若队列非空，则计算队列中元素个数的公式应为：(2)

 1. r-f
2. (m+r-f) mod m
3. (m-r+f)mod m
4. (m-r-f) mod m

Question 17. (单选)
计算机最主要的工作特点是(2)

 1. 存储程序与自动控制
2. 高速度与高精度
3. 可靠性与可用性
4. 有记忆能力

Question 18. (单选)
计算机中数据的表示形式是(3)

 1. 八进制
2. 十进制
3. 二进制
4. 十六进制

Question 19. (单选)
下面列出的四种存储器中，易失性存储器是(1)

 1. RAM
2. ROM
3. PROM
4. CD-ROM

Question 20. (单选)
I/O接口位于 (2)

 1. 总线和设备之间
2. CPU和I/O设备之间
3. 主机和总线之间
4. CPU和主存储器之间

Question 21. (单选)
计算机硬件能直接识别和执行的只有(4)

 1. 高级语言
2. 符号语言
3. 汇编语言
4. 机器语言

Question 22. (单选)
具有多媒体功能的微型计算机系统中，常用的CD-ROM是(2)

 1. 只读型大容量软盘
2. 只读型光盘
3. 只读型硬盘
4. 半导体只读存储器

Question 23. (单选)
微机中1K字节表示的二进制位数是(4)

 1. 1000
2. 8x1000
3. 1024
4. 8x1024

Question 24. (单选)
下列字符中，ASCII码值最小的是(2)

 1. a
2. A
3. x
4. Y

Question 25. (单选)
OSI(开放系统互联)参考模型的最低层是(3)

 1. 传输层
2. 网络层
3. 物理层
4. 应用层

Question 26. (单选)
在面向对象的系统中，系统责任的良好分配原则是(3)

 1. 在类之间均匀分配
2. 集中分配在少数控制类中
3. 根据交互图的消息进行分配
4. 根据个人喜好进行分配

Question 27. (单选)
在CMM模型中，对软件成熟度有以下5个级别，请从低到高排序
a 初始级:
软件过程的特点是无秩序的，偶尔甚至是混乱的。几乎没有什么过程是经过定义的,成功依
赖于个人的努力。

b 优化级:
利用来自过程和来自新思想、新技术的先导性试验的定量反馈信息，使持续过程改进成为
可能。

c 已定义级:
管理活动和工程活动两方面的软件过程均已文档化、标准化、并集成到组织的标准软件过
程。

d 已管理级:
已采集详细的有关软件过程和产品质量的度量,无论软件过程还是产品均得到定量了解和控
制。

e 可重复级:
已建立基本的项目管理过程去跟踪成本、进度和功能性。必要的过程纪律已经就位，使具
有类似应用的项目。能重

复以前的成功。
(3)

 1. acdbe
2. adceb
3. aecdb
4. abcde

Question 28. (单选)
在下面所列举的逻辑测试覆盖中，测试覆盖最强的是(3)

 1. 条件覆盖
2. 条件组合覆盖
3. 语句覆盖
4. 条件及判定覆盖

Question 29. (单选)
一般来说，在软件维护过程中，大部分工作是由什么引起的(3)

 1. 适应新的软件环境
2. 适应新的硬件环境
3. 用户的需求改变
4. 程序的可靠性

Question 30. (单选)(2)
PSP是？

 1. 团队软件过程
2. 个体软件过程
3. 过程改进过程
4. 质量管理过程

Question 31. (单选)
假定a和b为int型变量,则执行以下语句后b的值为   (4)
a=1; b=10;
do { b-=a; a++; } while (b--<0);

 1. 9
2. -2
3. -1
4. 8

Question 32. (单选)
设有以下宏定义:
#define N 3
#define Y(n) ( (N+1)*n)
则执行语句:z=2 * (N+Y(5+1));后,z的值为 (3)

 1. 出错
2. 42
3. 48
4. 54

Question 33. (单选)
执行以下程序段后,m的值为  (1)
int a[2][3]={ {1,2,3},{4,5,6} };
int m,*p;
p=&a[0][0];
m=(*p)*(*(p+2))*(*(p+4));

 1. 15
2. 14
3. 13
4. 12

Question 34. (单选)
有以下程序
main()
{ char a[]="programming", b[]="language";
char *p1,*p2;
int i;
p1=a; p2=b;
for(i=0;i<7;i++)
if(*(p1+i)==*(p2+i)) printf("％c",*(p1+i));
}
输出结果是 (4)

 1. gm
2. rg
3. or
4. ga

Question 35. (单选)
有以下程序
int fun(int x,int y,int *cp,int *dp)
{ *cp=x+y; *dp=x-y; }
main()
{ int a, b, c, d;
a=30; b=50;
fun(a,b,&c,&d);
printf("%d,%d
", c, d);
}
输出结果是 (3)

 1. 50,30
2. 30,50
3. 80,-20
4. 80,20

Question 36. (单选)
下述标识符中, 合法的用户标识符是(4)

 1. A#C
2. getch
3. void
4. sizeOf

Question 37. (单选)
以下选项中合法的字符常量是(3)

 1. A
2. '10'
3. 68
4. D

Question 38. (单选)
以下叙述正确的是 (3)

 1. 在C程序中，main函数必须位于程序的最前面
2. C程序的每行中只能写一条语句
3. C语言本身没有输入输出语句
4. 在对一个C程序进行编译的过程中，可发现注释中的拼写错误

Question 39. (单选)
以下叙述中不正确的是 (4)

 1. 在不同的函数中可以使用相同名字的变量
2. 函数中的形式参数是局部变量
3. 在一个函数内定义的变量只在本函数范围内有效
4. 在一个函数内的复合语句中定义的变量在本函数范围内有效

Question 40. (单选)
设int类型的数据长度为2个字节，则 unsigned int 类型数据的取值范围是 (2)

 1. 0~255
2. 0~65535
3. -32768~32767
4. -256~255

Question 41. (单选)
某文件中定义的静态全局变量(或称静态外部变量)其作用域是 (2)

 1. 只限某个函数
2. 本文件
3. 跨文件
4. 不限制作用域

Question 42. (单选)
语句:printf("%d
"，12 & 012)；的输出结果是 (3)

 1. 12
2. 012
3. 8
4. 6

Question 43. (单选)
设int x=4; 则执行以下语句: x+=x-=x-x;后,x的值为 (3)

 1. 0
2. 4
3. 8
4. 12

Question 44. (单选)
while(!x)中的(!x)与下面条件等价。 (4)

 1. x==1
2. x!=1
3. x!=0
4. x==0

Question 45. (单选)
已知int i,a;执行语句: i=(a=2*3,a*5),a+6;后,变量i的值是 (3)

 1. 6
2. 12
3. 30
4. 36

Question 46. (单选)
整型变量x和y的值相等、且为非0值，则以下选项中，结果为零的表达式是 (4)

 1. x || y
2. x | y
3. x & y
4. x ^ y

Question 47. (单选)
x、y、z被定义为int型变量，若从键盘给x、y、z输入数据，正确的输入语句是  (2)

 1. INPUT x、y、z;
2. scanf("%d%d%d",&x,&y,&z);
3. scanf("%d%d%d",x,y,z);
4. read("%d%d%d",x,y,z);

Question 48. (单选)
以下各选项企图说明一种新的类型名，其中正确的是 (2)

 1. typedef v1 int;
2. typedef int v3;
3. typedef v4: int;
4. typedef v2=int;

Question 49. (单选)
char x=3,y=6,z;
z=x^y<<2;
则z的二进制值是 (2)

 1. 10100
2. 11011
3. 11100
4. 11000

Question 50. (单选)
若有说明：int i, j=2，*p=&i;，则能完成i=j赋值功能的语句是 (2)

 1. i=*p;
2. *p=*&j;
3. i=&j;
4. i=**p;

Question 51. (问答)
给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a的bit 3。在以上两
个操作中，要保持其它

位不变。

 a|=0x4;

int b=a&0x7;
a>>=4;
a=(a<<4)|b;

Question 52. (问答)
有双向循环链表结点定义为：
struct node
{ int data;
struct node *front,*next;
};
有两个双向循环链表A，B，知道其头指针为：pHeadA,pHeadB，请写一函数将两链表中dat
a值相同的结点删除

 struct node
{ int data;
struct node *front,*next;
};
node* del(node *pHead){
    if(pHead==pHead->next){
                  free(pHead);
        return NULL;
         }
         node *p=pHead;
    pHead->next->front=pHead->front;
    pHead->front->next=pHead->next;
    pHead=pHead->next;
         free(p);
    return pHead;
}
void delequ(node*pHeadA,node *pHeadB){
    node *pA=pHeadA;
    node *pB;
    int flag;
    do{
        flag=0;
        pB=pHeadB;
        do{
            if(pB->data==pA->data){
                if(pA==pHeadA){
                    pHeadA=pA=del(pHeadA);
                    flag=1;
                }
                else{
                    pA=del(pA);
                }
                pB=del(pB);
                break;
            }
            pB=pB->next;
        }while(pB!=pHeadB);
        if(flag==0){
            pA=pA->next;
        }
    }while(!pA && !pB && (flag||(pA!=pHeadA)));
}

Question 53. (问答)
编程实现：找出两个字符串中最大公共子字符串,如"abccade","dgcadde"的最大子串为"c
ad"

 char* constr(char *A,char *B){
    int lenA=strlen(A),lenB=strlen(B);
    int itmp,conlen=0;
    char *pequ,*pH=NULL;
    char *pA,*pB,*pA2,*pB2;
    for(pA=A;pA-A
        for(pB=B;pB-B
            if(*pB==*pA){
                pA2=pA+1;
                pB2=pB+1;
                for(itmp=1;*pA2==*pB2 && pA2++-A                if(itmp>conlen){
                    conlen=itmp;
                    pH=pA;
                }
            }
            pB++;
        }
    }
    pequ=(char*)malloc(conlen+1);
    memcpy(pequ,pH,conlen);
    *(pequ+conlen)='\0';
    return pequ;
}

Question 54. (问答)
说明关键字static和volatile的含义

 static用于外部变量或者函数时，限制了它们的作用域为文件内部；static也可以用于内
部变量，这样，内部变

量在每次函数调用时都为同一存储，值具有连续性。

volatile说明了一个变量的值是会随机变化的，即使程序没有对它进行任何赋值操作。它
告诉编译器的优化处理器

，这些变量是实实在在存在的，在优化过程中不能无故消除，这样就保证了编译后的代码
在每次操作是从变量地址

处取数。

Question 55. (问答)
编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列
库函数

 void put(long data){
    long mask=0x1<<(8*sizeof(long)-1);
    int i;
    char c;
    if(data&mask)
    putchar('1');
    else
    putchar('0');
    mask=0x1<<(8*sizeof(long)-2);
    for(i=1;i<8*sizeof(long);i++){
        if(data&mask)
            putchar('1');
        else
            putchar('0');
        mask>>=1;
    }
    putchar('\n');
    mask=0xf<<(8*sizeof(long)-4);
    c=(data&mask)>>(8*sizeof(long)-4);
    if(c<10)
    putchar(c+'0');
    else
    putchar(c+'a');
    mask=0xf<<(8*sizeof(long)-8);
    for(i=1;i<2*sizeof(long);i++){
        c=(data&mask)>>(8*sizeof(long)-4*i-4);
        if(c<10)
            putchar(c+'0');
        else
            putchar(c+'a');
        mask>>=4;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
在这里公布选择题的答案没有意义的，选择题是随机从题库中提取的，每个人只有很少几
个是一样的，大部分都不一样。

最后的5个问答题是一样的。这里提供第54，55题的答案，仅供参考！
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
54题：
在C中，static变量的含义。
A:static 声明的变量在C语言中有两方面的特征：
　　1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原
来的赋值。这一点是它与堆栈变量和堆变量的区别。
　　2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全
局变量的区别。
Tips:
　　A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低
模块间的耦合度；
　　B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以
降低模块间的耦合度；
　　C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑
重入问题；
    D.如果我们需要一个可重入的函数，那么，我们一定要避免函数中使用static变量(这
样的函数被称为：带“内部存储器”功能的的函数)
     E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须
是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。

=====================================

volatile总是与优化有关，编译器有一种技术叫做数据流分析，分析程序中的变量在哪里
赋值、在哪里使用、在哪里失效，分析结果可以用于常量合并，常量传播等优化，进一步
可以死代码消除。但有时这些优化不是程序所需要的，这时可以用volatile关键字禁止做
这些优化，volatile的字面含义是易变的，它有下面的作用：

1 不会在两个操作之间把volatile变量缓存在寄存器中。在多任务、中断、甚至setjmp环
境下，变量可能被其他的程序改变，编译器 自己无法知道，volatile就是告诉编译器这种
情况。

2 不做常量合并、常量传播等优化，所以像下面的代码：
volatile int i = 1;
if (i > 0) ...

if的条件不会当作无条件真。

3 对volatile变量的读写不会被优化掉。如果你对一个变量赋值但后面没用到，编译器常
常可以省略那个赋值操作，然而对Memory Mapped IO的处理是不能这样优化的。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

55题，递归算法：
/*长整型转变成二进制*/
void binary(long n)
{
    char c;
    if(n/2!=0)
        binary(n/2);
        c=n%2+48;
        putch(c);
}

/*长整型转变成十六进制*/

void hex(long n)
{
    if(n/16!=0)
        hex(n/16);
        if(n%16>=0&&n%16<=9)
            {c=n%16+48;
             putch(c);
            }
        else
            {c=n%16-10+97;
            putch(c);
            }

}