C语言面试及答案分析第二部分程序代码评价或者找错

- 日理万妓 2022-10-25 11:26 339阅读 0赞

## 第二部分：程序代码评价或者找错 ##

### 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;
    /*1′s complement of zero */

对于一个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。  
如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可读性，代码的可修改性的好的话题。

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

### 6、写出下列代码的输出内容 ###

#include
    int inc(int a)
    { 
    	return(++a);
    }
    int multi(int*a,int*b,int*c)
    { 
    	return(*c=*a**b);
    }
    typedef int(FUNC1)(int in);
    typedef int(FUNC2) (int*,int*,int*);
    void show(FUNC2 fun,int arg1, int*arg2)
    { 
    	INCp=&inc;
    	int temp =p(arg1);
    	fun(&temp,&arg1, arg2);
    	printf(“%d\n”,*arg2);
    }
    main()
    { 
    	int a;
    	show(multi,10,&a);
    	return 0;
    }

答：110

### 7、请找出下面代码中的所以错误 ###

说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”

#include”string.h”
    main()
    { 
    	char*src=”hello,world”;
    	char* dest=NULL;
    	int len=strlen(src);
    	dest=(char*)malloc(len);
    	char* d=dest;
    	char* s=src[len];
    	while(len–!=0)
    	d++=s–;
    	printf(“%s”,dest);
    	return 0;
    }

答：  
方法1：

int main(){ 
    	char* src = “hello,world”;
    	int len = strlen(src);
    	char* dest = (char*)malloc(len+1);//要为\0分配一个空间
    	char* d = dest;
    	char* s = &src[len-1];//指向最后一个字符
    	while( len– != 0 )
    	*d++=*s–;
    	*d = 0;//尾部要加\0
    	printf(“%s\n”,dest);
    	free(dest);// 使用完，应当释放空间，以免造成内存汇泄露
    	return 0;
    }

方法2：

#include
    #include
    main()
    { 
    	char str[]=”hello,world”;
    	int len=strlen(str);
    	char t;
    	for(int i=0; i { 
    		t=str[i];
    		str[i]=str[len-i-1]; str[len-i-1]=t;
    	}
    	printf("%s",str);
    	return 0;
    }

### 8、请问下面程序有什么错误? ###

int a[60][250][1000],i,j,k;
    for(k=0;k<=1000;k++)
    for(j=0;j<250;j++)
    for(i=0;i<60;i++)
    a[i][j][k]=0;

答案：把循环语句内外换一下

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

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

答案：死循环

### 10、以下3个有什么区别 ###

char \* const p; //常量指针，p的值不可以修改  
char const \* p；//指向常量的指针，指向的常量值不可以改  
const char \*p； //和char const \*p

### 11、写出下面的结果 ###

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是指针，它们指向相同的常量区域。

### 12、以下代码中的两个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。

### 13、写出输出结果 ###

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].

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

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的时候就有问题。  
cosnt char\* s=“AAA”;  
然后又因为是常量，所以对是s\[0\]的赋值操作是不合法的。

### 15、有以下表达式： ###

int a=248; b=4;int const c=21;const int *d=&a;
    int *const e=&b;int const *f const =&a;

请问下列表达式哪些会被编译器禁止？为什么？

*c=32;d=&b;*d=43;e=34;e=&a;f=0x321f;
    *c 这是个什么东东，禁止
    *d 说了是const， 禁止
    e = &a 说了是const 禁止
    const *f const =&a; 禁止

### 16、交换两个变量的值，不使用第三个变量。 ###

即a=3,b=5,交换之后a=5,b=3;  
有两种解法, 一种用算术算法, 一种用^(异或)

a = a + b;
    b = a - b;
    a = a - b;
    or
    a = a^b;// 只能对int,char..
    b = a^b;
    a = a^b;
    or
    a ^= b ^= a;

### 17、下面的程序会出现什么结果 ###

#include
    #include
    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操作很危险

### 18、下面的语句会出现什么结果？ ###

char szstr\[10\];  
strcpy(szstr,”0123456789″);  
答案：长度不一样，会造成非法的OS，应该改为char szstr\[11\]；

### 19、(void *)ptr 和 (*(void\*\*))ptr的结果是否相同？ ###

答：其中ptr为同一个指针  
.(void *)ptr 和 (*(void\*\*))ptr值是相同的

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

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

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

### 21、对绝对地址0×100000赋值且想让程序跳转到绝对地址是0×100000去执行 ###

