面试题特别是字节对齐

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

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

示例代码如下:

#include<iostream>
using  namespace std;

#define   BIT3  (0x1<<3)

void Set_bit3(int &a)
{
    a|=BIT3;
}

void Clear_bit3(int &a)
{
    a&=~BIT3;
}

void main()
{
    int m=10;     //1010
    Set_bit3(m);  
    cout<<m<<endl;//1010 == 10
    Clear_bit3(m);
    cout<<m<<endl; //0010 == 2
    
    int n=7;
    Set_bit3(n);
    cout<<n<<endl; //1111 == 15
    Clear_bit3(n);
    cout<<n<<endl; //0111 == 7
}
/*
10
2
15
7
 */

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

（1）

#include<iostream.h>
#include<malloc.h>
#include<string.h>

void GetMemory(char *p,int num)
{
    p=(char *)malloc(sizeof(char)*num);
}

void  main()
{
    char *str = NULL;
    GetMemory(str,100);
    strcpy(str,"hello");
}

//GetMemory函数仅仅只改变了p指针的指向，而str的指向不变
//类似于：
//char  *str=NULL;
//char  *p = str;
//p = (char *)malloc(sizeof(char)*num);
//那么这样的三行代码执行结果显然没有达到改变str的作用

（2）

#include<iostream.h>
#include<string.h>
#include<malloc.h>

void  GetMemory2(char **p,int num)
{
    *p=(char *)malloc(sizeof(char)*num);
}

void main()
{
    char *str = NULL;
    GetMemory2(&str,100);
    strcpy(str,"hello");
    cout<<str<<endl;
    free(str);
}

//GetMemory函数“隔山打牛”
//类似于：
//char  *str=NULL;
//char  **p=&str;
//*p=(char *)malloc(sizeof(char)*num);
//那么这样的三行代码执行结果显然达到改变str的作用

（3）

#include<iostream.h>
#include<malloc.h>
#include<string.h>

char * GetMemory3(int num)
{
    char *p=(char *)malloc(sizeof(char)*num);
    return p;
}

void  main()
{
    char *str=NULL;    
    str=GetMemory3(100);
    strcpy(str,"hello");
    cout<<str<<endl;
    free(str);
}

//GetMemory函数功在当代，利在千秋
//尽管p变量在栈中，它当生则生，当死则死
//但是它在世的一瞬间，却创造了举世的成就，开天辟地！！
//p=(char *)malloc(sizeof(char)*num);一句足矣
//返回p的值,意义无量！

（4）

#include<iostream.h>
#include<string.h>
#include<malloc.h>

char *GetString()
{
    char p[]="hello  world";
    return p;  //编译器警告！！！返回局部变量
}

void  main()
{
    char *str=NULL;
    str=GetString();
    cout<<str<<endl; //垃圾
}

//GetMemory函数山寨版
//p变量在栈中，当生则生，当死则死
//但是它在世的一瞬间，却目光短浅，于后世无功！
//返回p的值,一文不值！

（5）

#include<iostream.h>
#include<string.h>
#include<malloc.h>

char * GetString()
{
    char *p="hello  world!";
    return p;
}

void  main()
{
    char *str=NULL;
    str=GetString();
    cout<<str<<endl;
}

//GetMemory函数正版
//p变量在栈中，当生则生，当死则死
//但是它在世的一瞬间，却赋予了一份常量，不随它的消失而泯灭！

（6）

#include<iostream>
#include<string>
#include<malloc.h>
using namespace std;

void GetString(char *&p)
{
    p=(char *)malloc(sizeof(char)*10);
}

void  main()
{
    char *str=NULL;
    GetString(str);
    strcpy(str,"hello");
    cout<<str<<endl;
    free(str);
    str=NULL;
}

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

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

#include<iostream.h>
#define MAX  255
void main()
{
    unsigned char A[MAX];
    for(int i = 0; i <= MAX; i++)
    {
        A[i] = i;
    }
}

无限循环.......

