考查一个初级嵌入式系统开发人员的C基本功，附有答案题目由资深嵌入式系统专家拟定,目的是考查入门级的嵌入式软件开发人员 Gavin Shaw提供详细解答

编者按:非常基本关于C语言的问题,一个信息类(计算机,资讯工程,电子工程, 通信工程)专业的本科毕业生应该达到的水平。题目不难,全部都能快速地答完，当然也需要一定的知识储备。

对于大多数人，我们预期你可能答错 3) 4) 15)题，所以答错3道以内的，我们认为你很棒

答错5道题以内，我们认为你还不错(你还可能答错第9题)

如果你有6道以上的题目不能答对,基本上我们都不好说什么了....

约定:

1) 下面的测试题中，认为所有必须的头文件都已经正确的包含了

2)数据类型

char 一个字节 1 byte

int 两个字节 2 byte (16位系统，认为整型是2个字节)

long int 四个字节 4 byte

float 四个字节4 byet

double 八个字节 8 byte

long double 十个字节 10 byte

pointer 两个字节 2 byte(注意，16位系统,地址总线只有16位)

第1题: 考查对volatile关键字的认识

#include<setjmp.h>

static jmp_buf buf;

main()

{

volatile int b;

b =3;

if(setjmp(buf)!=0)

{

printf("%d ", b);

exit(0);

}

b=5;

longjmp(buf , 1);

}

请问，这段程序的输出是

(a) 3

(b) 5

(c) 0

(d) 以上均不是

第2题:考查类型转换

main()

{

struct node

{

int a;

int b;

int c;

};

struct node s= { 3, 5,6 };

struct node *pt = &s;

printf("%d" , *(int*)pt);

}

这段程序的输出是:

(a) 3

(b) 5

(c) 6

(d) 7

第3题:考查递归调用

int foo ( int x , int n)

{

int val;

val =1;

if (n>0)

{

if (n%2 == 1) val = val *x;

val = val * foo(x*x , n/2);

}

return val;

}

这段代码对x和n完成什么样的功能(操作)?

(a) x^n (x的n次幂)

(b) x*n(x与n的乘积)

(c) n^x(n的x次幂)

(d) 以上均不是

第4题:考查指针,这道题只适合于那些特别细心且对指针和数组有深入理解的人

main()

{

int a[5] = {1,2,3,4,5};

int *ptr = (int*)(&a+1);

printf("%d %d" , *(a+1), *(ptr-1) );

}

这段程序的输出是:

(a) 2 2

(b) 2 1

(c) 2 5

(d) 以上均不是

第5题:考查多维数组与指针

void foo(int [][3] );

main()

{

int a [3][3]= { { 1,2,3} , { 4,5,6},{7,8,9}};

foo(a);

printf("%d" , a[2][1]);

}

void foo( int b[][3])

{

++ b;

b[1][1] =9;

}

这段程序的输出是:

(a) 8

(b) 9

(c) 7

(d)以上均不对

第6题目:考查逗号表达式

main()

{

int a, b,c, d;

a=3;

b=5;

c=a,b;

d=(a,b);

printf("c=%d" ,c);

printf("d=%d" ,d);

}

这段程序的输出是:

(a) c=3 d=3

(b) c=5 d=3

(c) c=3 d=5

(d) c=5 d=5

第7题:考查指针数组

main()

{

int a[][3] = { 1,2,3 ,4,5,6};

int (*ptr)[3] =a;

printf("%d %d " ,(*ptr)[1], (*ptr)[2] );

++ptr;

printf("%d %d" ,(*ptr)[1], (*ptr)[2] );

}

这段程序的输出是:

(a) 2 3 5 6

(b) 2 3 4 5

(c) 4 5 0 0

(d) 以上均不对

第8题:考查函数指针

int *f1(void)

{

int x =10;

return(&x);

}

int *f2(void)

{

int*ptr;

*ptr =10;

return ptr;

}

int *f3(void)

{

int *ptr;

ptr=(int*) malloc(sizeof(int));

return ptr;

}

