#include
using namespace std;
int i = 1;
int main()
{
int i = i;
printf("%d\n", i);
return 0;
}
A. main()里的i是一个未定义值
B. main()里的i值为1
C. 编译器不允许这种写法
D. main()里的i值为0
解析:当面试者看到int i=i;时,也许第一反应就是怎么有这么诡异的代码?但是在
C++中这样做是完全合法的(但显然不合理)。int i=i,i变量从声明的那一刻开始就是可见
的了,main()里的i不是1,因为它和main()外的i无关,而是一个未定义值。
博主第一次看到此解析,没有看明白它的意思。再这里用博主自己的话重新做一下说明,main
函数外的i
为全局变量,在全区域内都可以使用。而在’main’函数内,因为重新使用了int
,所以是重新定义的i
,与外面的i将没有任何关系。使用int i = i;
声明了一个局部变量i,并将其赋值为它自己。这是一个有问题的语句,因为它试图将未初始化的局部变量赋值给自己,导致结果是不确定的。
答案:A
题目变形:*如果看懂了上面的解释,变形题目就将so easy,too happy。答案大家就自己试一下吧,本文将不在给出!
#include
using namespace std;
int i = 1;
int main()
{
i = i;
printf("%d\n", i);
return 0;
}
#include
using namespace std;
int main()
{
int x = 2, y, z;
x *= (y=z=5);
cout << x << endl;
z = 3;
x == (y=z);
cout << x << endl;
x = (y==z);
cout << x << endl;
x = (y&z);
cout << x << endl;
x = (y&&z);
cout << x << endl;
y = 4;
x = (y|z);
cout << x << endl;
x = (y||z);
cout << x << endl;
return 0;
}
解析:
#include
using namespace std;
int func(int x)
{
int count = 0;
while(x)
{
count++;
x = x&(x-1);
}
return count;
}
int main()
{
cout << func(9999) << endl;
return 0;
}
解析:本题重点是x = x&(x-1);
这一行代码通过位运算将x的二进制表示中最右边的1变为0。这个操作会在每次循环中去掉x的二进制表示中的一个1。
本题func函数返回值是形参x转化成二进制后包含1的数量。理解这一点就很容易
答出来了。9999转化为二进制是10 0111 0000 1111
。
答案:8
// 第一段代码
using namespace std;
int main()
{
int a, x;
for(a=0, x=0; a<=1 && !x++; a++)
{
a++;
}
cout << a << x << endl;
return 0;
}
// 第二段代码
#include
using namespace std;
int main()
{
int a, x;
for(a=0, x=0; a<=1 && !x++;)
{
a++;
}
cout << a << x << endl;
return 0;
}
解析
先说第1段代码。
第1步:初始化定义a=0,x=0。
第2步:a小于等于1,x的非为1,符合循环条件。
第3步:x++后x自增为1。
第4步:进入循环体,a++,a自增为1。
第5步:执行for(a=0,x=0;a<=1 &&!x++;a++)中的a++,a自增为2。
第6步:a现在是2,已经不符合小于等于1的条件了,所以“&&”后面的“!x++”不执行,x
还是1,不执行循环体。
第7步:打印a和b,分别是2和1。
再说第2段代码。
第1步:初始化定义a=0,x=0。
第2步:a小于等于1,x的非为1,符合循环条件。
第3步:x++后x自增为1。
第4步:进入循环体,a++,a自增为1。
第5步:a现在是1,符合小于等于1的条件,所以“&&”后面的“!x++”被执行,x现在是
1,x的非为0,不符合循环条件,不执行循环体,但x++依然执行,自增为2。
第6步:打印a和b,分别是1和2。
答案:21 12
#include
int main()
{
int b = 3;
int arr[] = {6, 7, 8, 9, 10};
int *ptr = arr;
*(ptr++) += 123;
printf("%d, %d\n", *ptr, *(++ptr));
return 0;
}
解析:
C中printf计算参数时是从右到左压栈的
printf("%d\n ",*ptr);此时ptr应指向第一个元素6。
(ptr++)+=123应为ptr=ptr+123;ptr++,此时ptr应指向第二个元素7。
printf("%d,%d\n ", ptr, * (++ptr));从右到左运算,第一个是(++ptr),ptr++了,所以此时ptr指向第三个元素8, 第二个是ptr他也指向第三个元素8。
注意:此题目中b没有用,博主也不知道该公司怎么想的,一点干扰都没有。另外可能大家好奇加的123去哪里,这里笔者直接告诉大家,129变成了 *(ptr-2)
的结果。可以试试下面的变形
答案:8,8
变形:
#include
int main()
{
int b = 3;
int arr[] = {6, 7, 8, 9, 10};
int *ptr = arr;
*(ptr++) += 123;
// printf("%d, %d\n", *ptr, *(++ptr));
printf("%d\n", *(ptr-2));
return 0;
}
// 第一段
// 1.
if('A' == a)
{
a++;
}
// 2.
if(a == 'A')
{
a++;
}
// 第二段
// 1.
for(i=0; i<8; i++){
X = i+Y+J*7;
printf("%d", X);
}
// 2.
S = Y+J*7;
for(i=0; i<8; i++){
printf("%d", i+S);
}
解析:
A.第一种写法'A' == a
比较好一些。这时如果把 ==
误写做=
的话,因为编译器不允许
对常量赋值,就可以检查到错误。
B.第二种写法好一些,将部分加法运算放到了循环体外,提高了效率。缺点是程序不
够简洁。
int main()
{
float a = 1.0f;
cout << (int)a << endl;
cout << &a << endl;
cout << (int&)a << endl;
cout << boolalpha << ((int)a == (int&)a) << endl; // 输出什么?
float b = 0.0f;
cout << (int)b << endl;
cout << &b << endl;
cout << (int&)b << endl;
cout << boolalpha << ((int)b == (int&)b) << endl; // 输出什么
return 0;
}
解析:
在机器上运行一下,可以得到结果,“cout << (int&)a << endl;”输出的是
1065353216,而不是1。这是因为浮点数在内存里和整数的存储方式不同,(int&)a相当于将该浮点数地址开始的sizeof(int)个字节当成int型的数据输出,因此这取决于float型数据在内存中的存储方式,而不是经过(int&)a显示转换的结果(1)。
因为float a=1.0f在内存中的表示都是3f800000,而浮点数和一般整型不一样,所以当(int&)a强制转换时,会把内存值3f8000000当做int型输出,所以结果自然变为了1065353216(0x3f800000的十进制表示)。
而b为0.0f,所以输出的均为0。结果就为true了
答案:false true
int main()
{
unsigned int a = 0xFFFFFFF7;
unsigned char i = (unsigned char)a;
char *b = (char*)&a;
printf("%08x, %08x", i, *b);
return 0;
}
解析:
unsigned int变量赋值给unsigned char变量时会发生字节截断(3位和高于3位的将被程序自动丢弃)。
那么第二个数,也就是char* b=(char*)&a中a本身为一个uint类型的值,把它的地址赋给一个执行char类型数据的指针。char类型的长度只有一个字节,打印char类型的指针指向的值会是多少?
&a的结果是一个指针,它的类型取决于a的类型,此处&a的类型应该是:
unsigned int *;
char *b = (char*)&a;
上面等价于:
unsigned int *p = &a;
char *b = (char*)&p;
上面的步骤就是将一个unsigned int型的指针强制转换成一个char型的指针。
所以请注意:这里是char类型的指针转换,而不是char类型的转换。
答案:000000f7,fffffff7
int main()
{
unsigned char a = 0xA5;
unsigned char b = ~a>>4+1;
printf("b=%d\n", b);
return 0;
}
解析:
这道题目考查两个知识点:一是类型转换问题;二是算符的优先级问题。
对于第一个问题
:unsigned char b=~a>>4,在计算这个表达式的时候,编译器会先把a和
4的值转换为int类型(即所谓整数提升)后再进行计算,当计算结果出来后,再把结果转换
成unsigned char赋值给b。
对于第二个问题
:因为“~”的优先级高于“>>”和“+”,本题的过程是这样的:先对于1010
0101取反0101 1010;再右移,这里有一个问题,是先右移4位再加1呢,还是直接右移
5(4+1)位。因为“+”的优先级高于“>>”,所以直接右移5位。结果是0000 0010。
最后的结果应该是2才对,但把如上的指令放到vs code中运行,答案居然是250。
那么到底是什么地方出了问题?在调试的过程中进入汇编指令。可以看到高级语句转换
为汇编语言以后,是先执行取反再位移的。我们看到eax是16位的寄存器,于是在机器中
0xA5的寄存中表达是0000 0000 1010 0101 ,取反是1111 1111 0101 1010,那么右移5位是
0000 0111 1111 1010,由于是unsigned char型的只能表示低8位的数值,即250。
答案:250
解析:
2、4、8、16这样的数转化成二进制是10、100、1000、10000。如果X减1后与X
做与运算,答案若是0,则X是2的N次方。
答案:!(X&(X-1))
答案:
inline int max(int a, int b) { return a>=b ? a : b; }
inline int min(int a, int b) { return a<=b ? a : b; }
inline int medium(int a, int b, int c)
{
int t1 = max(a, b);
int t2 = max(b, c);
int t3 = max(a, c);
return min(t1, min(t2, t3));
}
int main()
{
int mid = medium(1, 3, 5);
printf("mid: %d\n", mid);
return 0;
}
答案:C++语言支持函数重载,C语言不支持函数重载。函数被C++编译后在库中的名
字与C语言的不同。假设某个函数的原型为void foo(int x, int y)。该函数被C编译器编译后在
库中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern "C"解决名字匹配问题。
答案:防止该头文件被重复引用。
int main()
{
int n = 'c';
switch(n++)
{
default: printf("error"); break;
case 'a': case 'A': case 'b': case 'B': printf("ab"); break;
case 'c': case 'C': printf("c");
case 'd': case 'D': printf("d");
}
return 0;
}
解析:
本题考的是switch中的“fall through”:如果case语句后面不加break,就依次执行下去。
int n = 'c';
这一行定义了一个整数变量n,并将其初始化为字符 ‘c’ 对应的ASCII码值,也就是99。
switch(n++):这是一个switch语句,它会根据n的值来选择不同的分支进行执行。n++表示先使用n的值,然后再将n自增1。
case 'a': case 'A': case 'b': case 'B': printf("ab"); break;
这是一个合并的case分支。如果n的值等于小写 ‘a’、大写 ‘A’、小写 ‘b’ 或大写 ‘B’,就会执行这个分支,打印 “ab” 并结束switch语句的执行。
case 'c': case 'C': printf("c");
这是另一个合并的case分支。如果n的值等于小写 ‘c’ 或大写 ‘C’,就会执行这个分支,打印 “c”。
case 'd': case 'D': printf("d");
这是又一个合并的case分支。如果n的值等于小写 ‘d’ 或大写 ‘D’,就会执行这个分支,打印 “d”。
答案:cd