15，17,18级面试题总结

小组15,17,18级面试题总结

c预处理器和c库

一个程序从源代码到可执行程序的过程

一 预编译
1.删除所有的#define，展开所有的宏定义。
2.处理所有的条件预编译指令，如“#if”、“#endif”、“#ifdef”、“#elif”和“#else”。
3.处理“#include”预编译指令，将文件内容替换到它的位置，这个过程是递归进行的，文件中包含其他文件。
4.删除所有的注释，“//”和“/**/”。
5.保留所有的#pragma 编译器指令，编译器需要用到他们，如：#pragma once 是为了防止有文件被重复引用。

---

二 编译
把预编译之后生成的xxx.i或xxx.ii文件，进行一系列词法分析、语法分析、语义分析及优化后，生成相应的汇编代码文件。
编译的步骤：
词法分析，语法分析，语义分析，中间代码生成，目标代码生成和优化

---

三 汇编
将汇编代码转变成机器可以执行的指令（机器语言）
注：汇编过程由as汇编器完成
经汇编过后，产生目标文件：.o(win),.obj(linux)
但是，经过预编译，编译，汇编之后生成机器可以执行的目标文件之后，还有一个问题——变量a和数组arr的地址还没有确定，需要由连接器完成接下来的工作。

---

四 链接
链接分为静态链接和动态链接，主要以静态链接为例：
1.链接：“组装”组装模块的过程。
2.链接的内容：把各个模块之间相互引用的部分都处理好，使得各个模块之间能够正确地衔接。
3.链接的过程：地址和空间的分配，符号决议（也叫符号绑定，倾向于动态链接）和重定位。

---

---

关于c中宏替换的问题

当一宏参数被放进宏时，通常（attention 有例外）这个宏参数会首先被全部展开。
当展开后的宏参数被放进宏体时，预处理器对新展开的宏体进行二次扫描，并继续展开。
例外:如果最外宏里对宏参数使用了#或##那么宏参数不会被展开。

---

条件编译

#define 定义一个预处理宏
#undef 取消宏的定义

#if 编译预处理中的条件命令，相当于C语法中的if语句
#ifdef 判断某个宏是否被定义，若已定义，执行随后的语句
#ifndef 与#ifdef相反，判断某个宏是否未被定义
#elif 若#if, #ifdef, #ifndef或前面的#elif条件不满足，则执行#elif之后的语句，相当于C语法中的else-if
#else 与#if, #ifdef, #ifndef对应, 若这些条件不满足，则执行#else之后的语句，相当于C语法中的else
#endif #if, #ifdef, #ifndef这些条件命令的结束标志.
defined 　与#if, #elif配合使用，判断某个宏是否被定义
条件编译与if语句:
条件编译里有判断语句，他的意思是如果宏条件符合，编译器就编译这段代码，否则编译器就忽略这段代码不编译，不生成汇编代码，采用条件编译，可以减少被编译语句，从而减少目标的长度。当条件编译比较多时，目标程序长度大大减少。
#include详解:
1.#include 实质是什么？

预编译的时候copy include头文件的内容到当前行

（疑问：预编译命令 $gcc -E test.c -o test.i）

2.#include “” 与<> 有何区别？

“”先在当前目录查找有无该头文件，有则包含该目录下的头文件，没有则到系统指定的目录下找该头文件

<>直接到系统指定的目录下查找该文件

(疑问：系统制定的默认目录为/user/include/，我们常使用的printf函数是在/user/include/stdio.h的文件中声明的)

验证结论：分别在当前目录和系统指定的目录下定义同名的头文件，但内容不一致，预编译后，看包含了哪个目录下的头文件
在gcc编译的时候，也可以通过-I 指定头文件所在的目录，若在指定的目录找不到，则回到默认的目录下查找
3.如何防止重复#include？（更确切的表述为“重复#include时如何防止重复定义/声明？”）需要说出2种方案，并说明各自的优缺点？
方案：#ifndef XXX
#define XXX
#endif 优点：所以的编译器都支持 缺点：出现宏名重复
宏名规则（大写，文件名作为宏名主体，以两个下划线开头以下划线结束），例如ov8830.h，宏名为__OV8830_H__，这样的宏名
出现的重复的几率就很低了！

---

static用法总结

