1、输出2,5      【注意指针指向的类型，操作指针的时候才知道指针移动的字节】
 
int main(){ 
    inta[5]={1,2,3,4,5};   
    int *ptr=(int*)(&a+1);//a指向int类型，&a指向数组类型
    printf("%d,%d",*(a+1),*(ptr-1));
}
 
2、死锁
 
产生死锁的必要条件：（1）互斥条件（资源一次只允许一个进程访问）；（2）不可剥夺条件（进程使用资源未完成之前，不能强行夺走）；（3）请求和保持条件（一个进程已经占有一个资源，还想获取另一个资源）；（4）循环等待条件。
 
产生死锁的原因：资源竞争，进程推进顺序错误。
 
死锁的处理：
 
预防死锁：通过设置某些限制条件，去破坏产生死锁的四个必要条件中的一个或几个条件，来防止死锁的发生。
 避免死锁：在资源的动态分配过程中，用某种方法去防止系统进入不安全状态，从而避免死锁的发生。
 检测死锁：允许系统在运行过程中发生死锁，但可设置检测机构及时检测死锁的发生，并采取适当措施加以清除。
 解除死锁：当检测出死锁后，便采取适当措施将进程从死锁状态中解脱出来。
 
3、main函数的返回值：C标准要求定义 int main()；   默认缺省的也是int 。返回值一般用来指示程序运行是否正确。
 
4、要对绝对地址0x100000赋值，我们可以用 (unsigned int*)0x100000 =1234; 那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
 
答：
 
((void (*)())0x100000)();
 
5、如下代码输出？
 
unsigned short A = 10; \\10自身是有符号数，10u才是无符号数
printf("~A = %u\n", ~A); \\出现无符号数的高位扩展，高位补符号位
char c=128; \\字符类型表示范围：-128~127
printf("c=%d\n",c); \\出现有符号数的位数扩展，高位补符号位
 
答案：4294967285   和    -128。
 
https://blog.csdn.net/weixin_38812277/article/details/90702682
 
 
 
6、用两个栈实现一个队列。【代码详见另一篇博客】
 
7、以下代码输出25 7
 
