浙江大华笔试题

请写出下面程序的输出结果：（答案在下面）

1、

view plain
  1. int count = 3;  
  2. int main(void)  
  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.     printf("%d %d\n",count, sum);  
  18.     return 0;  
  19. }  

extern int count是上边的全局变量。并且循环中的count值不变。
2、

view plain
  1. void func(char str[50])  
  2. {  
  3.     printf("A %d B %d ",sizeof(str), strlen(str));  
  4. }  
  5. int main(void)  
  6. {  
  7.     char stra[] = "HelloWorld";  
  8.     char *strb = stra;  
  9.     printf("C %d D %d ",sizeof(stra), sizeof(strb++));  
  10.     func(++strb);  
  11.     printf("E %d F %d\n",strlen(stra), strlen(strb++));  
  12.     return 0;  
  13. }  


3、

view plain
  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(void)  
  13. {  
  14.     std::vector<int>vec;  
  15.     for(int i = 0; i<4; i++)  
  16.     {  
  17.         vec.push_back(i);  
  18.         printf("%d ",func(vec));  
  19.     }  
  20.     return 0;  
  21. }  

k += *it%2==0? ++*it: (*it)++;  

k=k+(*it%2==0?++*it:(*it)++;)

4、

view plain
  1. class Base  
  2. {  
  3. public:  
  4.     int m_a;  
  5.     Base(int a=2):m_a(a)  
  6.     {  
  7.         printf("A %d ",m_a);  
  8.     }  
  9.     virtual ~Base()  
  10.     {  
  11.         printf("B %d ",m_a);  
  12.     }  
  13. };  
  14. class Derived:public Base  
  15. {  
  16. public:  
  17.     Derived(int a=4):Base(a)  
  18.     {  
  19.         printf("C %d ",m_a);  
  20.     }  
  21.     ~Derived()  
  22.     {  
  23.         printf("D %d ",m_a);  
  24.     }  
  25. };  
  26. int main(void)  
  27. {  
  28.     Base *aa,bb;  
  29.     aa = new Derived;  
  30.     delete aa;  
  31.     return 0;  
  32. }  

在delete aa 的时候   虚析够函数还是被调用了 

5、

view plain
  1. class Base  
  2. {  
  3. public:  
  4.     int m_a,m_b;  
  5.     Base(int a = 2,int b = 5):m_a(a),m_b(b)  {  }  
  6.     int func_a()  
  7.     {  
  8.         return m_a - m_b;  
  9.     }  
  10.     virtual int func_b()  
  11.     {  
  12.         return m_a + m_b;  
  13.     }  
  14. };  
  15. class Derived:public Base  
  16. {  
  17. public:  
  18.     Derived(int a = 4, int b = 7):Base(a, b)  {  }  
  19.     virtual int func_a()  
  20.     {  
  21.         return m_b + m_a;  
  22.     }  
  23.     int func_b()  
  24.     {  
  25.         return m_b - m_a;  
  26.     }  
  27. };  
  28. int main(void)  
  29. {  
  30.     Base *aa, *bb;  
  31.     aa = new Base(4, 7);  
  32.     bb = new Derived(3, 5);  
  33.     printf("%d %d %d %d\n",aa->func_a(), aa->func_b(), bb->func_a(), bb->func_b());  
  34.     delete aa;  
  35.     delete bb;  
  36.     return 0;  
  37. }  


6、

view plain
  1. struct SC  
  2. {  
  3.     int a;  
  4.     int b;  
  5.     int c;  
  6. };  
  7. struct SD  
  8. {  
  9.     int a;  
  10.     int b;  
  11.     int c;  
  12.     int d;  
  13. };  
  14. int main(void)  
  15. {  
  16.     struct SC c1[] = {{3},{4},{5},{6}};  
  17.     struct SD *c2 = (struct SD*)c1 + 1;  
  18.     printf("%d %d %d %d\n",c2->a,c2->b,c2->c,c2->d);  
  19.     return 0;  
  20. }  


7、

view plain
  1. int func(int n)  
  2. {  
  3.     int k = 1;  
  4.     if(n > 0)  
  5.     {  
  6.         k += func(--n);  
  7.         printf("%d ", n);  
  8.         k += func(--n);  
  9.     }  
  10.     return k;  
  11. }  
  12.   
  13. int main(void)  
  14. {  
  15.     int a = 3;  
  16.     printf("%d\n",func(a));  
  17.     return 0;  
  18. }  

答案：

1、  4   20

2、 C 11 D 4 A 4 B 9 E 10 F 9

3、 3  5  10  18

4、 A 2 A 4 C 4 D 4 B 4

5、 -3 11 -2 2

6、 0  0  5  0

7、  0  1  2  0  9


编程题：
1、函数checkstr判断一字符串是不是对称的。其中msg为输入的字符串，对称返回0，不对称返回-1，实现该函数。
int checkstr(cosnt char *msg);
2、给出一个单向链表的头指针，输出该链表中倒数第K个节点的指针，链表的倒数第0个节点为链表的尾节点（尾节点的next成员为NULL）
typedef struct Node
{
         struct Node *next
}NODE;
NODE* findnode(NODE *head,unsigned int k);

 

简答题：
1、简述动态链接库DLL和静态链接库lib的差别。
2、请简述MFC中的窗口收到WM_PAINT消息是如何处理的，什么情况下会产生WM_PAINT消息。
3、请简述Critical Section 、Mutex、Semaphore的功能和差别

Mutex是一把钥匙，一个人拿了就可进入一个房间，出来的时候把钥匙交给队列的第一个。一般的用法是用于串行化对critical section代码的访问，保证这段代码不会被并行的运行。

 

Semaphore是一件可以容纳N人的房间，如果人不满就可以进去，如果人满了，就要等待有人出来。对于N=1的情况，称为binary semaphore。一般的用法是，用于限制对于某一资源的同时访问。

 

Binary semaphore与Mutex的差异：

在有的系统中Binary semaphore与Mutex是没有差异的。在有的系统上，主要的差异是mutex一定要由获得锁的进程来释放。而semaphore可以由其它进程释放（这时的semaphore实际就是个原子的变量，大家可以加或减），因此semaphore可以用于进程间同步。Semaphore的同步功能是所有系统都支持的，而Mutex能否由其他进程释放则未定，因此建议mutex只用于保护critical section。而semaphore则用于保护某变量，或者同步。

 

另一个概念是spin lock，这是一个内核态概念。spin lock与semaphore的主要区别是spin lock是busy waiting，而semaphore是sleep。对于可以sleep的进程来说，busy waiting当然没有意义。对于单CPU的系统，busy waiting当然更没意义（没有CPU可以释放锁）。因此，只有多CPU的内核态非进程空间，才会用到spin lock。Linux kernel的spin lock在非SMP的情况下，只是关irq，没有别的操作，用于确保该段程序的运行不会被打断。其实也就是类似mutex的作用，串行化对critical section的访问。但是mutex不能保护中断的打断，也不能在中断处理程序中被调用。而spin lock也一般没有必要用于可以sleep的进程空间。
4、简述多线程程序对比单线程程序的优点和缺点。

4、多线程速度快，可以把耗时长的任务放到后台处理，但是也增加了管理和调度的时间，增加了不稳定性，需要复杂的同步机制，避免死锁等等，多核的情况下可以充分利用CPU，对于公共资源和变量访问和修改要特别注意。并不是多线程就一定好，当有大量的IO操作时，或者有比较耗时的任务，那么多线程就是比较好的选择。

posted @ 2011-10-13 12:50  张兰云  阅读(1785)  评论(0)  编辑  收藏  举报