【备战2014笔面试】C++经典笔试30题（1-10）

转自：http://blog.csdn.net/laoyang360/article/details/7935914

重拾C++经典笔试30题（1-10）

1.     /*----------------统计10进制转化为2进制1的个数-----------------

 

[cpp]  view plain copy

1. #include<iostream>  
2.   
3. using namespace std;  
4.   
5. //统计10进制转化为2进制1的个数-  
6.   
7. int total2Cnts(int x)    
8. {    
9.          int count = 0;             
10.            
11.          while(x!=0)    
12.          {                
13.               if((x%2)==1)  
14.               {  
15.                     count++;    
16.               }                           
17.               x = x/2;                
18.          }             
19.          return count;    
20. }    
21.   
22.   
23. int main()    
24. {        
25.     int i = 11;     
26.     cout << i <<"中1的个数为:" <<total2Cnts(i) << endl;    
27.     system("PAUSE");      
28.     return 0;    
29. }     

2.     /*---------------浮点转换---------------------------------

[cpp]  view plain copy

1. <span style="font-size:14px;">int main()  
2. {  
3.          float a = 1.0f;  
4.          cout << (int)a << endl;  
5.          cout << &a << endl;  
6.          cout << (int&)a <<endl;  
7.          cout << boolalpha << ((int)a == (int&)a ) << endl; //false  
8.    
9.          float b = 0.0f;  
10.          cout << (int)b << endl;  
11.          cout << &b << endl;  
12.          cout << (int&)b <<endl;  
13.          cout << boolalpha << ((int)b == (int&)b ) << endl; //true  
14.          return 0;  
15. }</span>  

---------------------------------------------------------*/

问题1：(int&)a中(int&)的确切含义是什么？(int&)a 等价于*(int*)&a;

问题2：浮点数的内存和整数的存储方式不同；int(&a) 相当于该浮点地址开始的sizeof(int)个字节当成int型的数据输出，这取决于float型数据在内存中的存储方式(这是关键)，而不是经过int(&a)显示转换的结果1。

3.     /*---------------位运算--------------------------------

[cpp]  view plain copy

1. <span style="font-size:14px;">#include<iostream>  
2. usingnamespace std;  
3. intmain()  
4. {  
5.     char a = 'a';  
6.     char b = ~a;  
7.     cout<<sizeof(a)<<endl;                //1  
8.     cout << typeid(a).name() <<endl;        // char  
9.     cout<<sizeof(b)<<endl;                //1  
10.     cout << typeid(a).name() <<endl;        // char  
11.     cout<<sizeof(~a)<<endl;                  //4  
12.     cout << typeid(~a).name() <<endl;        // int  
13.     cout<<sizeof(a&b)<<endl;                //4  
14.     cout << typeid(a&b).name()<< endl;        // int  
15.           
16.     return 0;  
17. }</span>  

---------------------------------------------------------*/

 

4.     /*------------------输入输出流与printf在多线程中的区别和影响--------------

[cpp]  view plain copy

1. int g_cnt;  
2. unsignedint _stdcall ThreadProc1(PVOID lpParameter)  
3. {  
4.          g_cnt++;  
5.         printf("subThreadis running! g_cnt = %d\n",g_cnt);  
6. //       cout << "subThread is running!g_cnt = " << g_cnt << endl; //此处和printf打印在多线程操作中的区别？  
7.          return 0;  
8. }  
9.    
10. int main()  
11. {  
12.     g_cnt = 0;  
13.          const int nThreadNum = 5;  
14.          HANDLE hThread1[nThreadNum];  
15.          //Caution...!  
16.          for( int i=0; i < nThreadNum; i++)  
17.          {  
18.                    hThread1[i]=(HANDLE)_beginthreadex(NULL,0,ThreadProc1,NULL,0,NULL);  
19.          }        
20.          WaitForMultipleObjects(nThreadNum,hThread1,true,INFINITE);  
21.    
22.          _endthreadex(0);  
23.          return 0;  
24.    
25. }  

-------------------------------------------------------------------*/