上面这3个函数哪一个最可能引起指针方面的问题

(a) 只有 f3

(b) 只有f1 and f3

(c) 只有f1 and f2

(d) f1 , f2 ,f3

第9题:考查自加操作(++)

main()

{

int i=3;

int j;

j = sizeof(++i+ ++i);

printf("i=%d j=%d", i ,j);

}

这段程序的输出是:

(a) i=4 j=2

(b) i=3 j=2

(c) i=3 j=4

(d) i=3 j=6

第10题:考查形式参数，实际参数，指针和数组

void f1(int *, int);

void f2(int *, int);

void(*p[2]) ( int *, int);

main()

{

int a;

int b;

p[0] = f1;

p[1] = f2;

a=3;

b=5;

p[0](&a , b);

printf("%d\t %d\t" , a ,b);

p[1](&a , b);

printf("%d\t %d\t" , a ,b);

}

void f1( int* p , int q)

{

int tmp;

tmp =*p;

*p = q;

q= tmp;

}

void f2( int* p , int q)

{

int tmp;

tmp =*p;

*p = q;

q= tmp;

}

这段程序的输出是:

(a) 5 5 5 5

(b) 3 5 3 5

(c) 5 3 5 3

(d) 3 3 3 3

第11题:考查自减操作(--)

void e(int );

main()

{

int a;

a=3;

e(a);

}

void e(int n)

{

if(n>0)

{

e(--n);

printf("%d" , n);

e(--n);

}

}

这段程序的输出是:

(a) 0 1 2 0

(b) 0 1 2 1

(c) 1 2 0 1

(d) 0 2 1 1

第12题:考查typedef类型定义,函数指针

typedef int (*test) ( float * , float*)

test tmp;

tmp 的类型是

(a) 函数的指针，该函数以 两个指向浮点数(float)的指针(pointer)作为参数(arguments)

Pointer to function of having two arguments that is pointer to float

(b) 整型

(c) 函数的指针，该函数以 两个指向浮点数(float)的指针(pointer)作为参数(arguments),并且函数的返回值类型是整型

Pointer to function having two argument that is pointer to float and return int

(d) 以上都不是

第13题:数组与指针的区别与联系

main()

{

char p;

char buf[10] ={ 1,2,3,4,5,6,9,8};

p = (buf+1)[5];

printf("%d" , p);

}

这段程序的输出是:

(a) 5

(b) 6

(c) 9

(d) 以上都不对

第14题: 考查指针数组的指针

Void f(char**);

main()

{

char * argv[] = { "ab" ,"cd" , "ef" ,"gh", "ij" ,"kl" };

f( argv );

}

void f( char **p )

{

char* t;

t= (p+= sizeof(int))[-1];

printf( "%s" , t);

}

这段程序的输出是:

(a) ab

(b) cd

(c) ef

(d) gh

第15题:此题考查的是C的变长参数,就像标准函数库里printf()那样,这个话题一般国内大学课堂是不会讲到的,不会也情有可原呵呵,

#include<stdarg.h>

int ripple ( int , ...);

main()

{

int num;

num = ripple ( 3, 5,7);

printf( " %d" , num);

}

int ripple (int n, ...)

{

int i , j;

int k;

va_list p;

k= 0;

j = 1;

va_start( p , n);

for (; j<n; ++j)

{

i = va_arg( p , int);

for (; i; i &=i-1 )

++k;

}

return k;

}

这段程序的输出是:

(a) 7

(b) 6

(c) 5

(d) 3

第16题:考查静态变量的知识

int counter (int i)

{

static int count =0;

count = count +i;

return (count );

}

main()

{

int i , j;

for (i=0; i <=5; i++)

j = counter(i);

}

本程序执行到最后,j的值是:

(a) 10

(b) 15

(c) 6

(d) 7

详细参考答案

第1题: (b)

volatile字面意思是易于挥发的。这个关键字来描述一个变量时，意味着 给该变量赋值(写入)之后，马上再读取，写入的值与读取的值可能不一样,所以说它"容易挥发"的。

