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;

}

输出结果：xⁿ

详细解析：

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