#define SQ(a) (a)*(a)
int main(){
	int a = 5;
	int b = SQ(a++);
	printf("%d %d",b,a);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

华为嵌入式软件开发笔试题：
 在一字符串中使用****隐藏敏感字符？
 
#include "stdio.h"
int main()
{
	int i=0, j=0,YS_LEN,MG_LEN,k=0,L=0,M=0,BZ;
	/* BZ为标记位，YS_LEN为待隐藏字符串,MG_LEN为敏感字符，L为待隐藏字符串指针，k为敏感字符串指针  */
	char a[1000];
	char b[1000];
	//*****************************************输入
	printf("请输入：");
		scanf_s("%c", &a[i]);
	while (a[i] != '#')
	{
		i++;
		scanf_s("%c", &a[i]);
	}
	YS_LEN = i;
	printf("请输入：");
		scanf_s("%c", &b[j]);
	while (b[j] !='#')
	{
		j++;
		scanf_s("%c", &b[j]);
	}
	MG_LEN = j-1;
//测试用的输出
	printf("b[0]=%c\n", b[1]);
	printf("MG_LEN=%d\n", MG_LEN);
	printf("YS_LEN=%d\n", YS_LEN);
//*********************************************处理
	while (L <= YS_LEN - MG_LEN )
	{
		while (a[L]!= b[1]&& L <= YS_LEN - MG_LEN)//**
		{
			L++;
			printf(" L=%d ", L);
			printf(" a[L]=%d ", a[L]);
			printf(" b[0]=%d\n", b[1]);
		}
		BZ = L;
		printf(" BZ=%d\n", BZ);
		k = 1;
 //测试用的输出
		printf("  b[k]=%d\n", b[k]);
		printf("  a[L]=%d\n", a[L]);
		printf("MG_LEN=%d\n", MG_LEN);
		while (a[L] == b[k] && k <= MG_LEN )
		{
			k++;
			L++;
 //测试用的输出
			printf("  b[k]=%d\n", b[k]);
			printf("  a[L]=%d\n", a[L]);
			printf("MG_LEN=%d\n", MG_LEN);
		}
//测试用的输出
		printf("k=%d\n", k);
		printf("MG_LEN=%d\n", MG_LEN);
		if (k ==MG_LEN+1)
		{
			for (i = 0; i < MG_LEN; i++)
			{
				a[i + BZ] = '*';
			}
			k = 1;
			L = BZ + MG_LEN;
		}
		else
		{
			k = 1;
			L = BZ + 1;
		}
	}
	for (i = 0; i < YS_LEN; i++)
	{
		printf("%c", a[i]);
	}
//测试用的输出
	printf("\n");
	printf("打印b");
	for (i = 1; i <= MG_LEN; i++)
	{
		printf("%c", b[i]);
	}
	return 0;
}

1）什么是预编译，何时需要预编译：
 
答案：
 
１、总是使用不经常改动的大型代码体。
 
２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。
 
预编译指令指示了在程序正式编译前就由编译器进行的操作，可以放在程序中的任何位置。
 
（2）char * constp char const * p const char *p 上述三个有什么区别？
 
答案：
 
char * const p; //常量指针，p的值不可以修改
 
char const * p；//指向常量的指针，指向的常量值不可以改 const char *p； //和char const *p
 
char * const p是一个char型指针，指针是常量，不允许修改，即类似p=q的语句是错误的； 
 char const * p和const char * p是同一种char型指针，指针指向的字符被看作是常量，不允许修改，即类似*p = q的语句是错误的。
 
（3）char str1[] = “abc”; charstr2[] = “abc”; const char str3[] = “abc”; const charstr4[] = “abc”; const char *str5 = “abc”; const char *str6= “abc”; char *str7 = “abc”; char *str8 = “abc”;cout < < ( str1 == str2 ) < < endl; cout < < ( str3 == str4 )< < endl; cout < < ( str5 == str6 ) < < endl; cout < <( str7 == str8 ) < < endl;
 
结果是：0 0 1 1str1,str2,str3,str4是数组变量，它们有各自的内存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。
 
（4）以下代码中的两个sizeof用法有问题吗？
 
[C易] void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母{ for( size_t i=0; i 
 
include 
 
include 
 
define SQUARE(a) ((a)*(a))
 
int a=5; 
 
int b; 
 
b=SQUARE(a++);
 
答案：这个没有问题，s（a＋＋），就是（（a＋＋）×（a＋＋））唯一要注意的就是计算后a＝7了
 
3: typedef unsigned char BYTE
 
intexamply_fun(BYTE gt_len; BYTE *gt_code)
 
{
 
BYTE *gt_buf; 
 
gt_buf=(BYTE )MALLOC(Max_GT_Length); 
 
......     
 
if(gt_len>Max_GT_Length) 
 
{ 
 
return GT_Length_ERROR; 
 
} 
 
……. 
 
}
 
答案：要释放内存问答题:
 
1.IP Phone的原理是什么?
 
答案：IPV6
 
2.TCP/IP通信建立的过程怎样，端口有什么作用？
 
答案：三次握手，确定是哪个应用程序使用该协议
 
（三）
 
1、局部变量能否和全局变量重名？
 
答案：能，局部会屏蔽全局。要用全局变量，需要使用”::” 局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内
 
2、如何引用一个已经定义过的全局变量？
 
答案：extern 可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错
 
3、全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？
 
答案：可以，在不同的C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错
 
4、语句for( ；1 ；)有什么问题？它是什么意思？
 
答案：和while(1)相同。
 
5、do……while和while……do有什么区别？
 
答案：前一个循环一遍再判断，后一个判断以后再循环。
 
6、请写出下列代码的输出内容＃include 
 
define MAX_SRM 256
 
DSN get_SRM_no()
 
{ 
 
static int SRM_no; 
 
int I; 
 
for(I=0;I

 
【程序员面试宝典】
 
 
 
1 读程序段，回答问题
(a) 
 int main(int argc,char *argv[])
 {
 int c=9,d=0;
 c=c++%5;
 d=c;
 printf("d=%d\n",d);
 return 0;
 }
 a) 写出程序输出
 b) 在一个可移植的系统中这种表达式是否存在风险？why?
 答案：5
 存在风险，因为c=c++%5;这个表达式对c有两次修改，行为未定义，c的值不确定
(b)
 #include "stdio.h"
 int a=0; // data section
 int b;   // data section
 static char c;  // BSS
 int main(int argc,char *argv[])
 {
 char d=4;  // stack
 static short e;    // BSS
 a++;
 b=100;
 c=(char)++a;
 e=(++d)++;
 printf("a=%d, b=%d, c=%d, d= %d, e=%d",a,b,c,d,e);
 return 0;
 }
 a) 写出程序输出
 b) 编译器如果安排各个变量(a,b,c,d)在内存中的布局(eg. stack,heap,data section,bss section),最好用图形方式描述。
 答案：a=2,b=100,c=2,d=6,e=5
 
重入一般可以理解为一个函数在同时多次调用，例如操作系统在进程调度过程中，或者单片机、处理器等的中断的时候会发生重入的现象。
 一般浮点运算都是由专门的硬件来完成，举个例子假设有个硬件寄存器名字叫做FLOAT，用来计算和存放浮点数的中间运算结果
 假设有这么个函数
 void fun()
 {
 //...这个函数对FLOAT寄存器进行操作
 }
 假如第一次执行，有个对浮点数操作运算的结果临时存在FLOAT寄存器中，而就在这时被中断了，而中断函数或者另一个进程也调用fun函数，这时第二次调用的fun函数在执行的过程中就会破坏第一次FLOAT寄存器中的结果，这样当返回到第一次fun函数的时候，结果就不正确了。

 可以把fun函数理解为printf()函数。
 
 
 
3.Heap与Stack的差别？【程序员面试宝典】
 
答案：Heap是堆，Stack是栈。
 
Stack的空间由系统自动分配/释放，Heap上的空间手动分配/释放。
 
Stack空间有限，Heap是很大的自由存储区，malloc函数分配的内存空间即在堆上。
 
网上经典例子：
 
int a = 0; //全局初始化区 
 
char *p1;//全局未初始化区 
 
void main(void)
 
{
 
  int b; //栈 
 
  char s[] = "abc"; //栈 
 
  char *p2; //栈 
 
  char *p3 = "123456"; //123456\0在常量区，p3在栈上
 
  static int c =0; //全局（静态）初始化区 
 
  p1 = (char *)malloc(10); //堆 
 
  p2 = (char *)malloc(20); //堆 
 
}
 
 
 
 
 
 
 
 
9.sizeof和strlen的区别?
 
答案：sizeof是运算符，在编译时即计算好了； 而strlen是函数，要在运行时才能计算。
 

 4 嵌入式系统相关问题
a) 对于整形变量A=0x12345678,请画出在little endian及big endian的方式下在内存中是如何存储的。
 little endian                big endian 刚好反过来
   高地址--〉 0x12      低地址--〉  0x12
                    0x34                          0x34
                    0x56                          0x56
   低地址--〉 0x78       高地址--〉 0x78
 
