迎战校招训练题

一、双空

编译器可以根据硬件特性选择合适的类型长度，但要遵循如下限制：short与int类型至少为___C___位，long至少为__D____位，并且short类型不长于int类型，int类型不得长于long类型。

A. 4    B.8  C.16 D. 32 E. 64

二、

如下结构体在64位机器上的大小为__D_字节。

struct s1
{
	char a;
	union
	{
		short b;
		char c:2,d:1;
	};
	int *e;
};

A.4 B. 11 C. 13 D. 16 E. 18

解析：这里考了struct的字节问题，需要考虑对齐。并且union 的字节取成员变量的最大字节，即2.a是一个指针，在64位系统下是8字节，所以考虑上对齐为16字节。

三、

以下程序输出结果是_C_____

#include <stdio.h>

void main()
{
	int a = 1, b = 1;
	a+++b;
	printf("a=%d,b=%d", a, b);
}

A.1,1    B.1,2      C.2,1      D.2,2
解析：

a+++b=a++ + b=(a++)+b

四、

以下程序输出的是__D_____

#include <stdio.h>


void main()
{
	int a = 5;
	int b;
	b = ++a;
	printf("a=%d,b=%d", a, b);
}

A.5,5      B.5,6        C.6,5       D.6,6
五、

请问以下程序输出结果是：____B_____

#include<iostream>
using namespace std;
int main () 
{

int a[][3]={{1,2,3},{4,5,0}},(*pa)[3],i;
pa=a;
for(int i=0;i<3;i++)
{
	if (i<2)
	{
		pa[1][i]=pa[1][i]-1;
	}
	else
	{
     pa[1][i]=1;

	}

}
printf("%d\n",a[0][1]+a[1][1]+a[1][2]);

}

A.6      B.7         C.8         D.9         E.10             F.以上答案不对
解析：

这里的 int (*pa)[3],实际上定义了一个指向由三个元素组成的一维数组，令pa=a,所以pa完全代替了a,所以后面的赋值，也就是对a的赋值，因此答案是B
六、

若有定义：int A[3][4];能表示数组元素A[1][1]的是____B_____

A. (A[1]+1)     B.*(&A[1][1])      C.(*(A+1)[1])       D.*(A+5)

解析：

A. (A[1]+1) 表示A[1][1]的地址，B.正确 C.正确的分解顺序是(A+1)[1]=*(A+1+1)=*(A+2):表示第二行第0列的首地址，然后再加上*,就表示A[2][0].   D.越界

注意：[ ]的优先级优于*或者&

七、

（多选）

定义一个函数指针变量pfun，使下面的赋值语句没有编译警告，且无编译错误：

int test(void)
{
	return 0;
}
pfun=test;

请选择：_____A, B____

A. int (*pfun)(void);

B.typedef  int(*PFUN)(void);

PFUN pfun;

C. int* (pfun)(void);

D.int *(*pfun)(void);

解析;本题考了函数指针，其中A是常规的做法，B、typedef的典型用法，typedef有两种用法，一种是创建别名，另一种是掩饰复合类型，如数组和指针。

例如，你不用像下面这样重复定义有 81 个字符元素的数组：

       char　line[81];
       char　text[81];

只需这样定义，Line类型即代表了具有81个元素的 字符数组，使用方法如下：

    typedef char Line[81];
    Line　text,line;
    getline(text);

或者如上面的题中的用法。

八、

定义变量a,包含10个函数指针的数组，函数带一个整型变量，返回值为整型：___C_____

A. int a[10]()    B. (int*) a[10]  C.int (*a[10])()  D.int *(a()[10])
九、

已知

	struct point
	{
		int a;
		int *b;	
	}p;
	p.a=300;
	p.b=(int*)500;

则 p.a+p.b的值是_B____

A.800   B.1700  C.2300 D.1100 
解析;

p.b=(int*)500;将500转化为指针，实际上就是pb取了500的八进制数，一般地址取十六进制（用printf("%X",p.b)输出）。然后p.a+p.b实际上就是将p.b的地址往后移了300*4=1200字节，（int为4个字节）所以实际上等于500+300*4=1700

参考：

1. 为什么整数可以转换为指针

