【计算机类职业资格】程序员面试-1及答案解析.doc

《【计算机类职业资格】程序员面试-1及答案解析.doc》由会员分享，可在线阅读，更多相关《【计算机类职业资格】程序员面试-1及答案解析.doc（28页珍藏版）》请在麦多课文档分享上搜索。

1、程序员面试-1 及答案解析(总分：100.00，做题时间：90 分钟)一、论述题(总题数：28，分数：100.00)1.static(静态)变量有什么作用 （分数：3.00）_2.const 有哪些作用 （分数：3.00）_3.switch 语句中的 case 结尾是否必须添加 break 语句?为什么 （分数：3.00）_4.volatile 在程序设计中有什么作用 （分数：3.00）_5.断言 ASSERT()是什么 （分数：3.00）_6.枚举变量的值如何计算 （分数：3.00）_7.char str1=“abc“;char str2=“abc“;str1 与 str2 不相等，为什么

2、（分数：3.00）_8.为什么有时候 main()函数会带参数?参数 argc 与 argv 的含义是什么 （分数：3.00）_9.C+里面是不是所有的动作都是 main()函数引起的 （分数：3.00）_10.*p+与(*p)+等价吗?为什么 （分数：3.00）_11.前置运算与后置运算有什么区别 （分数：3.00）_12.a 是变量，执行(a+)+=a 语句是否合法 （分数：3.00）_13.如何进行 float、bool、int、指针变量与“零值”的比较 （分数：4.00）_14.new/delete 与 malloc/free 的区别是什么 （分数：4.00）_15.什么时候需要将引用

3、作为返回值 （分数：4.00）_16.变量名为 618Software 是否合法 （分数：4.00）_17.C 语言中，整型变量 x 小于 0，是否可知 x2 也小于 0 （分数：4.00）_18.exit(status)是否跟从 main()函数返回的 status 等价 （分数：4.00）_19.已知 String 类定义，如何实现其函数体 （分数：4.00）_20.在 C+中如何实现模板函数的外部调用 （分数：4.00）_21.在 C+上中，关键字 explicit 有什么作用 （分数：4.00）_22.C+中异常的处理方法以及使用了哪些关键字 （分数：4.00）_23.如何定义和实现一

4、个类的成员函数为回调函数 （分数：4.00）_24.内存分配的形式有哪些 （分数：4.00）_25.什么是内存泄露 （分数：4.00）_26.栈空间的最大值是多少 （分数：4.00）_27.什么是缓冲区溢出 （分数：4.00）_28.sizeof 是关键字吗 （分数：4.00）_程序员面试-1 答案解析(总分：100.00，做题时间：90 分钟)一、论述题(总题数：28，分数：100.00)1.static(静态)变量有什么作用 （分数：3.00）_正确答案：()解析：在 C 语言中，关键字 static 的意思是静态，它有 3 个明显的作用： 1)在函数体内，静态变量具有“记忆”功能，即一个

5、被声明为静态的变量在这一函数被调用的过程中其值维持不变。 2)在模块内(但在函数体外)，它的作用域范围是有限制的，即如果一个变量被声明为静态的，那么该变量可以被模块内所有函数访问，但不能被模块外其他函数访问。它是一个本地的全局变量，如果一个函数被声明为静态的，那么该函数与普通函数作用域不同，其作用域仅在本文件中，它只可被这一模块内的其他函数调用，不能被模块外的其他函数调用，也就是说这个函数被限制在声明它的模块的本地范围内使用。 3)内部函数应该在当前源文件中说明和定义，对于可在当前源文件以外使用的函数，应该在一个头文件中说明，使用这些函数的源文件要包含这个头文件。 具体而言，static 全局