static全局变量与普通全局变量
全局变量（外部变量）的说明之前再冠以static就构成了静态的全局变量。全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。
这两者在存储方式上并无不同。这两者的区别在于非静态全局变量的作用域是整个源程序，当一个源程序由多个原文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。
　　由于静态全局变量的作用域限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其他源文件中引起错误。
　　static全局变量与普通的全局变量的区别是static全局变量只初始化一次，防止在其他文件单元被引用。
static函数与普通函数有什么区别？
　　static函数与普通的函数作用域不同。尽在本文件中。只在当前源文件中使用的函数应该说明为内部函数（static），内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件。
static函数与普通函数最主要区别是static函数在内存中只有一份，普通静态函数在每个被调用中维持一份拷贝程序的局部变量存在于（堆栈）中，全局变量存在于（静态区）中，动态申请数据存在于（堆）　
static局部变量和普通局部变量的区别
static局部变量和普通局部变量的存储方式与作用域都不同。普通局部变量只在声明它的函数被调用时才会分配栈空间，并且只能在该函数内使用。而static局部变量存储在数据段或bss段中（静态存储区），并且源文件的所有函数都可以使用它

数组中一些值得注意的问题

唉！！！！！！阴沟里翻船的地方来了。
以接下来的一道题来说明这个问题，在小组问题考核的过程中我这个题出了问题，一方面是由于紧张，但其实说明白很大的原因还在于对数组本质的理解偏差以及不到位造成的。
题目：若a[0][0]的地址为0x00000000，求程序输出的结果：

int main(int argc,char *argv[])
{
    int a[3][4];
    printf("%p%p%p%p%p%p\n",&a[0][0],a[0],a,a[0]+1,a+1,a[1]);
    return 0;
}

首先在此阐述一下数组指针和指针数组的区别：
数组指针（也称行指针）：
定义int (*p)[n];
()的优先级高，首先说明p是一个指针，指向一个整形的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整形数据的长度。
如要将二维数组赋给一指针，应这样赋值：
int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
p=a; //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++; //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]
所以数组指针也称指向一维数组的指针，亦称行指针
指针数组
定义int *p[n];
[]优先级高，先与p结合成为一个数组，再由int 说明这是一个整形指针数组，它有n个指针类型的数组元素。这里执行p+1时，则p指向下一个数组元素。
这样赋值是错误的：p=a；因为p是个不可知的表示，只存在p[0]、p[1]、p[2]…p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 p=a; 这里p表示指针数组第一个元素的值，a的首地址的值。
如要将二维数组赋给一指针数组:
int p[3];
int a[3][4];
p++; //该语句表示p数组指向下一个数组元素。注：此数组每一个元素都是一个指针
for(i=0;i<3;i++)
p[i]=a[i]
这里int p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]
所以要分别赋值。
这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。
比如要表示数组中i行j列一个元素：
(p[i]+j)、((p+i)+j)、((p+i))[j]、p[i][j]
优先级：()>[]>
数组指针和指针数组区别的出处

接下来看一下这道题：

int a[3][4]

1.sizeof(a),返回整个数组的长度。
2.fun(int *a),作为函数的形参，a的类型为int *
3.&a,它的类型为int ( *)[[3]][[4]]是一个数组指针
4.在表达式中，它的类型为int（const *)[4],即指向数组首元素a[0]的常量指针，a[0]它是一个int[4]
5.C语言中严格来说没有什么二维数组，它只有普通的一维数组，二维数组可以看成数组的数组，即对于a来说，它有三个元素，每个元素都是一个具有四个整形元素的一维数组（int[[4]]）。我们可以把a[0]第一个元素的数组名，其他以此类推。
6.显然

*a=*(a+0)=*(0+a)=a[0]=0[a]

所以有，a=&a[0]，如此就验证了上面的说法，此时a是一个int（*）[[4]]
7.a=&a[[0]]
所以有a+1=&a[[0]]+1,就是跨过第一行，即一个int[[4]],a[[0]]+1就是跨过第一行的第一个元素=&a[0][[1]],&a+1自然就跨过整个数组了。
（小注释:&加上数组名，其类型就会变为数组指针）
所以，显然上题的答案依次为：
0x00000000
0x00000000
0x00000000
0x00000004
0x00000010
0x00000010

---

sizeof()和strlen()中一些值得注意的问题。

