有助于理解C语言的测试题

引导语：对有些人来说C语言是比较难以理解的一种编程语言，以下是小编整理的有助于理解C语言的测试题，欢迎参考阅读!

　　第一题：

#include

02 staticjmp_bufbuf;

03 intmain(void)

04 {

05 volatileintb = 3;

06 if(setjmp(buf) != 0)

07 {

08 printf("%dn", b);

09 exit(0);

10 }

11 b = 5;

12 longjmp(buf, 1);

13 }

输出结果为A）3 B）5 C）0 D）都不是

答案为B，也就是输出5。

关键点在于理解setjmp以及longjmp，第一次运行到setjmp，会设置jmp_buf，然后返回0。当调用longjmp时，会把longjmp里面的非0值作为setjmp的返回值返回（如果longjmp的value参数为0，setjmp恢复后返回1，也就是当恢复到setjmp存储点的时候，setjmp一定不会返回0）。

setjmp-longjmp组合的用处类似于游戏中的存盘读盘功能，经常被用于类似C++的异常恢复操作。

　　第二题：

1 structnode

2 {

3 inta;

4 intb;

5 intc;

6 };

7 structnode s = { 3, 5, 6 };

8 structnode *pt = &s;

9 printf("%dn", *(int*)pt);

返回结果为3，这个算是比较简单，pt为指向结构s的指针，然后将pt转换为int指针，进行dereference，取出一个int值，那就是结构中第一个数。

我们将题目改动一下，如下代码：

structnode

02 {

03 chara;

04 charb;

05 shortc;

06 intd;

07 };

08 structnode s = { 3, 5, 6, 99 };

09 structnode *pt = &s;

10 printf("%Xn", *(int*)pt);

需要注意的是一般32位C编译器都认为char是8bit，short是16bit，int为32bit，所以node在内存中应该正好是对齐的，也就是abc这几个成员之间没有空隙。最终结果应该为60503，如果不是，欢迎你告诉我你具体的编译环境以及硬件配置。

　　第三题：

1 intfoo(intx,intn){

2 intval = 1;

3 if(n > 0)

4 {

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

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

7 }

8 returnval;

9 }

这道题其实最简单的办法就是在纸上做一个推演计算，一步一步跑一下，就能得到答案了，这里面没有任何复杂的C语言概念。

　　第四题：

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

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

3 printf("%d %dn", *(a + 1), *(ptr – 1));

这道题考的其实是指向数组的指针，&a是一个隐式的指向int [5]数组的指针，它和int* ptr是不一样的，如果真要定义这个指针，应该是int (*ptoa)[5]。所以ptoa每一次加一操作都相当于跨越int a[5]的内存步长（也就是5个int长度），也就是说&a + 1其实就是指向了a[5]这个位置，实际上内存里面这个位置是非法的，但是对ptr的强制转换导致了后面ptr-1的内存步长改为了1个int长度，所以ptr-1实际指向了a[4]。至于*(a+1)没什么好说的，值就是2。

　　第五题：

01 voidfoo(int[][3]);

02 intmain(void)

03 {

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

05 foo(a);

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

07 return0;

08 }

09 voidfoo(intb[][3])

10 {

11 ++b;

12 b[1][1] = 9;

13 }

其实和前一题有异曲同工之妙，++b的步长实际上是3个int，也就是++b运算以后，b指向{4,5,6}这个数组的开始，而b[1]就是{7,8,9}, b[1][1]实际上就是8这个值也就是main函数中的a[2][1].

　　第六题：

inta, b, c, d;

2 a = 3;

3 b = 5;

4 c = a, b;

5 d = (a, b);

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

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

这个其实有两个C语言知识点，一个是等号操作符优先级高于逗号操作符，另一个是逗号操作符相当于运算逗号前半部后半部的表达式，然后返回后半部表达式的值。所以c等于a（先计算等号），而d等于b（逗号表达式返回b）。

　　第七题：

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

2 int(*ptr)[3] = a;

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

4 ++ptr;

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