6、变量和普通的全局变量的区别在于 static 全局变量只初始化一次，这样做的目的是为了防止在其他文件单元中被引用。static 局部变量和普通局部变量的区别在于 static 局部变量只被初始化一次，下一次的运算依据是上一次的结果值。static()函数与普通函数的区别在于作用域不一样，static()函数只在一个源文件中有效，不能被其他源文件使用。 C+中，在类内数据成员的声明前加上关键字 static，该数据成员就是类内的静态数据成员。静态数据成员有以下特点： 1)对于非静态数据成员，每个类对象都有自己的复制品。而静态数据成员被当做是类的成员。无论这个类的对象被定义了多少个，静态数据成员在

7、程序中也只有一份复制品，由该类型的所有对象共享访问。 2)静态数据成员存储在全局数据区。定义时要分配空间，所以不能在类声明中定义。由于静态数据成员属于本类的所有对象共享，所以它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，程序员也可以使用它。 3)静态数据成员和普通数据成员一样遵从 public、protected、private 访问规则。 4)static 成员变量的初始化是在类外，此时不能再带上 static 的关键字。private、protected 的static 成员虽然可以在类外初始化，但是不能在类外被访问。 与全局变量相比，使用静态数据成员有以

8、下两个优势： 1)静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其他全局名字冲突的可能性。 2)可以实现信息隐藏。静态数据成员可以是 private 成员，而全局变量不能。 需要注意的是，类的静态成员必须初始化，因为它是在程序初始化的时候分配的。类中只是声明，在 cpp中才是初始化，可以在初始化的代码上放个断点，在程序执行 main()的第一条语句之前就会先走到那儿。如果静态成员是个类，那么就会调用到它的构造函数。 与静态数据成员一样，当类的成员函数前面添加了 static 关键字后就变为了类的静态成员函数，静态成员函数为类的全部服务而不是为某一个类的具体对象服务。静态成员函数是类

9、的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个 this 指针，this 指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this 是默认的。如函数 fn()实际上是 this-fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有 this 指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，只能调用其余的静态成员函数。 引申 1：为什么 static 变量只初始化一次? 对于所有的对象(不仅仅是静态对象)，初始化都只有一次，而由于静态变量具有“记忆”功能，初始化后，一直没有被销

10、毁，而是保存在内存区域中，所以不会再次初始化。 存放在静态区的变量的生命周期一般比较长，一般与整个源程序“同生死、共存亡”，所以它只需初始化一次。而 auto 变量，即自动变量，由于存放在栈区，一旦调用过程结束，就会立刻被销毁。 分析以下程序代码： #includestdio.h int main() fun(0); fun(1); fun(2); return 0; 程序输出为 0 0 0 程序每次输出都为 0，是因为 value 是静态类型(static)，只会定义一次。也就是说，不管调用 fun()这个函数多少次，static int value=i+这个定义语句只会在第一次调用的时候执

11、行，由于第一次执行的时候 i=0，所以 value 也就被初始化成 0 了，以后调用 fun()都不会再执行这条语句的。 分析以下一段代码： #includestdio.h void fun(int i) static int value=i+: value=i+: printf(“%d/n“,value); int main() fun(0); fun(1); fun(2); return 0; 程序输出为 1 1 2 上述代码之所以输出为 1,1,2,是因为当调用 fun(0)时，由于 value 被声明为 static，所以定义语句只执行一次，此时 value=i+，value 的值为

12、0，i 的值变为 1，执行第二行语句 value=i+后，此时 value 的值为 i 的初值为 1，接着 i 的值变为 2，所以第一次输出为 1。当调用 fun(1)时，因为 value 是静态变量，具有记忆功能，所以会跳过定义语句，只执行 value=i+语句，所以 value 的值为 1，而此时 i 的值变为2，所以第二次调用时输出为 1。当调用 fun(2)的时候，也会跳过定义语句，只执行 value=i+语句，所以 value 的值为 2，i 的值变为 3，所以第三次调用时输出为 2。 引申 2：在头文件中定义静态变量，是否可行?为什么? 不可行，如果在头文件中定义静态变量，会造成资