这是因为这个变量可能一个寄存器，直接与外部设备相连，你写入之后，该寄存器也有可能被外部设备的写操作所改变;或者，该变量被一个中断程序，或另一个进程改变了.

volatile 不会被编译器优化影响，在longjump 后,它的值 是后面假定的变量值,b最后的值是5,所以5被打印出来.

setjmp : 设置非局部跳转 /* setjmp.h*/

Stores context information such as register values so that the lomgjmp function can return control to the statement following the one calling setjmp.Returns 0 when it is initially called.

Lonjjmp: 执行一个非局部跳转 /* setjmp.h*/

Transfers control to the statement where the call to setjmp (which initialized buf) was made. Execution continues at this point as if longjmp cannot return the value 0.A nonvolatile automatic variable might be changed by a call to longjmp.When you use setjmp and longjmp, the only automatic variables guaranteed to remain valid are those declared volatile.

Note: Test program without volatile qualifier (result may very)

更详细介绍，请参阅 C语言的setjmp和longjmp

一个定义为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;

}

讲讲我的理解： （欢迎打板子...~~！）

关键在于两个地方：

1. 编译器的优化 (请高手帮我看看下面的理解)

在本次线程内, 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；

当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致

举一个不太准确的例子：

发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资

员工 －－ 原始变量地址

银行卡号 －－ 原始变量在寄存器的备份

2. 在什么情况下会出现(如1楼所说)

1). 并行设备的硬件寄存器（如：状态寄存器）

2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

3). 多线程应用中被几个任务共享的变量

补充： volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；

“易变”是因为外在因素引起的，象多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；

而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了； 大家看看前面那种解释（易变的）是不是在误导人

－－－－－－－－－－－－简明示例如下：－－－－－－－－－－－－－－－－－－

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

使用该关键字的例子如下：

int volatile nVint;

>>>>当要求使用volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：

volatile int i=10;

int a = i;

...

//其他代码，并未明确告诉编译器，对i进行过操作

int b = i;

>>>>volatile 指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样以来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

>>>>注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：

>>>>首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：

>>

＃i nclude <stdio.h>

void main()

{

int i=10;

int a = i;

printf("i= %d",a);

//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道

__asm {

mov dword ptr [ebp-4], 20h

}

int b = i;

printf("i= %d",b);

}

然后，在调试版本模式运行程序，输出结果如下：

i = 10

i = 32

然后，在release版本模式运行程序，输出结果如下：

i = 10

i = 10

输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：

＃i nclude <stdio.h>

void main()

{

volatile int i=10;

int a = i;

printf("i= %d",a);

__asm {

mov dword ptr [ebp-4], 20h

}

int b = i;

printf("i= %d",b);

}

分别在调试版本和release版本运行程序，输出都是：

i = 10

i = 32

这说明这个关键字发挥了它的作用！

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

volatile对应的变量可能在你的程序本身不知道的情况下发生改变

比如多线程的程序，共同访问的内存当中，多个程序都可以操纵这个变量

你自己的程序，是无法判定合适这个变量会发生变化

还比如，他和一个外部设备的某个状态对应，当外部设备发生操作的时候，通过驱动程序和中断事件，系统改变了这个变量的数值，而你的程序并不知道。

对于volatile类型的变量，系统每次用到他的时候都是直接从对应的内存当中提取，而不会利用cache当中的原有数值，以适应它的未知何时会发生的变化，系统对这种变量的处理不会做优化——显然也是因为它的数值随时都可能变化的情况。

--------------------------------------------------------------------------------

典型的例子

for ( int i=0; i<100000; i++);

这个语句用来测试空循环的速度的

但是编译器肯定要把它优化掉，根本就不执行

如果你写成

for ( volatile int i=0; i<100000; i++);

它就会执行了

volatile的本意是“易变的”

由于访问寄存器的速度要快过RAM，所以编译器一般都会作减少存取外部RAM的优化。比如：

static int i=0;

int main(void)

