(各个公司面试原题)在线做了一套C/C++综合测试题，也来测一下你的水平吧(二)

刚才把最后的10道题又看了下，也发上来吧。

下面给出试题，和我对题目的一些理解

以下题目出自 牛客网

前10道题地址

在线做了一套C/C++综合测试题，也来测一下你的水平吧(一)

11.设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？

[cpp] view
plaincopy

1. C c;
2. void main()
3. {
4. A*pa=new A();
5. B b;
6. static D d;
7. delete pa;
8. }

• A B C D
• A B D C
• A C D B
• A C B D

答案：B

c是全局变量，a、b是局部变量，d是静态的局部变量

先构造的后析构，静态的局部变量d在main函数结束时析构，全局变量c在程序结束时析构。

语句

[cpp] view
plaincopy

1. delete pa;

使得a先于b析构

附图

12.

若char是一字节，int是4字节，指针类型是4字节，代码如下：

[cpp] view
plaincopy

1. class CTest
2. {
3. public:
4. CTest():m_chData(‘\0’),m_nData(0)
5. {
6. }
7. virtual void mem_fun(){}
8. private:
9. char m_chData;
10. int m_nData;
11. static char s_chData;
12. };
13. char CTest::s_chData=’\0’;

问：

（1）若按4字节对齐sizeof(CTest)的值是多少？

（2）若按1字节对齐sizeof(CTest)的值是多少？

请选择正确的答案。

• 16 4
• 16 10
• 12 9
• 10 10

答案：C

首先，分析类
CTest中占存储空间的变量和函数

变量：char型变量占1个字节，int型变量占4个字节，sizeof(CTest)所求得的长度不包含static变量的字节数

函数：类的普通函数在实例化时才分配内存空间，虚函数(不论多少个)则维护一个指针指向的虚函数表，指针占4个字节

所以，

若4字节对齐，则
4(int)+4(长度为1字节的char)+4(指向虚函数表的指针)=12

若1字节对齐，则
4(int)+1(长度为1字节的char)+4(指向虚函数表的指针)=9

13.

在Java中，以下关于方法重载和方法重写描述正确的是？

• 方法重载和方法的重写实现的功能相同
• 方法重载出现在父子关系中，方法重写是在同一类中
• 方法重载的返回值类型必须一致，参数项必须不同
• 方法重写的返回值类型必须相同。（或是其子类）

答案：D

这题的关键是分清方法重载和方法重写的概念。

要注意的是，可重载的方法，需要以下条件

1.方法名相同

2.方法参数个数不同 || 方法参数个数相同但至少有一对对应参数的类型不同

3.与返回值无关

而可重写的方法都是继承过来的，为维护一致性，返回值类型必然需要相同

14.

下列给定程序中，函数fun的功能是:求ss所指字符串数组中长度最短的字符串所在的行下标，作为函数值返回，并把其串长放在形参n所指的变量中。ss所指字符串数数组中共有M个字符串，且串长小于N。

请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。

试题程序。

[cpp] view
plaincopy

1. #define M 5
2. #define N 20
3. int fun(char(* ss)[N], int *n)
4. {
5. int i, k = 0, len = N;
6. for (i = 0; i < ______; i++)
7. {
8. len = strlen(ss[i]);
9. if (i == 0)
10. *n = len;
11. if (len ____ * n);
12. {
13. *n = len;
14. k = i;
15. }
16. }
17. return ( _____ );
18. }
19. main( )
20. {
21. char ss[M][N] = {"shanghai", "guangzhou", "beijing", "tianjing", "chongqing"};
22. int n, k, i;
23. printf("\nThe originalb stringsare:\n");
24. for (i = 0; i < M; i++)
25. puts(ss[i]);
26. k = fun(ss, &n);
27. printf("\nThe length of shortest string is: % d\n", n);
28. printf("\nThe shortest string is: % s\n", ss[k]);
29. }

