C语言笔试题

Q：printf和scanf的返回值是什么？

int main()  
{  
    int i = 43;  
    int n = printf("%d\n",i);
    printf("%d\n",n);     
    return 0;
} 

A：printf函数返回3，因为其输出了'4', '3', '\n' 三个字符。
printf返回的是成功输出到STDOUT的字符数。如果发生错误，返回一个负数。
scanf返回的是成功赋值的变量个数，如果发生错误，返回EOF

Q：既然fgetc是接收输入的字符，返回值用char或者unsigned char不就行了，为什么用int呢？
A：这个主要是因为文件结束或者读写文件出错的标志被规定成EOF，也就是-1导致的。unsigned char根本取不到-1这个值，而如果用char做返回值的话，它无法分辨0xFF字符和EOF，因为这两个数值都被char认为是-1，所以它也不能作为返回值。

Q：此段程序希望输出数组中的所有元素，但却没有得到想要的结果，是什么产生歧义？

#include <stdio.h> 
#define TOTAL_ELEMENTS (sizeof(array) / sizeof(array[0])) 
int array[] = {23,34,12,17,204,99,16}; 
int main() 
{
    int d;
    for(d=-1;d <= (TOTAL_ELEMENTS-2);d++)
        printf("%d\n",array[d+1]);
    return 0; 
} 

A：运行上面的程序，结果是什么都没有输出，导致这个结果的原因是sizeof的返回值是一个unsinged int，为此在比较int d 和TOTAL_ELEMENTS两个值都被转换成了unsigned int来进行比较，这样就导致-1被转换成一个非常大的值，以至于for循环不满足条件。因此，如果不能理解sizeof操作符返回的是一个unsigned int的话，就会产生类似如上的歧义。

Q：下面这段程序的输出结果是：

#include <stdio.h> 
#define f(a,b) a##b 
#define g(a)   #a 
#define h(a) g(a)   
int main() 
{
    printf("%s\n", h(f(1,2)));
    printf("%s\n", g(f(1,2)));
    return 0; 
} 

A：在C语言的宏中，#的功能是将其后面的宏参数进行字符串化操作（Stringfication）。而##被称为连接符（concatenator），用来将两个Token连接为一个Token。
看到这段程序你可能会认为，这两个printf输出的同一个结果，可是答案却非如此，本题的输出是12和f(1,2)，为什么会这样呢？因为这是宏，宏的解开不象函数执行那样由里到外。#将右边的参数做整体的字符串替换，即便是另一个宏，也不展开，所以，g(f(1,2))->"f(1,2)"。对于h(f(1,2))，由于h(a)是非#或##的普通宏，需要先宏展开其参数a，即展开f(1,2)为12，则h(a) 宏替换为h(12)，进而宏替换为g(12), 进而宏替换为"12"。

Q：假如我们的a的地址是：0Xbfe2e100, 而且是32位机，那么这个程序会输出什么？

#include <stdio.h>
int main()
{
    int a[5];
    printf("%x\n", a);
    printf("%x\n", a+1);
    printf("%x\n", &a);
    printf("%x\n", &a+1);
    return 0;
}

A：
第一条printf语句应该没有问题，就是 bfe2e100。
第二条printf语句你可能会以为是bfe2e101。那就错了，a+1，编译器会编译成 a+ 1*sizeof(int)，int在32位下是4字节，所以是加4，也就是bfe2e104。
第三条printf语句可能是你最头疼的，我们怎么知道a的地址？我不知道吗？可不就是bfe2e100。那岂不成了a==&a啦？这怎么可能？自己存自己的？也许很多人会觉得指针和数组是一回事，那么你就错了。如果是 int *a，那么没有问题，因为a是指针，所以 &a 是指针的地址，a 和 &a不一样。但是这是数组啊a[]，所以&a其实是被编译成了 &a[0]。
第四条printf语句就很自然了，就是bfe2e104。还是不对，因为是&a是数组，被看成int(*)[5]，所以sizeof(a)是5，也就是5*sizeof(int)，也就是bfe2e114。

Q：如下代码为什么结果始终不对？

#include <stdio.h>
int main()
{
    int a = 2;
    if(a & 1 == 0)
        printf("a & 1 == 0");
    else
        printf("a & 1 != 0");
    return 0;
}

为什么输出“a & 1 != 0”?
A：这是因为==的优先级高于表示位与运算符&.所以a & 1 == 0的实际代码是a & (1 == 0)，也就是a & 0, 当然结果不是预期了。（优先级：==和!= 高于 & 高于 ^ 高于 | 高于 && 高于 || ）。优先级从高到低：算术运算符，位移运算符，关系运算符，位操作& ^ |

Q：如下代码输出什么？

int main()
{
    int i = 6;
    if( ((++i < 7) && ( i++/6)) || (++i <= 9));
        printf("%d\n",i);
    return 0;
}