问题：写多线程上述操作最基本实例的时候，发现了用printf能正常逐行打印输出，而用cout<<输出流则出现并行输出的现象。
原因：一个是C库(printf)，一个是C++库(cout)。两者的缓冲方式有所不同，而且使用相互独立的缓冲区。printf是传统的行缓冲，cout则是基于字符的缓冲。注意同一个程序中不要混合两种输出方式，有可能导致输出混乱。

5.     位运算

X&Y指取出X与Y的相同位；

X异或Y取出X与Y的不同位；

X右移1等价于X除以2。

X左移1等价于X乘以2.

//取出a,b中较大者。

[cpp]  view plain copy

1. <span style="font-size:14px;">intmaxFun(int a, int b)  
2. {  
3.          return (((a+b) + abs(a-b))/2);  
4. }</span>  

上式简化为：若a>b,((a+b)+(a-b))/2= a; 若a<b,((a+b)-(a-b))/2=b.显然才有了绝对值一说。

[cpp]  view plain copy

1. <span style="font-size:14px;">   
2. //a,b交换操作  
3. voidexchange(int& a, int& b)  
4. {  
5.          a = a^b;  
6.          b = a^b;  
7.          a = a^b;  
8. }</span>  

6.     求解结构体偏移量的方法？

[cpp]  view plain copy

1. <span style="font-size:14px;">#define FIND(STRUC, e)(size_t)&(((STRUC*)0)->e)  
2. structstudent  
3. {  
4.          int a;  
5.          char b[20];  
6.          double c;  
7. };//32  
8.    
9. intmain()  
10. {  
11.          cout << FIND(student,a) <<endl; //0  
12.          cout << FIND(student,b) <<endl; //4  
13.          cout << FIND(student,c) <<endl; //24  
14.           
15.          cout << sizeof(student) <<endl; //32  
16.          return 0;  
17. }  
18. #define FIND(STRUC, e)(size_t)&(((STRUC*)0)->e)</span>  

解读：

第一步，((TRUC*)0)将0转化为STRUC*指针所指向的地址；

第二步，&(((STRUC*)0)->e)结构体指针成员e的地址，由于结构体的首地址为0，&(((STRUC*)0)->e)即为e距离结构体成员的偏移量。

第三步，强制类型转换，最终求的是偏移值，最好定义为无符号数据。size_t 等价于 unsigned int

7.     注意以下的表示方法！

#define SECONDS_PER_YEAR 365UL*24UL*3600UL用法值得商榷！

#defineMIN(a,b) ((a)<=(b) ? (a):(b))

8.      const与define对比？

	const	define
1． 是否具有类型？	有类型	没有类型
2． 是否进行安全检查？	编译器有安全检查	仅是字符替换
3.        是否可调试？	可调试	不可调试

 

内联函数与define宏定义对比？

	优点	缺点及注意点
Define宏定义	1.提高了运行效率	1.不可调试，无法进行安全检查（类型） 2.可能出现边际效应导致出错。 3.不能操作类的私有数据成员。
内联函数	1提高效率及安全性； 2编译器可以用上下文优化技术继续对结果代码优化。	1每一次内联处都要拷贝代码，使程序总工作量大； 2.短小、 简单函数设为内联（重复调用，无switch、for、while）等语句； 3.不要将构造、析构函数设置为内联函数。

 

 

9.     不常用的mutalbe关键字

[MSDN]mutable

C++Specific —>mutable member-variable-declaration;

Thiskeyword can only be applied to non-static and non-const data members of aclass. If a data member is declared mutable, then it is legal to assign a valueto this data member from a const member function.

解读：mutable成员变量的声明,这个关键字只能应用于类的非静态与非const数据成员。如果一个数据成员声明为mutable，那么通过const成员函数给数据成员分派一个值是合法的。

[作用]：加mutable关键字的成员变量，修饰为const的成员函数就可以修改它了。

不加mutable，会报错：l-value specifies const object。

[cpp]  view plain copy

