浙江大华 研发类试题

来源：http://blog.csdn.net/mishifangxiangdefeng/article/details/8116876

一、程序编写题

1.函数checkstr判断一个字符串是不是对称的，如：“abccba”是对称的，"abccbaa"则不是对称的。函数声明如下，其中msg为输入的字符串，对称返回0，不对称返回-1，请实现该函数。
int checkstr(const char *msg);

答：

[cpp] view plaincopy
  1. int checkstr(const char *msg)  
  2. {  
  3.     int i = 0, len;  
  4.     while(msg[i] != '\0')i++;  
  5.     len = i;  
  6.     for(i = 0; i < len/2; i++)  
  7.         if(msg[i] != msg[len-i-1])  
  8.             return -1;  
  9.     return 0;  
  10. }  

 

2.给出一个单向链表的头指针，输出该链表中倒数第k个节点的指针。链表的倒数第0个节点为链表的尾结点（尾结点的next成员为NULL）。

函数findnode实现上述功能，链表节点定义及函数声明如下，请实现函数findnode。

[cpp] view plaincopy
  1. typedef struct Node  
  2. {  
  3.     struct Node *next;  
  4. }Node;  
  5. Node* findnode(Node *head, unsigned int k);  

答：

[cpp] view plaincopy
  1. Node* findnode(Node *head, unsigned int k)  
  2. {  
  3.     int cnt = 0;  
  4.     Node *p = head;  
  5.     while(p)  
  6.     {  
  7.         cnt++;  
  8.         p = p->next;  
  9.     }  
  10.     if(cnt < k)  
  11.         return NULL;  
  12.     cnt = cnt - k - 1;  
  13.     p = head;  
  14.     while(cnt--)  
  15.         p = p->next;  
  16.     return p;  
  17. }  


二、程序填空题

1.请写出下面程序的运行结果
[cpp] view plaincopy
  1. int count = 3;  
  2. int main()  
  3. {  
  4.     int i, sum, count = 2;  
  5.     for(i = 0, sum = 0; i < count; i += 2,count++)  
  6.     {  
  7.         static int count = 4;  
  8.         count++;  
  9.         if(i % 2 == 0)  
  10.         {  
  11.             extern int count;  
  12.             count++;  
  13.             sum += count;  
  14.         }  
  15.         sum += count;  
  16.     }  
  17.     cout<<count<<' '<<sum<<endl;  
  18.     return 0;  
  19. }  
请问其运行结束时的打印信息是                
[cpp] view plaincopy
  1. 答：4 20  
  2. extern是引用全局的count，定义为static的count只初始化一次，见static总结  
  3. for循环里的count指的是main()里的，static =4这句只执行一次，count++是static这个count，最后输出的是main()里的count  

2.请写出下面程序的运行结果
[cpp] view plaincopy
  1. void func(char str[50])  
  2. {  
  3.     cout<<sizeof(str)<<' '<<strlen(str)<<endl;  
  4. }  
  5. int main()  
  6. {  
  7.     char stra[] = "HelloWorld";  
  8.     char *strb = stra;  
  9.     cout<<sizeof(stra)<<' '<<sizeof(strb++)<<endl;  
  10.     func(++strb);  
  11.     cout<<strlen(stra)<<' '<<strlen(strb++)<<endl;  
  12.     return 0;  
  13. }  
请问其运行结束时的打印信息是                
[cpp] view plaincopy
  1. 答：  
  2. 11 4  
  3. 4 9  
  4. 10 9  
  5. sizeof(stra) = 11：char数组的大小=数组元素的个数=字符个数+1  
  6. sizeof(strb++) = 4：strb是一个指针，在32位系统中，指针的大小是4。注意sizeof有一个特性：编译的时候就把strb替换成类型了，所以里面任何加减操作都是无效的，事实上++没有执行  
  7. sizeof(str) = 4：不管数组作为参数怎么表示，数组还是以地址来传递的。str是一个指向stra[1]的指针，所以大小是4，与后面的[50]没有关系  
  8. strlen(str) = 9：strlen是指不包括'\0'的字符的个数，与[50]没有关系  
  9. strlen(stra) = 10：strlen不包括'\0'  
  10. strlen(strb++) = 9：strb指向stra[1]，再计算长度，再更改strb为stra[2]  