Sizeof与Strlen的区别与联系
一、sizeof
sizeof(…)是运算符，在头文件中typedef为unsigned int，其值在编译时即计算好了，参数可以是数组、指针、类型、对象、函数等。
它的功能是：获得保证能容纳实现所建立的最大对象的字节大小。
由于在编译时计算，因此sizeof不能用来返回动态分配的内存空间的大小。实际上，用sizeof来返回类型以及静态分配的对象、结构或数组所占的空间，返回值跟对象、结构、数组所存储的内容没有关系。
具体而言，当参数分别如下时，sizeof返回的值表示的含义如下：
数组——编译时分配的数组空间大小；
指针——存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为4或8，与电脑的地址线宽有关系）；
类型——该类型所占的空间大小；
对象——对象的实际占用空间大小；
函数——函数的返回类型所占的空间大小。函数的返回类型不能是void。
二、strlen
strlen(…)是函数，要在运行时才能计算。参数必须是字符型指针（char*）。当数组名作为参数传入时，实际上数组就退化成指针了。
它的功能是：返回字符串的长度。该字符串可能是自己定义的，也可能是内存中随机的，该函数实际完成的功能是从代表该字符串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL。
sizeof（）求结构体大小
要注意字节对齐，因为这样有助于加快计算机的取数速度。
求sizeof（）求结构体大小的规则如下：
先介绍一个相关的概念——偏移量。偏移量指的是结构体变量中成员的地址和结构体变量地址的差。结构体大小等于最后一个成员的偏移量加上最后一个成员的大小。显然，结构体变量中第一个成员的地址就是结构体变量的首地址。因此，第一个成员i的偏移量为0。第二个成员c的偏移量是第一个成员的偏移量加上第一个成员的大小（0+4）,其值为4；第三个成员j的偏移量是第二个成员的偏移量加上第二个成员的大小（4+1）,其值为5。
然而，在实际中，存储变量时地址要求对齐，编译器在编译程序时会遵循两条原则：
（1）结构体变量中成员的偏移量必须是成员大小的整数倍（0被认为是任何数的整数倍）
（2）结构体大小必须是所有成员大小的整数倍，也即所有成员大小的公倍数。
例子：

struct stu
{
    int k;
    short t;
};

其大小为6
对比下面两种定义顺序：

struct stu3
{ 
     char c1; 
     int i;
     char c2;
}；
struct stu4
{
     char c1;
     char c2;
     int i;
}；

stu3：偏移量 0
0+1=1=4
4+4=8
大小：8+2=10=12
同理stu4为8；
对于嵌套的结构体，需要将其展开。对结构体求sizeof时，上述两种原则变为：
（1）展开后的结构体的第一个成员的偏移量应当是被展开的结构体中最大的成员的整数倍。
（2）结构体大小必须是所有成员大小的整数倍，这里所有成员计算的是展开后的成员，而不是将嵌套的结构体当做一个整体。
例子：

  struct stu5
{
     short i;
     struct 
     {
          char c;
          int j;
     } ss; 
     int k;
}；

结构体stu5的成员ss.c的偏移量应该是4，而不是2。整个结构体大小应该是16。

struct stu5
{
      char i;
      struct 
      {
           char c;
           int j;
      } ss; 
      char a;
      char b;
      char d;
      char e;
      char f;
}；

结构体ss单独计算占用空间为8，而stu5的sizeof则是20，不是8的整数倍，这说明在计算sizeof(stu5)时，将嵌套的结构体ss展开了，这样stu5中最大的成员为ss.j，占用4个字节，20为4的整数倍。如果将ss当做一个整体，结果应该是24了。

const限定符

以const声明的对象，其值不能通过赋值或递增来修改。
注：
const修饰指针和形参：
const放在*的左侧的任意位置，限定了指针指向的数据不能改变
const放在解引用符号的右侧限定了指针本身不能改变

extern

利用关键字extern，可以在一个文件中引用另一个文件中定义的变量或者函数。
1.引用同一个文件中的变量
2.引用另一个文件中的变量
注：只有当一个变量是全局变量时，extern变量才会起作用。extern关键字只需要指明类型名和变量名就行了，不能在重复赋值，初始化需要在源文件所在处进行，但是在声明后就可以使用变量名修改了。
3.引用另一个文件中的函数

stdout stdin stderr

分别为标准输出，终端的标准输入，标准错误输出。
linux下stdout行缓冲
win下stdout无行缓冲

最后最后，关于大小端的一些问题

例题：

  #include <stdio.h>
  2 #include <string.h>
  3 struct node
  4 {
  5     char a;
  6     short b;
  7     int c;
  8 };
  9 int main()
 10 {
 11     struct node s;
 12     memset(&s,0,sizeof(s));
 13     s.a=3;
 14     s.b=5;
 15     s.c=7;
 16     struct node *pt=&s;
 17     printf("%d\n",*(short *)pt);
 18     printf("%lld\n",*(long long *)pt);
 19     return 0;
 20 }

第一个printf
低字节
03
00（空）
05
00
07
00
00
00
高字节
所以第一个printf中的数为
00050003=327683。
其余同理。