知识点总结(1)

1.关于引用与指针的区别，下面叙述错误的是：
正确答案: B
引用必须被初始化，指针不必。
指针初始化以后不能被改变，引用可以改变所指的对象。
删除空指针是无害的，不能删除引用。
不存在指向空值的引用，但是存在指向空值的指针。

解析：
指针在建立后会被分配一块空间，用于存储其所指向的地址，因为指针是有对应内存空间的，因此指针值（指向的内存空间）是可以改变的；
而引用则不行，引用没有内存空间，仅仅是被引对象内存空间的别名，改变引用如&a=4实际上等价于a=4,改变的是被引对象的值，不改变该引用所指的内存空间；
指向空值的引用是没有意义的（因为引用对象不能改变，也就是这个引用永远指向null，那这个引用根本就没有存在的必要）；
指向空值的指针是有意义的，尤其在指针被删除后，如果不对指针进行赋值，则指针的值将会由系统随机指定，这样后续如果有对指针的操作的话，将会带来很大的风险。
因此指针被删除后必须赋值为null；
因为引用无法改变，因此不进行初始化的引用没有意义；
因为指针可以改变，因此指针可以不进行初始化，可以在后续程序中动态改变；

总结一下引用和指针的区别：
  1、引用是直接访问，指针是间接访问
  2、引用是变量的别名，本身不单独分配自己的内存空间。指针有自己的内存空间。
  3、引用一旦初始化，不能再引用其他变量。而指针可以！

下面哪项是数组优于链表的特点？
正确答案: D
方便删除
方便插入
长度可变
存储空间小

数组与链表的优缺点：
数组,在内存上给出了连续的空间.链表,内存地址上可以是不连续的,每个链表的节点包括原来的内存和下一个节点的信息(单向的一个,双向链表的话,会有两个). 

数组优于链表的: 
1.内存空间占用的少,因为链表节点会附加上一块或两块下一个节点的信息.但是数组在建立时就固定了.所以也有可能会因为建立的数组过大或不足引起内存上的问题. 
2.数组内的数据可随机访问.但链表不具备随机访问性.这个很容易理解.数组在内存里是连续的空间.比如如果一个数组地址从100到200,且每个元素占用两个字节,那么100-200之间的任何一个偶数都是数组元素的地址.可以直接访问.链表在内存地址可能是分散的.所以必须通过上一节点中的信息找能找到下一个节点. 
3.查找速度上.这个也是因为内存地址的连续性的问题 
链表优于数组的: 
1.插入与删除的操作.如果数组的中间插入一个元素,那么这个元素后的所有元素的内存地址都要往后移动.删除的话同理.只有对数据的最后一个元素进行插入删除操作时,才比较快.链表只需要更改有必要更改的节点内的节点信息就够了.并不需要更改节点的内存地址. 
2.内存地址的利用率方面.不管你内存里还有多少空间,如果没办法一次性给出数组所需的要空间,那就会提示内存不足,磁盘空间整理的原因之一在这里.而链表可以是分散的空间地址. 
3.链表的扩展性比数组好.因为一个数组建立后所占用的空间大小就是固定的.如果满了就没法扩展.只能新建一个更大空间的数组.而链表不是固定的,可以很方便的扩展.
数组与链表的优缺点；    
数组:
  优点：使用方便 ，查询效率 比链表高，内存为一连续的区域 
  缺点：大小固定，不适合动态存储，不方便动态添加
 链表：
  优点：可动态添加删除   大小可变   
  缺点：只能通过顺次指针访问，查询效率低
 补充：
顺序表的优点:查找方便,适合随机查找 
顺序表的缺点:插入、删除操作不方便，因为插入、删除操作会导致大量元素的移动 
链接表的优点:插入、删除操作方便，不会导致元素的移动，因为元素增减，只需要调整指针。 
顺序表的缺点:查找方便，不适合随机查找
链表的特性是在中间任意位置添加删除元素的都非常的快，不需要移动其它的元素。  
链表顾名思义，要把各个元素链接起来才算撒。    
通常链表每一个元素都要保存一个指向下一个元素的指针（单链表）。    
双链表的化每个元素即要保存到下一个元素的指针，还要保存一个上一个元素的指针。    
循环链表则把最后一个元素中保存下一个元素指针指向第一个元素。    
数组是一组具有相同类型和名称的变量的集(百度)合。这些变量称为数组的元素,每个数组元素都有一个编号,这个编号叫做下标,我们可以通过下标来区别这些元素。数组元素的个数有时也称之为数组的长度。
数组在进行查找，排序操作是很方便；链表不需要连续空间，而且作插入操作方便！    
分配空间上也不同，建立过程也不同！
链表和数组的本质差异    
  1     在访问方式上    
        数组可以随机访问其中的元素    
        链表则必须是顺序访问，不能随机访问   
  2     空间的使用上    
        链表可以随意扩大    
        数组则不能    

数据的逻辑结构是指数据的各数据项之间的逻辑关系()
正确答案: B
对
错

解析：逻辑结构间的关系是数据元素之间的关系，而数据项是数据元素中的一个属性。
这里一定要注意概念上的区别。

假定变量 i ,f 和 d数据类型分别为int,float和double(int用补码表示，float和double分别用IEEE754单精度和双精度浮点数据格式表示)，已知i=785,f=1.5678 e3 ,d=1.5 e100。 若在32位机器中执行下列关系表达式，则结果为 “ 真 ” 是（）
( I )i = = (int)(float) i
(II)f = =(float)(int)f
(III)f= = (float)(double) f
(IV)(d+f)-d= = f
正确答案: B
仅I和II
仅I和III
仅II和III
仅III和IV

解析：
(Ⅰ)i变成浮点数，不变； 
(Ⅱ)f变成整数时，精度变小； 
(Ⅲ)f转为双精度，大小不变； 
(Ⅳ)双精度值不等于单精度值。

C 语言中函数调用的方式有（）。
正确答案: D
函数调用作为语句一种
函数调用作为函数表达式一种
函数调用作为语句或函数表达式两种
函数调用作为语句或函数表达式或函数参数三种

解析：
这个题的疑惑点在于函数是否可以作为一个函数的参，
通过了解得到了，函数其实是可以作为一个函数的参数
因为：函数返回值在寄存器中, 没有地址, 不能作为形参，但可以作为实参

在程序设计中，要对两个16K×16K的多精度浮点数二维数组进行矩阵求和时，行优先读取和列优先读取的区别是（）
正确答案: B
没区别
行优先快
列优先快
2种读取方式速度为随机值，无法判断

解析:若在内存中,则数据可以”随机存取”,
但内存数据被读取或写入时,所需要的时间与这段信息所在的位置无关.
但是在读取和写入磁盘时,其所需要的时间与位置就会有关系.
因为在BASIC,PASCAL和C/C++语言中,数组的存放是按照行优先来存放的,按行号第一行第二行…以此类推.
本题关键是考察内存抖动的问题,如果按列访问则需要跳过一大串内存地址,这样可能需求的内存地址不在当前页中则需要进行页置换,这样便需要硬盘IO,减低速度.

#include <stdio. h>
void fun ( int *s)
{
    static int j = 0;
    do {
        s[j] + = s[j+1];
    }while(+ + j < 2);
}
main()
{ 
    int i , a[10]={1,2,3,4,5};
    for( i = 1; i < 3; i + + ) fun( a );
    for( i = 1; i < 5; i + +)printf("%d",a[i]);
    printf("\n");
}

程序运行后的输出结果是？
正确答案: B
34756
5745
5795
35745

解析：
for( i = 1; i < 3; i + + )将调用两次fun(a)
第一次调用fun(a)时数组的前两个元素变位3、5，此时j=2;
第二次调用fun(a)时，虽然j=2已经不满足++j<2但还是要执行一次，数组第三个元素变为7
然后for循环下标从1开始，所以输出后4个元素。5745

有两点需要注意的：
do-while循环 ：在判断while条件前先执行一次do循环
static变量 ：程序再次调用时static变量的值不会重新初始化，而是在上一次退出时的基础上继续执行。

可是如果不注意下边这个，前边这些作对了都是白搭！
一定要注意下标是从第二个元素开始的呀！！

若有定义语句:char s[3][10],(*k)[3],*p;则以下赋值语句错误的是()

1.p=s; 
2.p=k;
3.p=s[0]; 
4.k=s;

正确答案: A
124
1234
12
234