1. <span style="font-size:14px;">classmutClS  
2. {  
3. public:  
4.          mutClS(int nx):m_x(nx) {}  
5.          ~mutClS(){}  
6.          void increase( int incx) const  
7.          {  
8.                    m_x += incx;  
9.          }  
10.          void decrease(int decx) const  
11.          {  
12.                    m_x -= decx;  
13.          }  
14.          void display()  
15.          {  
16.                    cout << m_x <<endl;  
17.          }  
18. private:  
19.          mutable int m_x; //注意此处！  
20. };  
21.    
22. intmain()  
23. {  
24.          mutClS objA(35);  
25.          objA.increase(5);  
26.          objA.display();  
27.    
28.          objA.decrease(5);  
29.          objA.display();  
30.    
31.          return 0;  
32. }</span>  

10.  C++对象的内存布局

先看一下以下程序占用内存的大小，即：sizeof(simpleClass)=？

[cpp]  view plain copy

1. <span style="font-size:14px;">class simpleClass  
2. {  
3. public:  
4.          simpleClass(){}  
5.          virtual ~simpleClass() {}  
6.    
7.          int getValue(){}  
8.          virtual void fool(){}  
9.          static void addCount(){}  
10.    
11.          static int nCount;  
12.          int nValue;  
13.          char c;  
14. };</span>  

该simpleClass类中含有构造、析构、静态成员函数、虚函数、普通成员函数；静态成员变量、普通成员变量。

分析：

类别	类型	存储类别	占内存情况
数据成员	static int nCount;	全局/静态存储区	不作为对象占据内存的一部分
	int nValue; char c;	非静态数据成员 栈存储区	根据地址对齐，二者占用8字节空间。
成员函数	static void addCount(){}	C++编译器采用普通与C函数类似的方式进行编译，只不过对函数进行了名字修饰（name mangling），用来支持重载；并且在参数列增加了一个this指针，用来表明哪一个对象调用的该函数。	静态和非静态成员函数的多少对对象的大小没有影响。
	int getValue(){} 构造、析构函数、拷贝构造
	virtual void fool(){}	C++编译器在碰到虚函数的类时，会分配一个指针指向一个函数地址表，叫做“虚函数表”。	占4个字节，虚函数表指针占据的4个字节。

 

看下面注释的结果值，再分析：

[cpp]  view plain copy

1. <span style="font-size:14px;">int main()  
2. {  
3.          simpleClass aSimple;  
4.          cout << "Object startaddress:\t" << &aSimple << endl; //0012FF68  
5.          cout << "nValueaddress:\t" << &aSimple.nValue << endl; //0012FF6C  
6.          printf("c address: %x\n",&aSimple.c); //0012FF70  
7.          cout << "size: "<< sizeof(simpleClass) << endl; //12  
8.          return 0;  
9. }</span>  

&aSimple= 0012FF68；即虚函数表指针占据的一个对象开始的4个字节。

结论如下：

（1）非静态数据成员是影响对象占据内存的主要因素，随着对象数目的增多，非静态数据成员占据的内存也会相应增加。

（2）所有的对象共享一份静态数据成员，所以静态数据成员占据的内存的数量不会随着对象数目的增加而增加。

（3）静态成员函数和非静态成员函数不会影响对象内存的大小，虽然其实现会占据相应的内存空间，同样也不会随着对象数目的增加而增加。

（4）如果对象中包含虚函数，会增加4个字节的空间，不论有多少个虚函数。

——摘自《C++应用程序性能优化》（第2版）P25

扩展一：如果在simpleClass的基础上增加继承类，如下：继承类所占内存大小是多少？

[cpp]  view plain copy

1. <span style="font-size:14px;">class derivedClass :public simpleClass  
2. {  
3. public:  
4.          derivedClass(){}  
5.          ~derivedClass(){}  
6.          int nSubValue;  
7. };</span>  

答案：16个字节，派生类derivedClass与其基类simpleClass使用的是同一个虚函数表。或者说派生类在构造时，不再创建一个新的虚函数表，而应该是在基类的虚函数表中增加或修改。

