C/C++面试笔试（2）
1.
#include <stdio.h>
#include <setjmp.h>
#include<string.h>
#include <conio.h>
#include <stdlib.h>
static jmp_buf buf;//
int main(void)
{
volatile int b = 3;//用来修饰被不同线程访问和修改的变量
if (setjmp(buf) != 0)
{
printf("%d\n", b);
exit(0);
}
b = 5;
longjmp(buf, 1);//发生异常跳转
}
输出结果：5
详细解析：
关键点在于理解setjmp以及longjmp，第一次运行到setjmp，会设置jmp_buf，然后返回0。当调用longjmp时，会把longjmp里面的非0值作为setjmp的返回值返回（如果longjmp的value参数为0，setjmp恢复后返回1，也就是当恢复到setjmp存储点的时候，setjmp一定不会返回0）。
setjmp和logjmp是配合使用的，用它们可以实现跳转的功能，和goto语句很类似，不同的是goto只能实现在同一个函数之内的跳转，而setjmp和logjmp可以实现在不同函数间的跳转
用法：
首先用setjmp设置跳转的地点，setjmp的参数buf是用来保存设置跳转点时的函数使用的重要数据，当从其他函数跳转回来，如果不用这个保存的数据恢复当前函数的一些数据的话，跳转回来是不能运行的。第一次设置的时候setjmp返回值为0
使用longjmp就可以跳转到setjmp的地方了，参数buf就是使用setjmp的时候保存的，而第二个参数会在跳转以后把这个值让setjmp返回的，也就是longjmp第二个参数，就是跳转到setjmp之后setjmp函数要返回的值
这个代码里运行步骤
1.先执行setjmp，因为是第一次设置跳转点，返回值是0，不执行if语句块里的语句，
2.然后执行b=5，b的值就是5了
3.再执行longjmp跳转之后， 最后再执行setjmp， 这时setjmp会返回1（也就是longjmp的第二个参数指定的值），就会执行if语句块里的语句----打印之后终止程序，这时b的值是5，就会打印出5来
2.
#include<stdio.h>
int main(void)
{
struct node
{
int a;
int b;
int c;
};
struct node s = { 3, 5, 6 };
struct node *pt = &s;
printf("%d\n", *(int*)pt);
return 0;
}
输出结果：3
详细解析：
(int *)pt指向结构体的第一个成员的地址,pt指向结构体，(int*)pt把pt强制类型转换为指针类型，*（int*）pt就是取指针pt指向的值。
pt是一个指向某类型的指针，*pt就是pt指向元素的值，*pt=x就是把那个值赋值给x。
拓展：
struct MyStruct
{
char dda; //偏移量为0，满足对其方式，dda占用1个字节。
double dda1; /* 可用的地址偏移量为1，不是sizeof（double）的倍数，为满足对齐方式需要补足7个字节才能使偏移量变为8，vc自动填充7个字节，dda1存放 在偏移量为8的地址上，它占用8个字节。*/
int type /*下一个可用地址的偏移量为16，是sizeof(int)的倍数，满足int的对其方式，所以不需要vc自动填充，type存放在偏移量为16的地址上，他占用4字节*/
}；/*所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构的节边界数——结构中占用最大空间的类型所占用的字节数，即sizeof(double)=8的倍数。所以该结构总的大小为：sizeof(MyStruct)为1+7+8+4+4=24.其中总的有7+4=11个字节是vc自动填充的，没有放任何有意义的东西*/
练习（1）.class B
{
private:
bool m_bTemp;
int m_nTemp;
bool m_bTemp2;
};
cout<<sizeof(B)<<endl;
答案：12 （注意bool 1字节）
练习（2）.class A
{
double d;
float a;
int b;
static int b;
char c;
A();
~A();
};
A a;
cout<<sizeof(A)<<endl;
cout<<sizeof(a)<<endl;
答案：24 24(静态变量时存放在全局数据区的，而sizeof计算栈中分配的大小，是不会计算在内的)
练习(3)以下代码输出是什么？
class B
{
float f;
char p;
int adf[3];
};
cout<<""<<sizeof(B);
答案：20
解析：
偏移量 内存 0 4 4 1 5+3 12 最终结果：sizeof(B)=4+1+12+3=20
4.
int foo(int x, int n){
int val = 1;
if (n > 0)
{
if (n % 2 == 1) val *= x;
val *= foo(x * x, n / 2);
}
return val;
}
输出结果：xn
详细解析：
foo(x, 0) = 1
foo(x, 1) = x * foo(x, 0) = x
foo(x, 2) = foo(x * x, 1) = x * x
foo(x, 3) = x * foo(x, 2) = x * (x * x)
5.1
#include <stdio.h>
int main(void)
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int*)(&a + 1);
printf("%d %d\n", *(a + 1), *(ptr - 1));
return 0;
}
输出结果：2 5
详细解析：
表达式 结果 *a 1 *(a+1) 2 *(a+2) 3
*（x+i） ==x[i]
&a是一个隐式的指向int[5]数组的指针，它和int* ptr是不一样的，如果真要定义这个指针，应该是int(*ptr)[5]。所以ptr每一次加一操作都相当于跨越int[5]的内存步长（也就是5个int长度），也就是说&a+ 1其实就是指向了a[5]这个位置，实际上内存里面这个位置是非法的，但是对ptr的强制转换导致了后面ptr-1的内存步长改为了1个int长度，所以ptr-1实际指向了a[4]。
5.2
#include <stdio.h>
int main(void)
{
int a[][3] = {1, 2, 3, 4, 5, 6};
int (*ptr)[3] = a;
printf("%d %d ", (*ptr)[1], (*ptr)[2]);
++ptr;
printf("%d %d\n", (*ptr)[1], (*ptr)[2]);
return 0;
}
输出结果：2 3 5 6
详细解析：
ptr为指向int[3]数组的指针，首先指向a[0]，所以(*ptr)[1],(*ptr)[2]就是a[0][1], a[0][2].然后++ptr，相当于ptr指向了a[1]，这时得到的是a[1][1]，a[1][2]，所以结果就是2，3,5, 6。
5.3
#include <stdio.h>
int main(void)
{
char p;
char buf[10] = {1, 2, 3, 4, 5, 6, 9, 8};
p = (buf + 1)[5];
printf("%d\n", p);
return 0;
}
输出结果：9
详细解析：
记住,x[i]相当于*(x + i),所以(buf + 1)[5]等价于*(buf + 1 + 5),或buf[6]。