{

...

while (1)

{

if (i) dosomething();

}

}

/* Interrupt service routine. */

void ISR_2(void)

{

i=1;

}

程序的本意是希望ISR_2中断产生时，在main当中调用dosomething函数，但是，由于编译器判断在main函数里面没有修改过i，因此

可能只执行一次对从i到某寄存器的读操作，然后每次if判断都只使用这个寄存器里面的“i副本”，导致dosomething永远也不会被

调用。如果将将变量加上volatile修饰，则编译器保证对此变量的读写操作都不会被优化（肯定执行）。此例中i也应该如此说明。

一般说来，volatile用在如下的几个地方：

1、中断服务程序中修改的供其它程序检测的变量需要加volatile；

2、多任务环境下各任务间共享的标志应该加volatile；

3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；

另外，以上这几种情况经常还要同时考虑数据的完整性（相互关联的几个标志读了一半被打断了重写），在1中可以通过关中断来实

现，2中可以禁止任务调度，3中则只能依靠硬件的良好设计了。

第2题: (a)

结构题的成员在内存中的地址是按照他们定义的位置顺序依次增长的。如果一个结构体的指针被看成 它的第一个成员的指针,那么该指针的确指向第一个成员

第3题: (a)

此题目较难.

这个程序的非递归版本

int what ( int x , int n)

{

int val;

int product;

product =1;

val =x;

while(n>0)

{

if (n%2 == 1)

product = product*val; /*如果是奇数次幂, x(val)

要先乘上一次,;

偶数次幂,最后返回时才会到这里

乘以1*/

val = val* val;

n = n/2;

}

return product;

}

/* 用二元复乘策略 */

算法描述

(while n>0)

{

if next most significant binary digit of n( power) is one

then multiply accumulated product by current val ,

reduce n(power) sequence by a factor of two using integer pision .

get next val by multiply current value of itself

}

第4题: (c)

a的类型是一个整型数组,它有5个成员

&a的类型是一个整型数组的指针

所以&a + 1指向的地方等同于 a[6]

所以*(a+1) 等同于a[1]

ptr等同 a[6], ptr-1就等同与a[5]

第5题: (b)

题目自身就给了足够的提示

b[0][0] = 4

b[1][0] = 7

第6题: (c)

考查逗号表达式,逗号表达式的优先级是很低的，比 赋值(=)的优先级 低. 逗号表达式的值就是最后一个元素的值

逗号表达式的还有一个作用就是分割函数的参数列表..

E1, E2, ..., En

上面这个表示式的左右是,E1, E2,... En的值被分别计算出来，En计算出来的结构赋给整个逗号表达式

c=a,b; / *yields c=a* /

d=(a,b); /* d =b */

第7题: (a)

ptr是一个数组的指针，该数组有3个int成员

第8题: (c)

f1显然有问题，它返回一个局部变量的指针，局部变量是保存在stack中的,退出函数后，局部变量就销毁了，保留其指针没有意义，因为其指向的stack空间可能被其他变量覆盖了

f2也有问题, ptr是局部变量，未初始化，它的值是未知的，*ptr不知道指向哪里了，直接给*ptr赋值可能会覆盖重要的系统变量，这就是通常说的野指针的一种

第9题: (b)

sizeof 操作符给出其操作数需要占用的空间大小，它是在编译时就可确定的，所以其操作数即使是一个表达式，也不需要在运行时进行计算.( ++i + ++ i )是不会执行的，所以

i 的值还是3

第10题: (a)

很显然选a.

f1交换*p 和 q的值，f1执行完后, *p 和 q的值的确交换了, 但 q的改变不会影响到 b的改变, *p 实际上就是 a

所以执行f1后, a=b=5

这道题考查的知识范围很广,包括typedef自定义类型,函数指针,指针数组

void(*p[ 2 ]) ( int *, int);

定义了一个函数指针的数组p,p有两个指针元素. 元素是函数的指针，函数指针指向的函数是一个带2个参数,返回void的函数，所带的两个参数是 指向整型的指针，和整型