3.请写出下面程序的运行结果
[cpp] view plaincopy
  1. int func(int n)  
  2. {  
  3.     int k = 1;  
  4.     if(n > 0)  
  5.     {  
  6.         k += func(--n);  
  7.         cout<<n;  
  8.         k += func(--n);  
  9.     }  
  10.     return k;  
  11. }  
  12. int main()  
  13. {  
  14.     int a = 3;  
  15.     cout<<func(a)<<endl;  
  16.     return 0;  
  17. }  
请问其运行结束时的打印信息是                
答：01209

4.请写出下面程序的运行结果
[cpp] view plaincopy
  1. struct SC{int a,b,c;};  
  2. struct SD{int a,b,c,d;};  
  3. int main()  
  4. {  
  5.     struct SC c1[] = {{3}, {4}, {5}, {6}};  
  6.     struct SD *c2 = (struct SD*)c1 + 1;  
  7.     cout<<c2->a<<c2->b<<c2->c<<c2->d<<endl;  
  8.     return 0;  
  9. }  
请问其运行结束时的打印信息是                
[cpp] view plaincopy
  1. 答：0050  
  2. c1的存储方式是这样的：  
  3. 3 0 0 | 4 0 0 | 5 0 0 | 6 0 0  
  4. c1[0] | c1[2] | c1[3] | c1[4]  
  5. c1转换为CD结构后是这样的：  
  6. 3 0 0 4 | 0 0 5 0 | 0 6 0 0  
  7.   c1[0]  |  c1[1]   |    c1[2]  
  8. c2 = c1 + 1，因此c2指向转换后的c1[1]，即0050  

5.请写出下面程序的运行结果
[cpp] view plaincopy
  1. class Base  
  2. {  
  3. public:  
  4.   
  5.     int m_a;  
  6.     Base(int a = 2):m_a(a){cout<<'A'<<m_a;}  
  7.     virtual ~Base(){cout<<'B'<<m_a;}  
  8. };  
  9. class Derived:public Base  
  10. {  
  11. public:  
  12.     Derived(int a = 4):Base(a){cout<<'C'<<m_a;}  
  13.     ~Derived(){cout<<'D'<<m_a;}  
  14. };  
  15. int main()  
  16. {  
  17.     Base *aa, bb;  
  18.     aa = new Derived;  
  19.     delete aa;  
  20.     return 0;  
  21. }  
请问其运行结束时的打印信息是                
[cpp] view plaincopy
  1. 答：A2A4C4D4B4B2  
  2. L17：生成一个基类对象，调用一次基类的构造函数  
  3. L18：生成一个子类的对象，先调用基类构造函数，再调用子类构造函数  
  4. L19：由于析构函数是虚函数，根据待释放对象的类型来调用析构函数。aa指向的是子类对象，先调用子类析构函数，再调用基类析构函数  
  5. L21：bb是栈内对象，自动释放，调用一次基类的析构函数  

6.请写出下面程序的运行结果
[cpp] view plaincopy
  1. class Base  
  2. {  
  3. public:  
  4.     int m_a, m_b;  
  5.     Base(int a = 3, int b = 5):m_a(a), m_b(b){}  
  6.     int func_a(){return m_a - m_b;}  
  7.     virtual int func_b(){return m_a + m_b;}  
  8. };  
  9. class Derived:public Base  
  10. {  
  11. public:  
  12.     Derived(int a = 4, int b = 7):Base(a, b){}  
  13.     virtual int func_a(){return m_b + m_a;}  
  14.     int func_b(){return m_b - m_a;}  
  15. };  
  16. int main()  
  17. {  
  18.     Base *aa, *bb;  
  19.     aa = new Base(4, 7);  
  20.     bb = new Derived(3, 5);  
  21.     cout<<aa->func_a()<<' '<<aa->func_b()<<' '<<bb->func_a()<<' '<<bb->func_b()<<endl;  
  22.     delete aa;delete bb;  
  23.     return 0;  
  24. }  