• N < k
• N > k
• M < k
• M > k

答案：C

感觉比较水的一道题。。。。分析下代码就OK了

15.

写出下面程序的输出结果

[cpp] view
plaincopy

1. class A
2. {
3. public:
4. void FuncA()
5. {
6. printf( "FuncA called\n" );
7. }
8. virtual void FuncB()
9. {
10. printf( "FuncB called\n" );
11. }
12. };
13. class B : public A
14. {
15. public:
16. void FuncA()
17. {
18. A::FuncA();
19. printf( "FuncAB called\n" );
20. }
21. virtual void FuncB()
22. {
23. printf( "FuncBB called\n" );
24. }
25. };
26. void main( void )
27. {
28. B b;
29. A *pa;
30. pa = &b;<span style="white-space:pre">        </span>//pa为一个指向a对象的指针，这里，将其绑定在对象b上
31. A *pa2 = new A;<span style="white-space:pre">     </span><span style="line-height: 28.7999992370605px; font-family: arial, STHeiti, ‘Microsoft YaHei‘, 宋体;">//pa2为一个指向a对象的指针</span>
32. pa->FuncA();<span style="white-space:pre"> </span>//FuncA为普通函数，这里调用A类的FuncA函数
33. pa->FuncB();<span style="white-space:pre"> </span>//FuncB为虚函数，根据继承性原理，子类有的调用子类，子类没有的，调用父类，这里，调用B类的Fun<span style="white-space:pre">            </span>cB函数
34. pa2->FuncA(); <span style="white-space:pre">   </span>//这里调用A类的FuncA函数
35. pa2->FuncB();<span style="white-space:pre">    </span>//因为pa2是一个指向A类的指针，所以，在A类中寻找FuncB函数，这里，调用A类的FuncB函数
36. delete pa2;
37. }

• FuncA called FuncB called FuncA called FuncB called
• FuncA called FuncBB called FuncA called FuncB called
• FuncA called FuncBB called FuncAB called FuncBB called
• FuncAB called FuncBB called FuncA called FuncB called

答案：B

详情见注释

16.

In the main() function, after ModifyString(text) is called, what’s the value of ‘text’?

[cpp] view
plaincopy

1. int FindSubString( char* pch )<span style="white-space:pre">  </span>//这个函数是用来搜索回文字符串的，并且回文字符串的左右边上的字符要比回文串的开头结尾要大，比如BCDCB不行，但ABA可以

[cpp] view
plaincopy

1. {
2. int   count  = 0;
3. char  * p1   = pch;<span style="white-space:pre">     </span>//注意，指针pch在函数FindSubString中并未改变指向
4. while ( *p1 != ‘\0‘ )
5. {
6. if ( *p1 == p1[1] - 1 )
7. {
8. p1++;
9. count++;
10. }else  {
11. break;
12. }
13. }
14. int count2 = count;
15. while ( *p1 != ‘\0‘ )
16. {
17. if ( *p1 == p1[1] + 1 )
18. {
19. p1++;
20. count2--;
21. }else  {
22. break;
23. }
24. }
25. if ( count2 == 0 )
26. return(count);
27. return(0);
28. }
29. void ModifyString( char* pText )
30. {
31. char  * p1   = pText;
32. char  * p2   = p1;
33. while ( *p1 != ‘\0‘ )
34. {
35. int count = FindSubString( p1 );<span style="white-space:pre">    </span>//count为要跳过的字符数
36. if ( count > 0 )
37. {
38. *p2++ = *p1;
39. sprintf( p2, "%i", count );<span style="white-space:pre">     </span>//把跳过的字符数量count覆盖在*p1+1的位置
40. while ( *p2 != ‘\0‘ )<span style="white-space:pre">   </span>//这个while循环很重要，应该是，只有*p2指向‘\0‘时，缓冲放在缓冲区的count才会真的覆盖text串的值
41. {
42. p2++;
43. }
44. p1 += count + count + 1;<span style="white-space:pre">    </span>//p1跳过回文字符串
45. }else  {
46. *p2++ = *p1++;
47. }
48. }
49. }
50. void main( void )
51. {
52. char text[32] = "XYBCDCBABABA";
53. ModifyString( text );
54. printf( text );
55. }