依然是2维数组相关题目，ptr为指向int [3]数组的指针，首先指向a[0]，所以(*ptr)[1], (*ptr)[2]就是a[0][1], a[0][2].然后++ptr，相当于ptr指向了a[1]，这时得到的`是a[1][1]，a[1][2]，所以结果就是2，3, 5, 6。

　　第八题：

01 int*f1(void)

02 {

03 intx = 10;return&x;

04 }

05 int*f2(void)

06 {

07 int*ptr; *ptr = 10;returnptr;

08 }

09 int*f3(void)

10 {

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

12 }

这里考的是返回一个指针的问题，一般来说返回指针的函数，里面一定有malloc之类的内存申请操作，传入指针类型，则是对指针指向的内容做修改。如果想修改指针本身，那就要传入指针的指针。

　　第九题：

1 inti = 3;intj;

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

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

这道题考的内容其实就是sizeof，如果计算表达式，那么表达式是不会做计算的，也就是不管加加减减，sizeof就是针对i计算大小。在32位机器上，这个j应该为4。

我将代码扩展了一下，看看大家能不能想到结果：

1 shortm;intn;doubledn;

2 intj =sizeof( m + n);

3 intk =sizeof( n + n);

4 intl =sizeof( m);

5 intl2 =sizeof(m * m);

6 intl3 =sizeof(m + dn);

7 intl4 =sizeof(m + m);

　　第十题：

01 voidf1(int*,int);

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

03 intmain(void)

04 {

05 inta = 3;

06 intb = 5;

07 p[0] = f1;

08 p[1] = f1;

09 p[0](&a, b);

10 printf("%d %d ", a, b);

11 p[1](&a, b);

12 printf("%d %dn", a, b);

13 return0;

14 }

15 voidf1(int*p,intq)

16 {

17 inttmp = *p; *p = q; q = tmp;

18 }

函数指针的数组p勉强算是一个知识点，另外一个知识点就是第八题提到的，对于int q这样的参数，是不会修改其内容的。而*p则可修改p指向的内容。

　　第十一题：

01 voide(int);

02 intmain(void)

03 {

04 inta = 3;

05 e(a);

06 put'n');

07 return0;

08 }

09 voide(intn)

10 {

11 if(n > 0)

12 {

13 e(–n);

14 printf("%d ", n);

15 e(–n);

16 }

17 }

这道题自己debug一下就完全明白了，主要知识点就是递归调用，另外前置后置自减操作的返回值问题。

　　第十二题：

1 typedefint(*test)(float*,float*);

2 test tmp;

也是经常出现的一类题，对复杂的指针定义做解析，实际上K&R里面（5.12）也有介绍该如何解读。不熟悉的朋友可以试着练习练习标准库中的bsearch，qsort以及signal函数。

　　第十三题：

1 charp;

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

3 p = (buf + 1)[5];

4 printf("%dn", p);

也就是p实际指向*(buf + 1 + 5)，写的更诡异一些就是p=5[buf +1];也是同样结果。

　　第十四题：

类似十三题，也是把数组弄得有些诡异，(p += sizeof(int))[-1];相当于*(p + sizeof(int) + (-1))。

　　第十五题：

01 intripple(intn, …)

02 {

03 inti, j, k;

04 va_listp;

05 k = 0;

06 j = 1;

07 va_start(p, n);

08 for(; j < n; ++j)

09 {

10 i =va_arg(p,int);

11 for(; i; i &= i – 1)

12 ++k;

13 }

14 returnk;

15 }

16 intmain(void)

17 {

18 printf("%dn", ripple(3, 5, 7));

19 return0;

20 }

这道题也是两个知识点，一个是可变参数函数定义以及如何实现，va_arg会把5，7依次取出来。另一个知识点是i &= i-1，实际上是计算了i二进制形式中1的个数，每次计算都会消减掉最低有效位上的1。比如7二进制表示为111。i &= i –1的计算结果依次为110，100, 000 （也就是0）。在hacker's Delights这本书里介绍了很多类似技巧。

　　第十六题：

01 intcounter(inti)

02 {

03 staticintcount = 0;

04 count = count + i;

05 returncount;

06 }

07 intmain(void)

08 {

09 inti, j;

10 for(i = 0; i <= 5; i++) j = counter(i);

11 printf("%dn", j);

12 return0;

13 }

只要了解静态局部变量的真正内涵，这道题就是小菜啦。