13、源浪费的问题，同时也可能引起程序错误。因为如果在使用了该头文件的每个 C 语言文件中定义静态变量，按照编译的步骤，在每个头文件中都会单独存在一个静态变量，从而会引起空间浪费或者程序错误。 所以不推荐在头文件中定义任何变量，当然也包括静态变量。2.const 有哪些作用 （分数：3.00）_正确答案：()解析：常类型也称为 const 类型，是指使用类型修饰符 const 说明的类型。const 是 C 和 C+中常见的关键字，在 C 语言中，它主要用于定义变量为常类型以及修饰函数参数与返回值，而在 C+中还可以修饰函数的定义，定义类的成员函数。常类型的变量或对象的值是不能被更新的。 一般而言，

14、const 有以下几个方面的作用： 1)定义 const 常量，具有不可变性。例如： const int MAX=100; int ArrayMAX; 2)进行类型检查，使编译器对处理内容有更多的了解，消除了一些隐患。例如：voidf(const int i).编译器就会知道 i 是一个常量，不允许修改。 3)避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。同宏定义一样，可以做到不变则已，一变都变。如 1)中，如果想修改 MAX 的内容，只需要定义 constint MAX=期望值即可。 4)保护被修饰的东西，防止被意外的修改，增强了程序的健壮性。上例中，如果在函数体内修改了变量

15、 i的值，那么编译器就会报错。例如： void f(const int i) i=10: 上述代码对 i 赋值会导致编译错误。 5)为函数重载提供参考。 class A void f(int i) . 定义一个函数 void f(int i) const . 上一个函数的重载 6)节省空间，避免不必要的内存分配。例如： #define PI 3.14159 该宏用来定义常量 const doulbe Pi=3.14159; 此时并未将 Pi 放入只读存储器中 double i=Pi; 此时为 Pi 分配内存，以后不再分配 double I=PI; 编译期间进行宏替换，分配内存 double i

16、=Pi; 没有内存分配 double J=PI: 再次进行宏替换，又一次分配内存 const 定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是像#define 一样给出的是立即数，所以 const 定义的常量在程序运行过程中只有一份复制品，而#define 定义的常量在内存中有若干个复制品。 7)提高了程序的效率。编译器通常不为普通 const 常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。 引申 1：什么情况下需要使用 const 关键字? 1)修饰一般常量。一般常量是指简单类型的常量。这种常量在定义时，修

17、饰符 const 可以用在类型说明符前，也可以用在类型说明符后。 例如：int const x=2 或 const int x=2。 2)修饰常数组。定义或说明一个常数组可以采用如下格式： int const a8=1,2,3,4,5,6,7,8; const int a 8=1,2,3,4,5,6,7,8; 3)修饰常对象。常对象是指对象常量，定义格式如下： class A; const A a: A const a: 定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符 const 可以放在类名后面，也可以放在类名前面。 4)修饰常指针。 const int *A:const 修

18、饰指向的对象，A 可变，A 指向的对象不可变 int const *A:const 修饰指向的对象，A 可变，A 指向的对象不可变 int *const A:const 修饰指针 A，A 不可变，A 指向的对象可变 const int *const A;指针 A 和 A 指向的对象都不可变 5)修饰常引用。使用 const 修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下： const double 6)修饰函数的常参数。const 修饰符也可以修饰函数的传递参数，格式如下： void Fun(const int Var); 告诉编译器 var 在函数体

19、中的无法改变，从而防止了使用者一些无意的或错误的修改。 7)修饰函数的返回值。const 修饰符也可以修饰函数的返回值，返回值不可被改变，格式如下： const int Fun1(); const MyClass Fun2(); 8)修饰类的成员函数。const 修饰符也可以修饰类的成员函数，格式如下： class ClassName public: int Fun() const; ; 这样，在调用函数 Fun()时就不能修改类或对象的属性。 9)在另一连接文件中引用 const 常量。使用方式有： extem const int i: extern const int j=10; 第一种用