• XYBCDCBABABA
• XYBCBCDAIBAA
• XYBCDCBAIBAA
• XYBCDDBAIBAB

答案：C

看注释吧，有些地方我也不太明白，就把看懂的注释了。

17.

下面程序的功能是输出数组的全排列。请填空。

[cpp] view
plaincopy

1. void perm(int list[], int k, int m)
2. {
3. if (    )
4. {
5. copy(list,list+m,ostream_iterator<int>(cout," "));
6. cout<<endl;
7. return;
8. }
9. for (int i=k; i<=m; i++)
10. {
11. swap(&list[k],&list[i]);
12. (    );
13. swap(&list[k],&list[i]);
14. }
15. }

• k!=m 和 perm（list，k+1，m）
• k==m 和 perm（list，k+1，m）
• k!=m 和 perm（list，k，m）
• k==m 和 perm（list，k，m）

答案：B

好吧(∩_∩)，是不是ACM时代见过？字符串全排列，用的是DFS

可参见NYOJ32 组合数

18.

写出下列程序的运行结果。

[cpp] view
plaincopy

1. #include "stdio.h"
2. int sum(int a)
3. {
4. auto int c = 0;
5. static int b = 3;
6. c += 1;
7. b += 2;
8. return (a + b + c);
9. }
10. int main()
11. {
12. int i;
13. int a = 2;
14. for (i = 0; i < 5; i++)
15. {
16. printf("%d,", sum(a));
17. }
18. }

• 6，8，10，12，14，
• 8，10，12，14，16，
• 10，12，14，16，18
• 12，14，16，18，20

答案：B

又道水题。。。static类型的变量初始化一次，存在于整个函数生存期

19.

[cpp] view
plaincopy

1. #include<iostream>
2. using namespace std;
3. class MyClass
4. {
5. public:
6. MyClass(int i = 0)
7. {
8. cout << i;
9. }
10. MyClass(const MyClass &x)
11. {
12. cout << 2;
13. }
14. MyClass &operator=(const MyClass &x)
15. {
16. cout << 3;
17. return *this;
18. }
19. ~MyClass()
20. {
21. cout << 4;
22. }
23. };
24. int main()
25. {
26. MyClass obj1(1), obj2(2);
27. MyClass obj3 = obj1;
28. return 0;
29. }

运行时的输出结果是（）

• 11214444
• 11314444
• 122444
• 123444

答案：C

主要是选C和选D的讨论，这涉及到浅复制和深复制

[cpp] view
plaincopy

1. MyClass obj3= obj1;

这里进行的是浅复制，调用的是copy construction函数

若上边那行代码是如下形式

[cpp] view
plaincopy

1. MyClass obj3;
2. obj3= obj1;

则进行的是深复制，调用的是assignment operators 函数

20.

如下代码输出结果是什么？

[cpp] view
plaincopy

1. #include<stdio.h>
2. char *myString()
3. {
4. char buffer[6] = {0};<span style="white-space:pre">   </span>//存放在栈上，在函数末尾将释放
5. char *s = "Hello World!";
6. for (int i = 0; i < sizeof(buffer) - 1; i++)
7. {
8. buffer[i] = *(s + i);
9. }
10. return buffer;<span style="white-space:pre">  </span>//buffer的内存将释放，从而*buffer变成一个野指针
11. }
12. int main(int argc, char **argv)
13. {
14. printf("%s\n", myString());
15. return 0;
16. }

• Hello
• Hello World!
• Well
• 以上全部不正确

答案：D

详情见注释

总算完了。。。。继续调摄像头去了。。。。