p[ 0 ] = f1; p[ 1 ] = f2 contain address of function .function name without parenthesis represent address of function Value and address of variable is passed to function only argument that is effected is a (address is passed). Because of call by value f1, f2 can not effect b

第11题: (a)

考查--操作和递归调用,仔细分析一下就可以了

第12题: (c)

分析函数声明，建议不会的看看《C专家编程》

这里介绍一个简单规则:从左往有，遇到括号停下来，将第一个括号里的东西看成一个整体

第13题: (c)

考查什么时候数组就是指针.对某些类型T而言，如果一个表达式是 T[] (T的数组), 这个表达式的值实际上就是指向该数组的第一个元素的指针.所以(buf+1)[5]实际上就是*(buf +6)或者buf[6]

第14题: (b)

sizeof(int)的值是2,所以p+=sizeof(int) 指向 argv[2],这点估计大家都没有什么疑问

(p+=sizeof(int))[-1] 指向 argv[1],能理解吗，因为(p+=sizeof(int))[-1] 就相当于 (p+=2)[-1] ,也就是(p+2-1)

第15题: (c)

在C编译器通常提供了一系列处理可变参数的宏，以屏蔽不同的硬件平台造成的差异，增加程序的可移植性。这些宏包括va_start、 va_arg和va_end等。

采用ANSI标准形式时，参数个数可变的函数的原型声明是：

type funcname(type para1, type para2, ...)

这种形式至少需要一个普通的形式参数，后面的省略号不表示省略，而是函数原型的一部分。type是函数返回值和形式参数的类型。

不同的编译器，对这个可变长参数的实现不一样 ，gcc4.x中是内置函数.

程序分析

va_list p; /*定义一个变量 ,保存 函数参数列表 的指针*/

va_start( p , n); /*用va_start宏 初始化 变量p,

va_start宏的第2个参数n ,

是一个固定的参数,

必须是我们自己定义的变长函数的最后一个入栈的参数

也就是调用的时候参数列表里的第1个参数*/

for (; j<n; ++j) /* j从1开始, 遍历所有可变参数 */

{

i = va_arg( p , int); /*va_arg取出当前的参数,

并认为取出的参数是一个整数(int) */

for (; i; i &=i-1 ) /*判断取出的i是否为0*/

++k; /* 如果i不为0, k自加,

i与i-1进行与逻辑运算, 直到i 为0

这是一个技巧，下面会谈到它的功能*/

}

当我们调用ripple函数时，传递给ripple函数的 参数列表的第一个参数n的值是3 .

va_start 初始化 p士气指向第一个未命名的参数(n是有名字的参数) ,也就是 is 5 (第一个).

每次对 va_arg的调用，都将返回一个参数，并且把 p 指向下一个参数.

va_arg 用一个类型名来决定返回的参数是何种类型,以及在 var_arg的内部实现中决定移动多大的距离才到达下一个 参数

(; i; i&=i-1) k++ /* 计算i有多少bit被置1 */

5用二进制表示是 (101) 2

7用二进制表示 (111) 3

所以 k 返回 5(2+3),也即本题应该选c

举个例子，就很好理解了

令 i= 9 = 1001

i-1 = 1000

(i-1) +1 = i

1000

+1

1 001

因为i与i-1的最右边的那位(最低位) 肯定是不同，如果i1,i-1肯定是0，反之亦然. i & i-1 这个运算，在二相补的数字系统中，将会 消除最右边的1位

第16题: (b)

答案是(b)

相传高斯小学一年级的时候就会做这类等比数列的题目了.这道题考查的是静态变量的知识,当每次调用完函数之后,静态变量的值不会丢失,这与栈中的临时局部变量明显不同的地方.

所以,第一次调用counter(0)之后,count =0

第二次调用counter(1)后 count = 0+1;

第三次调用counter(2) count = 1+2; /* count = count +i */

第四次调用counter(3) count = 3+3;

第五次调用counter(4) count = 6+4;

第六次调用counter(5) count = 10+5;