面试题（1）

【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;     //0111
    Set_bit3(n);
    cout << n << endl; //1111 == 15
    Clear_bit3(n);
    cout << n << endl; //0111 == 7

    int s = 3;     //0011
    Set_bit3(s);
    cout << s << endl; //1011 == 11
    Clear_bit3(s);
    cout << s << endl; //0111 == 3

    system("pause");
}
// run out
/*
10
2
15
7
11
3
请按任意键继续. . .
 */

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

（1）

#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的指向不变
// 类似于：
// (1) char  *str = NULL;
// (2) char  *p = str;
// (3) p = (char *)malloc(sizeof(char) * num);
// 那么这样的三行代码执行结果显然没有达到改变str的作用

（2）

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

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

void main()
{
    char *str = NULL;
    GetMemory2(&str, 100);
    strcpy(str, "hello");
    printf("%s", str);
    free(str);
    getchar();
}

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

（3）

#include<string.h>
#include<malloc.h>
#include<stdio.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");
    printf("%s", str);
    free(str);
    getchar();
}

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

（4）

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

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

void  main()
{
    char *str = NULL;
    str = GetMemory4();
    printf("%s", str);
}

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

（5）

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

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

void  main()
{
    char *str = NULL;
    str = GetMemory5();
    printf("%s", str);
    getchar();
}

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

（6）

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

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

void  main()
{
    char *str = NULL;
    GetMemory6(str);
    strcpy(str, "hello");
    printf("%s", str);
    free(str);
    str = NULL;
    getchar();
}

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

【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>
using namespace std;

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;
    system("pause");
}

//run out:
/*
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);
     system("pause");
 }

 /* run out：
 0   1
 4   2
 */

 

Good Good Study, Day Day Up.

顺序  选择  循环  坚持