b) 在ARM系统中，函数调用的时候，参数是通过哪种方式传递的?
 参数<=4时候，通过R0~R3传递，>4的通过压栈方式传递
 
c) 中断(interrupt,如键盘中断)与异常(exception,如除零异常)有何区别?
 异常：在产生时必须考虑与处理器的时钟同步，实践上，异常也称为同步中断。在处理器执行到由于编程失误而导致的错误指令时，或者在执行期间出现特殊情况(如缺页)，必须靠内核处理的时候，处理器就会产生一个异常。
 所谓中断应该是指外部硬件产生的一个电信号，从cpu的中断引脚进入，打断cpu当前的运行；
 所谓异常，是指软件运行中发生了一些必须作出处理的事件，cpu自动产生一个陷入来打断当前运行，转入异常处理流程。
 
5 设周期性任务P1,P2,P3的周期为T1,T2,T3分别为100，150，400；执行时间分别为20，40，100。请设计一种调度算法进行任务调度，满足任务执行周期及任务周期。
 
6 优先级反转问题在嵌入式系统中是一中严重的问题，必须给与足够重视。
 a) 首先请解释优先级反转问题
 b) 很多RTOS提供优先级继承策略(Priority inheritance)和优先级天花板策略(Priority ceilings)用来解决优先级反转问题，请讨论这两种策略。
  
 高优先级任务需要等待低优先级任务释放资源，而低优先级任务又正在等待中等优先级任务的现象叫做优先级反转
   优先级继承策略(Priority inheritance):继承现有被阻塞任务的最高优先级作为其优先级，任务退出临界区，恢
 复初始优先级。
   优先级天花板策略(Priority ceilings):控制访问临界资源的信号量的优先级天花板。
   优先级继承策略对任务执行流程的影响相对教小，因为只有当高优先级任务申请已被低优先级任务占有的临界资源
 这一事实发生时，才抬升低优先级任务的优先级。
 

 预处理器（Preprocessor）
 
