面经 - C/C++ 基础篇

// Code 1
int i=1;
int main()
{
    int i=i;
}

// Code 2
int main()
{
    int i=i;
}

// Ps：Code1 和 Code2 是等价的。

A. The i within main will have an undefined value. (main() 里的 i 是一个未定义值)
B. The i within main will bave a value of 1. (main() 里的i值为1)
C. The compiler will not allow this statement. (编译器不允许这种写法)
D. The i within main will have a value of 0. (main() 里的i值为0)
解析：当面试者看到int i=i;时，也许第一反应就是怎么有这么诡异的代码？但是在C++中这样做是完全合法的（但显然不合理）。int i=i, i变量从声明的那一刻开始就是可见的了，main()里的i不是1,因为它和main()外的i无关，而是一个未定义值。

#include<bits/stdc++.h>

using namespace std;

int main()
{
    int a[]={6,7,8,9,10};
    int *p=a;
    *(p++)+=123;
    printf("%d,%d\n",*p,*(++p));

    return 0;
}

A. 88    B. 1308    C. 77    D. 78
解析：
a、*(p++)+=123应为*p=*p+123;p++，此时 p 应指向第二个元素7。
b、printf( "%d,%d\n ",*p,*(++p)); 从右到左运算，第一个是(++p)，也就是p++，*p=8，此时p指向第三个元素8，所以全部为8。

// 写法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);
}

解析：第二种写法好一些，将部分加法运算放到了循环体外，提高了效率。缺点是程序不够简洁。

#include <iostream>

using namespace std;

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

答案：false true 或者 0 1。
解析：在机器上运行一下，可以得到结果，“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的十进制表示）。
i、(int)x 强制类型转换，是将浮点数x为参数构造整数（即float转换为int）。
ii、(int &)y 则是告诉编译器将y看成int对待（内存里的数据不做任何转换),所以(int &)x值为1071 644 672。
iii、浮点数0.0是比较特殊的，它并不按照上面说的浮点数的格式存储，浮点数0.0在内存里的存储是000.....000（全零）。

#include <stdio.h>
int  main()
{
    unsigned int a = 0xFFFFFFF7;
    unsigned char i = (unsigned char)a;
    char* b = (char*)&a;
    printf("%08x, %08x", i,*b);

    return 0;
}

答案：000000f7，fffffff7。
解析：unsigned int变量赋值给unsigned char变量时会发生字节截断（unsigned int：4字节；unsigned char：1字节）。 那么第二个数，也就是char* b = (char*)&a中a本身为一个uint（unsigned int）类型的值，把它的地址赋给一个执行char类型数据的指针。char类型的长度只有一个字节，打印char类型的指针指向的值会是多少？ &a的结果是一个指针，它的类型取决于a的类型，此处&a的类型应该是：
unsigned int *;
char *b = (char *)&a;
上面等价于：
unsigned int *p = &a; // p中的内容是a的地址，即p指向a
char *b = (char *)p;  // 此处的强制转换只是使b也指向a而已
上面的步骤就是将一个unsigned int型的指针强制转换成一个char型的指针。所以请注意：这里是char类型的指针转换，而不是char类型的转换。 这样转换后，假设a的地址是x：
p + 1 = x + 1*sizeof(int) = x + 1 * 4 = x + 4;         
b + 1 = x + 1*sizeof(char) = x + 1 * 1 = x + 1;
影响的是指针的寻址。

int x=4,y=7;
y=y+++x-3;
System.out.format("%d,%d\n", x,y);

Console：
4,8