【嵌入式注意的细节】嵌入式开发中易失误的细节（笔试题）
#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL
我在这想看到几件事情：
1) 括号的使用 ；
2)意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。
3) 表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。
#define MIN(A,B) （（A） <= (B) ? (A) : (B))
1) 懂得在宏中小心地把参数用括号括起来
2) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？
least = MIN(*p++, b); // *p++ <=b? *p++:b;
h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（ An array of ten pointers to functions that take an integer argument and return an integer ）
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) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。(本地函数）
大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。
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;
}
访问固定的内存位置（Accessing fixed memory locations）
10. 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。
这一问题测试你是否知道为了访问一绝对地址把一个整型数（0x67a9）强制转换（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()经常有重入和性能上的问题。如果你丢掉了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了。
可重入函数一般不包括全局变量，不会用到浮点寄存器（因为浮点寄存器的上下文可能不会保存），而且要注意竟态的情况（会造成数据不一致）。
unsigned int zero = 0;
unsigned int compzero = 0xFFFF;
对于一个int型不是16位的处理器为说，上面的代码是不正确的。应编写如下：
unsigned int compzero = ~0;
这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。
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 两个指针。
在启动阶段分为stage1和stage2
stage1就是在rom中执行的。
看到书上说为了让stage2执行得快点 就要将其拷贝到ram中去执行
所以我就想问问 为什么在ram中运行比在rom中运行要快
试题1：请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1
解答：
int checkCPU( )
{
{
union w
{
int a;
char b;
} c;
c.a = 1;
return(c.b ==1);
}
}
剖析：
嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
| 内存地址 | 0x4000 | 0x4001 |
| 存放内容 | 0x34 | 0x12 |
而在Big-endian模式CPU内存中的存放方式则为：
| 内存地址 | 0x4000 | 0x4001 |
| 存放内容 | 0x12 | 0x34 |
32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
| 内存地址 | 0x4000 | 0x4001 | 0x4002 | 0x4003 |
| 存放内容 | 0x78 | 0x56 | 0x34 | 0x12 |
而在Big-endian模式CPU内存中的存放方式则为：
| 内存地址 | 0x4000 | 0x4001 | 0x4002 | 0x4003 |
| 存放内容 | 0x12 | 0x34 | 0x56 | 0x78 |
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。如果谁能当场给出这个解答，那简直就是一个天才的程序员。
3、在C++程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？ （5分）
答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);
该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。
2.
char str[] = “Hello” ;
char *p = str ;
int n = 10;
请计算
sizeof (str ) = 6 （2分）
sizeof ( p ) = 4 （2分）
sizeof ( n ) = 4 （2分）
void Func ( char str[100])
{
请计算
sizeof( str ) = 4 （2分）
}
void *p = malloc( 100 );
请计算
sizeof ( p ) = 4 （2分）
在32位处理器上指针的长度为4字节,为什么是4字节,而不是16字节,或者32字节,哪位详细的解释清楚
果你学过汇编的话就会很清楚了，但是没学过也没关系。首先教你两个名词 地址和偏移地址(物理地址=段地址*16+偏移地址)。段地址和偏移地址都可以由四位十六进制（用十六进制只是为了表示方便，用二进制表示的话太长了）组成如：ffff:0000 面表示段地址后面表示偏移地址，计算机中每四位二进制可以表示一个十六进制数，那么八位就表示两个十六进制了也就是说两个十六进制数表示一个字节，那么 地址占两个字节移地址占两个字节加起来就是四个字节了，而指针变量存放的就是偏移地址和段地址，自然也就是占四个字节了。
4.有关内存的思考题
其他技巧： 锐捷笔试3.定义一个宏把第二位清零，其余位取反 答：#define NBL(a) (((a)&(~2))^2)
void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
请问运行Test函数会有什么样的结果？
答:程序崩溃。
因为GetMemory并不能传递动态内存，
Test函数中的 str一直都是 NULL。
strcpy(str, "hello world");将使程序崩溃。
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
请问运行Test函数会有什么样的结果？
答：可能是乱码。
因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
请问运行Test函数会有什么样的结果？
答：
（1）能够输出hello
（2）内存泄漏
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}
请问运行Test函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预料，非常危险。
因为free(str);之后，str成为野指针，
if(str != NULL)语句不起作用。
6。main()
{
int a[5]={1,2,3,4,5};
int *ptr=(int *)(&a+1);
printf("%d,%d",*(a+1),*(ptr-1));
}
答案：2。5 *(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5。 &a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int） int *ptr=(int *)(&a+1); 则ptr实际是&(a[5]),也就是a+5 原因如下： &a是数组指针，其类型为 int (*)[5]; 而指针加1要根据指针类型加上一定的值，不同类型的指针+1之后增加的大小不同 a是长度为5的int数组指针，所以要加 5*sizeof(int) 所以ptr实际是a[5] 但是prt与(&a+1)类型是不一样的(这点很重要) 所以prt-1只会减去sizeof(int*) a,&a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5].
5.内存对齐
VC 的自定义n字节对齐宏#pragma pack（n） http://blog.sina.com.cn/s/blog_4c0cb1c00101aexx.html
有的时候，在脑海中停顿了很久的“显而易见”的东西，其实根本上就是错误的。就拿下面的问题来看：
struct T
char ch ;
int i ;
} ;
使用sizeof(T)，将得到什么样的答案呢？要是以前，想都不用想，在32位机中，int是4个字节，char是1个字节，所以T一共是5个字节。实践出真知，在VC6中测试了下，答案确实8个字节。哎，反正受伤的总是我，我已经有点麻木了，还是老老实实的接受吧！为什么答案和自己想象的有出入呢？这里将引入内存对齐这个概念。
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。
http://blog.csdn.net/gulanglinux/article/details/4376691
Win32平台下的微软C编译器
结构体的总大小为结构体 最宽基本类型成员 大小的整数倍
在GNU GCC编译器中 （对齐模数最大只能是 4，也就是说，即使结构体中有double类型，对齐模数还是4）
{
char ch ;
double d ;
} ;
char小于4，所以补充至4字节 ，double =8为4的2倍不用补充了。=8+4=12
那么在GCC下，sizeof(T)应该等于12个字节。
结构体中含有位域(bit-field)：
struct N
{
char c : 2 ;
int i : 4 ;
} ;
VC 采取不压缩方式：
最长为int 4字节，char <4 补充至4 所以等于 8；
Dev-C++和GCC都采取压缩方式：
如果 char <最长的 int的4 需补充的 3字节可以容下后面的 int i : 4 ;则压缩在一起 =4字节（1字节装：c，后三字节装i） ，后三字节装不下，则另开空间，则=4+4=8；
4 ) 如果位域字段之间穿插着非位域字段，则不进行压缩；
备注：
结构体
{
char c : 2 ;
double i ;
int c2 : 4 ;
} N3 ;
在GCC下占据的空间为16字节（c不够4 <gcc的K），补成4，c2也是补成4,4+4+8=16），在VC下占据的空间应该是24个字节。
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
5、new和malloc的区别？delete和delete [] 的区别
1 我认为new\delete和malloc\free最大区别是对对象的理解。
如果你使用
Foo* foo = malloc(sizeof(Foo));//Foo是一个类
初始化，那么你将不会调用Foo的构造方法，而只是单纯的分配空间。而且我们只认为你是分配一个空间，而不是想创建一个对象。
Foo* foo = new Foo()；则会调用Foo的构造方法来初始化对象，也就是说你既要分配空间又要初始化这段空间，让它变成一个对象。
对于delete和free也有同样的问题，就是delete会调用析构函数，free则不会。
说白了，new\delete玩的是对象，而malloc\free仅仅是内存空间而已
2 对于除去对象意外的其他情况，比如int和float等
int* Array=new int[10];和int* Array=malloc(sizeof(int)*10);只存在使用技巧的差别，没有本质的差别。
3 最后也提醒你new\delete和malloc\free只能成对使用，不能混了。
delete和delete [] 的区别
用 new 分配的单个对象的内存空间的时候用 delete，回收用 new[] 分配的一组对象的内存空间的时候用 delete[]。
定义一个类数组：T* p1 = new T[NUM];
delete p1 在回收空间的过程中，只有 p1[0] 这个对象调用了析构函数，其它对象如 p1[1]、p1[2] 等都没有调用自身的析构函数，这就是问题的症结所在。如果用 delete[]，则在回收空间之前所有对象都会首先调用自己的析构函数。
基本类型的对象没有析构函数，所以回收基本类型组成的数组空间用 delete 和 delete[] 都是应该可以的；但是对于类对象数组，只能用 delete[]。对于 new 的单个对象，只能用 delete 不能用 delete[] 回收空间。
所以一个简单的使用原则就是：new 和 delete、new[] 和 delete[] 对应使用。
http://www.cnblogs.com/charley_yang/archive/2010/12/08/1899982.html
6、什么是引用？
对象的别名(另一个名称)。
引用经常用于“按引用传递(pass-by-reference)”：
{
int tmp = i;
i = j;
j = tmp;
}
int main()
{
int x, y;
// ...
swap(x,y);
}
此处的 i 和 j 分别是main中的 x 和 y。换句话说，i 就是 x —— 并非指向 x 的指针，也不是 x 的拷贝，而是 x 本身。对 i 的任何改变同样会影响 x，反之亦然。（关于引用的注意：首先，要认识到在任何情况下都不能使用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象，但是该变量在某些时候也可能不指向任何对象，这时你应该把变量声明为指针，因为这样你可以赋空值给该变量。相反，如果变量肯定指向一个对象，例如你的设计不允许变量为空，这时你就可以把变量声明为引用。
“但是，请等一下”，你怀疑地问，“这样的代码会产生什么样的后果？”
char *pc = 0; // 设置指针为空值
char& rc = *pc; // 让引用指向空值
这是非常有害的，毫无疑问。结果将是不确定的（编译器能产生一些输出，导致任何事情都有可能发生）。应该躲开写出这样代码的人，除非他们同意改正错误。如果你担心这样的代码会出现在你的软件里，那么你最好完全避免使用引用，要不然就去让更优秀的程序员去做。我们以后将忽略一个引用指向空值的可能性。
因为引用肯定会指向一个对象，在C＋＋里，引用应被初始化。）
转译符
1、cout<<strlen("\t"\065\xff\n");
A、5
B、15
C、8
D、语句不合法
正确答案：A
\065和\xff都是ASCII字符。做题需仔细。
所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。而C中定义了一些字母前加""来表示常见的那些不能显示的ASCII字符，如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了。
http://baike.baidu.com/view/1875666.htm
4、预处理器标志#error的目的是什么？
正确答案：生成编译错误消息
http://blog.csdn.net/chenghf1979/article/details/5201074
5、动态链接库和静态链接库的区别
http://www.cnblogs.com/Winston/archive/2008/07/05/1236273.html
6、[cpp] view plaincopyprint?
- int *p1=(int *)0x800500;
- int *p2=(int *)0x800518;
- cout<<p2-p1<<endl;
int *p1=(int *)0x800500; int *p2=(int *)0x800518; cout<<p2-p1<<endl;
代码执行结果？
正确答案：6
0x18转换10进制为24 字节.p指向的是int 类型 长度为4字节 24/4=6
7、
int a;
int *b;
}s[4],*p;
int n=1,i;
for(i=0;i<4;i++)
{
s[i].a=n;
s[i].b=&s[i].a;
n+=2;
}
p=&s[0];
p++;
printf("%d,%d\n",(++p)->a,(p++)->a);
正确答案：7,3
这道题需要注意printf参数从右边开始压栈,所以先执行将（p)->a 结果压入堆栈，然后p++，然后执行++p，然后将(++p)->a 压入堆栈，然后进入函数sprintf……
c/c++的函数参数压栈顺序：http://blog.csdn.net/yingxunren/article/details/3979270
其他技巧：
锐捷笔试3.定义一个宏把第二位清零，其余位取反
答：#define NBL(a) (((a)&(~2))^2) （2==0000 0010 ，^ 是异或，相同为0 不同为1）