【4】求最大字段和

示例代码如下：

#include<iostream>
using namespace std;

inline int Max(int a,int b)
{
    return a > b ? a : b; 
}

int MaxSubSum(int br[],int n)
{
    int data= 0,max= 0;
    for(int i=0 ;i<n ;++i)
    {
        data = Max(0,br[i]);       
        max = Max(data+max,max);   
    }
    return max;
}

void main()
{
    int ar[] = {1,-4,-2,-1,7,-3,9};
    int result1 = MaxSubSum(ar,7);
    cout<<result1<<endl;  //17
}

【5】字节对齐

示例代码：

#include<iostream.h>
class A
{
public:
  int i;
};
class  B
{
public:
  char  ch;
};
class C
{
public:
    int i;
    short j;
};
class D
{
public:
    int i;
    short j;
    char ch;
};
class E
{
public:
    int i;
    int ii;
    short j;
    char ch;
    char chr;
};
class F
 {
public:
    int i;
    int ii;
    int iii;
    short j;
    char ch;
    char chr;
};
class G
{
public:
    int i;
    int ii;
    short j;
    char ch;
    char chr;
    int iii;
};
class H
{
public:
    int i;
    int ii;
    char ch;
    char chr;
    int iii;
    short j;
};
class I
{
public:
    int i;
    char ch;
    int ii;
    char chr;
    int iii;
    short j;
};
void  main()
{
    cout<<"sizeof(int): "<<sizeof(int)<<endl;
    cout<<"sizeof(short): "<<sizeof(short)<<endl;
    cout<<"sizeof(char): "<<sizeof(char)<<endl;
    cout<<endl;
    cout<<"sizeof(A): "<<sizeof(A)<<endl;
    cout<<"sizeof(B): "<<sizeof(B)<<endl;
    cout<<"sizeof(C): "<<sizeof(C)<<endl;
    cout<<"sizeof(D): "<<sizeof(D)<<endl;
    cout<<"sizeof(E): "<<sizeof(E)<<endl;
    cout<<"sizeof(F): "<<sizeof(F)<<endl;
    cout<<"sizeof(G): "<<sizeof(G)<<endl;
    cout<<"sizeof(H): "<<sizeof(H)<<endl;
    cout<<"sizeof(I): "<<sizeof(I)<<endl;
}

//Out   put:
/*
sizeof(int): 4
sizeof(short): 2
sizeof(char): 1

sizeof(A): 4
sizeof(B): 1
sizeof(C): 8
sizeof(D): 8
sizeof(E): 12
sizeof(F): 16
sizeof(G): 16
sizeof(H): 20
sizeof(I): 24
*/

【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则为大端模式。

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

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

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

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

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

示例代码如下：

#include<iostream>
using namespace std;

int CheckCpu()
{
    union w
    {
        int a;
        char b;
    }c;
    c.a=1;
    return (c.b==1);
}

void main()
{
    cout<<CheckCpu()<<endl;   //1   //说明是小端模式
}

总结：

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

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

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

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

示例代码如下：

#include<iostream>
using namespace std;

void  select(int ar[],int n)
 {
     int m1, m2;
     m1 = m2 = 0xffff;
     int x1, x2;
     x1 = x2 = 0;
     for(int j = 0; j < n ;j++)    
     {    
         if (ar[j] < m1)
         {
             m2 = m1;    //暂存次小
             x2 = x1;    //暂存次小索引
             m1 = ar[j]; //暂存最小
             x1 = j;     //暂存最小索引
         }
         else if(ar[j] < m2 )
         {
             m2 = ar[j]; //保存次小
             x2 = j;     //保存次小索引             
         }
     }
     cout<<x1<<"   "<<m1<<endl;   //输出最小
     cout<<x2<<"   "<<m2<<endl;   //输出次小
 }
 void  main()
 {
     int ar[5] = {1, 7, 5, 4, 2};
     select(ar,5);
 }

 /*运行结果：
 0   1
 4   2
 */