解析：
p 是指向 char 的指针
k 是指向 char数组的指针，数组大小为3
s 是指向 char数组的指针，数组大小为10
k=s 错误是因为，k和s指向的数组大小不同。
k+1 地址移动3个 char的大小
s+1 地址移动10 个char的大小
char s[3][10]    s 是数组指针，类型为char (*)[3]，所指向的每个数组长度为10;
char (*k)[3]    很明显k就是一个数组指针，类型也为 char (*)[3]，但是所指向的每个数组的长度未知;
char *p    类型为char * 指针。
因此，在没有强制类型转换的情况下，只有类型完全相同的指针才能相互复制。
答案：1,2,4
—— —— —— ——3为什么正确？—— —— ——
s[0] 是指向第一行数组的首元素的地址，即s[0] == &s[0][0]，指针类型为char *，因此可以与char * p进行复制操作。

在面向数据流的设计方法中，一般把数据流图中的数据划分为以下哪两种。
正确答案: C
数据流和事务流
变换流和数据流
变换流和事务流
控制流和事务流

解析：
在面向数据流的设计方法中，一般把数据流图中的数据流划分为两种类型，一种是变换流，一种是事务流。
信息沿着输入通路进入系统，同时将信息的外部形式转换成内部表示，然后通过变换中心处理，再沿着输出通路转换成外部形式化离开系统，具有这种特性的信息流称为变换流。
信息沿着输入通路到达一个事务中心，事务中心根据输入信息的类型在若干个动作序列中选择一个来执行，这种信息流称为事务流。

下列哪个用法哪个是错误的()
正确答案: C
int *a;
extern const int array[256];
const int &ra;
typedef void (*FUN)();

解析：
指针本质上是一个存放地址的变量，他是独立的。
而引用是别名，在整个生命周期中对于 将他初始化的变量（也可是指向的表达式）有依附性。
相当与访问的接口。需要初始化。
引用在使用的时候，必须要初始化。

在 C 语言中，引用数组元素时，其数组下标的数据类型允许是（ ）。
正确答案: A B C
整型常量
整型表达式
整型变量
任何类型的表达式

解析：题目问的是引用数组元素，在定义数组的时候，下标引用符中不能为变量，
但是在引用数组元素的时候，下标的数据类型就可以是变量了。

下列代码的运行结果是（）

int a[]={1,2,3,4};
int *b=a;
*b+=2;
*(b+2)=2;
b++;
printf(“%d,%d\n”,*b,*(b+2));

正确答案: C
1,3
1,2
2,4
3,2

解析：
b首先指向a的第一个元素
*b+=2将第一个元素加2，第一个元素变为3
*（b+2）=2将数组第三个元素变为2
b++使得b指向第二个元素
因此打印的为第二个元素和第四个元素为2,4

STL中的unordered_map和priority_queue使用的底层数据结构分别是什么?()
正确答案: B
rbtree,queue
hashtable,heap
rbtree,heap
hashtable,queue

解析：
unordered_map：是所谓的哈希map，很容易就选了hashtable
priority_queue：是所谓的优先级队列，说白了就是一个二叉堆，所以底层应该是用heap实现，并非名字中的queue
map： 
map内部实现了一个红黑树，该结构具有自动排序的功能，因此map内部的所有元素都是有序的，红黑树的每一个节点都代表着map的一个元素，
因此，对于map进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了map的效率。
unordered_map: unordered_map内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的

下面说明不正确的是（）。
正确答案: D
char a[10]=“china”；
char a[10],*p=a;p=“china”；
char *a;a=“china”；
char a[10],*p;p=a=“china”；

解析：
C语言中，在定义字符型数组时，可以直接用字符串对数组赋初值，只要
数组定义的大小能容纳字符串中的字符即可，另外，对定义的字符型指针变量可以将字
符串常量对其赋值，但数组名是地址常量，是不能用字符串对其赋值的。
指针的指向是可以修改的，所以C是正确的，但是数组的内容是不可以修改的，所以D是错误的。

字符串www.qq.com所有非空子串（两个子串如果内容相同则只算一个）个数是（）
正确答案: D
1024
1018
55
50

解析：
总的子串个数为 10+9+8+7+。。+1 = 55
由于相同子串算一个，所以要减去2个w，一个.，一个ww，一个q，所以还有50个

已知如下类说明：

public class Test{
    private float f=1.0f;
    int m=12;
    static int n=1;
    public static void main(String args[]){
        Test t=new Test();
    }
}

如下哪些使用是正确的（）
正确答案: D
t.f = 1.0
this.n
Test.m
Test.n

解析：
A：编译不成功，因为float浮点类型默认是double类型 所以float f=1.0f;（必须加上f 强调定义的是float）此处是精度由高(double)向低(float)转型所以会报错但是若是float f=1;
这里是默认类型是Int 类型  精度由低(int)向高转型(float)不丢失精度不会报错。
B：this的使用时针对在方法内部使局部变量等值于实例变量而使用的一个关键字，此处的n是静态变量而非实例变量 所以this的调用会出错（试想一下，static本来是全类中可以使用的，是全局的，你非得this去调用，这不是区分局部变量和实例变量的分水线吗？但是此处是全局的，不需要区分）
C：m是实例变量，什么是实例变量：就是需要new 一个对象出来才能使用的，这里直接用类名就调用了
D：类变量可以通过类直接调用

C++中，如果x是整型变量，则合法的形式为（）
正确答案: D
&(x+5)
*x
&*x
*&x

解析：
x是整型变量，有一个存储地址
A，x有地址，但是x+5这个表达式不能取地址操作
B，*是取指针变量指向的内容，x不是指针，错误
C，C选项中也包含*x，道理同B选项，是错误的
D，x变量先去地址，得到指向x的指针:&x 然后再用*操作符取该地址的内容，结果还是x，是合法的

在C++里，堆中存储的数据是（）？
正确答案: D
局部变量
函数返回值
函数参数
new和malloc申请的内存

解析：
栈：就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
堆：就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
自由存储区：就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
全局存储区（静态存储区）：全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后有系统释放。
常量存储区：这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。

19.
给出以下定义，下列哪些操作是合法的？

const char *p1 = “hello”;
char *const p2 = “world”;

正确答案: A
p1++;
p1[2] = ‘w’;
p2[2] = ‘l’;
p2++;

解析：
口诀：左定值，右定向。
即 const在*的左边不能改变字符串常量的值，故B错；
const在*的右边不能改变指针的指向，故D错；
由于 “world“存储在字符常量区，不能直接修改其值，故C错；
若要修改其值，应该改为char str []= "world";
p2本身是指针常量，可以指向非常量的字符。但是"hello"这样声明的字符串是存储在只读存储区的，不可修改

2个同名成员函数，可以重载的是（）?
正确答案: B C
int A::f() 和double A::f()
void A::f(int) 和void A::f(short)
void A::f() 和void A::f() const
void A::f(int) 和void A::f(const int)
const int A::f() 和int A::f()

解析：
A.返回值不能区分重载函数，只有函数名、形参个数、形参类型可以
B.int和short不一样，所以可以重载
C.const放在函数后面是指这个成员函数为常成员函数，不能修改类里的成员变量，可以起到重载的作用。
D.int和const int都是int类型，区别是后者不能对形参进行修改而已，这样写不可以重载，编译会报错。
E.函数前面加const也起不来重载的作用，其作用在于声明返回的值为cosnt不可修改，绝大多数情况下没啥意义。
PS：声明一个成员函数的时候用const关键字是用来说明这个函数是 "只读(read-only)"函数，也就是说明这个函数不会修改任何数据成员(object)。
为了声明一个const成员函数，把const关键字放在函数括号的后面。声明和定义的时候都应该放const关键字。
任何不会修改数据成员的函数都应该声明为const类型，如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这可以提高程序的健壮性。

设Tree为已定义的类名，下列语句能正确创建 Tree 对象的是 。
正确答案: B
Tree t=new Tree;
Tree t=new Tree();
Tree t=Tree();
Tree t[ ]=new Tree[10];

解析：
声明：类名 变量名，创建：new 构造器（）
D生成的是一个数组，并不是Tree对象。
至于D选项，题目要求的是创建Tree对象，而不是创建数组对象，所以不符合题意
D创建的数组对象，不是Tree对象！需要用对象的时候还得再次new，不然直接用数组调用提示空指针！

22.
程序会出现死循环的问题，必然会越界
原因是：
在代码中创建了i和a两个局部变量，局部变量是存储在栈中的，而栈的使用规则又是先使用高地址，再使用低地址，那么i的地址一定是校于a的地址的，那这个时候，先使用，再，又因为随着数组下标的增长，数组的地址是从低到高的，那么数组随着下标的增长，出现越界访问，向后就可能会遇到i，如果i被改掉，那么就是循环变量被改掉了，那么造成了死循环。

在重载运算符函数时，下面（）运算符必须重载为类成员函数形式（）
正确答案: D

+
-
++
->

