互联网几道常考易错笔试题总结

转载于http://blog.csdn.net/chhuach2005/article/details/40322895

1）  覆盖 重载 隐藏

覆盖：基类定义的虚函数，派生类中重新定义，派生类的虚函数表将覆盖基类已定义的虚函数。

重载：重载发生在同一个类中，重载不能跨类。重载是因为函数名相同，函数的参数个数或参数的类型不同，而调用相应的函数。

隐藏：这个，以前没怎么注意。隐藏发生在派生类中有何基类同名的虚函数时，此时基类中的同名重载函数不被继承到派生类。

代码说明如下：

[cpp] view plaincopy

1. class Base//基类中fun1有3个函数，是重载
2. {  
3. public:  
4. virtual void fun1(int a)  
5.     {  
6.         cout<<"Base fun1 int  "<<a<<endl;  
7.     }  
8. virtual void fun1(double a)  
9.     {  
10.         cout<<"Base fun1 double  "<<a<<endl;  
11.     }  
12. void fun1()  
13.     {  
14.         cout<<"Base fun1 ()  "<<5<<endl;  
15.     }  
16. };  
18. class Derive:public Base // 显然派生类中的fun1(int a)是基类的fun1(int a)的重写
19. {  
20. public:  
21. virtual void fun1(int a)  
22.     {  
23.         cout<<"Derive fun1 int  "<<a<<endl;  
24.     }  
25. };  
27. int _tmain(int argc, _TCHAR* argv[])  
28. {  
29.     Base *p=new Derive;//隐藏的函数，用指针可以调用，隐藏和多态同时出现时，隐藏优先级高
30.     p->fun1(3.3);//由于隐藏优先级高，此处用基类指针调用fun1（3.3），不会发生多态，调用的是基类的fun1（3.3），在基类又会产生重载。
31.     p->fun1(3);  //多态调用派生类中的函数
32.     p->fun1();   //同理会调用基类的fun1（）函数，在基类会有重载。
33.     Derive *p1=new Derive;  
34.     p1->fun1(3.3);//因为派生类没有继承fun1（double），因此fun1（3.3）会调用fun1（int）
35. //p1->fun1();//由于fun1（）未被继承到派生类中，本行调用若不注释，会出错编译不通过。
36.     Base *p2=new Base;  
37.     p2->fun1(3.3);  
38.     system("pause");  
39. return 0 ;  
40. }  

运行结果：

结果如图1所示，与以上分析相同

图1  重载、覆盖、隐藏

2）  类变量的声明与执行顺序

且看以下代码

[cpp] view plaincopy

1. class A  
2. {  
3. public:  
4.     A()  
5.     {  
6.         cout<<"A is called"<<endl;  
7.     }  
8. };  
10. class B  
11. {  
12. public:  
13.     B()  
14.     {  
15.         cout<<"B is called"<<endl;  
16.     }  
17. };  
19. class C  
20. {  
21. public:  
22.     C()  
23.     {  
24.         cout<<"C is called"<<endl;  
25.     }  
26. };  
27. class D  
28. {  
29. public:  
30.     D()  
31.     {  
32.         cout<<"D is called"<<endl;  
33.     }  
34. };  
36. void test()  
37. {  
38. static C c;  
39.     D d;  
40. }  
41. A a;  
42. int _tmain(int argc, _TCHAR* argv[])  
43. {  
44.         test();  
45.        system("pause");  
46. return 0 ;  
47. }  
48. B b;  

你觉得构造的顺序到底是怎样的呢？是main（）函数体先执行还是b先构造呢？

执行结果为图2，从图2中可以看出，是先构造类的全局变量的，哪怕它在main函数之后，在main函数里的类变量构造是按类变量的定义顺序构造的。

图2  类变量的构造顺序

3）  Main函数能递归吗

[cpp] view plaincopy

1. int  main()  
2. {  
3. static int n=5;  
4.     cout<<n<<endl;  
5.     n--;  
6. if (n==0)  
7.     {  
8.         system("pause");  
9. return 0 ;  
10.     }  
11.     main();  
12. }  

实际测试是可以递归的 运行结果如下：

          图3   main（）递归