1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）
          #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 【程序员面试宝典】
 我在这想看到几件事情：
 1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）
 2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。
 3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
 4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。
 
2 . 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。
         #define MIN(A,B) （（A） <= (B) ? (A) : (B))  【程序员面试宝典】
 这个测试是为下面的目的而设的：
 1) 标识#define在宏中应用的基本知识。这是很重要的。因为在  嵌入(inline)操作符 变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。
 2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。
 3) 懂得在宏中小心地把参数用括号括起来
 4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
         least = MIN(*p++, b);
 
3. 预处理器标识#error的目的是什么？
 如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。
 

 死循环（Infinite loops）
 
4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？
 这个问题用几个解决方案。我首选的方案是：
 
while(1)
 {
 
}
 
一些程序员更喜欢如下方案：
 
for(;;)
 {
 
}
 
这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。
 
第三个方案是用 goto
 Loop:
 ...
 goto Loop;
 应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。
 

 数据声明（Data declarations）
 
5. 用变量a给出下面的定义
a) 一个整型数（An integer） 
 b)一个指向整型数的指针（ A pointer to an integer） 
 c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r 
 d)一个有10个整型数的数组（ An array of 10 integers） 
 e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers） 
 f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers） 
 g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer） 
 h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ） 【程序员面试宝典】
 
答案是： 
 a) int a; // An integer 
 b) int *a; // A pointer to an integer 
 c) int **a; // A pointer to a pointer to an integer 
 d) int a[10]; // An array of 10 integers 
 e) int *a[10]; // An array of 10 pointers to integers 
 f) int (*a)[10]; // A pointer to an array of 10 integers 
 g) int (*a)(int); // A pointer to a function a that takes an integer argument and returns an integer 
 h) int (*a[10])(int); // An array of 10 pointers to functions that take an integer argument and return an integer
 
人们经常声称这里有几个问题是那种要翻一下书才能回答的问题，我同意这种说法。当我写这篇文章时，为了确定语法的正确性，我的确查了一下书。但是当我被面试 的时候，我期望被问到这个问题（或者相近的问题）。因为在被面试的这段时间里，我确定我知道这个问题的答案。应试者如果不知道所有的答案（或至少大部分答 案），那么也就没有为这次面试做准备，如果该面试者没有为这次面试做准备，那么他又能为什么出准备呢？
 
Static
 
6. 关键字static的作用是什么？【程序员面试宝典】
 这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：
 1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
 2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
 3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。
 
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
 
     static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
      static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
      static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
 

 Const
 
7．关键字const有什么含意？
 我只要一听到被面试者说："const意味着常数"，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着"只读"就可 以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）
 如果应试者能正确回答这个问题，我将问他一个附加的问题：
下面的声明都是什么意思？【程序员面试宝典】
 
const int a;
 int const a;
 const int *a;
 int * const a;
 int const * a const;
 
/******/
 前 两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型 数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数 是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：
 1) 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理 其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）
 2) 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。
 3) 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。
 

 Volatile
 
8. 关键字volatile有什么含意?并给出三个不同的例子。【程序员面试宝典】
一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：
 1) 并行设备的硬件寄存器（如：状态寄存器）
 2) 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)
 3) 多线程应用中被几个任务共享的变量
 
回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。搞嵌入式的家伙们经常同硬件、中断、RTOS等等打交道，所有这些都要求用到volatile变量。不懂得volatile的内容将会带来灾难。
 假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。