扩展二：空类的大小，以及单继承、多继承，虚拟继承后的空类大小。

[cpp]  view plain copy

1. <span style="font-size:14px;">class A  
2. {  
3.    
4. };  
5. class B  
6. {  
7. };  
8.    
9. class C : public  A  
10. {  
11. };  
12.    
13. class D : virtualpublic  B //4  
14. {  
15. };  
16.    
17. class E : public  A, public B  
18. {  
19. };  
20.    
21. int main()  
22. {  
23.          cout << sizeof(A) << endl; //1  
24.          cout << sizeof(B) << endl; //1  
25.          cout << sizeof(C) << endl; //1  
26.          cout << sizeof(D) << endl; //4[涉及虚拟继承（虚指针）]  
27.          cout << sizeof(E) << endl; //1  
28.          return 0;  
29. }</span>  

扩展三：为了避免出现菱形问题，用使用虚拟继承后的子类大小。示例如下：

[cpp]  view plain copy

1. <span style="font-size:14px;">class baseClass  
2. {  
3. public:  
4.          virtual void fool(void) {}  
5.          int nValue;  
6.          char c;  
7. };  
8.    
9. class midClass1 : virtualpublic baseClass  
10. {  
11. public:  
12.          virtual void setVal(){}  
13.          int nMidValue1;  
14. };  
15.    
16. class midClass2 : virtualpublic baseClass  
17. {  
18. public:  
19.          virtual void setVal(){}  
20.          int nMidValue2;  
21. };  
22.    
23. class derivedClass :  public midClass1,  public midClass2  
24. {  
25. public:  
26.          virtual void foo2(){}  
27.          int subVal;  
28. };  
29. int main()  
30. {  
31.          cout << sizeof(baseClass) << endl; //12  
32.          cout << sizeof(midClass1) << endl; //24  
33.          cout << sizeof(midClass2) << endl; //24  
34.          cout << sizeof(derivedClass) << endl; //48  
35.          return 0;  
36. }</span>  

已经知道的，对于baseClass类的大小，考虑地址对齐为4(c)+4(nvalue)+4(虚拟函数指针)共12个字节；

如果去掉虚拟继承，为如下形式：

class midClass1 : publicbaseClass //仅是增加了nMidValue1，扩展为16字节

class midClass2 : publicbaseClass //仅是增加了nMidValue2，扩展为16字节

classderivedClass :  public midClass1,  public midClass2 //在继承midclass1，midclass2基础上仅是增加了subVal，为16+16+4=36字节。

不理解点：为什么加了虚拟继承，sizeof(midClass1)= 24；sizeof(midClass2)=24；sizeof(derivedClass)48；

主要原因，VisualC++添加了了虚拟基类表指针来实现虚拟继承，类中只要有visual函数就会产生这个vtb 虚函数表和一个vptr虚函数指针,它们都会占内存的。

具体为什么增加了8个字节，希望与大家探讨！

【已解决】主要原因，VisualC++添加了了虚拟基类表指针来实现虚拟继承，因此，空间变大？实际怎么多了8个字节。。
      解读：baseClass类包含1个虚函数表指针（4个字节）、1个int型数据成员（4个字节）、1个char型数据（对齐后4个字节）成员，共12个字节。
      midClass1同midClass2一致，需要在baseClass类的基础上，多了1个虚函数表指针（4个字节）、1个指向虚基类表的指针（4个字节）、一个整形数据成员（4个字节），合计共12+12 =24个字节。
derivedClass 在上述的基础上，包含baseClass(12个字节)、midClass1(新增12个字节)、midClass2(新增12个字节)、derivedClass的1个整形数据成员（4个字节），合计共40个字节。注意derivedClass是继承而非虚拟继承自两个父类，所以没有指向虚基类表的指针。
      扩展，如果将上述继承该为：class derivedClass : virtual public midClass1, virtual public midClass2.上述大小会变为48个字节（多了两个指向虚基类表的指针（每个4个字节））。