嵌入式C语言面试题
1、  解释C语言关键字extern、static的含义。

1、  概念基础：

局部变量：函数内部定义的变量（包括定义在函数内部复合语句中的变量）。

全局变量：定义在函数外部的变量。

作用域：任何标识符（包括变量、函数名、符号常量及新的数据名）都有它的作用范围，此范围称为该标识符的作用域。比如符号常量的作用域是从定义符号 常量的地方开始到包含这个#define命令（作用于该符号常量）的文件末尾或者遇到#undef命令（作用于该符号常量）为止。

2、  对于变量：

static关键字：static可以用于修饰局部变量以扩展局部变量的生存期 ，被static关键字修饰的局部变量的生存期为：在调用该变量所在的函数前已生成，直到程序退出才消亡，因此在调用该局部变量所在的函数后该变量仍然存在并保持最后使用的值。虽然static关键字可以改变局部变量的生存期，但是不能改变局部变量的作用域，该局部变量仍然只能在定义它的函数中使用。

       static关键字也可可用于修饰全局变量，此时它的作用在于限制该全局变量的作用域，只能在定义该全局变量的文件中才能使用。

extern关键字：只能用于扩展没有被static关键字修饰的全局变量 。 默认情况下全局变量只能在定义它的文件中使用（从定义该全局变量开始到所在文件的文件尾），但如果在另一个文件中将这个变量声明为外部变量，那么这个变量 的作用域将被扩展到另外一个文件中。也可以在定义全局变量之前声明该变量，从而在文件中可以在定义该全局变量前使用该全局变量。

3、  对于函数：

static关键字：在定义函数时在函数首部的最左边加上static可以把该函数声明为内部函数（又叫静态函数），这样该函数就只能在其定义所在的文件中使用，如果在不同的文件中有同名的内部函数，则互不干扰。

extern关键字：在定义函数时如果在函数首部的最左端冠以关键字extern，则表示此函数是外部函数，可供其他文件调用。C语言规定，如果在定义函数时省略extern，则隐含为外部函数。

       在文件中要调用其他文件中的外部函数，则需要在文件中用extern声明该外部函数，然后就可以使用。


2、  解释C语言关键字volatile、const的含义。
volatile 影响编译器编译的结果,指出，volatile 变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化，以免出错，（VC++ 在产生release版可执行码时会进行编译优化，加volatile关键字的变量有关的运算，将不进行编译优化。）。
例如：
volatile int i=10;
int j = i;
...
int k = i;
volatile 告诉编译器i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的可执行码会重新从i的地址读取数据放在k中。
而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在k中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问，不会出错。

1、什么是const?
常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）

2、为什么引入const？
const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

