c语言常见面试题（持续更新）

浅拷贝存在的问题：当出现类的等号赋值时，系统会调用默认的拷贝函数——即浅拷贝，它能够完成成员的一一复制。当数据成员中没有指针时，浅拷贝是可行的。但当数据成员中有指针时，如果采用简单的浅拷贝，则两类中的两个指针将指向同一个地址，当对象快结束时，会调用两次fre e函数，此时p2已经是野指针，指向的内存空间已经被释放掉，再次fre e会报错；这时，必须采用深拷贝。

深拷⻉就是，让两个结构体变量的指针成员分别指向不同的堆区空间，只是空间内容拷⻉⼀份，这样在各个结构体变量释放的时候就不会出现多次释放同⼀段堆区空间的问题.

2.9 #include<&g t; 与#include “”的区别

#include <> 是到系统指定目录去寻找头文件；#include “” 先到项目指定目录寻找头文件，再

到系统指定目录去寻找头文件

2.10 宏定义define 的宏与内联函数和typedef 、以及const 的区别

宏定义又称为宏代换、宏替换，简称“宏”。

ifn def/define/endif 的作用？
防止头文件被重复包含和编译。头文件重复包含会增大程序大小，重复编译增加编译时间。

与内联区别
a. 内联函数在编译时展开，宏在预处理时展开；
b. 内联函数直接嵌入到目标代码中，宏是简单的做文本替换；
c. 内联函数有类型检测、语法判断等功能，而宏没有；
d. inline函数是函数，宏不是；

与typedef区别
#define 用于为各种数据类型定义别名，与 typedef 类似，但是它们有以下几点不同：

a. typedef 仅限于为类型定义符号名称，定义一种类型的别名，而不只是简单的宏替换

b. #define 不仅可以为类型定义别名，也能为数值定义别名，比如您可以定义 1 为 ONE。
c. typedef 编译阶段会检查错误，#define 预处理阶段不检查错误。

与const区别
a. 数据类型：const 修饰的变量有明确的类型，而宏没有明确的数据类型
b. 安全方面：const 修饰的变量会被编译器检查，而宏没有安全检查
c. 内存分配：con st修饰的变量只会在第一次赋值时分配内存，而宏是直接替换，每次替换后

的变量都会分配内存
d. 作用场所：con st修饰的变量作用在编译、运行的过程中，而宏作用在预编译中。从编译器

的角度讲，最大的优势是简单，方便。因为预处理就可以解决掉#define，用不着编译器。
e. 代码调试：con st方便调试，而宏在预编译中进行所以没有办法进行调试。

2.11 c语言中的有符号和无符号数

a. 有符号数 signed ，首位为符号位，0正 1负 ,使用源码和反码表示，无法表示出（对于

8bit）-128，使用补码表示：10000000 表示-128,一般的机器都是补码表示法，范围为

– (2^(n-1)) ~ 2^(n-1) – 1

b. 无符号数 unsigned，表示的正数的范围会变大，范围为0 ~ 2^n -1

c. 计算机中的补码将计算机中的减法运算统一为加法运算

2.12 指针数组和数组指针

指针数组：本质上是数组，数组中的变量为指针，用于二维数组和矩阵的行，int *a[3];

数组指针：本质上是指针，指向数组的指针，指向的是整个数组，数组的首地址，int (*a) [3];

int array[3] = {1,2,3}; a = &arr a y;是正确的，a = array;是错误的；

取值：*(*a + 1) 等价于 (*a)[1]

2.13 指针和指针变量

        指针：内存中每⼀个字节都会分配编号，这个编号就是地址, ⽽指针就是内存单元的编号。一个变量的地址就称为该变量的指针他保存的是一个地址。
指针变量：：c语言有很多种变量，每种变量都会储存一种数据，而指针变量就是专门来储存指针的变量，本质是变量只是该变量存放的是空间的地址编号
        二级指针：指针本身也是一个变量，也要占用内存空间，而二级指针就是指向这块变量的指针。一般二级指针用在二维数组中。
        int *p;
        p=&a;

int *p就是指针变量
对a取地址，p就是一个指针用来保存地址。

2.14 比较 描述一下内存分区

栈区（stack）：存放函数的形参、返回值、con st 修饰的局部变量，局部变量等，由编译器自动分配释放，空间大小

一般由系统确定，地址由高到低

堆区（heap）：由程序员自由申请释放，空间比较大，地址一般由低到高增长，使用malloc()

和free()来管理

全局/静态区：存放全局变量和静态变量（全局静态变量和局部静态变量），全局区存放未初

始化的放在全局区（.bss段），初始化的放在静态区（.data段）

常量区：为只读区域.rodata，存放一些常量，比如 con st修饰的字符串常量，con st修饰的其

他变量存储在相应的位置

代码区： 为只读区域 text段，存放程序的二进制代码 .，由操作系统管理，函数存放在这里

2.15 堆和栈的对比

        申请方式
        stack:由系统自动分配。例如，声明在函数中一个局部变量int b;系统自动在栈中为b开辟空间
        heap:需要程序员自己申请，并指明大小，在c中malloc函数

申请大小的限制
栈：栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思

是栈顶的地址和栈的最大容量是系统预先规定好的，如果申请的空间超过栈的剩余空间时，

将提示 overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的

空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限

于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。堆的访问

需要访存两次。

        申请效率的比较
        栈:由系统自动分配，速度较快。但程序员是无法控制的。
        堆:是由new或者malloc分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最

方便.

        堆和栈中的存储内容
        栈：局部变量和形参，函数返回值
        堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容由程序员安排。

2.16 vector和array的区别