1)一个参数既可以是const还可以是volatile吗？解释为什么。
 2); 一个指针可以是volatile 吗？解释为什么。
 3); 下面的函数有什么错误：【程序员面试宝典】
 
int square(volatile int *ptr)
 {
         return *ptr * *ptr;
 }
 
下面是答案：
 1)是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。
 2); 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。
 3) 这段代码有点变态。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：
 
int square(volatile int *ptr) 
 {
     int a,b;
     a = *ptr;
     b = *ptr;
     return a * b;
 }
 
由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：
 
long square(volatile int *ptr) 
 {
     int a;
     a = *ptr;
     return a * a;
 }
 
位操作（Bit manipulation）
 
9. 嵌入式系统总是要用户对变量或寄存器进行位操作。给定一个整型变量a，写两段代码，第一个设置a的bit 3，第二个清除a 的bit 3。在以上两个操作中，要保持其它位不变。【程序员面试宝典】
 对这个问题有三种基本的反应
 1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
 2) 用bit fields。Bit fields是被扔到C语言死角的东西，它保证你的代码在不同编译器之间是不可移植的，同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序，它用到了bit fields因此完全对我无用，因为我的编译器用其它的方式来实现bit fields的。从道德讲：永远不要让一个非嵌入式的家伙粘实际硬件的边。
 3) 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法，是应该被用到的方法。最佳的解决方案如下：
 
#define BIT3 (0x1 << 3)
 static int a;
 
void set_bit3(void) 
 {
     a |= BIT3;
 }
 void clear_bit3(void) 
 {
     a &= ~BIT3;
 }
 
一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数，这也是可以接受的。我希望看到几个要点：说明常数、|=和&=~操作。
 

 访问固定的内存位置（Accessing fixed memory locations）
 
10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。【程序员面试宝典】
 这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同。典型的类似代码如下：
     int *ptr;
     ptr = (int *)0x67a9;
     *ptr = 0xaa55;
 
 A more obscure approach is: 
 一个较晦涩的方法是：
 
    *(int * const)(0x67a9) = 0xaa55;
 
即使你的品味更接近第二种方案，但我建议你在面试时使用第一种方案。
 
中断（Interrupts）
 
11. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字 __interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。【程序员面试宝典】
 
__interrupt double compute_area (double radius) 
 {
     double area = PI * radius * radius;
     printf("\nArea = %f", area);
     return area;
 }
 
这个函数有太多的错误了，以至让人不知从何说起了：
 1) ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
 2) ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
 3) 在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
 4) 与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。
 

 代码例子（Code examples）
 
12 . 下面的代码输出是什么，为什么？
 
void foo(void)
 {
     unsigned int a = 6;
     int b = -20;
     (a+b > 6) ? puts("> 6") : puts("<= 6");
 }
这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式 计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。
 
13. 评价下面的代码片断：【程序员面试宝典】
 
unsigned int zero = 0;
 unsigned int compzero = 0xFFFF; 
 /*1's complement of zero */
 
对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：
 
unsigned int compzero = ~0;
 
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
 到 了这个阶段，应试者或者完全垂头丧气了或者信心满满志在必得。如果显然应试者不是很好，那么这个测试就在这里结束了。但如果显然应试者做得不错，那么我就 扔出下面的追加问题，这些问题是比较难的，我想仅仅非常优秀的应试者能做得不错。提出这些问题，我希望更多看到应试者应付问题的方法，而不是答案。不管如 何，你就当是这个娱乐吧...
 

 动态内存分配（Dynamic memory allocation）
 
14. 尽管不像非嵌入式计算机那么常见，嵌入式系统还是有从堆（heap）中动态分配内存的过程的。那么嵌入式系统中，动态分配内存可能发生的问题是什么？
 这 里，我期望应试者能提到内存碎片，碎片收集的问题，变量的持行时间等等。这个主题已经在ESP杂志中被广泛地讨论过了（主要是 P.J. Plauger, 他的解释远远超过我这里能提到的任何解释），所有回过头看一下这些杂志吧！让应试者进入一种虚假的安全感觉后，我拿出这么一个小节目：
下面的代码片段的输出是什么，为什么？【程序员面试宝典】
 