2. int *p=(int *)100; 数字转换成int类型的指针？

3.c语言 一个指针值加上一个整型值是什么意思？

十、

（多选） 以下程序输出__A,B_____
     printf("%d",55^0xAA);

A. 157  B.0x9D   C.127 D.128

解析：  55（二进制）：110111  0xAA(二进制)：10101010 二者取异或运算得：10011101------>十进制（157）,十六进制（0x9D）

十一、

   以下程序输出的是_____C_____

        int a,b;
	a=1;
	b=32;
	printf("%d,%d\n",a<<b,1<<32);

A.0,0   B.0,1      C.1,0    D.1,1

 解析;   左移或者右移把握一个标准，就是在移位运算时，byte、short和char类型移位后的结果会变成int类型，对于byte、short、char和int进行移位时，规定实际移动的次数是移动次数除以32的余数，也就是移位33次和移位1次得到的结果相同。移动long型的数值时，规定实际移动的次数是移动次数和64的余数，也就是移动66次和移动2次得到的结果相同。

而且左移时高位移出(舍弃)，低位的空位补零。右移时，若是负数，低位舍弃，高位补1,；若是正数，低位舍弃，高位补0

例如：

int i = 1, j = 0x80000000; //设int为32位
     i = i << 33; // 33 % 32 = 1 左移1位,i变成2
     j = j << 33; // 33 % 32 = 1 左移1位,j变成0,最高位被丢弃
     int k= 0x80000000; 即二进制为100000000 00000000 00000000 00000000
     k = k>> 1; //k的值不会变成0x40000000,而会变成0xc0000000，即二进制为11000000 00000000 00000000 000000000

这里a=1,a<<32 //32%32=0，未移位，故a=1,  但是1<<32，由于越界，直接舍弃高位，所以答案为0，总之记住若是int类型，移动的次数为移动次数与32/64的余数，若是一个数常数，则移位超过32/64，直接舍弃高位，为0

十二、

如果数组a的首地址为65072，每个整数为16位的，则下列程序打印输出的是______C_______

#include <stdio.h>
int main()
{
	int a[3][4]={1,3,5,7,9,7,5,3,1,3,5,7};
	printf("%u\n",a+1);
	return 0;
}

A. 65088    B. 65120    C. 65080   D.65096 E.以上答案都不对
解析：

       a的首地址：65072，a+1指向a[1][0],离首地址相差4个int,由于每个整数为16位，也就是2字节，所以共相差8个字节，因此输出65072+8=65080

十三、

如果数组a的首地址为50152，则下列程序打印输出的是______B_______

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

A. 50168    B.50200     C.50153     D.50156     E.以上答案都不对

解析：

   注意到a为二维数组的首地址，指向第0行，&a+1指向二维数组的最后一个元素的下一个元素，因此：50152+12*4=50200

十四、

请问以下程序输出结果是_____C_______

 

        int a[3][3]={1,2,3,4,5,6,7,8,9};
	int (*ptr)[3]=a;
	printf("%d",(*(ptr+1))[2]);

A.4     B.5     C.6     D.7

解析：ptr=a;所以ptr指向a数组的第0行，然后再看(*(ptr+1))[2]);，看的顺序是：ptr+1---->*(ptr+1)------->(*(ptr+1))[2]),依次指向： 1行首地址；1行0列首地址；1行2列元素，即a[1][2],也就是6

十五、多选题

HASH值计算公式是(MAC[1]^MAC[2]^MAC[3]^MAC[4])%8

下面4个MAC地址，哪些是不会发生hash冲突的___？？______

A. 00 d0 f8 01 02 03

B.00 1a a9 7f 78 58

C. 00 00 5e 00 01 cc

D.02 03 05 06 aa fe

解析： MAC地址是6字节十六进制数组成的。

A： d0 ^ f8 ^ 01 ^ 02=11010000 ^ 11111000 ^00000001^00000010=00101011=43(10进制)

B：1a ^ a9 ^ 7f  ^78=00011010 ^10101001 ^01111111 ^01111000=10110100=180(10进制)

C: 00^ 5e ^ 00^ 01=95(10进制)

D:03^ 05 ^06^ aa=170(10进制)

