NO.4|C++语言基础|静态动态绑定|深浅拷贝|拷贝构造|内存对齐|内存泄漏|平衡二叉树|红黑树|defineconsttypedefinline|forkwaitexec|编译|链接|联编-优快云博客

本文链接：https://blog.youkuaiyun.com/CoderZzz6310/article/details/146144685

![[Pasted image 20250310093356.png]]

31. 静态绑定和动态绑定的介绍

说起静态绑定和动态绑定，我们⾸先要知道静态类型和动态类型，静态类型就是它在程序中被声明时所采⽤的类型，在编译期间确定。动态类型则是指“⽬前所指对象的实际类型”，在运⾏期间确定。

静态绑定

⼜名早绑定，绑定的是静态类型，所对应的函数或属性依赖于对象的静态类型，发⽣在编译期间。

动态绑定

⼜名晚绑定，绑定的是动态类型，所对应的函数或属性依赖于动态类型，发⽣在运⾏期间。

⽐如说， virtual 函数是动态绑定的，⾮虚函数是静态绑定的，缺省参数值也是静态绑定的。这⾥呢，就需要注意，我们不应该重新定义继承⽽来的缺省参数，因为即使我们重定义了，也不会起到效果。因为⼀个基类的指针指向⼀个派⽣类对象，在派⽣类的对象中针对虚函数的参数缺省值进⾏了重定义，但是缺省参数值是静态绑定的，静态绑定绑定的是静态类型相关的内容，所以会出现⼀种派⽣类的虚函数实现⽅式结合了基类的缺省参数值的调⽤效果，这个与所期望的效果不同。

32. 深拷⻉和浅拷⻉的区别（举例说明深拷⻉的安全性）

当出现类的等号赋值时，会调⽤拷⻉函数，在未定义显示拷⻉构造函数的情况下，系统会调⽤默认的拷⻉函数－即浅拷⻉，它能够完成成员的⼀⼀复制。当数据成员中没有指针时，浅拷⻉是可⾏的。

但当数据成员中有指针时，如果采⽤简单的浅拷⻉，则两类中的两个指针指向同⼀个地址，当对象快要结束时，会调⽤两次析构函数，⽽导致指野指针的问题。

所以，这时必需采⽤深拷⻉。深拷⻉与浅拷⻉之间的区别就在于深拷⻉会在堆内存中另外申请空间来存储数据，从⽽也就解决来野指针的问题。简⽽⾔之，当数据成员中有指针时，必需要⽤深拷⻉更加安全。

33. 什么情况下会调⽤拷⻉构造函数(三种情况)

类的对象需要拷⻉时，拷⻉构造函数将会被调⽤，以下的情况都会调⽤拷⻉构造函数：

⼀个对象以值传递的⽅式传⼊函数体，需要拷⻉构造函数创建⼀个临时对象压⼊到栈空间中。
⼀个对象以值传递的⽅式从函数返回，需要执⾏拷⻉构造函数创建⼀个临时对象作为返回值。
⼀个对象需要通过另外⼀个对象进⾏初始化。

34. 为什么拷⻉构造函数必需时引⽤传递，不能是值传递？

为了防⽌递归调⽤。当⼀个对象需要以值⽅式进⾏传递时，编译器会⽣成代码调⽤它的拷⻉构造函数⽣成⼀个副本，如果类 A 的拷⻉构造函数的参数不是引⽤传递，⽽是采⽤值传递，那么就⼜需要为了创建传递给拷⻉构造函数的参数的临时对象，⽽⼜⼀次调⽤类 A 的拷⻉构造函数，这就是⼀个⽆限递归。

35. 结构体内存对⻬⽅式和为什么要进⾏内存对⻬？

⾸先我们来说⼀下结构体中

内存对⻬的规则：