char *ptr;
 if ((ptr = (char *)malloc(0)) == NULL) 
     puts("Got a null pointer");
 else
     puts("Got a valid pointer");
 
这 是一个有趣的问题。最近在我的一个同事不经意把0值传给了函数malloc，得到了一个合法的指针之后，我才想到这个问题。这就是上面的代码，该代码的输 出是"Got a valid pointer"。我用这个来开始讨论这样的一问题，看看被面试者是否想到库例程这样做是正确。得到正确的答案固然重要，但解决问题的方法和你做决定的基 本原理更重要些。
 
Typedef 
  
15 Typedef 在C语言中频繁用以声明一个已经存在的数据类型的同义字。也可以用预处理器做类似的事。例如，思考一下下面的例子：
 
#define dPS struct s *
 typedef struct s * tPS;
 
以上两种情况的意图都是要定义dPS 和 tPS 作为一个指向结构s指针。哪种方法更好呢？（如果有的话）为什么？
 这是一个非常微妙的问题，任何人答对这个问题（正当的原因）是应当被恭喜的。答案是：typedef更好。思考下面的例子：
 
dPS p1,p2;
 tPS p3,p4;
 
第一个扩展为
 
struct s * p1, p2;
 .
 上面的代码定义p1为一个指向结构的指，p2为一个实际的结构，这也许不是你想要的。第二个例子正确地定义了p3 和p4 两个指针。
 
 
 
晦涩的语法
 
16 . C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什么？
 
int a = 5, b = 7, c;
 c = a+++b;
 
这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：
 
c = a++ + b;
 
因此, 这段代码持行后a = 6, b = 7, c = 12。
 如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。
 
 
 
12：引用和指针有什么区别？
       1:应用必须初始化，指针不必；
        2：引用处画化后不能改变，指针可以被改变；
        3：不存在指向空值的引用，但存在指向空值的指针；
    13：全局变量与局部变量在内存中是否有区别，是什么区别？
         全局变量存储在静态数据库，局部变量存储在堆栈；
 14：写出float，bool，int 类型与零的比较，假设变量为X：
        Int ：    if（x==0）
        Float：    if（x>0.0000001&&x）
        Bool:      if(x==false)
 15:Intertnet采用哪种网络协议，该协议的主要层次结构？
    TCP/IP协议
 应用层/传输层/网络层/数字链路层/物理层。
 16：IP地址有两部分组成： 网络号和主机号
 17：程序的局部变量存储在（栈）中，全局变量存储于（静态存储区），动态申请数据存储于（堆中）；
 18：编写一个字符串复制函数：strcpy（const char *str，const char *str1）
          void strcpy(const *char str,const chat *str1)
             {
                if(*str1==’\0’) return;
 char *sp1,*sp2;
 sp1= str;
 sp2=str1;
 while(*sp2!=’\0’)
 {
 *sp1=sp2;
 sp1++;
 sp2++;
 }
 }
 19:编写一个函数实现字符串翻转 void rechange（char *str）
            void rechange（char *str）
                {
 Int len；
 char t；
 len=strlen（str）；
 for（int i=0；len/2；i++）
 {
 t=str;
 str=str[len-i-1];
 str[len-i-1]=t;
 }
 } 
 20:编写一个函数实现字符串比较 int strcmp（char *str1，char *str2）,相等返回1，不相等返回0：
    int strcmp（char *str1，char *str2）
 {
 if（*str1==‘\0’||*str2==’\0’） return;
 while(*str1！=’\0’&&*str2！=’\0’&&*str1==*str2)
 {
 str1++；
 str2++；
 }
 if(*str1==*str2)
 return 1;
 else return 0;
 }
 }
 21：进程和线程的区别：
      1：调度：线程作为调度和分配的基本单元，进程作为拥有资源的基本单位；
       2：并发性：不仅进程可以并发执行，同一进程内的线程也可以并发执行。
       3：拥有资源：进程是拥有资源的基本独立单元，线程不拥有资源，但可以访问进程内的资源；
 4：在创建或撤销线程时，由于系统都要为之分配和回收内存资源，导致系统的开销明显大于创建或撤销线程时的开销。