解析：
只能使用成员函数重载的运算符有：=、()、[]、->、new、delete。
在多数情况下，将运算符重载为类的成员函数和类的友元函数都是可以的。但成员函数运算符与友元函数运算符也具有各自的一些特点：
( 1 ) 一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
( 2 ) 以下一些双目运算符不能重载为类的友元函数： = 、()、[]、 -> 。
( 3 ) 类型转换函数只能定义为一 个类的成员函数而不能定义为类的友元函数。
( 4 ) 若一个运算符的操作需要修改对象的状态，选择重载为成员函数较好。
( 5 ) 若运算符所需的操作数（尤其是第一个操作数）希望有隐式类型转换，则只能选用友元函数。
( 6 ) 当运算符函数是一个成员函数时，最左边的操作数（或者只有最左边的操作数）必须是运算符类的一　个类对象（或者是对该类对象的引用）。如果左边的操作数必须是一个不同类的对象，或者是一个内部　类型的对象，该运算符函数必须作为一个友元函数来实现。
( 7 ) 当需要重载运算符具有可交换性时，选择重载为友元函数。

下列选项中正确的语句组是（）。
正确答案: D
char s[8]; s={“Beijing”};
char *s; s={“Beijing”};
char s[8]; s=“Beijing”;
char *s; s=“Beijing”;

解析：
数组名是一个不可修改的常量。
char s[8]; s={"Beijing"};
char s[8]; s="Beijing";
这两种写法都是错的！因为是先声明了，然后再定义初始化的，这么一来就得修改数组名，而这是不允许的！
但是假如这么写：
char s[8]={"Beijing"};
char s[8]="Beijing";
那就是对的！

() 的作用是将源程序文件进行处理，生成一个中间文件，编译系统将对此中间文件进行编译并生成目标代码。
正确答案: A
编译预处理
汇编
生成安装文件
编译

解析：
预处理， 展开头文件/宏替换/去掉注释/条件编译         （test.i main .i）
编译，    检查语法，生成汇编                       （ test.s  main .s）
汇编，   汇编代码转换机器码(二进制)                 (test.o main.o)
链接     链接到一起生成可执行程序                  （a.out）
题目中说了，要把目标文件编译成目标代码，那么 预处理--编译--汇编--链接，编译前面是预处理啦

在二进制数据中，小数点向右移一位，则数据
正确答案: C
除以10
除以2
乘以2
乘以10

解析：
十进制数据右移n位，乘以10^n,左移n位，除以10^n
二进制数据右移n位，乘以2^n,左移n位，除以2^n(右移数据变大，乘操作，左移数据变小，除操作)

设函数fun和实参数组的说明形式为：
void fun(char ch,float x[]);
float a[10];
以下对函数的调用语句中，正确的是（）
正确答案: D
fun(“abc”，a[]);
t=fun(‘D’，A);
fun(‘65’，2.8);
fun(32，a);

解析：
选D。考察的是对函数的调用，涉及到调用时的实参和函数定义时的形参匹配问题。
根据题目：函数定义fun第一个参数为char类型，第二个为float数组类型。
选项A：“abc”属于字符串，与定义函数参数不匹配，所以A错误。
选项B：fun函数为void没有返回值，所以无法赋值给t；所以B错误。
选项C：第二个参数2.8属于double类型，float类型后面需加上f，即2.8f。因此和定义函数参数类型不匹配，所以C错误。

一种既有利于短作业又兼顾长期作业的调度方式是（）
正确答案: D
先来先服务
均衡调度
最短作业优先
最高响应比优先

解析：
响应比最高者优先算法综合考虑作业的等待时间和计算时间
计算时间短的作业容易得到较高的响应比，可能被选中。
但是，一个计算时间长的作业在等待了相当长的时间后，也将获得较高的响应比。

若 ch 为 char 型变量，k 为 int 型变量（已知字符 a 的 ASCII 十进制代码为97），
则以下程序段的执行结果是（）。
ch=‘a’; k=12; printf("%x,%o,",ch,ch,k);
printf(“k=%%d\n”,k);
正确答案: C
因变量类型与格式描述符的类型不匹配，输出无定值
输出项与格式描述符个数不符，输出为零值或不定值
61,141,k=%d
61,141,k=%12

解析：
printf("%x,%o,",ch,ch,k);//将ch以16进制输出为61,八进制为141，k参数被忽略。
printf("k=%%d\n",k);   // %是控制符，用 %% 表示输出一个百分号

使用白盒测试方法时，设计测试用例应根据（ ）。
正确答案: A
程序的内部逻辑
程序的复杂结构
程序的功能
使用说明书

解析：
白盒测试又称结构测试、透明盒测试、逻辑驱动测试或基于代码的测试。
白盒测试是一种测试用例设计方法，盒子指的是被测试的软件，白盒指的是盒子是可视的，即清楚盒子内部的东西以及里面是如何运作的。
"白盒"法全面了解程序内部逻辑结构、对所有逻辑路径进行测试。
"白盒"法是穷举路径测试。在使用这一方案时，测试者必须检查程序的内部结构，从检查程序的逻辑着手，得出测试数据。贯穿程序的独立路径数是天文数字。

线性表采用链表存储时,结点和结点内部的存储空间可以是不连续的()
正确答案: B
对
错

解析：
结点内部的空间必须是连续的，结点和结点之间可以是不连续的。
1.原理：线性表采用链表存储时，不要求结点所占空间连续，但是一个结点内部空间必须连续。
有人说结点内部是指针的话就不连续，这是不对的，结点内部如果是指针，结点分配空间的时候，分配的是指针类型，指针所指的空间不是结点内部的空间。如果指针所指空间也算结点内部空间的话，那指针数组也不连续了，岂不是推翻了数组内部空间是连续的结论了。
2.该题的关键是这个题目要表达什么意思，该题的语言表达很拗口，不同的人有不同的理解，因此， 结点和结点内部 的存储空间可以由以下几种理解：
(1) 结点的存储空间(所有结点) 和 结点内部的存储空间(所有结点的内部空间) ，这两个肯定是可以不连续的，选A。
(2) 结点的存储空间 (所有结点)    和 结点内部的存储空间(某个结点的内部空间) ，前者是可以不连续的，后者必须连续，选B。

下列运算符中优先级最高的是（）。
正确答案: B
<
+
&&
!=

解析：
算术运算符>关系运算符>逻辑运算符

一个有序数列，序列中的每一个值都能够被2或者3或者5所整除，这个序列的初始值从1开始，但是1并不在这个数列中。求第1500个值是多少？
正确答案: C
2040
2042
2045
2050

解析：
2、3、5的最小公倍数是30。[ 1, 30]内符合条件的数有22个。如果能看出[ 31, 60]内也有22个符合条件的数，那问题就容易解决了。也就是说，这些数具有周期性，且周期为30.
第1500个数是：1500/22=68   1500%68=4。也就是说：第1500个数相当于经过了68个周期，然后再取下一个周期内的第4个数。一个周期内的前4个数：2,3,4,5。
故，结果为68*30=2040+5=2045

下列代码输出什么（）

char *a[] = {"BEIJING", "SHENZHEN", "SHANGHAI", "GUANGZHOU"};
char **pa[] = {a+3, a+2, a+1, a};
char ***ppa = pa;
int main(void) {
    printf("%s, ", **++ppa);
    printf("%s, ", *--*++ppa+3);
    printf("%s, ", *ppa[-2]+3);
    printf("%s", ppa[-1][-1]+1);
}

正确答案: B
BEIJING, SHENZHEN, SHANGHAI,GUANGZHOU
SHANGHAI, JING, NGZHOU, HENZHEN
SHANGHAI,BEIJING, GUANGZHOU, SHENZHEN
SHANGHAI,EIJING,ZHOU,ZHEN


35.

"My salary was increased by 15%!"

下列哪个选项可以准确的显示出上述语句？
正确答案: D
printf("“My salary was increased by 15/%!”\n");
printf(“My salary was increased by 15%!\n”);
printf(“My salary was increased by 15’%’!\n”);
printf("“My salary was increased by 15%%!”\n");

解析：
printf("\"My salary was increased by 15%%!\"\n");
最前和最后的“”是printf()需要的
\" 为 “
%% 为 %
！ 为 ！ （！不需要转义）
\" 为 ”

对于软件的β测试，下列描述正确的是( )。
正确答案: D
β测试就是在软件公司内部展开的测试，由公司专业的测试人员执行的测试
β测试就是在软件公司内部展开的测试，由公司的非专业测试人员执行的测试
β测试就是在软件公司外部展开的测试，由专业的测试人员执行的测试
β测试就是在软件公司外部展开的测试，可以由非专业的测试人员执行的测试

