面试题--特别是字节对齐

来源：http://www.cnblogs.com/Braveliu/archive/2013/01/04/2844757.html

【1】设置或者清除某位。

示例代码如下:

 1 #include<iostream>
 2 using  namespace std;
 3 
 4 #define   BIT3  (0x1<<3)
 5 
 6 void Set_bit3(int &a)
 7 {
 8     a|=BIT3;
 9 }
10 
11 void Clear_bit3(int &a)
12 {
13     a&=~BIT3;
14 }
15 
16 void main()
17 {
18     int m=10;     //1010
19     Set_bit3(m);  
20     cout<<m<<endl;//1010 == 10
21     Clear_bit3(m);
22     cout<<m<<endl; //0010 == 2
23     
24     int n=7;
25     Set_bit3(n);
26     cout<<n<<endl; //1111 == 15
27     Clear_bit3(n);
28     cout<<n<<endl; //0111 == 7
29 }
30 /*
31 10
32 2
33 15
34 7
35  */

【2】指针引用经典笔试题

（1）

 1 #include<iostream.h>
 2 #include<malloc.h>
 3 #include<string.h>
 4 
 5 void GetMemory(char *p,int num)
 6 {
 7     p=(char *)malloc(sizeof(char)*num);
 8 }
 9 
10 void  main()
11 {
12     char *str = NULL;
13     GetMemory(str,100);
14     strcpy(str,"hello");
15 }
16 
17 //GetMemory函数仅仅只改变了p指针的指向，而str的指向不变
18 //类似于：
19 //char  *str=NULL;
20 //char  *p = str;
21 //p = (char *)malloc(sizeof(char)*num);
22 //那么这样的三行代码执行结果显然没有达到改变str的作用

（2）

 1 #include<iostream.h>
 2 #include<string.h>
 3 #include<malloc.h>
 4 
 5 void  GetMemory2(char **p,int num)
 6 {
 7     *p=(char *)malloc(sizeof(char)*num);
 8 }
 9 
10 void main()
11 {
12     char *str = NULL;
13     GetMemory2(&str,100);
14     strcpy(str,"hello");
15     cout<<str<<endl;
16     free(str);
17 }
18 
19 //GetMemory函数“隔山打牛”
20 //类似于：
21 //char  *str=NULL;
22 //char  **p=&str;
23 //*p=(char *)malloc(sizeof(char)*num);
24 //那么这样的三行代码执行结果显然达到改变str的作用

（3）

 1 #include<iostream.h>
 2 #include<malloc.h>
 3 #include<string.h>
 4 
 5 char * GetMemory3(int num)
 6 {
 7     char *p=(char *)malloc(sizeof(char)*num);
 8     return p;
 9 }
10 
11 void  main()
12 {
13     char *str=NULL;    
14     str=GetMemory3(100);
15     strcpy(str,"hello");
16     cout<<str<<endl;
17     free(str);
18 }
19 
20 //GetMemory函数功在当代，利在千秋
21 //尽管p变量在栈中，它当生则生，当死则死
22 //但是它在世的一瞬间，却创造了举世的成就，开天辟地！！
23 //p=(char *)malloc(sizeof(char)*num);一句足矣
24 //返回p的值,意义无量！

（4）

 1 #include<iostream.h>
 2 #include<string.h>
 3 #include<malloc.h>
 4 
 5 char *GetString()
 6 {
 7     char p[]="hello  world";
 8     return p;  //编译器警告！！！返回局部变量
 9 }
10 
11 void  main()
12 {
13     char *str=NULL;
14     str=GetString();
15     cout<<str<<endl; //垃圾
16 }
17 
18 //GetMemory函数山寨版
19 //p变量在栈中，当生则生，当死则死
20 //但是它在世的一瞬间，却目光短浅，于后世无功！
21 //返回p的值,一文不值！

（5）

 1 #include<iostream.h>
 2 #include<string.h>
 3 #include<malloc.h>
 4 
 5 char * GetString()
 6 {
 7     char *p="hello  world!";
 8     return p;
 9 }
10 
11 void  main()
12 {
13     char *str=NULL;
14     str=GetString();
15     cout<<str<<endl;
16 }
17 
18 //GetMemory函数正版
19 //p变量在栈中，当生则生，当死则死
20 //但是它在世的一瞬间，却赋予了一份常量，不随它的消失而泯灭！

（6）

 1 #include<iostream>
 2 #include<string>
 3 #include<malloc.h>
 4 using namespace std;
 5 
 6 void GetString(char *&p)
 7 {
 8     p=(char *)malloc(sizeof(char)*10);
 9 }
10 
11 void  main()
12 {
13     char *str=NULL;
14     GetString(str);
15     strcpy(str,"hello");
16     cout<<str<<endl;
17     free(str);
18     str=NULL;
19 }

以上几种例子是面试时遇到的最频繁的试题，在此特意备份，以便学习。

【3】这道题是最典型的数组越界示例：

 1 #include<iostream.h>
 2 #define MAX  255
 3 void main()
 4 {
 5     unsigned char A[MAX];
 6     for(int i = 0; i <= MAX; i++)
 7     {
 8         A[i] = i;
 9     }
10 }

无限循环.......

【4】求最大字段和

示例代码如下：

 1 #include<iostream>
 2 using namespace std;
 3 
 4 inline int Max(int a,int b)
 5 {
 6     return a > b ? a : b; 
 7 }
 8 
 9 int MaxSubSum(int br[],int n)
