题海拾贝No.9|C语言笔试-＞程序代码评价或者找错

题目及解析

1、下面的代码输出是什么，为什么？

void foo(void)
{
unsigned int a = 6;
int b = -20;
(a+b > 6) ? puts(“> 6″) : puts(“<= 6");
}

这个问题测试你是否懂得C语言中的整数自动转换原则，不管如何，这无符号整型问题的答案是输出是 ">6″。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果答错了这个问题，也就到了得不到这份工作的边缘。

2、评价下面的代码片断：

unsigned int zero = 0;
unsigned int compzero = 0xFFFF;

对于一个int型不是16位的处理器为说，上面的代码是不正确的。
应编写如下：

unsigned int compzero = ~0;

这一问题真正能揭露出应试者是否懂得处理器字长的重要性。好的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而PC机程序往往把硬件作为一个无法避免的烦恼。

3、 C语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是，它做些什么？

int a = 5, b = 7, c;
c = a+++b;

上面的例子是完全合乎语法的。问题是编译器如何处理它。水平不高的编译作者实际上会争论这个问题，根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：
c = a++ + b;
因此, 这段代码持行后a = 6, b = 7, c = 12。
实际上这里是有争议的，也有可能是
c = a + ++b;
结果可能是a = 5, b = 8, c = 13。
这个问题是一个关于代码编写风格，代码的可读性，代码的可修改性的话题。

4、设有以下说明和定义：

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。DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20
data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.
所以结果是 20 + 32 = 52.
当然…在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20

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

#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;
}

答：10，12，120
a 先把值给 b 然后再自加 1，所以 b 值为10，这时候的a是11了，然后再加 1 再给值给 c，所以 c 的值是12，后面的是先10*12等于120 赋给 d，之后再自加 1，变成13。

6、请问下面程序会出现什么情况?

#define Max_CB 500
void LmiQueryCSmd(Struct MSgCB * pmsg)
{
unsigned char ucCmdNum;
......
for(ucCmdNum=0;ucCmdNum<MAX_CB;UCCMDNUM++)
{
......;
}

答案：死循环，因为unsigned char 范围是0~255，永远比500小

7、以下3个有什么区别
char * const p; //常量指针，p的值不可以修改
char const * p；//指向常量的指针，指向的常量值不可以改
const char *p； //和char const *p

8、写出下面的结果

char str1[] = "abc";
char str2[] = "abc";
const char str3[] = "abc";
const char str4[] = "abc";
const char *str5 = "abc";
const char *str6 = "abc";
char *str7 = "abc";
char *str8 = "abc";
cout << ( str1 == str2 ) << endl;
cout << ( str3 == str4 ) << endl;
cout << ( str5 == str6 ) << endl;
cout << ( str7 == str8 ) << endl;

结果是：0 0 1 1
解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；
而str5,str6,str7,str8是指针，它们指向相同的常量区域。
9、以下代码中的两个sizeof用法有问题吗？

void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
for( size_t i=0; i
if( 'a'<=str[i] && str[i]<='z' )
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;

答：函数内的sizeof有问题。
根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。
函数外的str是一个静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此sizeof作用上只将其当指针看，一个指针为4个字节，因此返回4。
10、写出输出结果(数组和指针一起考察)

int 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
a是数组首地址，也就是a[0]的地址	&a是对象（数组）首地址
a+1是数组下一元素的地址，即a[1]	&a+1是下一个对象的地址，即a[5]

11、请问以下代码有什么问题：

int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}

没有为str分配内存空间，将会发生异常
问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);

"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
const char* s=“AAA”;然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

12、交换两个变量的值，不使用第三个变量。
即a=3,b=5,交换之后a=5,b=3;
有两种解法, 一种用算术算法, 一种用^(异或)
a = a + b;b = a - b;a = a - b;

a = a^ b; b = a^ b;a = a^ b; // 只能对int,char…
上式子也可以写成
a ^= b ^= a;
13、下面的程序会出现什么结果

void getmemory(char *p)
{
	p=(char *) malloc(100);
	strcpy(p,”hello world”);
}
int main( )
{
	char *str=NULL;
	getmemory(str);
	printf(“%s/n”,str);
	free(str);
	return 0;
}

程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险
14、下面的语句会出现什么结果？

char szstr[10];
strcpy(szstr,”0123456789″);

答案：长度不一样，会造成非法的OS，应该改为char szstr[11]；

15、(void *)ptr 和 (*(void**))ptr的结果是否相同？
答：其中ptr为同一个指针，(void *)ptr 和 (*(void**))ptr值是相同的

16、函数既然不会被其它函数调用，为什么要返回1？

int main()
{
int x=3;
printf(“%d”,x);
return 1;
}

答：mian中，c标准认为0表示成功，非0表示错误。具体的值是某种具体出错信息

17、对绝对地址0×100000赋值且想让程序跳转到绝对地址是0×100000去执行
(unsigned int*)0×100000 = 1234;
首先要将0×100000强制转换成函数指针,即:
(void (*)())0×100000
然后再调用它:
*((void (*)())0×100000)();
用typedef可以看得更直观些:

typedef void(\*)() voidFuncPtr;
*((voidFuncPtr)0×100000)();

18、分析下面的程序：

void GetMemory(char **p,int num)
{
	*p=(char *)malloc(num);
}
int main()
{
	char *str=NULL;
	GetMemory(&str,100);
	strcpy(str,”hello”);
	free(str);
	if(str!=NULL)
	{
		strcpy(str,”world”);
	}
	printf(“\n str is %s”,str);
	getchar();
}

问输出结果是什么？说明原因
输出str is world。
free 只是释放的str指向的内存空间,它本身的值还是存在的.
所以free之后，有一个好的习惯就是将str=NULL.
此时str指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的话,这段存储空间是可能被重新分配给其他变量的,
尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常会打印出world来。
这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完成的。
当你malloc一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的，但最好别这么干。

19、下面的函数实现在一个数上加一个数，有什么错误？请改正。

int add_n ( int n )
{
static int i = 100;
i += n;
return i;
}

当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题就出在 static上，比如你第一次调用是add_n(10)，之后结果是110，是，没问题，但再执行一次add_n(10)时就是120了，因为static让函数里的 i 只会初始化一次为100，往后改成多少就是多少了。

20、给出下面程序的答案

typedef struct AA
{
	int b1:5;
	int b2:2;
}AA;
void main()
{
	AA aa;
	char cc[100];
	strcpy(cc,”0123456789abcdefghijklmnopqrstuvwxyz”);
	memcpy(&aa,cc,sizeof(AA));
	cout << aa.b1 <<ENDL;
	cout << aa.b2 <<ENDL;
}

答案是 -16和１
首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit.
经过strcpy和memcpy后,aa的4个字节所存放的值是:
0,1,2,3的ASC码，即00110000,00110001,00110010,00110011
所以，最后一步：显示的是这４个字节的前５位，和之后的２位
分别为：10000,和01
因为int是有正负之分　　所以：答案是-16和１

21、求函数返回值，输入x=9999;

int func （ x ）
{
	int countx = 0;
	while ( x )
	{
		countx ++;
		x = x&(x-1);
	}
	return countx;
}

这是统计9999的二进制数值中有多少个1的函数，用此法求1的个数效率很高。不必一个一个移位。循环次数最少。