解析：
α、β、λ常用来表示软件测试过程中的三个阶段
α是第一阶段，一般只供内部测试使用；
β是第二个阶段，已经消除了软件中大部分的不完善之处，但仍有可能还存在缺陷和漏洞，一般只提供给特定的用户群来测试使用；
λ是第三个阶段，此时产品已经相当成熟，只需在个别地方再做进一步的优化处理即可上市发行。
Beta测试是一种验收测试。所谓验收测试是软件产品完成了功能测试和系统测试之后，在产品发布之前所进行的软件测试活动，它是技术测试的最后一个阶段，通过了验收测试，产品就会进入发布阶段。
验收测试一般根据产品规格说明书严格检查产品，逐行逐字地对照说明书上对软件产品所做出的各方面要求， 确保所开发的软件产品符合用户的各项要求。 
通过综合测试之后，软件已完全组装起来，接口方面的错误也已排除，软件测试的最后一步——验收测试即可开始。验收测试应检查软件能否按合同要求进行工作，即是否满足软件需求说明书中的确认标准。
Beta测试由软件的最终用户们在一个或多个客房场所进行。与Alpha测试不同，开发者通常不在Beta测试的现场，因Beta测试是软件在开发者不能控制的环境中的“真实”应用。用户Beta测试过程中遇到的一切问题（真实在或想像的），并且定期把这些问题报告给开发者。接收到在Beta测试期间报告的问题之后，开发者对软件产品进行必要的修改，并准备向全体客户发布最终的软件产品。

有以下程序

#include <stdio.h>
#include <stdlib.h>
void fun ( int *pl,int *p2,int *s )
{
    s ＝ (int*) malloc(sizeof(int));
    *s ＝ *pl + *(p2++ );
}
main( )
{
    int a [2] ＝ {1,2},b [2] ＝ ｛10,20｝,*s ＝ a;
    fun (a,b,s); 
    printf ( "%d \n", *s);
}

程序运行后的输出结果是?
正确答案: C
11
10
1
2

解析在fun函数中，指针s实际上是实参s的一份拷贝。对指针s值得改变，并不会改变实参s的值。通过调用malloc，给指针s赋值上新的地址，之后对指针s所指向内存的修改不会对实参s所指向的内存产生影响。
所以，fun函数执行后，对指针s的值和s所指向的内存不会产生任何影响。

只有单重继承的类层次结构是（）层次结构。
正确答案: C
网状型
星型
树型
环型

解析：
单重继承的类层次结构表现为树型层次结构；
多重继承的类层次结构变现为网状层次结构。

char* s="AAA"; //1
printf("%s",s); //2
s[0]='B'; //3
printf("%s",s); //4

哪一句会出错？
正确答案: C
第1句
第2句
第3句
第4句

解析：
初始化指针时所创建的字符串常量被定义为只读。如果试图通过指针修改这个字符串的值，程序就会出现未定义的行为。S[0]只可读，不可写
在定义char* s="AAA";时，表示定义了一个指针s，其指向的地址是常量区"AAA"的地址，此时如果想修改*s就是在试图修改常量"AAA"，显然这是违法的；
如果定义成char s[]="AAA"；此时相当于创建了一个副本，其值为"AAA"，不再是常量，可以通过s[i] = ***；修改"AAA"的值

十进制数50表示成符合C语言规定的八进制数为________。
正确答案: D
20
32
62
062

解析：
c语言中八进制表示为了与十进制区分前面要加0

请找出下面程序中有哪些错误：

int main()
{
   int i=10;
   int j=1;
   const int *p1;//(1)
   int const *p2=&i; //(2)
   p2=&j;//(3)
   int *const p3=&i;//(4)
   *p3=20;//(5)
   *p2=30;//(6)
   p3=&j;//(7)
return 0;
}

正确答案: C
1,2,3,4,5,6,7
1,3,5,6
6,7
3,5

解析：
（1）const int*p1：表示不能通过指针p1修改它指向的内存单元的值，但是p1本身可修改。
（2）int const*p2=&i：与p1相同，即不能修改p2指向的内存单元的值，但是可以修改p2使其指向其它的内存单元。这里p2指向了整型变量i
（3）p2=&j：修改p2，使其指向整型变量 j ，由（2）可知（3）没错。
（4）int *constp3=&i：p3本身是指向整型变量的常指针,即p3初始化后不能再指向其它的内存单元，但是可以修改p3指向的内存单元的值。这里p3指向了整型变量i。
（5）*p3=20：通过p3将变量i的值修改为2，由(4)可知（5）没错。
（6）*p2=30：通过p2修改它所指向的内存单元的值，由（2）可知（6）错误。
（7）p3=&j：修改p3,使其指向j,由(4)可知（7）错误。

下面的程序执行后，文件test.txt中的内容是（）.

#include <stdio.h> 
void fun (char *fname,char *st) 
{ 
FTLE *myf;int i; 
myf=fopen (fname,"w"); 
for (i=0;i<strlen(st);i++) fputc (st[i],myf); 
fclose (myf); 
} 
void main() 
{ 
fun("test.txt","new world")；
fun("test.txt","hello,"); 
} 

正确答案: A
hello,
new worldhello，
new world
hello,rld

解析：
【解释】函数fun的功能就是将第二个参数字符串写入到文件test.txt中，但因为打开
文件test.txt的方式是以只写方式，所以每次调用函数fun后都会将原来文件内容清除（如
果test.txt文件存在），这样一来test.txt中的内容将是最后一次调用fun函数写入的字符串。
因为第二次的fun()会调用到myf = fopen(fname, "w");
而"w"选项是会截断文件内容的(也就是清除文件里原来的内容).所以当第二次调用fun()的时候就清除了第一次输入的"new world".也就是相当于打开了一个全新的文件,并往里面写入"hello,".所以输出内容是"hello,"

递归函数最终会结束，那么这个函数一定？
正确答案: B
使用了局部变量
有一个分支不调用自身
使用了全局变量或者使用了一个或多个参数
没有循环调用

解析：
B肯定是对的，只有一次循环满足某个条件，不调用自己就返回，递归才会一层一层向上返回。
那么C呢，想一下，全局变量和参数确实可以用来控制递归的结束与否。
该不该选C呢？再仔细看一下题目（说实话，我很讨厌这种文字游戏），“这个函数一定...“，所以，问题集中在，是否是一定会使用这两种方式呢？ 显然不是的。
除了C中提到的两种情况外，还有如下控制递归的方式：
1.局部静态变量是可以控制递归函数最终结束的
2.可能通过异常来控制递归的结束。
3.可以利用BIOS或OS的一些数据或一些标准库的全局值来控制递归过程的终止。
4.可以把一些数据写入到BIOS或OS的系统数据区，也可以把数据写入到一个文件中，以此来控制递归函数的终止。

下面有关函数模板和类模板的说法正确的有？
正确答案: A B
函数模板的实例化是由编译程序在处理函数调用时自动完成的
类模板的实例化必须由程序员在程序中显式地指定
函数模板针对仅参数类型不同的函数
类模板针对仅数据成员和成员函数类型不同的类

解析：
C：函数模版还可以将 函数返回值类型 作为模版参数。
D：类模板还可以针对 继承的基类类型 作为模板参数。

下面（ ）不是数据字典的内容。
正确答案: A
程序
处理逻辑
数据结构
外部实体

解析：
数据字典是指对数据的数据项、数据结构、数据流、数据存储、处理逻辑、外部实体等进行定义和描述。

类所实现的接口以及修饰不可以是（）。
正确答案: D
void
public
abstract
final

解析：
final可以修饰方法，属性，类，就是不能修饰接口，因为final修饰表示不能被继承
final  修饰类不能被继承 ， 修饰变量不能被重新赋值  ，相当于常量 ， 修饰方法不可以被重写。

Vi编辑器中,怎样将字符AAA全部替换成yyy?
正确答案: B
p/AAA/yyy/
s/AAA/yyy/g
i/AAA/yyy/
p/AAA/yyy/h

解析：
sed是非交互式的编辑器。它不会修改文件，除非使用shell重定向来保存结果。默认情况下，所有的输出行都被打印到屏幕上。sed编辑器逐行处理文件（或输入），并将结果发送到屏幕。
sed命令行格式为：
sed [-nefri] ‘command’ 输入文本    
常用选项：
-n∶使用安静(silent)模式。在一般 sed 的用法中，所有来自 STDIN的资料一般都会被列出到萤幕上。但如果加上 -n 参数后，则只有经过sed 特殊处理的那一行(或者动作)才会被列出来。
-e∶直接在指令列模式上进行 sed 的动作编辑；
-f∶直接将 sed 的动作写在一个档案内， -f filename 则可以执行 filename 内的sed 动作；
-r∶sed 的动作支援的是延伸型正规表示法的语法。(预设是基础正规表示法语法)
-i∶直接修改读取的档案内容，而不是由萤幕输出。       
常用命令：
a   ∶新增， a 的后面可以接字串，而这些字串会在新的一行出现(目前的下一行)～
c   ∶取代， c 的后面可以接字串，这些字串可以取代 n1,n2 之间的行！
d   ∶删除，因为是删除啊，所以 d 后面通常不接任何咚咚；
i   ∶插入， i 的后面可以接字串，而这些字串会在新的一行出现(目前的上一行)；
p  ∶列印，亦即将某个选择的资料印出。通常 p 会与参数 sed -n 一起运作～
s  ∶取代，可以直接进行取代的工作哩！通常这个 s 的动作可以搭配正规表示法！例如 1,20s/old/new/g！
g 是行内进行全局替换