10 {
11     int data= 0,max= 0;
12     for(int i=0 ;i<n ;++i)
13     {
14         data = Max(0,br[i]);       
15         max = Max(data+max,max);   
16     }
17     return max;
18 }
19 
20 void main()
21 {
22     int ar[] = {1,-4,-2,-1,7,-3,9};
23     int result1 = MaxSubSum(ar,7);
24     cout<<result1<<endl;  //17
25 }

【5】字节对齐

示例代码：

  1 #include<iostream.h>
  2 class A
  3 {
  4 public:
  5   int i;
  6 };
  7 class  B
  8 {
  9 public:
 10   char  ch;
 11 };
 12 class C
 13 {
 14 public:
 15     int i;
 16     short j;
 17 };
 18 class D
 19 {
 20 public:
 21     int i;
 22     short j;
 23     char ch;
 24 };
 25 class E
 26 {
 27 public:
 28     int i;
 29     int ii;
 30     short j;
 31     char ch;
 32     char chr;
 33 };
 34 class F
 35  {
 36 public:
 37     int i;
 38     int ii;
 39     int iii;
 40     short j;
 41     char ch;
 42     char chr;
 43 };
 44 class G
 45 {
 46 public:
 47     int i;
 48     int ii;
 49     short j;
 50     char ch;
 51     char chr;
 52     int iii;
 53 };
 54 class H
 55 {
 56 public:
 57     int i;
 58     int ii;
 59     char ch;
 60     char chr;
 61     int iii;
 62     short j;
 63 };
 64 class I
 65 {
 66 public:
 67     int i;
 68     char ch;
 69     int ii;
 70     char chr;
 71     int iii;
 72     short j;
 73 };
 74 void  main()
 75 {
 76     cout<<"sizeof(int): "<<sizeof(int)<<endl;
 77     cout<<"sizeof(short): "<<sizeof(short)<<endl;
 78     cout<<"sizeof(char): "<<sizeof(char)<<endl;
 79     cout<<endl;
 80     cout<<"sizeof(A): "<<sizeof(A)<<endl;
 81     cout<<"sizeof(B): "<<sizeof(B)<<endl;
 82     cout<<"sizeof(C): "<<sizeof(C)<<endl;
 83     cout<<"sizeof(D): "<<sizeof(D)<<endl;
 84     cout<<"sizeof(E): "<<sizeof(E)<<endl;
 85     cout<<"sizeof(F): "<<sizeof(F)<<endl;
 86     cout<<"sizeof(G): "<<sizeof(G)<<endl;
 87     cout<<"sizeof(H): "<<sizeof(H)<<endl;
 88     cout<<"sizeof(I): "<<sizeof(I)<<endl;
 89 }
 90 
 91 //Out   put:
 92 /*
 93 sizeof(int): 4
 94 sizeof(short): 2
 95 sizeof(char): 1
 96 
 97 sizeof(A): 4
 98 sizeof(B): 1
 99 sizeof(C): 8
100 sizeof(D): 8
101 sizeof(E): 12
102 sizeof(F): 16
103 sizeof(G): 16
104 sizeof(H): 20
105 sizeof(I): 24
106 */

【6】大小端判断

题目：请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1

分析：
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。

但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），

另外，对于位数大于 8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。

因此就导致了大端存储模式和小端存储模式。

例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。

对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。

小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。

嵌入式开发对大小端都比较敏感。所谓的大端模式是指：

数据的低位（就是权值较小的后面那几位）保存在内存的高地址中，而数据的高位，保存在内存的低地址中。

这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；

所谓的小端模式是指：数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中，

这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的实际逻辑方法一致。

示例代码如下：

 1 #include<iostream>
 2 using namespace std;
 3 
 4 int CheckCpu()
 5 {
 6     union w
 7     {
 8         int a;
 9         char b;
10     }c;
11     c.a=1;
12     return (c.b==1);
13 }
14 
15 void main()
16 {
17     cout<<CheckCpu()<<endl;   //1   //说明是小端模式
18 }

总结：

其实大小端的问题很简单的，就是因为数据在同样的内存可以有两种存储模式。

简单记住：低低小，低高大。

也就是说：低位数据存入低地址小端；低位数据存入高地址大端。

【7】求整型数组中的最小以及次小项

示例代码如下：

 1 #include<iostream>
 2 using namespace std;
 3 
 4 void  select(int ar[],int n)
 5  {
 6      int m1, m2;
 7      m1 = m2 = 0xffff;
 8      int x1, x2;
 9      x1 = x2 = 0;
10      for(int j = 0; j < n ;j++)    
11      {    
12          if (ar[j] < m1)
13          {
14              m2 = m1;    //暂存次小
15              x2 = x1;    //暂存次小索引
16              m1 = ar[j]; //暂存最小
17              x1 = j;     //暂存最小索引
18          }
19          else if(ar[j] < m2 )
20          {
21              m2 = ar[j]; //保存次小
22              x2 = j;     //保存次小索引             
23          }
24      }
25      cout<<x1<<"   "<<m1<<endl;   //输出最小
26      cout<<x2<<"   "<<m2<<endl;   //输出次小
27  }
28  void  main()
29  {
30      int ar[5] = {1, 7, 5, 4, 2};
31      select(ar,5);
32  }
33 
34  /*运行结果：
35  0   1
36  4   2
37  */