请问其运行结束时的打印信息是                
答：-3 11 -2 2

7.请写出下面程序的运行结果
[cpp] view plaincopy
  1. #include <vector>  
  2. int func(std::vector<int> vec)  
  3. {  
  4.     static int k = 2;  
  5.     std::vector<int>::reverse_iterator it;  
  6.     for(it = vec.rbegin(); it != vec.rend(); ++it)  
  7.     {  
  8.         k += *it % 2 == 0 ? ++*it : (*it)++;  
  9.     }  
  10.     return k;  
  11. }  
  12. int main()  
  13. {  
  14.     std::vector<int> vec;  
  15.     for(int i = 0; i < 4; ++i)  
  16.     {  
  17.         vec.push_back(i);  
  18.         cout<<func(vec)<<endl;  
  19.     }  
  20.     return 0;  
  21. }  
请问其运行结束时的打印信息是                
答：3 5 10 18

8.以下程序输入10个整数到a数组，找到并输出其中最大的整数及其下标。
如输入：80 290 150 520 330 -160 -99 0 200 9
则输出：a[3] = 520
请填写空出的语句
[cpp] view plaincopy
  1. #define N 10  
  2. int get_max_index(int a[], int n)  
  3. {  
  4.     int i, k = 0;  
  5.     for(i = 1; i < n; i++)  
  6.         if ( ________ )  
  7.             k = i;  
  8.     return ________ ;  
  9. }  
  10. void main()  
  11. {  
  12.     int i, k, a[N];  
  13.     for(i = 0; i < N; i++)  
  14.         cout<<a[i];  
  15.     k = ________ ;  
  16.     cout<<k<<" = "<<a[k]<<endl;  
  17. }  
[cpp] view plaincopy
  1. 答：  
  2. a[i] > a[k]  
  3. k  
  4. get_max_index(a, N)  

三、程序改错题

指出下列代码行是否有编译错误或运行错误，请用“正确”，“错误”填空。假定必须的标准头文件已经包含。
[cpp] view plaincopy
  1. int main()  
  2. {  
  3.     int v1[] = {0, 1, 2, 3};                     //________  
  4.     int v2[5, 2] = {0};                          //________  
  5.     char v3[8] = {"a", "b", 0};                  //________  
  6.     char v4[6] = "string";v4 = "new string";     //________  
  7.     extern int x1; x1++;                         //________  
  8.     const int x2; x2++;                          //________  
  9.     static int x3 = 0; x3++;                     //________  
  10.     int& x4 = 0; x4++;                           //________  
  11.     int* p1 = &x2; p1++;                         //________  
  12.     void* p2 = &x3; p2++;                        //________  
  13.     return 0;  
  14. }  
[cpp] view plaincopy
  1. 答：  
  2. L3：正确  
  3. L4：错误，二维数组的定义方式为int v2[5][2] = {0};  
  4. L5：错误，char型只能包含一个字符，"a"包含两个字符，应改为char v3[8] = {'a', 'b', 0};  
  5. L6：错误，第一句数组越界，第二句无法从char [11]转换为char [6]  
  6. L7：正确  
  7. L8：错误，常量必须初始化，且不能对常量修改  
  8. L9：正确  
  9. L10：错误，引用必须使用一个对象来初始化，如int &x4 = x1;  
  10. L11：错误，x2是一个常量，p1不是指向常量的指针  
  11. L12：错误，void不能说明p2的对象的大小  

四、选做题（请选作适合自己方向的一类题目）

算法类

问答题：
1.写出以（0，0）为圆心旋转a度的旋转变化函数矩阵。
2.给出一个常用的3阶的拉普拉斯模板。
3.Fisher线性差别的准则是什么？
4.SVM是什么含义？