采用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是（）
正确答案: D
递归次数与初始数据的排列次序无关
每次划分后，先处理较长的分区可以减少递归次数
每次划分后，先处理较短的分区可以减少递归次数
递归次数与每次划分后得到的分区处理顺序无关

解析：
这道题混淆了递归深度和递归次数，无论是先长还是先短，递归次数是不变的，但递归深度依据给定数据会在O(logN)~O(N)之间变化。
原因是对两部分待排序区间进行递归形成的是二叉树，递归深度取决于二叉树的高度。
如果轴点恰好平分两个待排序部分，那么递归深度达到最优，即O(logN)，但如果轴点使两部分极不平衡，那么二叉树就会退化为单链表，其深度会达到O(N)。
递归次数与各元素的初始排列有关。如果每一次划分后分区比较平衡，则递归次数少；如果划分后分区不平衡，则递归次数多。递归次数与处理顺序无关。

下面程序段执行后的输出结果是（）（□表示一个空格）。

int a=3366；
printf("│%-08d│",a)；

正确答案: C
│-0003366│
│00003366│
│3366□□□□│
输出格式非法

解析：
%-08d表示输出占8个空格的位置，并且左对齐，所以正确的答案是C。
左对齐即右边是空格，-8代表一个八个位置，不是八个空格

在异常处理中，以下描述不正确的有
正确答案: D
try块不可以省略
可以使用多重catch块
finally块可以省略
catch块和finally块可以同时省略

解析：
假如try中有异常抛出，则会去执行catch块，再去执行finally块；假如没有catch 块，可以直接执行finally 块，方法就以抛出异常的方式结束，而finally 后的内容也不会被执行，所以catch 和 finally 不能同时省略。
用try-catch 捕获异常;
用try-finally 清除异常;
用try-catch-finally 处理所有的异常. 三者选一种即可

某线性表中有100000个元素，其中前99990个元素递增有序，则采用（）方法进行递增排序时关键字比较次数最少。
正确答案: B
简单选择排序
直接插入排序
二路归并排序
快速排序

考察的是排序原理和适用场景。
根据题目中的“前99990个元素递增有序”，得出关键字比较次数最少的原理就是这99990个元素不参与比较或者移动等耗时操作。
根据以下对各种排序的思想分析，二路归并和快速排序没有利用大部分为递增序列而不参与比较或者移动的操作，简单排序的时间复杂度大于直接插入排序。所以选B。
简单选择排序思想为在当前待排序数列中选出最小值添加到有序序列中，其移动次数正序为0次，比较次数复杂度O(n2)。
直接插入排序思想为整个排序过程为n-1趟，先将序列中的第一个当成有序子序列，然后从第二个开始逐个进行插入，直至整个序列有序，最好的情况下正序移动次数为0，比较次数为n-1，时间复杂度为O(n)。
二路归并排序初始序列含有n个记录则可以看成n个有序的子序列，每个子序列长度为1；两两合并，得到n/2个长度为2或1的有序子序列，再两两合并，……如此重复，直到得到一个长度为n的有序序列为止。归并时间复杂度O(nlog2n)
快速排序选定一个基准值，通过一趟排序将待排分割成独立的两部分，前一部分均小于或等于基准值，后一部分大于基准值，然后对每个部分继续进行上述的重复操作，直到整个序列有序。最好的情况是基准值能够均衡分为两部分，最坏的就是只得到一个比上一次划分少一个记录的子序列O(n2)

关系规范化中的插入操作异常是指（ ）。
正确答案: D
不该删除的数据被删除
不该插入的数据被插入
应该删除的数据未被删除
应该插入的数据未被插入

删除异常是不该删除的被删除
插入异常是该插入的没插入

未初始化的全局变量放在下面哪个段中（）
正确答案: D
text
data
variable
bss

数据段包括初始化的数据和未初始化的数据（BSS）两部分 。BSS段存放的是未初始化的全局变量和静态变量。

malloc函数进行内存分配是在什么阶段?
正确答案: D
编译阶段
链接阶段
装载阶段
执行阶段

程序占用三种类型的内存：静态内存、栈内存、堆内存； 
静态内存： 
用来保存局部static对象、类static数据成员以及定义在任何函数之外的变量 
栈内存： 
用来保存定义在函数内的非static对象。
分配在静态内存或栈内存中的对象由编译器自动创建和销毁。对于栈对象，仅在其定义的程序块运行时才存在；static对象在使用之前分配，在程序结束时销毁。
堆内存： 
在程序运行时分配。动态对象的生存周期由程序（用户）来控制。

下面哪个测试属于黑盒测试（ ）。
正确答案: B
基本路径测试
等价类划分
判定结构分析
逻辑覆盖测试

黑盒测试方法包括等价类划分法、边界值分析法、错误推测法、因果图法、判定表驱动法、正交试验设计法、功能图法、场景法等。
白盒测试方法有代码检查法、静态结构分析法、静态质量度量法、逻辑覆盖法、基本路径测试法、域测试、符号测试、Z路径覆盖、程序变异。

哪些字段适合建立索引?
正确答案: B C D
在select子句中的字段
外键字段
主键字段
在where子句中的字段

1、表的主键、外键必须有索引；
2、数据量超过300的表应该有索引；
3、经常与其他表进行连接的表，在连接字段上应该建立索引；
4、经常出现在Where子句中的字段，特别是大表的字段，应该建立索引；
5、索引应该建在选择性高的字段上；
6、索引应该建在小字段上，对于大的文本字段甚至超长字段，不要建索引；
7、复合索引的建立需要进行仔细分析；尽量考虑用单字段索引代替：
A、正确选择复合索引中的主列字段，一般是选择性较好的字段；
B、复合索引的几个字段是否经常同时以AND方式出现在Where子句中？单字段查询是否极少甚至没有？如果是，则可以建立复合索引；否则考虑单字段索引；
C、如果复合索引中包含的字段经常单独出现在Where子句中，则分解为多个单字段索引；
D、如果复合索引所包含的字段超过3个，那么仔细考虑其必要性，考虑减少复合的字段；
E、如果既有单字段索引，又有这几个字段上的复合索引，一般可以删除复合索引；
8、频繁进行数据操作的表，不要建立太多的索引；
9、删除无用的索引，避免对执行计划造成负面影响；

下列定义数组的语句中正确的是（）。
正确答案: A C
#define size 10
char str1[size],str2[size+2];

char str[];
int num[‘10’];
int n=5; int a[n][n+2];

解析：
A选项：不用说了，宏替换，没问题；
B选项：非法定义，一维数组必须定义数组元素个数；
C选项：‘10’表示的字符‘0’，转换成十进制为48，所以该选项最终为int num[48]；
D选项：错误，数组定义下角标不能为变量

标识符命名规则：
C/C++标识符命名规则:
1. 所有标识符必须由一个字母(a~z或A~Z)或下划线(_)开头；
2. 标识符的其它部分可以用字母、下划线或数字(0~9)组成；
3. 大小写字母表示不同意义, 即代表不同的标识符，如前面的For和for；
4 标识符不能与C++的关键字相同。如int, double, new, static, define，struct等。 C++的关键字在此不一一列举，可自行查阅
AC都符合命名规则。由于区分大小写，选项B的For不属于关键字，for才是。而D是C/C++的关键字struct，用来定义结构体（结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量）

以下程序是用来计算两个非负数之间的最大公约数：

long long gcd(long long x, long long y) {
    if (y == 0)
        return x;
    else
        return gcd(y, x % y);
}

我们假设x,y中最大的那个数的长度为n，基本运算时间复杂度为O(1)，那么该程序的时间复杂度为()：
正确答案: B
O(1)
O(logn)
O(n)
O(n^2)

求最大公约数用的是辗转相除法（欧几里得算法），所以是O(logn)

语句 scanf("%7.2f",&a);是一个合法的scanf 函数。请问这句话的说法是正确的吗？
正确答案: B
正确
错误

解析：
scanf函数不能控制输入的精度只能控制长度；
printf函数既能控制输出的精度也能控制长度。