对于结构体中的各个成员，第⼀个成员位于偏移为 0 的位置，以后的每个数据成员的偏移量必须是 min(#pragma pack() 制定的数，数据成员本身⻓度) 的倍数。
在所有的数据成员完成各⾃对⻬之后，结构体或联合体本身也要进⾏对⻬，整体⻓度是min(#pragma pack()制定的数，⻓度最⻓的数据成员的⻓度) 的倍数。

那么内存对⻬的作⽤是什么呢？

经过内存对⻬之后， CPU 的内存访问速度⼤⼤提升。因为 CPU 把内存当成是⼀块⼀块的，块的⼤⼩可以是 2， 4， 8， 16 个字节，因此 CPU 在读取内存的时候是⼀块⼀块进⾏读取的，块的⼤⼩称为内存读取粒度。⽐如说 CPU 要读取⼀个 4 个字节的数据到寄存器中（假设内存读取粒度是 4），如果数据是从 0 字节开始的，那么直接将 0-3 四个字节完全读取到寄存器中进⾏处理即可。

如果数据是从 1 字节开始的，就⾸先要将前 4 个字节读取到寄存器，并再次读取 4-7 个字节数据进⼊寄存器，接着把 0 字节， 5， 6， 7 字节的数据剔除，最后合并 1， 2， 3， 4 字节的数据进⼊寄存器，所以说，当内存没有对⻬时，寄存器进⾏了很多额外的操作，⼤⼤降低了 CPU 的性能。

另外，还有⼀个就是，有的 CPU 遇到未进⾏内存对⻬的处理直接拒绝处理，不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。所以内存对⻬还有利于平台移植。

36. 内存泄漏的定义，如何检测与避免？

定义：

内存泄漏简单的说就是申请了⼀块内存空间，使⽤完毕后没有释放掉。它的⼀般表现⽅式是程序运⾏时间越⻓，占⽤内存越多，最终⽤尽全部内存，整个系统崩溃。由程序申请的⼀块内存，且没有任何⼀个指针指向它，那么这块内存就泄漏了。

如何检测内存泄漏

⾸先可以通过观察猜测是否可能发⽣内存泄漏， Linux 中使⽤ swap 命令观察还有多少可⽤的交换空间，在⼀两分钟内键⼊该命令三到四次，看看可⽤的交换区是否在减少。

还可以使⽤其他⼀些 /usr/bin/stat ⼯具如 netstat、 vmstat 等。如发现波段有内存被分配且从不释放，⼀个可能的解释就是有个进程出现了内存泄漏。

当然也有⽤于内存调试，内存泄漏检测以及性能分析的软件开发⼯具 valgrind 这样的⼯具来进⾏内存泄漏的检测。

37. 说⼀下平衡⼆叉树、⾼度平衡⼆叉树（AVL）

⼆叉树：

任何节点最多只允许有两个⼦节点，称为左⼦节点和右⼦节点，以递归的⽅式定义⼆叉树为，⼀个⼆叉树如果不为空，便是由⼀个根节点和左右两个⼦树构成，左右⼦树都可能为空。

⼆叉搜索树：

⼆叉搜索树可以提供对数时间的元素插⼊和访问。节点的放置规则是：任何节点的键值⼀定⼤于其左⼦树的每⼀个节点的键值，并⼩于其右⼦树中的每⼀个节点的键值。因此⼀直向左⾛可以取得最⼩值，⼀直向右⾛可以得到最⼤值。插⼊：从根节点开始，遇键值较⼤则向左，遇键值较⼩则向右，直到尾端，即插⼊点。删除：如果删除点只有⼀个⼦节点，则直接将其⼦节点连⾄⽗节点。如果删除点有两个⼦节点，以右⼦树中的最⼩值代替要删除的位置。

平衡⼆叉树：

其实对于树的平衡与否没有⼀个绝对的标准， “平衡”的⼤致意思是：没有任何⼀个节点过深，不同的平衡条件会造就出不同的效率表现。以及不同的实现复杂度。有数种特殊结构例如 AVL-tree, RB-tree, AA-tree，均可以实现平衡⼆叉树

AVL-tree ：

⾼度平衡的平衡⼆叉树（严格的平衡⼆叉树） AVL-tree 是要求任何节点的左右⼦树⾼度相差最多为 1 的平衡⼆叉树。当插⼊新的节点破坏平衡性的时候，从下往上找到第⼀个不平衡点，需要进⾏单旋转，或者双旋转进⾏调整。

38. 说⼀下红⿊树（RB-tree）

红⿊树的定义：
性质1：每个节点要么是⿊⾊，要么是红⾊。
性质2：根节点是⿊⾊。
性质3：每个叶⼦节点（NIL）是⿊⾊。
性质4：每个红⾊结点的两个⼦结点⼀定都是⿊⾊。
性质5：任意⼀结点到每个叶⼦结点的路径都包含数量相同的⿊结点。

39. 说⼀下 define、 const、 typedef、 inline 使⽤⽅法？

const 与 `#define` 的区别

const 定义的常量是变量带类型，⽽ #define 定义的只是个常数不带类型；
define 只在预处理阶段起作⽤，简单的⽂本替换，⽽ const 在编译、链接过程中起作⽤；
define 只是简单的字符串替换没有类型检查。⽽const是有数据类型的，是要进⾏判断的，可以避免⼀些低级错误；
define 预处理后，占⽤代码段空间， const 占⽤数据段空间；
const 不能重定义，⽽ define 可以通过 #undef 取消某个符号的定义，进⾏重定义；
define 独特功能，⽐如可以⽤来防⽌⽂件重复引⽤。

`#define` 和别名 typedef 的区别

执⾏时间不同， typedef 在编译阶段有效， typedef 有类型检查的功能； #define 是宏定义，发⽣在预处理阶段，不进⾏类型检查；
功能差异， typedef ⽤来定义类型的别名，定义与平台⽆关的数据类型，与 struct 的结合使⽤等。
#define 不只是可以为类型取别名，还可以定义常量、变量、编译开关等。
作⽤域不同， #define 没有作⽤域的限制，只要是之前预定义过的宏，在以后的程序中都可以使⽤。
⽽ typedef 有⾃⼰的作⽤域。

define 与 inline 的区别

#define是关键字， inline是函数；
宏定义在预处理阶段进⾏⽂本替换， inline 函数在编译阶段进⾏替换；
inline 函数有类型检查，相⽐宏定义⽐较安全；

40. 预处理，编译，汇编，链接程序的区别

⼀段⾼级语⾔代码经过四个阶段的处理形成可执⾏的⽬标⼆进制代码。
预处理器→编译器→汇编器→链接器：最难理解的是编译与汇编的区别。
这⾥采⽤《深⼊理解计算机系统》的说法。

预处理阶段：

写好的⾼级语⾔的程序⽂本⽐如 hello.c，预处理器根据 #开头的命令，修改原始的程序，如#include<stdio.h> 将把系统中的头⽂件插⼊到程序⽂本中，通常是以 .i 结尾的⽂件。

编译阶段：

编译器将 hello.i ⽂件翻译成⽂本⽂件 hello.s，这个是汇编语⾔程序。⾼级语⾔是源程序。所以注意概念之间的区别。汇编语⾔程序是⼲嘛的？每条语句都以标准的⽂本格式确切描述⼀条低级机器语⾔指令。不同的⾼级语⾔翻译的汇编语⾔相同。

汇编阶段：

汇编器将 hello.s 翻译成机器语⾔指令。把这些指令打包成可重定位⽬标程序，即.o⽂件。 hello.o是⼀个⼆进制⽂件，它的字节码是机器语⾔指令，不再是字符。前⾯两个阶段都还有字符。

链接阶段：

⽐如 hello 程序调⽤ printf 程序，它是每个 C 编译器都会提供的标准库 C 的函数。这个函数存在于⼀个名叫 printf.o 的单独编译好的⽬标⽂件中，这个⽂件将以某种⽅式合并到 hello.o 中。链接器就负责这种合并。得到的是可执⾏⽬标⽂件。

41. 说⼀下 fork， wait， exec 函数

⽗进程产⽣⼦进程使⽤ fork 拷⻉出来⼀个⽗进程的副本，此时只拷⻉了⽗进程的⻚表，两个进程都读同⼀块内存。

当有进程写的时候使⽤写实拷⻉机制分配内存， exec 函数可以加载⼀个 elf ⽂件去替换⽗进程，从此⽗进程和⼦进程就可以运⾏不同的程序了。

fork 从⽗进程返回⼦进程的 pid，从⼦进程返回 0，调⽤了 wait 的⽗进程将会发⽣阻塞，直到有⼦进程状态改变，执⾏成功返回 0，错误返回 -1。

exec 执⾏成功则⼦进程从新的程序开始运⾏，⽆返回值，执⾏失败返回 -1。

42. 动态编译与静态编译

静态编译

编译器在编译可执⾏⽂件时，把需要⽤到的对应动态链接库中的部分提取出来，连接到可执⾏⽂件中去，使可执⾏⽂件在运⾏时不需要依赖于动态链接库；

动态编译

可执⾏⽂件需要附带⼀个动态链接库，在执⾏时，需要调⽤其对应动态链接库的命令。所以其优点⼀⽅⾯是缩⼩了执⾏⽂件本身的体积，另⼀⽅⾯是加快了编译速度，节省了系统资源。缺点是哪怕是很简单的程序，只⽤到了链接库的⼀两条命令，也需要附带⼀个相对庞⼤的链接库；⼆是如果其他计算机上没有安装对应的运⾏库，则⽤动态编译的可执⾏⽂件就不能运⾏。

43. 动态链接和静态链接区别

静态连接库就是把 (lib) ⽂件中⽤到的函数代码直接链接进⽬标程序，程序运⾏的时候不再需要其它的库⽂件；动态链接就是把调⽤的函数所在⽂件模块（DLL）和调⽤函数在⽂件中的位置等信息链接进⽬标程序，程序运⾏的时候再从 DLL 中寻找相应函数代码，因此需要相应DLL ⽂件的⽀持。

静态链接库与动态链接库都是共享代码的⽅式，如果采⽤静态链接库，则⽆论你愿不愿意， lib中的指令都全部被直接包含在最终⽣成的 EXE ⽂件中了。但是若使⽤ DLL，该 DLL 不必被包含在最终 EXE ⽂件中， EXE ⽂件执⾏时可以“动态”地引⽤和卸载这个与 EXE 独⽴的 DLL ⽂件。

静态链接库和动态链接库的另外⼀个区别在于静态链接库中不能再包含其他的动态链接库或者静态库，⽽在动态链接库中还可以再包含其他的动态或静态链接库。

动态库就是在需要调⽤其中的函数时，根据函数映射表找到该函数然后调⼊堆栈执⾏。如果在当前⼯程中有多处对dll⽂件中同⼀个函数的调⽤，那么执⾏时，这个函数只会留下⼀份拷⻉。
但如果有多处对 lib ⽂件中同⼀个函数的调⽤，那么执⾏时该函数将在当前程序的执⾏空间⾥留下多份拷⻉，⽽且是⼀处调⽤就产⽣⼀份拷⻉。

44. 动态联编与静态联编

在 C++ 中，联编是指⼀个计算机程序的不同部分彼此关联的过程。按照联编所进⾏的阶段不同，可以分为静态联编和动态联编；

静态联编

是指联编⼯作在编译阶段完成的，这种联编过程是在程序运⾏之前完成的，⼜称为早期联编。要实现静态联编，在编译阶段就必须确定程序中的操作调⽤（如函数调⽤）与执⾏该操作代码间的关系，确定这种关系称为束定，在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引⽤的类型。其优点是效率⾼，但灵活性差。