(unsigned int*)0×100000 = 1234;
    首先要将0×100000强制转换成函数指针,即:
    (void (*)())0×100000
    然后再调用它:
    *((void (*)())0×100000)();
    用typedef可以看得更直观些:
    typedef void(*)() voidFuncPtr;
    *((voidFuncPtr)0×100000)();

### 22、输出多少？并分析过程 ###

unsigned short A = 10;
    printf(“~A = %u\n”, ~A);
    char c=128;
    printf(“c=%d\n”,c);

第一题，～A ＝0xfffffff5,int值 为－11，但输出的是uint。所以输出4294967285  
第二题，c＝0×10,输出的是int，最高位为1，是负数，所以它的值就是0×00的补码就是128，所以输出－128。  
这两道题都是在考察二进制向int或uint转换时的最高位处理。

### 23、分析下面的程序： ###

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一块内存的时候，管理库向操作系统申请一块空间（可能会比你申请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会将内存还给操作系统，因此你是可以继续访问这块地址的，只不过。。。。。。。。楼上都说过了，最好别这么干。

### 24、char a\[10\],strlen(a)为什么等于15？运行的结果 ###

#include “stdio.h”
    #include “string.h”
    void main()
    { 
    	char aa[10];
    	printf(“%d”,strlen(aa));
    }

sizeof()和初不初始化，没有关系；  
strlen()和初始化有关。  
char (\*str)\[20\];/*str是一个数组指针，即指向数组的指针．*/  
char \*str\[20\];/*str是一个指针数组，其元素为指针型数据．*/

### 25、long a=0×801010;a+5=? ###

答：0×801010用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进制的值为8392720，再加上5就是8392725

### 26、给定结构struct A ###

{ 
    	char t:：4;
    	char k:4;
    	unsigned short i:8;
    	unsigned long m;
    };

问sizeof(A) = ?  
给定结构struct A

{ 
    	char t:4; 4位
    	char k:4; 4位
    	unsigned short i:8; 8位
    	unsigned long m; // 偏移2字节保证4字节对齐
    }; // 共8字节

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

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

当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题就出在 static上

### 28、给出下面程序的答案 ###

#include
    
    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 < cout << aa.b2 
    }

答案是 -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和１

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

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

结果呢？  
知道了这是统计9999的二进制数值中有多少个1的函数，且有  
9999＝9×1024＋512＋256＋15  
9×1024中含有1的个数为2；  
512中含有1的个数为1；  
256中含有1的个数为1；  
15中含有1的个数为4；  
故共有1的个数为8，结果为8。

*  1 = 0111，正好是原数取反。这就是原理。  
    用这种方法来求1的个数是很效率很高的。  
    不必去一个一个地移位。循环次数最少。

### 30、分析： ###

struct bit
    {  
    	int a:3;
    	int b:2;
    	int c:3;
    };
    int main()
    { 
    	bit s;
    	char *c=(char*)&s;
    	cout< *c=0x99;
    	cout << s.a < int a=-1;
    	printf("%x",a);
    	return 0;
    }

输出为什么是  
1  
\-1  
\-4  
ffffffff  
因为0x99在内存中表示为 100 11 001 , a = 001, b = 11, c = 100  
当c为有符合数时, c = 100, 最高1为表示c为负数，负数在计算机用补码表示，所以c = -4;同理  
b = -1;  
当c为有符合数时, c = 100,即 c = 4,同理 b = 3

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

#define MAX 255
    int main()
    { 
    	unsigned char A[MAX],i;//i被定义为unsigned char
    	for (i=0;i<=MAX;i++)
    	A[i]=i;
    }

解答：死循环加数组越界访问（C/C++不进行数组越界检查）  
MAX=255  
数组A的下标范围为:0…MAX-1,这是其一…  
其二.当i循环到255时,循环内执行:  
A\[255\]=255;  
这句本身没有问题…但是返回for (i=0;i<=MAX;i++)语句时,  
由于unsigned char的取值范围在(0…255),i++以后i又为0了…无限循环下去.

### 32、写出sizeof(struct name1)=,sizeof(struct name2)=的结果 ###

struct name1{ 
    	char str;
    	short x;
    	int num;
    }
    struct name2{ 
    	char str;
    	int num;
    	short x;
    }

sizeof(struct name1)=8,sizeof(struct name2)=12  
在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间；同时为保证整个结构的自然对齐（这里是4字节对齐），在x后还要补齐2个字节，这样就是12字节。