SQL Server 支持哪几种备份？
正确答案: A B C D
数据库备份
事务日志备份
差异备份
文件和文件组备份

SQL支持的备份类型有四种：
1、完全数据库备份
2、差异备份或称增量备份
3、事务日志备份
4、数据库文件和文件组备份

下列哪种函数可以定义为虚函数（）
正确答案: B
构造函数
析构函数
内联成员函数
静态成员函数

解析：
虚函数：在某基类中声明为 virtual 并在一个或多个派生类中被重新定 义的成员函数。
虚析构函数是为了解决基类的指针指向派生类对象，并用基类的指针删除派生类对象。
1.构造函数执行时还未创建对象，此时还没有虚函数表。
2.将基类的析构函数声明为虚函数，delete一个指向子类对象的基类指针，实际被执行的是子类的析构函数，而子类的析构函数会自动的调用基类的析构函数，进而保证所有资源都可以释放，防止内存泄露。
3.虚函数不可内联
4.静态成员函数属于类，不属于特定对象，既不会通过虚函数来调用。因为虚函数表位于特定的对象之中

在一般情况下，采用压缩存储后，对称矩阵是所有特殊矩阵中存储空间节约最多的，这样的说法正确吗？
正确答案: B
正确
不正确

解析：
稀疏矩阵，0元素远多于非0元素且非0元素分布没有规律。比如一个矩阵只有零散的两个1，其他元素都是0，那压缩存储的时候只需要记录这两个非0元素的位置（行，列）还有值（1）就可以了，其他元素都是0。
压缩情况下，稀疏矩阵占用内存最少

简单选择排序

简单选择排序原理：在待排序数组中选出最小的(或最大)的与第一个位置的数据交换 然后在剩下的待排序数组中找出最小(或最大)的与第二个位置的数据交换，以此类推，直到第n-1个元素
最好情况下，即待排序记录初始状态就已经是正序排列了，则不需要移动记录。第一次内循环比较N - 1次，然后是N-2次，N-3次，……，最后一次内循环比较1次。(N - 1) + (N - 2) + ... + 1，求等差数列和，得 (N - 1 + 1)* N / 2 = N^2 / 2。舍去最高项系数，其时间复杂度为 O(N2)。

静态局部变量存储在进程的（）。
正确答案: D
栈区
寄存器区
代码区
全局区

解析：
栈区：存放局部变量和函数参数值。
寄存器区：存放register变量
代码区：存放函数体中的二进制代码
全局区：存放全局变量和静态变量
堆区：malloc（C）和new（C++）动态申请的内存

函数 rewind的作用是（）。
正确答案: A
使位置指针重新返回文件的开头
将位置指针指向文件中所要求的特定位置
使位置指针指向文件的末尾
使位置指针自动移至下一个字符位置

解析：
函数名: rewind()
功 能: 将文件内部的位置指针重新指向一个流（数据流/文件）的开头
注意：不是文件指针而是文件内部的位置指针，随着对文件的读写文件的位置指针（指向当前读写字节）向后移动。而文件指针是指向整个文件，如果不重新赋值文件指针不会改变。
rewind函数作用等同于 (void)fseek(stream, 0L, SEEK_SET); [1]
用 法: void rewind(FILE *stream);

C++的虚函数必须是类的一个成员，而不允许是类的友元。
正确答案: A
T
F

解析：
Ｃ＋＋　类的友元：
可以是一个函数，也可以是一个类.
定义在某类外部的函数或类，但是需要在类内部进行说明，为了与该类的成员加以区别，说明前加“friend”关键字即可。
友元可以访问该类中的私有成员，友元的作用在于提高程序的运行效率，但是同时破坏了类的封装性和隐藏性。
C++虚函数：
基类中被 “virtual”关键字修饰的成员函数 ，
在若干个派生类中被重新定义的成员函数，实现多态性。
根据 类的 友元的定义，以及类的虚函数的定义， 答案易得，虚函数必须是类的一个成员。

关于C语言中volatile关键字，下面的说法哪一个是错误的？
正确答案: B
编译器会禁止对volatile修饰的变量进行读写优化
用volatile修饰的变量，读取速度会更快
每一次读取volatile修饰的变量都会从内存中读取

解析：
volatile提醒编译器它后面所定义的变量随时都有可能改变 ，因此编译后的程序每次需要存储或读取这个变量的时候 ，都会直接从变量地址中读取数据。
如果没有volatile关键字，则编译器可能优化读取和存储， 可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的现象。
1> 告诉compiler 不能做任何优化
2> 用volatile 定义的变量会在程序外被改变,每次都必须从内存中读取，而不能重复使用放在***或寄存器中的备份。

有以下程序

main()
{ int a=666,b=888;
  printf("%d\n",a,b);
}

程序运行后的输出结果是( )。
正确答案: B
错误信息
666
888
666,888

解析：
printf函数参数的入栈顺序是从右到左（888先入栈，接着666入栈）。所以从栈里面读取一个数据时，只会读取最后入栈的数据，也即666.

在C++中，要实现动态联编，必须使用（ ）调用虚函数。
正确答案: D
类名
派生类指针
对象名
基类指针

解析：
实现动态联编用父类指针或引用指向子类对象

（）设计模式将抽象部分与它的实现部分相分离。
正确答案: B
Singleton（单例）
Bridge（桥接）
Composite（组合）
Facade（外观）

解析：
1.桥接模式产生原因：同一个类型,有两个变化的维度（两个维度的抽象：一个抽象部分的抽象，一个实现部分的抽象）
Bridge模式是一种抽象与其实现相分离的模式。它主要应用于：当事物是一组变化量，和对这些事物的操作方法(实现)也是一组变化量的情况，也就是说它们都是多变的。
2.组合模式（Composite）属于结构性模式，它描述了对象间的组合关系。对象间常常通过树结构来组织（包含）起来，以实现整体-部分的层次结构。
3.Facade 外观模式，是一种结构型模式，它主要解决的问题是：组件的客户和组件中各种复杂的子系统有了过多的耦合，随着外部客户程序和各子系统的演化，这种过多的耦合面临很多变化的挑战。
4.单例 模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。

类A是类B的友元,类C是类A的公有派生类,忽略特殊情况则下列说法正确的是()
正确答案: B D
类B是类A的友元
类C不是类B的友元
类C是类B的友元
类B不是类A的友元

解析：
(1) 友元关系不能被继承。
(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

有以下表达式：

int a=248, b=4;
int const c=21;
const int *d=&a; 
int *const e=&b;
int const * const f =&a; 

请问下列表达式哪些会被编译器禁止?
正确答案: A B C D
*c=32
*d=43
e=&a
f=0x321f
d=&b
*e=34

解析：
int const c=21;  //变量c的值不能改变
const int *d=&a;  //指针变量d指向的值不能改变
int *const e=&b;  //指针的指向不能改变
int const *f const =&a; //指针不能改变，指针指向的值也不能改变。
选择 A *c = 32;有误  因为c不是指针。
答案 F e=34 是不是有笔误， 如果是*e=34是对的， e=34表示把地址为34的赋值给指针e,就不可以。

顺序表
优点：查找和修改（首先要查找到）效率高，空间占用比链表小，时间复杂度 O(1)
缺点：插入和删除元素时，后面的元素都需要进行移动，编译时确定大小，时间复杂度 O(n)
链表
优点：插入和删除元素比较方便，只需要修改指针，空间大小不必指定，时间复杂度 O(n)
缺点：查询和修改（首先要查找到）效率并不高，而且因为添加了指针等中间数据结构，所以空间占用比顺序表大，时间复杂度 O(1)

8进制数256，转化成7进制数是
正确答案: B
356
336
338
346

解析：
八进制256转换为十进制为174，174/7=24余6，24/7=3余3，3/7=0余3，逆序取余得336

std::vector::iterator重载了下面哪些运算符？
正确答案: A C D

++
>>
>*（前置）
==

解析：
++，--用于双向迭代，迭代器最基本的功能；
*用于复引用迭代器用于引用迭代器对应的元素，也是基本操作；
==用于判断两个迭代器是否相等，迭代的时候需要判断迭代器是否到了某个位置；

77.
调用以下函数，将返回

public static int func()
{
    try
    {
        return 1;
    }
    catch (Exception e)
    {
        return 2;
    } finally
    {
        return 3;
    }
}

正确答案: C
1
2
3
编译错误

解析:
当程序执行到try语句块中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally语句块中的程序.

全局变量可不可以声明在可被多个.C文件包含的头文件中？
正确答案: A
可以
不可以

不使用关键字，在链接时会引发“符号被多重定义”错误；
使用static关键字，定义变为内部链接，此时所谓的全局变量相当于每个c文件的局部变量，没有全局变量的效果；

下面不是面向对象的基本原则的是？
正确答案: C
单一职责原则（Single-Resposibility Principle）
开放封闭原则（Open-Closed principle）
抽象类原则（Abstract-Class principle）
依赖倒置原则（Dependecy-Inversion Principle）
接口隔离原则（Interface-Segregation Principle）

面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP） 
里氏替换原则（LSP） 
依赖倒置原则（DIP） 
接口隔离原则（ISP）

以下叙述中正确的是（）
正确答案: A
int* p1; int ** p2; int *p3;都是合法的定义指针变量的语句
指针变量只能通过求地址运算符（&) 来获得地址值
语句p=NULL;与p=\0;是等价的语句
语句p=NULL;执行后，指针p指向地址为0的存储单元