3、cons有什么主要的作用？
（1）可以定义const常量，具有不可变性。 例如：
const int Max=100; int Array[Max];
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改；
（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max=you want;即可！
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：
void f(const int i) { i=10;//error! }
（5） 为函数重载提供了一个参考。
class A { ......
void f(int i) {......} //一个函数
void f(int i) const {......} //上一个函数的重载 ......
};
（6） 可以节省空间，避免不必要的内存分配。例如：
#define PI 3.14159 //常量宏
const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......
double i=Pi; //此时为Pi分配内存，以后不再分配！
double I=PI; //编译期间进行宏替换，分配内存
double j=Pi; //没有内存分配
double J=PI; //再进行宏替换，又一次分配内存！
const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
（7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。



3、举例说明typedef和define的用法。
typedef和#define的用法与区别
一、typedef的用法
在C/C++语言中，typedef常用来定义一个标识符及关键字的别名，它是语言编译过程的一部分，但它并不实际分配内存空间，实例像：
typedef    int       INT;
typedef    int       ARRAY[10];
typedef   (int*)   pINT;
typedef可以增强程序的可读性，以及标识符的灵活性，但它也有“非直观性”等缺点。
二、#define的用法
#define为一宏定义语句，通常用它来定义常量(包括无参量与带参量)，以及用来实现那些“表面似和善、背后一长串”的宏，它本身并不在编
译过程中进行，而是在这之前(预处理过程)就已经完成了，但也因此难以发现潜在的错误及其它代码维护问题，它的实例像：
#define   INT             int
#define   TRUE         1
#define   Add(a,b)     ((a)+(b));
#define   Loop_10    for (int i=0; i<10; i++)
在Scott Meyer的Effective C++一书的条款1中有关于#define语句弊端的分析，以及好的替代方法，大家可参看。
三、typedef与#define的区别
从以上的概念便也能基本清楚，typedef只是为了增加可读性而为标识符另起的新名称(仅仅只是个别名)，而#define原本在C中是为了定义常量
，到了C++，const、enum、inline的出现使它也渐渐成为了起别名的工具。有时很容易搞不清楚与typedef两者到底该用哪个好，如#define
INT int这样的语句，用typedef一样可以完成，用哪个好呢？我主张用typedef，因为在早期的许多C编译器中这条语句是非法的，只是现今的
编译器又做了扩充。为了尽可能地兼容，一般都遵循#define定义“可读”的常量以及一些宏语句的任务，而typedef则常用来定义关键字、冗
长的类型的别名。
宏定义只是简单的字符串代换(原地扩展)，而typedef则不是原地扩展，它的新名字具有一定的封装性，以致于新命名的标识符具有更易定义变
量的功能。请看上面第一大点代码的第三行：
typedef    (int*)      pINT;
以及下面这行:
#define    pINT2    int*
效果相同？实则不同！实践中见差别：
pINT a,b;的效果同int *a; int *b;表示定义了两个整型指针变量。
而pINT2 a,b;的效果同int *a, b;表示定义了一个整型指针变量a和整型变量b。



typedef的四个用途和两个陷阱
用途一：
定义一种类型的别名，而不只是简单的宏替换。可以用作同时声明指针型的多个对象。比如：
char*   pa,   pb;     //   这多数不符合我们的意图，它只声明了一个指向字符变量的指针，  
//   和一个字符变量；
以下则可行：
typedef   char*   PCHAR;     //   一般用大写
PCHAR   pa,   pb;                 //   可行，同时声明了两个指向字符变量的指针
虽然：
char   *pa,   *pb;
也可行，但相对来说没有用typedef的形式直观，尤其在需要大量指针的地方，typedef的方式更省事。

用途二：
用在旧的C代码中（具体多旧没有查），帮助struct。以前的代码中，声明struct新对象时，必须要带上struct，即形式为：   struct   结构名   对象名，如：
struct   tagPOINT1
{
       int   x;
       int   y;
};
struct   tagPOINT1   p1;  

而在C++中，则可以直接写：结构名   对象名，即：
tagPOINT1   p1;

估计某人觉得经常多写一个struct太麻烦了，于是就发明了：
typedef   struct   tagPOINT
{
       int   x;
       int   y;
}POINT;

POINT   p1;   //   这样就比原来的方式少写了一个struct，比较省事，尤其在大量使用的时候

或许，在C++中，typedef的这种用途二不是很大，但是理解了它，对掌握以前的旧代码还是有帮助的，毕竟我们在项目中有可能会遇到较早些年代遗留下来的代码。

用途三：
用typedef来定义与平台无关的类型。
比如定义一个叫   REAL   的浮点类型，在目标平台一上，让它表示最高精度的类型为：
typedef   long   double   REAL;  
在不支持   long   double   的平台二上，改为：
typedef   double   REAL;  
在连   double   都不支持的平台三上，改为：
typedef   float   REAL;  
也就是说，当跨平台时，只要改下   typedef   本身就行，不用对其他源码做任何修改。
标准库就广泛使用了这个技巧，比如size_t。
另外，因为typedef是定义了一种类型的新别名，不是简单的字符串替换，所以它比宏来得稳健（虽然用宏有时也可以完成以上的用途）。

用途四：
为复杂的声明定义一个新的简单的别名。方法是：在原来的声明里逐步用别名替换一部分复杂声明，如此循环，把带变量名的部分留到最后替换，得到的就是原声明的最简化版。举例：

1.   原声明：int   *(*a[5])(int,   char*);
变量名为a，直接用一个新别名pFun替换a就可以了：
typedef   int   *(*pFun)(int,   char*);  
原声明的最简化版：
pFun   a[5];  

2.   原声明：void   (*b[10])   (void   (*)());
变量名为b，先替换右边部分括号里的，pFunParam为别名一：
typedef   void   (*pFunParam)();
再替换左边的变量b，pFunx为别名二：
typedef   void   (*pFunx)(pFunParam);
原声明的最简化版：
pFunx   b[10];

3.   原声明：doube(*)()   (*e)[9];  
变量名为e，先替换左边部分，pFuny为别名一：
typedef   double(*pFuny)();
再替换右边的变量e，pFunParamy为别名二
typedef   pFuny   (*pFunParamy)[9];
原声明的最简化版：
pFunParamy   e;  

理解复杂声明可用的“右左法则”：从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。举例：
int   (*func)(int   *p);
首先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int。
int   (*func[5])(int   *);
func右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明func的元素是指针（注意这里的*不是修饰func，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指针，它指向的函数具有int*类型的形参，返回值类型为int。

也可以记住2个模式：
type   (*)(....)函数指针  
type   (*)[]数组指针  
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

陷阱一：
记住，typedef是定义了一种类型的新别名，不同于宏，它不是简单的字符串替换。比如：
先定义：
typedef   char*   PSTR;
然后：
int   mystrcmp(const   PSTR,   const   PSTR);

const   PSTR实际上相当于const   char*吗？不是的，它实际上相当于char*   const。
原因在于const给予了整个指针本身以常量性，也就是形成了常量指针char*   const。
简单来说，记住当const和typedef一起出现时，typedef不会是简单的字符串替换就行。

陷阱二：
typedef在语法上是一个存储类的关键字（如auto、extern、mutable、static、register等一样），虽然它并不真正影响对象的存储特性，如：
typedef   static   int   INT2;   //不可行
编译将失败，会提示“指定了一个以上的存储类”。

　 4、语句for( ；1 ；)有什么问题？它是什么意思？

　　5、do……while和while……do有什么区别？

　　6、请写出下列代码的输出内容

　　#include

　　main()

　　{

　　　int a,b,c,d;

　　　a=10;

　　　b=a++;

　　　c=++a;

　　　d=10*a++;

　　　printf(“b，c，d：%d，%d，%d”，b，c，d）;

　　　return 0;

　　}

答：13, 10, 12, 120

　　7、设有以下说明和定义：（32位编译器情况下）

　　typedef union {long i; int k[5]; char c;} DATE;

　　struct data { int cat; DATE cow; double dog;} too;

　　DATE max;

　　则语句 printf(“%d”,sizeof(struct date)+sizeof(max));的执行结果是：__52_____

8、下面是51单片机最小系统电路图，试分析该电路结构以及实现原理？

9、谈谈汇编语言、C和C++三种语言在嵌入式开发中的区别和特点？简述你对嵌入式概念的理解？

10、列举常见的嵌入式操作系统和单片机？简要介绍你以前做过的项目，在项目中用过什么处理器和操作系统，实现什么功能以及关键技术。