请写出下面程序的输出结果:(答案在下面)
1、
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. "%d %d\n",count, sum);
18. return 0;
19. }
extern int count是上边的全局变量。并且循环中的count值不变。
2、
1. void func(char str[50])
2. {
3. "A %d B %d ",sizeof(str), strlen(str));
4. }
5. int main(void)
6. {
7. char stra[] = "HelloWorld";
8. char *strb = stra;
9. "C %d D %d ",sizeof(stra), sizeof(strb++));
10. func(++strb);
11. "E %d F %d\n",strlen(stra), strlen(strb++));
12. return 0;
13. }
3、
1. #include <vector>
2. int func(std::vector<int>vec)
3. {
4. static int k = 2;
5. 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. int>vec;
15. for(int i = 0; i<4; i++)
16. {
17. vec.push_back(i);
18. "%d ",func(vec));
19. }
20. return 0;
21. }
k += *it%2==0? ++*it: (*it)++;
k=k+(*it%2==0?++*it:(*it)++;)
4、
1. class Base
2. {
3. public:
4. int m_a;
5. int a=2):m_a(a)
6. {
7. "A %d ",m_a);
8. }
9. virtual ~Base()
10. {
11. "B %d ",m_a);
12. }
13. };
14. class Derived:public Base
15. {
16. public:
17. int a=4):Base(a)
18. {
19. "C %d ",m_a);
20. }
21. ~Derived()
22. {
23. "D %d ",m_a);
24. }
25. };
26. int main(void)
27. {
28. Base *aa,bb;
29. new Derived;
30. delete aa;
31. return 0;
32. }
在delete aa 的时候 虚析够函数还是被调用了
5、
1. class Base
2. {
3. public:
4. int m_a,m_b;
5. 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. 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. new Base(4, 7);
32. new Derived(3, 5);
33. "%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、
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. "%d %d %d %d\n",c2->a,c2->b,c2->c,c2->d);
19. return 0;
20. }
7、
1. int func(int n)
2. {
3. int k = 1;
4. if(n > 0)
5. {
6. k += func(--n);
7. "%d ", n);
8. k += func(--n);
9. }
10. return k;
11. }
12.
13. int main(void)
14. {
15. int a = 3;
16. "%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操作时,或者有比较耗时的任务,那么多线程就是比较好的选择。