a. array的元素存在于栈上，而vector只有元信息存在于栈上，数据存在于堆上。所以vector不会爆栈
b. vector是顺序容器，其利用连续的内存空间来存储元素，但是其内存空间大小是能够改变的。
c. vector 效率偏低，因为当向vecto r中添加新元素的时候，内存空间不够，需要重新申请更大的空间，由于vector是连续内存空间的，因此其申请更多空间的时候，可能整个位置发生改变，需要将原来空间里的数据拷贝过去。

2.17 结构体和共用体

结构体中的成员拥有独⽴的空间，共用体也叫联合体，共⽤体的成员共享同⼀块空间，但是每个共⽤体成员能访问共⽤区的空间⼤⼩是由成员⾃身的类型决定。
共用体使用覆盖技术，成员变量相互覆盖，可以用来求系统的大小端，共用体的大小由它的最大

的变量决定，当然要满足对齐原则。利用联合体实现大小端的判断参考我之前写的详解大端序和小端序(c语言实现

union un_big_little _endian{

int a;

char b;

}; // 4个字节大小，变量a 和b 共享一块空间

2.18 extern 关键字

extern 是c语言的一个关键字，可以用于修饰全局变量和函数，可以表示申明一个变量和函数

，可以放在任意位置，后续就可以引用该变量或者函数；extern 也用于多文件编程，在其他

文件申明一个变量和函数，为了在该文件中引用，申明是不分配内存的，只有定义才会分配

内存。

extern 申明时不要初始化值，否则会变成定义。

2.19 register 关键字

示registe r 失效；

2.20 volatile 关键字

volatile修饰的变量表示只能从内存中取值，不能被优化，由于程序在编译运行中，会对变量

做优化，比如会将值拿到寄存器中，volatile修饰的变量就是不允许这种优化，以防止多个

线程共享此变量时，取到的值不同步。

2.21 rest r ict 关键字

c99 中的关键字，编译使用 std=c99使用， rest r ict 修饰指针，表示该指针指向的地址中的变

量的值，只能通过该指针进行修改，这样程序在运行时，得到的结果具有一致性，程序就会

对代码进行一定的优化。可以参考之前我写的C99中的restrict关键字详解

2.22 数组

数组中元素：数组中的数据类型是一致的，数组的存储是在一块连续的空间中，因此数组的

访问复杂度为O(1)。

一维数组：int a[3];

数组名：数组名代表数组首元素的地址，a 与 &a[0]等价，sizeof(a) = 12,代表数组的大

小

取值：a[1] 等价 *(a+1)

地址：&a[0] + 1等价于 a + 1，加1指的是数组中元素地址的加1个元素大小的地址；

&a 表示数组地址，&a + 1表示整个数组的地址加1个数组大小的地址；

二维数组：int a[3][3];

二维数组的本质是一维数组，二维数组可以利用二维指针，或者指针数组来操作。

数组名：本质上是首行元素的地址，表示上于首元素的地址是一样的，sizeof(a) = 36 ,

代表整个二维数组的大小；sizeof(a[0]) = 12 ,代表一行元素的大小，此时a代表整

个数组，a[0]代表第一行，

取值：a[1][1] 等价 *(&a[0][0] +1)

地址：&a[0][0] + 1 ，单个元素的地址加1个元素大小的地址

&a + 1，表示整个数组地址加1个二维数组大小的地址

&a[0] + 1，表示首行元素的地址加1行大小的地址

2.23 attribute 关键字

attribute：属性，主要是用来在函数或数据声明中设置其属性，与编译器相关可以设置多种属

性。包括对齐、自定义段、格式、有无内联、有无使用等。

例如：int unint_val __attribute__((section(“.data”))); 定义该变量在.data段

Header_t h and _herder __attribute__ ((aligned(16)));定义该变量16字节对齐

struct Header_t

{

int version[16];

uint8_t lhi;

}__attribute__((packed)); //定义结构体减少对齐

2.24 字节对齐原则

（1）第一个成员的首地址为0.

（2）每个成员的首地址是自身大小的整数倍

（3）结构体的总大小，为其成员中所含最大类型的整数倍。

具体可以参考我之前写的字节对齐原则

2.25 c语言函数的调用过程

 1 int Add(int x,int y)
 2 {
 3     int sum = 0;
 4     sum = x + y;
 5     return sum;
 6 }
 7 
 8 int main ()
 9 {
10     int a = 10;
11     int b = 12;
12     int ret = 0;
13     ret = Add(a,b);
14     return 0;
15 }

1、参数拷贝（参数实例化）分配内存。
2、保存当前指令的下一条指令，并跳转到被调函数。

main函数中的操作：

        接下来是调用Add函数并执行的一些操作，包括：
        1、移动ebp、esp形成新的栈帧结构。
        2、压栈（push）形成临时变量并执行相关操作。
在一个栈中，依据函数调用关系，发起调用的函数（caller）的栈帧在下面（高地址方向），

被调用的函数的栈帧在上面。每发生一次函数调用，便产生一个新的栈帧，当一个函数返回

时，这个函数所对应的栈帧被清除（eliminated）
3、return一个值。

Add函数中的操作：

        被调函数完成相关操作后需返回到原函数中执行刚才保存的下一条指令，操作如下：
        1、出栈（pop）。
        2、恢复 main函数的栈帧结构。（pop ）
        3、返回 main函数
        这些操作也在Add函数中进行。至此，在main函数中调用Add函数的整个过程已经完成。
        总结起来整个过程就三步：
                1）根据调用的函数名找到函数入口；
                2）在栈中审请调用函数中的参数及函数体内定义的变量的内存空间
                3）函数执行完后，释放函数在栈中的申请的参数和变量的空间，最后返回值（如果有的话）