20、法是正确的；而第二种用法是错误的，常量不可以被再次赋值。另外，还要注意，常量必须初始化，如 const int i=5。 引申 2：什么是常引用? 常引用也称为 const 引用。之所以引入常引用，是为了避免在使用变量的引用时，在毫不知情的情况下改变了变量的值，从而引起程序错误。常引用主要用于定义一个普通变量的只读属性的别名，作为函数的传入形参，避免实参在调用函数中被意外地改变。 const 引用的意思是指向 const 对象的引用，非 const 引用表示指向非 const 类型的引用。如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。常引用声明方式：

21、const 类型标识符 const double 如果对第 1)种使用方法进行相应的改造，也可以变为合法，例如： const int ival=1024; 1)const int 2)int 在上例中，第 1)种方法的引用是合法的，而第 2)种方法的引用是非法的。上例中，可以读取 refVal 的值，但是不能修改它，因为 refVal 的类型是 const，任何对 refVal 的赋值都是不合法的(const 引用是只读的，常量即不能作为左值的量，定义式中赋初值除外)。同时，const 引用可以初始化为不同类型的对象或者初始化为右值，如字面值常量，而非 const 引用只能绑定到与该引用同类型

22、的对象。例如，下述 const 引用都是合法的。 inti=42; const int const int 在使用 const 引用进行函数调用的时候，需要注意一个问题，例如下面函数声明： void bar(string 那么下面的表达式将是非法的： bar(“hello world“); 程序示例如下： #includeiostream #includestring using namespace std; void bar(string int main() bar(“hello world“); return 0; 程序输出为 hello world 原因在于“hello world”串

23、会产生一个临时对象，而在 C+中，临时对象是 const 类型的。因此上面的表达式就试图将一个 const 类型的对象转换为非 const 类型，这是非法的。引用型参数应该在能被定义为const 的情况下，尽量定义为 const。3.switch 语句中的 case 结尾是否必须添加 break 语句?为什么 （分数：3.00）_正确答案：()解析：一般必须在 case 语句结尾添加 break 语句。因为一旦通过 switch 语句确定了入口点，从入口点的case 语句开始一直往下执行，除非遇到关键字 break，否则会执行满足这个 case 之后的其他 case 语句，直到 switch

24、结束或者遇到 break 为止。如果在 switch 中省略了 break 语句，那么匹配的 case 值后的所有情况(包括 default 情况)都会被执行。 程序代码如下： #includestdio.h int main() int i; for(i=0;i3;i+) switch(i) case 0: printf(“%d/n,i); case 2: printf(“%d/n“,i); default: printf(“%d/n“,i); return 0; 输出为 0 0 0 1 2 2 case 0 的时候执行 3 次打印，case 1 的时候执行一次 default，case 2

25、 的时候执行两次打印。如果将case 2 后面添加 break 语句，则最后输出为 0012，因为此时 case 0 执行两次，case1 执行一次default，case 2 执行一次。 需要注意的是，switch(c)语句中 c 可以是 int、long、char、unsigned int 等类型，唯独不可以是float 类型。4.volatile 在程序设计中有什么作用 （分数：3.00）_正确答案：()解析：编译器优化的时候可能会出现问题，如当遇到多线程编程时，变量的值可能因为别的线程而改变了，而该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。例如，在本次线程内

26、，当读取一个变量时，为提高存取速度，编译器优化过程中有时会先把变量读取到一个寄存器内；当以后再取变量值时，就直接从寄存器中取值；当变量值在本线程里改变时，会同时把变量的新值复制到该寄存器中，以便保持一致。 volatile 是一个类型修饰符(type specitier)，它用来修饰被不同线程访问和修改的变量。被 volatile类型定义的变量，系统每次用到它的时候都是直接从对应的内存当中提取，而不会利用 cache 中的原有数值，以适应它的未知何时会发生的变化，系统对这种变量的处理不会做优化。所以，volatile 一般用于修饰多线程间被多个任务共享的变量和并行设备硬件寄存器等。 对于 vo

27、latile 关键字的作用，可以通过在代码中插入汇编代码，测试有无 volatile 关键字对程序最终代码的影响。 首先建立一个 voltest.cpp 文件，输入下面的代码： #includestdio.h int main() int i=10; int a=i; printf(“i=%d/n“,a);下面汇编语句的作用是改变内存中 i 的值，但是又不让编译器知道 _asm mov dword ptr ebp-4,20h int b=i; printf(“i=%d/n“,b); return 0; 在 debug 调试版本模式运行程序，输出结果如下： i=10 i=32 在 release

28、 版本模式运行程序，输出结果如下： i=10 i=10 输出的结果明显表明，在 release 模式下，编译器对代码进行了优化，第二次没有输出正确的 i 值。把 i的声明加上 volatile 关键字，程序实例如下： #includestdio.h int main() volatile int i=10; int a=printf(“i=%d/n“,a);下面汇编语句的作用是改变内存中 i 的值，但是又不让编译器知道 printf(“i=%d/n“,a);下面汇编语句的作用是改变内存中的值，但是又小让编译器知道 _asm mov dword ptr ebp-4,20h int b=i; pr

29、intf(“i=%d/n“,b); return 0; 分别在 debug 调试版本和 release 发布版本运行程序，输出如下所示： i=10 i=32 一个定义为 volatile 的变量是指这个变量可能会被意想不到地改变，这样编译器就不会去假设这个变量的值了。准确地说，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值(From Memory)，而不是使用保存在寄存器里的备份。5.断言 ASSERT()是什么 （分数：3.00）_正确答案：()解析：ASSERT()一般被称为断言，它是一个调试程序时经常使用的宏。它定义在assert.h头文件中，通常用于判断程序中是否出现了非法

30、的数据，在程序运行时它计算括号内的表达式的值。如果表达式的值为 false(0)，程序报告错误，终止运行，以免导致严重后果，同时也便于查找错误；如果表达式的值不为 0，则继续执行后面语句。在此需要强调一点，ASSERT()捕获的是非法情况，而非错误情况，错误情况是必然存在的，并且一定需要作出相应的处理，而非法情况则不是，它可能只是漏洞而已。 其用法如下： ASSERT(n!=0); k=10/n; 需要注意的是，ASSERT()只在 Debug 版本中有，编译的 Release 版本则被忽略。还需要注意的一个问题是ASSERT()与 assert()的区别，ASSERT()是宏，而 asser

31、t()是 ANSIC 标准中规定的函数，它与 ASSERT()的功能类似，但是可以应用在 Release 版本中。 使用 assert()的缺点是，频繁的调用会极大地影响程序的性能，增加额外的开销。在调试结束后，可以通过在包含#include assert.h的语句之前插入#define NDEBUG 来禁用 assert()调用，示例代码如下：#includestdio.h #define NDEBUG #include assert.h 对于 assert()的使用，需要注意以下几个方面： 1)在函数开始处检验传入参数的合法性。例如： assert(nNewSize=0); assert(

32、nNewSize=MAX_BUFFER_SIZE); 2)每个 assert()一般只检验一个条件，而不对多个条件进行检验，因为同时检验多个条件时，如果断言失败，则无法直观地判断是哪个条件失败。例如，assert(nOffset=0i+。 4)并非所有的 assert()都能代替过滤条件，对于有的地方，assert()无法达到条件过滤的目的。 5)一般在编程的时候，为了形成逻辑和视觉上的一致性，会将 assert()与后面的语句之间空一行来隔开。6.枚举变量的值如何计算 （分数：3.00）_正确答案：()解析：对如下程序实例进行分析。 #includestdio.h int main() en