B 选项描述不正确，指针变量可以通过求地址运算符（ &) 来获得地址值，可以通过指针变量获得地址值，还可以通过标准函数获得地址值； 
C 选项中， p=NULL ；和 p=0 ；或 p='\0' ；等价； 
D 选项中，语句 p=NULL; 执行后，指针 p 并不是指向地址为 0 的存储单元，而是具有一个确定的值 -" 空 " 。因此 A 选项正确。
p=NULL,意思是p没有指向任何地方。既然没有指向任何地方

下列关于虚函数的说法正确的是（）
正确答案: C D
在构造函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效
在析构函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效
静态函数不可以是虚函数
虚函数可以声明为inline

C、静态函数不可以是虚函数
因为静态成员函数没有this，也就没有存放vptr的地方，同时其函数的指针存放也不同于一般的成员函数，其无法成为一个对象的虚函数的指针以实现由此带来的动态机制。静态是编译时期就必须确定的，虚函数是运行时期确定的。
D、虚函数可以声明为inline
inline函数和virtual函数有着本质的区别，inline函数是在程序被编译时就展开，在函数调用处用整个函数体去替换，而virtual函数是在运行期才能够确定如何去调用的，因而inline函数体现的是一种编译期机制，virtual函数体现的是一种运行期机制。
因此，内联函数是个静态行为，而虚函数是个动态行为，他们之间是有矛盾的。
函数的inline属性是在编译时确定的， 然而，virtual的性质则是在运行时确定的，这两个不能同时存在，只能有一个选择，文件中声明inline关键字只是对编译器的建议，编译器是否采纳是编译器的事情。
我并不否认虚函数也同样可以用inline来修饰，但你必须使用对象来调用，因为对象是没有所谓多态的，多态只面向行为或者方法，但是C++编译器，无法保证一个内联的虚函数只会被对象调用，所以一般来说，编译器将会忽略掉所有的虚函数的内联属性。
什么函数不能声明为虚函数？
一个类中将所有的成员函数都尽可能地设置为虚函数总是有益的。
设置虚函数须注意：
1：只有类的成员函数才能说明为虚函数；
2：静态成员函数不能是虚函数；
3：内联函数不能为虚函数；
4：构造函数不能是虚函数；
5：析构函数可以是虚函数，而且通常声明为虚函数。

下面有关vector和list的区别，描述错误的是？
正确答案: D
vector拥有一段连续的内存空间，因此支持随机存取，如果需要高效的随即存取
list拥有一段不连续的内存空间，如果需要大量的插入和删除，应该使用list
vector::iterator支持“+”、“+=”、“<”等操作符
list::iterator则不支持“+”、“+=”、“<”等操作符运算，但是支持了[ ]运算符

vector和built-in数组类似，它拥有一段连续的内存空间，并且起始地址不变，因此它能非常好的支持随即存取，即[]操作符但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当该数组后的内存空间不够时，需要重新申请一块足够大的内存并进行内存的拷贝。这些都大大影响了vector的效率。
list就是数据结构中的双向链表(根据sgi stl源代码)，因此它的内存空间可以是不连续的
通过指针来进行数据的访问，这个特点使得它的随即存取变的非常没有效率，因此它没有提供[]操作符的重载。
但由于链表的特点，它可以以很好的效率支持任意地方的删除和插入。

二分查找方法的思想：将数列按有序化(递增或递减)排列，查找过程中采用跳跃式方式查找，即先以有序数列的中点位置为比较对象，如果要找的元素值小 于该中点元素，则将待查序列缩小为左半部分，否则为右半部分。通过一次比较，将查找区间缩小一半。
最好的情况是：待查关键字刚好位于序列中间，第一次即查到。
最坏的情况是：第一次查找，还剩下n/2个元素需要比较；第二次，还剩n/4……第i次查找，还剩下n/2i个元素需要比较，直到剩余最后一个元素，查找结束。
最后n/2i=1，即n=2i，i为查找的次数（长度），i=log2n

以下程序的输出结果是（ ）。

main()
{ int
a=4,b=5,c=0,d;
d=!a&&!b||!c;
printf("%d\n",d);
}

正确答案: A
1
0
非0的数
-1

!a&&!b||!c
首先求非运算，得0&&0||1
然后求与运算，得0||1
最后求或运算，得1

两个二进制数的异或结果是？
正确答案: D
两数和
两数差
两数差的绝对值
以上都不正确

两个相同的数异或可能为两数差，如 1001 ^ 0101 = 0     (9 - 9 = 0)；
两个不同的数异或可能为两数和，如1001 ^ 0110 = 1111 (9 + 6 = 15)  
两个不同的数异或可也能啥都不是，如1001 ^ 1010 = 0011 (9 10 3)

C库函数中malloc依赖下面哪个系统调用增长堆空间？（）
正确答案: C
open
ioctl
sbrk
write

open：打开和创建文件；
ioctl：设备输入输出操作的系统调用；
sbrk：实现虚拟内存到内存的映射；
write:将数据写入一个打开的文件。

哈夫曼树的结点个数不能是偶数()
正确答案: A
对
错

假设哈夫曼树是二叉的话，则度为0的结点个数为N，度为2的结点个数为N-1，则结点总数为2N-1。
哈夫曼树只有度为0和2的节点。
假设度为0的节点为N，则度为2的节点为N-1；则节点个数为2N-1，始终为奇数

设数据集合为 D={ 1,3,5,7,9 } ， D 上的关系为 R ，下列数据结构 B= （ D ， R ）中为非线性结构的是（ ）。
正确答案: D
R={ (5,1), (7,9), (1,7), (9,3) }
R={ (9,7), (1,3), (7,1), (3,5) }
R={ (1,9), (9,7), (7,5), (5,3) }
R={ (1,3), (3,5), (5,9) }

一个非空的数据结构如果满足以下两个条件：有且只有一个根结点；每一个结点最多有一个前件，也最多有一个后件，则称为线性结构，在数据结构中习惯称为线性表。 A 选项中， 5 为根结点，线性表为 51793 。 B 选项中， 9 为根结点，线性表为 97135 。 C 选项中， 1 为根结点，线性表为 19753 。 D 选项，结点 1 与 7 都是根结点，属于非线性结构，故 D 选项正确。

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算,则利用（）存储方式最节省时间。
正确答案: A
顺序表
双链表
带头结点的双循环链表
单循环链表

因为该线性表最常用的操作是“存取任一指定序号的元素和在最后进行插入和删除运算“。要想以最快的速度”存取任一指定序号的元素“，顺序存储方式最合适（随机存取）；另外，该线性表经常”在最后进行插入和删除运算“，顺序存储方式也挺合适；故，线性表的顺序存储方式（顺序表）最节省时间。

拓扑排序运算只能用于（ ）
正确答案: C
带权有向图
连通无向图
有向无环图
无向图

只有有向无环图才可以进行拓扑排序,拓扑排序因此能够被用来检测有向图是否有环。由一个集合上的一个偏序来得到集合上的一个全序。所以只能用在有向图中，且如果有向图存在环的话也无法得到图的所有节点，所以拓扑排序只能用在无环有向图中。

不合法的main函数命令行参数表示形式是__________
正确答案: C
main( int a, char *c[])
main(int arc, char **arv)
main(int argc, char *argv)
main( int argv, char *argc[])

argc（argument count，参数数目）表示命令行参数的数目，通常不用具体指明，编译器将会根据用户的参数输入自动确定。
argv（argument vector，参数向量）表示参数列表，是一个指针数组（每个参数都是按指针传入）。所以，argv有三种形式，分别是A、B、D三个选项。故C错误

二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值，这样的说法正确吗？
正确答案: B
正确
不正确

二叉排序树（Binary Sort Tree）又称二叉查找树.它或者是一棵空树；或者是具有下列性质的二叉树：
（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值； 
（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值； 
（3）左、右子树也分别为二叉排序树