43%8=3,180%8=4 ，95%8=7 ，170%8=2 好像都不会冲突啊，怎么做？

十六、

请补齐以下程序____？？______

      

int setx_r(int len)
{

	Lock(cb);
	g_ptx_ptr->length=len;
        g_ptx_ptr->str=kmalloc(d_len);
	if (g_ptx_ptr->str==null||g_ptx_ptr!=OK)
	{
		_________________;
		return ERR;
	}
	Unlock(ch);
	Return Success;
}

A. Lock(cb) B.Unlock(cb) C. break D.不必填写 E。以上答案都不对

十七、

以下程序输出是___D_____

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define Max 10
char* test()
{
char buf[Max];
memset(buf,0,Max);
sprintf(buf,"%s","001");
sprintf(buf,"%s%s",buf,buf);
return buf;

}
void main()
{
	
	printf("%s",test());

}

A.001    B.001001  C.001001001  D.不确定或者运行错误 E.以上答案都不对

答案： D

解析：由于char* test(),返回的是局部指针，所以一旦函数调用结束，buf分配的内存释放，所以返回的是随机的字符。

十八、

请问以下程序输出结果是______F____

int i,j;
int array[10];
int *ap=array+5;
for(i=0;i<10;i++)
{
	array[i]=i;
}
i=3;j=5;
printf("i[array]+j=%d\n",i[array]+j);

A.3   B.4  C. 5  D.6 E.7  F.8 G.9  H.以上答案都不对
解析： 上面代码起初我以为是错的，后来实际编译一下，可以通过，i[array]相当于*(array+i),也就是array[i],所以这里相当于array[3]+5=3+5=8

十九、

下面程序片段的运算结果为____C_______

int main () 
{
int x=2016,y=2017,z=2018;
z+=x+++y++;
printf("%d\n",z);
   
}

A.4033 B.4034 C.6051 D.6052
解析： z+=x+++y++,由于++的优先级优于+,故左式相当于z+=(x++)+(y++);x++,y++,都是先使用后自增，故z=2016+2017+2018=6051

二十、

下面程序的输出结果为_______C______

#include<iostream>
#include<math.h> //包含了<string.h>
using namespace std;

char buf[256];
int main () 
{
sprintf(buf+sprintf(buf,"%s","abc\0%de"),"%s","fgh%%di");
printf(buf,112);
return 0;
   
}

A.abc    B.fgh     C.abcfgh%di      D.fgh%de      E.abc%de

二十一、下面的输出结果是____8_____

	char* s = "\\tmp012\012";
	cout << strlen(s) << endl;

解析： 最初拿到这道题，我的答案是7,原因是'\\'使用了转义字符表达‘\’，后面还有‘\0’，strlen遇到'\0'就停止计数，所以共有'\\'+'t'+'m'+'p'+'0'+'1'+'2'共7个字符。其实错了，'\012'，实际上是用八进制表示的字符'\n'，表示换行。所以共有8个字符。实际上，‘\0’是不会直接出现在字符串中，编译器默认字符串的末尾为‘\0’。在C++中，除了用八进制表示字符，还可以使用'\x**'即一个十六进制表示一个字符，或者使用ASCII值直接表示。

二十二、下面的输出结果是_____53_____

int a[5] = { 9876, 0123, 4567, 2345, 8901 };
	printf("%x\n", *(a + 1));

解析： *(a+1)=a[1]=0123,输出%x，实际上输出16进制。而0123是8进制，转化为16进制为53.
二十三、下面的输出结果是_____0____

	int a = -6;
	unsigned int b = 6;
	cout << a + b << endl;

解析：unsigned int 与int相加时会转化为int，再加

二十四、在32位系统下，下面的输出结果是__64 ，16， 16， 4_______

	int a[4][4];
	cout << sizeof(a) << endl;
	cout << sizeof(a[0]) << endl;
	cout << sizeof(*a) << endl;
	cout << sizeof(*a+1) << endl;

解析：a表示二维数组，故字节为4*4*4=64，a[0]或者*a代表0行一维数组，故字节为4*4=16,而*a+1表示0行1列元素的地址，是一个指针，所以字节为4