33、uma,b=5,c,d=4,e); printf(“%d%d%d%d%d/n“,a,b,c,d,e); return 0; 程序输出为 0 5 6 4 5 为什么 c 的值为 6 呢?其实，在枚举中，某个枚举变量的值默认为前一个变量的值加 1，而如果第一个枚举变量没有被赋值，则其默认值为 0。所以在上例中，a，b，c，d，e 的值分别为 0，5，6，4，5，其中b 与 e 的值都为 5，从这个例子中还可以看出枚举变量值是可以重复的。7.char str1=“abc“;char str2=“abc“;str1 与 str2 不相等，为什么 （分数：3.00）_正确答案：()解析：两者不相等。因为

34、 str1 和 str2 都是字符数组，每个都有自己的存储区，它们的值是各存储区的首地址。但有些情况却不一样，程序示例如下： #includeiostream using namespace std; int main() const char str3=“abc“; const char str4=“abc“; const char* str5=“abc“; const char* str6=“abc“; coutboolalpha(str3=str4)endl; coutboolalpha(str5=str6)endl; return 0; 程序输出为 false true 为什么上面程序

35、示例的输出结果不都是 false 呢?上例中，str3 和 str4 两个字符数组都存储在栈空间上，但两者地址值不相等。而 str5 和 str6 并非字符数组而是字符指针，并不分配存储区，其后的“abc”以常量形式存于常量区，str5 和 str6 是指它们指向的地址的首地址，而它们自己仅是指向该区首地址的指针，所以相等( printf(“该命令一共有%d 个参数:/n“,argc-1); for(count=1;countargc;count+) printf(“%d:%s/n“,count,argvcount); return 0; 编译运行，在命令行输入 c I love you 回车

36、，下面是运行该程序的结果： 该命令一共有 3 个参数： 1: I 2: love 3: you 在本例中，程序从命令行中接受了 4 个字符串(此处包括程序名)，并将它们存储在字符串数组中，其中argv0表示 a(程序名)，argv1对应字符串 I，argV2对应字符串 love，argv3对应字符串you。argc 的值为参数的个数，程序自动统计。 同时需要注意，一个 C 语言程序总是从 main()函数开始执行的。9.C+里面是不是所有的动作都是 main()函数引起的 （分数：3.00）_正确答案：()解析：不是。对于 C+程序而言，静态变量、全局变量、全局对象的分配早在 main()函数

37、之前就已经完成了。所以并不是所有的动作都是由 main()引起的，只有编译器是由 main()开始执行的，main()只不过是一个约定的函数入口，在 main()函数中的显示代码执行之前，会调用一个由编译器生成的_main()函数，而_main()函数会进行所有全局对象的构造及初始化工作。 以如下程序示例代码为例： class A; A a; int main() . 程序在执行时，首先初始化全局变量，当这个变量是一个对象时，则会调用该对象的构造函数，所以上例中，a 的构造函数先执行，然后再执行 main()函数。C+中并非所有的动作都是 main()引起的。 怎样在 main()函数退出之后

38、再执行一段代码?答案依然是全局对象，当程序退出时，全局变量必须销毁，自然会调用全局对象的析构函数，所以剩下的就同构造函数一样了。10.*p+与(*p)+等价吗?为什么 （分数：3.00）_正确答案：()解析：在回答这个问题前，必须弄明白一个问题，就是 C 语言中操作符的优先级问题。在 C 语言中，优先级由高到低的排序主要遵循如下规则： 1)函数符号()，数组下标，数组下标符号.，成员符号-，结合性从左往右。 2)单目运算符：!，+，-，-(type)*， a=10; b=a+; c=+a; d=10*a+; printf(“%d/n%d/n%d/n%d/n”,a,b,c,d); return 0; 程序输出为 13 10 12 120 上例中，首先赋值 a 为 10，然后执行 b=a+语句，由于后置操作符的特性，所以首先执行 b=a 操作，即 b的值为 10，然后执