如有定义：char str[20];，能将从键盘输入的字符串“How are you”保存到 str 数组的语句是（ ）
正确答案: C
scanf("%s", str);
str[] = getch();
gets(str);
str = gets();

因为scanf不能输入空格，而gets函数却可以gets(字符数组名或指针)gets能够接受空格、制表符Tab和回车等。gets和sacnf函数，在字符串接受结束后自动加'\0'

按排序过程中依据的原则分类，快速排序属于（ ）。
正确答案: C
插入类的排序方法
选择类的排序方法
交换类的排序方法
归并类的排序方法

快速排序属于交换类排序。
交换类：快排，冒泡
插入类：希尔，直接插入
选择：堆排序，简单选择
归并类：二路/多路归并

有如下程序，输入数据：12345M678＜cR＞后（表示回车），x的值是（） 。

#include<stdio.h>
int main()
{
int x;
float y;
scanf("%3d%f",&x,&y);
}

正确答案: B
12345
123
45
345

scanf确实可以设置输入整数的宽度，%3d表示取三位整数；
printf也可以设置输出整数的宽度，%3d表示输出至少3位，假如超过3位，有多少输出多少。

用不带头结点的单链表存储队列,其队头指针指向队头结点,队尾指针指向队尾结点,则在进行出队操作时()
正确答案: C
仅修改队头指针
仅修改队尾指针
队头、队尾指针都可能要修改
队头、队尾指针都要修改

当队列中只有一个元素时，出队后需要清空对头和队尾指针。
多于一个元素时，只需要修改对头指针就行了，head->next;
但当只有一个元素时，head==rear，此时出队的话，队列就会变成空，需要同时修改对头和队尾指针，不然会超出边界。

假设以数组A[60]存放循环队列的元素,其头指针是front=47,当前队列有50个元素,则队列的尾指针值为()
正确答案: B
3
37
97
50

队列中元素的个数： (rear-front+QueueSize)%QueueSize
根据题意得：（rear - 47  + 60）% 60 = 50
=>    rear = 37   选B

题目来源于王道论坛
下列排序算法中，元素的移动次数与关键字的初始排列次序无关的是 。
正确答案: C
直接插入排序
起泡排序
基数排序
快速排序

基数排序不需要进行记录关键字间的比较，是一种借助于多关键字排序的思想对单逻辑关键字进行排序的方法。

判断下列说法是否正确：F=(a,F)是一个递归的广义表，它的深度是1,长度是2。( ）
正确答案: B
正确
错误

广义表是由n个元素组成的序列，n是广义表的长度。
广义表的深度： 广义表中括号的最大层数叫广义表的深度。
F=(a,F)的长度为2，由于属于递归表，所以深度为无穷，F相当于一个无限的表(a,(a,(a,(...))))。

下列关于数组与指针的区别描述正确的是？
正确答案: B
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。
用运算符sizeof 可以计算出数组的容量（字节数）
指针可以随时指向任意类型的内存块。
用运算符sizeof 可以计算出指针所指向内容的容量（字节数）

A.堆上创建动态数组
B.sizeof(数组名)就是数组的容量
C.const指针不可以
D. char* str = "hello"; sizeof(str)不能计算出内容的容量，只是指针的容量。

下列叙述中正确的是（ ）。
正确答案: A
在栈中，栈顶指针的动态变化决定栈中元素的个数
在循环队列中，队尾指针的动态变化决定队列的长度
在循环链表中，头指针和链尾指针的动态变化决定链表的长度
在线性链表中，头指针和链尾指针的动态变化决定链表的长度

在链式存储结构中，无论是循环链表还是线性链表，插入和删除元素时，只需要改变相应位置的结点指针即可，头指针和尾指针无法确定链表的长度。
B：应该是队尾和对头指针共同决定
C、D：如果中间插入和删除，并不影响头指针和尾指针

在链队列中,即使不设置尾指针也能进行入队操作()
正确答案: A
对
错

若使用不设置尾指针的链表作为链队列的存储结构，在进行入队操作的时候需要遍历整个链队列至队尾，然后在进行插入。这当然是可行的，只是效率有所下降。 如果只使用一个指针又要保持效率的话，可以使用只带尾指针的循环单链表作为存储结构，这样出队和入队的开销都是O(1)。

一组记录的排序码为（46，79，56，38，40，84），一趟排序的结果为（40，38，46，56，79，84），则采用的是（）排序算法。
正确答案: C
起泡
直接插入
快速
2-路归并

A选项起泡算法：相邻元素两两比较，一个元素大于右侧相邻元素交换位置，否则位置不变。
一趟排序为：46，56，38，40，79，84
B选项直接插入：每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
一趟排序为：38，40，46，79，56，84
C选项快速：挑选一个基准元素，大于基准元素的放在其右边，小于基准元素的放在其左边，从而拆分为两部分，以此类推直到不可拆分为止。
以源数据第一个元素46为基准，采用双边循环法设置left和right两个指针指向数组最左和最右两端，从右指针开始，如果大于或等于基准元素则指针向左移动，如果小于基准元素则停止。转向left指针向右移动如果小于或等于基准元素则继续向右移动，如果大于基准元素则停止。交换两指针元素后，右指针继续上述操作比较，直到最后把基准元素和两指针重复元素交换位置。第一趟排序结束得出如下排序，所以C正确。
一趟排序为：40，38，46，56，79，84
D选项2-路归并：将一个数组分成两个数组，分别对两个数组进行排序，循环第一步，直到划分出来的“小数组”只包含一个元素，只有一个元素的数组默认为已经排好序
一趟排序为：46，56，79合并；38，40，84合并

循环队列的存储空间为 Q(1:40) ，初始状态为 front=rear=40 。经过一系列正常的入队与退队操作后， front=rear=15 ，此后又退出一个元素，则循环队列中的元素个数为（ ）
正确答案: A
39，或0且产生下溢错误
14
40
15

front==rear代表着队列满，或者空。然后又退出去了一个数据，所以当为空的时候，就会产生下溢。为满的时候，就是总个数-1也就是39个
发表于 2017-03-09 15:03:10

在快速排序中，要使最坏情况的空间复杂度为O(log2n )则要对快速排序作( )修改。
正确答案: A
划分元素为三者取中
采用表排序
先排最小集合
先排大集合

快速排序的思想：
先从数列中取出一个数作为基准数
分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边
再对左右区间重复第二步，直到各区间只有一个数
最优的情况下空间复杂度为：O(log2n)  ；每一次都平分数组的情况，基准数尽量为中间数。

派生类中虚函数原型的（）。
正确答案: D
函数类型可以与基类中虚函数的原型不同
参数个数可以与基类中虚函数的原型不同
参数类型可以与基类中虚函数的原型不同
以上都不对

c ++规定虚函数在派生类中重新定义时，其函数原型，包括函数类型、函数名、参数个数、参数类型的顺序，都必须与基类中的原型完全相同

邻接矩阵存储有n个结点(0,1,…,n)和e条边的有向图(0≤e≤n(n-1))。在邻接矩阵中删除结点i(0≤i≤n-1)的时间复杂度是（）
正确答案: B
O(1)
O(n)
O(e)
O(n+e)

8.
关于类模板的说法正确的是（）
正确答案: B
类模板的主要作用是生成抽象类
类模板实例化时，编译器根据给出的模板实参生成一个类
在类模板中的数据成员具有同样类型
类模板中的成员函数没有返回值

A，可以生成非抽象类
B，类是对象的抽象，类模板可以说是类的抽象，用以生成一个类
C，类模板与普通类一样，可以使用任意数据类型
D，不正确，可以有返回值

在排序方法中，元素比较次数与元素的初始排列无关的是（）
正确答案: D
Shell 排序
归并排序
直接插入排序
选择排序

10.
如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是：
正确答案: D
一元运算符
二元运算符
选项A）和选项B）都可能
重载错误

友元函数重载时,参数列表为1,说明是1元,为2说明是2元
成员函数重载时,参数列表为空,是一元,参数列表是1,为2元
友元函数重载运算符时，因为没有this指针指向对象，因此参数个数保持和原来一样，运算符至少有一个参数

逻辑数据独立性是指修改（ ） 。
正确答案: C
内模式保持模式不变
外模式保持模式不变
模式保持外模式不变
模式保持内模式不变

逻辑独立性是外模式不变，模式改变时，如增加新的关系，新的属性，改变属性的数据类型，由数据库管理员对各个外模式/模式的映像做相应改变，可以使得外模式不变，因为应用程序依据外模式编写的，所以外模式不变，应用程序也不变，即保证了逻辑独立
物理独立性是模式不变，内模式改变，如数据库存储结构发生改变，选用另一种数据结构，由数据库管理员对各个模式/内模式的映像做相应改变，可以使得模式不变 ，从而保证了应用程序也不变