DSP类

略

驱动类

略

应用类

略

Windows类

1.简述动态连接库(dll)和静态连接库lib的差别。
http://youranxiaoxian.diandian.com/post/2011-10-16/5836945
[cpp] view plaincopy
  1. 答： 静态连接库就是把(lib)文件中用到的函数代码直接链接进目标程序，程序运行的时候不再需要其它的库文件；动态链接就是把调用的函数所在文件模块 （DLL）和调用函数在文件中的位置等信息链接进目标程序，程序运行的时候再从DLL中寻找相应函数代码，因此需要相应DLL文件的支持。    
  2.     静 态链接库与动态链接库都是共享代码的方式，如果采用静态链接库，则无论你愿不愿意，lib 中的指令都全部被直接包含在最终生成的 EXE 文件中了。但 是若使用 DLL，该 DLL 不必被包含在最终 EXE 文件中，EXE 文件执行时可以“动态”地引用和卸载这个与 EXE 独立的 DLL 文件。 静态链接库和动态链接库的另外一个区别在于静态链接库中不能再包含其他的动态链接库或者静态库，而在动态链接库中还可以再包含其他的动态或静态链接 库。  

2.请简述MFC中窗口收到WM_PAINT消息是如何处理的，什么情况下产生WM_PAINT消息。
[cpp] view plaincopy
  1. 处理过程：  
  2. （1）BeginPaint开始画，就是用白刷去掉原窗口  
  3. （2）GetClientPaint获得窗口显示区域和尺寸等信息并绘制  
  4. （3）EndPaint释放绘图句柄。  
  5. 产生WM_PAINT消息：  
  6. （1）第一次创建一个窗口时  
  7. （2）改变窗口大小时  
  8. （3）把窗口从另一个窗口背后移出时  
  9. （4）最大化或最小化窗口时  

3.请简述Critical Section、Mutex、Semaphore的功能和差别。
[cpp] view plaincopy
  1. Critical Section（临界区）是一段代码，用于保护另一段代码。它保证在一个时刻只有一个内核控制路径访问被临界区保护的代码。  
  2. Mutex（互斥量）：使两个进程互斥地访问一个资源。支持PV操作。资源个数为1，可以看作是信息量的特殊情况。  
  3. Semaphore：一种只能被互斥访问的资源有n个，支持申请和释放该资源的操作。  

4.简述多线程程序对比单线程程序的优点和缺点。
[cpp] view plaincopy
  1. （1）多线程的优点：  
  2. 无需跨进程边界；  
  3. 程序逻辑和控制方式简单；  
  4. 所有线程可以直接共享内存和变量等；  
  5. 线程方式消耗的总资源比进程方式好；  
  6. （2）多线程缺点：  
  7. 每个线程与主程序共用地址空间，受限于2GB地址空间；  
  8. 线程之间的同步和加锁控制比较麻烦；  
  9. 一个线程的崩溃可能影响到整个程序的稳定性；  
  10. 到达一定的线程数程度后，即使再增加CPU也无法提高性能；  
  11. 线程能够提高的总性能有限，而且线程多了之后，线程本身的调度也是一个麻烦事儿，需要消耗较多的CPU  
  12. （3）多进程优点：  
  13. 每个进程互相独立，不影响主程序的稳定性，子进程崩溃没关系；  
  14. 可以尽量减少线程加锁/解锁的影响，极大提高性能，就算是线程运行的模块算法效率低也没关系；  
  15. 通过增加CPU，就可以容易扩充性能；  
  16. 每个子进程都有2GB地址空间和相关资源，总体能够达到的性能上限非常大  
  17. （4）多进程缺点：  
  18. 逻辑控制复杂，需要和主程序交互；  
  19. 多进程调度开销比较大；  
  20. 需要跨进程边界，如果有大数据量传送，就不太好，适合小数据量传送、密集运算 
posted on 2013-03-28 15:42  猿人谷  阅读(521)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 猿人谷
Powered by .NET 9.0 on Kubernetes