A：8。本题主要考的是&&和||的短路求值的问题。所为短路求值：对于（条件1 && 条件2），如果“条件1”是false，那“条件2”的表达式会被忽略了。对于（条件1 || 条件2），如果“条件1”为true，而“条件2”的表达式则被忽略了。

Q：sizeof后面可以跟表达式，下面的代码，为什么i++无效呢？

#include <stdio.h>
int main()
{
    int i = 1;
    sizeof(i++);
    printf("%d\n", i);
    return 0;
}

运行结果：1
A：正因为sizeof是编译期求值的，所以如果它跟着表达式，那么表达式是不被计算的，只是根本表达式的类型得到它占用的空间。

Q：下面的程序试图使用“位操作”来完成“乘5”的操作，不过这个程序中有个BUG，你知道是什么吗？

#include <stdio.h>
#define PrintInt(expr) printf("%s : %d\n",#expr,(expr))
int FiveTimes(int a)
{
    int t;
    t = a<<2 + a;
    return t;
}
int main()
{
    int a = 1;
    PrintInt(FiveTimes(a));
    return 0;
}

A：本题的问题在于函数FiveTimes中的表达式“t = a<<2 + a;”，对于a<<2这个位操作，优先级要比加法要低，所以这个表达式就成了“t = a << (2+a)”，于是我们就得不到我们想要的值。该程序修正如下：“t = (a<<2) + a;”

Q：如下代码关于位运算符的操作为何最终结果和预期不符？

#include <stdio.h>
int main()
{
    unsigned char c = 0xfc;
    unsigned int i = ~c;
    printf("%x\n",i);
    return 0;
}

运行结果：0xffffff03
按照上面的代码，~c应该得到的是0x03, 那么结果应该是0x03, 怎么会是上面的结果呢？
A：这是因为位运算是被提升到整形运算的。上面的变量c是无符号字符型，在进行~位运算时，是首先提升为整形，即为0x000000fc, 然后取反得到0xffffff03, 所以i得到的数值是这个。同理，如果c是char类型，提升为整形时为0xfffffffc，再取反得到的就是0x03。其实变量被提升有很多地方，比如short计算时也会提升为int再继续计算。

Q：下面这个程序执行后会有什么错误或者效果:

#define MAX 255
int main()
{
    unsigned char A[MAX];
    unsigned chat i;
    for (i = 0; i <= MAX; i++)
        A[i] = i;
}

A：MAX=255，数组A的下标范围为：0..MAX-1,下标越界。当i循环到255时，循环内执行: A[255]=255;这句本身没有问题，但是返回for(i=0;i<=MAX;i++)语句时，由于unsigned char的取值范围在[0,255]，i++以后i又为0了，无限循环下去。
注意：char类型为一个字节，取值范围是[-128,127]，unsigned char取值范围[0,255]

Q：有a和b两个整型变量，不用“if”,“? :”,“switch”或者是其他判断语句，如何得到大者和小者？
A：大者:((a+b)+abs(a-b))/2
   小者:((a+b)-abs(a-b))/2

Q：请定义一个宏，比较两个数a、b的大小，不能使用大于、小于、if语句
A：可以判断两个数相减后的符号，32位整数相减后的符号位：

#define MAX(a,b)  ((((a)-(b))&(1<<31))?(b):(a))

Q：定义一个宏，求一个结构体struct中某个变量相对于struct的偏移量

A：#define OFFSET(struct, member)  ((unsigned int)&((struct *)0)->member)

Q：求不小于x的最小的2的K次方的数：

int pow2_ceil(unsigned int x)
{
    x--;
    x |= x >> 1;
    x |= x >> 2;
    x |= x >> 4;
    x |= x >> 8;
    x |= x >> 16;
    x++;
    return x;
}

灵活的位操作可以有效地提高程序运行的效率：
1.设置x的bit5为1，其他位不变：x |= (1<<5);
2.设置x的bit5为0，其他位不变：x &= ~(1<<5);
3.判断x的bit5是否为1，（x & (1<<5)) != 0 ? 1:0;
4.判断一个数是不是偶数：(num & 1) == 0 ? 1:0;

关于C中volatile关键字的作用：一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。
下面是volatile变量的几个例子：
     1). 并行设备的硬件寄存器（如：状态寄存器）
     2). 一个中断服务子程序中会访问到的非自动变量（Non-automatic variables，自动变量是auto或register变量）
     3). 多线程应用中被几个任务共享的变量：volatile 关键字告诉编译器不要持有变量的临时性拷贝。请看以下情形：A线程将变量复制入寄存器，然后进入循环，反复检测寄存器的值是否满足一定条件，它期待B线程改变变量的值。在此种情况下，当B线程改变了变量的值时，已改变的值对其在寄存器的值没有影响。所以A线程进入死循环。