c++面试知识

1.堆，栈，自由存储区，全局/静态存储区和常量存储区 代码区

https://blog.csdn.net/caogenwangbaoqiang/article/details/79788368

BSS段：BSS段（bss segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。
数据段：数据段（data segment）通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。
代码段：代码段（code segment/text segment）通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定，并且内存区域通常属于只读, 某些架构也允许代码段为可写，即允许修改程序。在代码段中，也有可能包含一些只读的常数变量，例如字符串常量等。
堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
栈(stack)：栈又称堆栈，是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。

栈 ，在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作，效率很高，但是分配的内存容量有限。

堆，就是那些由malloc分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个malloc就要对应一个free。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。

自由存储区，就是那些由new等分配的内存块，他和堆是十分相似的，不过它是用delete来结束自己的生命的。

全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改。
　　
　　代码区存放程序编译后可以执行代码的地方。比如执行代码时写的While语句、if条件语句等，都会存放到此。

2.static关键字的作用

1. 全局静态变量

在全局变量前加上关键字static，全局变量就定义成一个全局静态变量.
内存中的位置：静态存储区，在整个程序运行期间一直存在。
初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）；
作用域：全局静态变量在声明他的文件之外是不可见的，准确地说是从定义之处开始，到文件结尾。

全局变量本身就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件中不能使用它。

2. 局部静态变量

在局部变量之前加上关键字static，局部变量就成为一个局部静态变量。
内存中的位置：静态存储区
初始化：未经初始化的全局静态变量会被自动初始化为0（自动对象的值是任意的，除非他被显式初始化）；
作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变。

把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域，限制了它的使用范围。

3. 静态函数

在函数返回类型前加static，函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。函数的实现使用static修饰，那么这个函数只可在本cpp内使用，不会同其他cpp中的同名函数引起冲突；
内部函数和外部函数:当一个源程序由多个源文件组成时，Ｃ语言根据函数能否被其它源文件中的函数调用，将函数分为内部函数和外部函数。
(1) 内部函数（又称静态函数）
　　如果在一个源文件中定义的函数，只能被本文件中的函数调用，而不能被同一程序其它文件中的函数调用，这种函数称为内部函数。定义一个内部函数，只需在函数类型前再加一个“static”关键字即可，如下所示：
　　　　static 函数类型 函数名(函数参数表)
　　　　　　{……}
　　关键字“static”，译成中文就是“静态的”，所以内部函数又称静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名，因为同名也没有关系。
(2) 外部函数
　　外部函数的定义：在定义函数时，如果没有加关键字“static”，或冠以关键字“extern”，表示此函数是外部函数：
　　　　[extern] 函数类型 函数名(函数参数表)
　　　　　　{……}
调用外部函数时，需要对其进行说明：
[extern] 函数类型 函数名(参数类型表)[，函数名2(参数类型表2)……]；
[案例]外部函数应用。
（1）文件mainf.c
　　main()
　　　{ extern void input(…),process(…),output(…);
　　　　input(…); process(…); output(…);
　　 }
（2）文件subf1.c
　　……
　　extern void input(……)
　　{……}
（3）文件subf2.c
　　……
　　extern void process(……)
　　{……}

4. 类的静态成员

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用。
静态数据成员不能在类中初始化(对于常量静态类变量有待考证，好像可以在类外或main()函数之前定义，初始化可以放在类中)，一般在类外和main()函数之前初始化，缺省时初始化为0。静态数据成员用来定义类的各个对象所公有的数据，比全局变量更安全。

5. 类的静态函数

静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。静态成员函数没有this指针。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

静态成员变量和静态成员函数的使用应该是在不建立任何对象的情况下调用它们。

3.C++和C的区别

设计思想上：
C++是面向对象的语言，而C是面向过程的结构化编程语言

语法上：

C++具有重载、继承和多态三种特性

C++相比C，增加多许多类型安全的功能，比如强制类型转换、

C++支持范式编程，比如模板类、函数模板等

4.C/C++ 中指针和引用的区别

1.指针有自己的一块空间，而引用只是一个别名；

2.使用sizeof看一个指针的大小是4，而引用则是被引用对象的大小；

3.指针可以被初始化为NULL，而引用必须被初始化且必须是一个已有对象 的引用；

4.作为参数传递时，指针需要被解引用才可以对对象进行操作，而直接对引 用的修改都会改变引用所指向的对象；

5.可以有const指针，但是没有const引用；

6.指针在使用中可以指向其它对象，但是引用只能是一个对象的引用，不能 被改变；

7.指针可以有多级指针（**p），而引用至于一级；

8.指针和引用使用++运算符的意义不一样；

9.如果返回动态内存分配的对象或者内存，必须使用指针，引用可能引起内存泄露。

5.调用operator+=来定义operator+更有效

下面给出operator+通过operator+=实现

 1 Sales_data& 
 2 Sales_data::operator+=(const Sales_data &rhs)
 3 {
 4     units_sold += rhs.units_sold;
 5     revenue += rhs.revenue;
 6     return *this;
 7 }
 8 
 9 Sales_data
10 operator+(const Sales_data &lhs, const Sales_data &rhs)
11 {
12     Sales_data sum = lhs;
13     sum += rhs;
14     return sum;
15 }

首先operator+有两个参数，其参数类型为const，是不需要改变的，其返回类型为Sales_data类型的一个拷贝。不过每次都需要在函数体内定义一个临时变量，用来返回拷贝。
而operator+=有一个参数，其参数类型为const，不需要改变，其返回类型为Sales_data类型的引用。每次不需要在函数内创建临时变量，直接可返回*this。
如果用operator+来定义operator+=的话，则不论调用operator+还是operator+=，每次都会创建一个Sales_data的临时变量。

以下为operator+=来定义operator+的代码：

 1 Sales_data& Sales_data::operator+=(const Sales_data &rhs)
 2 {
 3     Sales_data old_data = *this;
 4     *this = old_data + rhs;
 5     return *this;
 6 }
 7 
 8 Sales_data operator+(const Sales_data &lhs, const Sales_data &rhs)
 9 {
10     Sales_data sum;
11     sum.units_sold = lhs.units_sold + rhs.units_sold;
12     sum.revenue = lhs.revenue + rhs.revenue;
13     return sum;
14 }

所以说调用operstor+=来定义operator+是更有效率的。

6.排序算法相关稳定性分析

https://blog.csdn.net/yushiyi6453/article/details/76407640
冒泡排序
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。

选择排序
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n - 1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择，如果当前元素比一个元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。

插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。比较是从有序序列的末尾开始，也就是想要插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面，否则一直往前找直到找到它该插入的位置。如果碰见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。

快速排序
快速排序有两个方向，左边的i下标一直往右走，当a[i] <= a[center_index]，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。而右边的j下标一直往左走，当a[j] > a[center_index]。如果i和j都走不动了，i <= j，交换a[i]和a[j],重复上面的过程，直到i > j。 交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为5 3 3 4 3 8 9 10 11，现在中枢元素5和3（第5个元素，下标从1开始计）交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j] 交换的时刻。

归并排序

归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素（认为直接有序）或者2个序列（1次比较和交换），然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。

基数排序

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。

希尔排序(shell)

希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小， 插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。

堆排序

我们知道堆的结构是节点i的孩子为2 * i和2 * i + 1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n 的序列，堆排序的过程是从第n / 2开始和其子节点共3个值选择最大（大顶堆）或者最小（小顶堆），这3个元素之间的选择当然不会破坏稳定性。但当为n / 2 - 1， n / 2 - 2， … 1这些个父节点选择元素时，就会破坏稳定性。有可能第n / 2个父节点交换把后面一个元素交换过去了，而第n / 2 - 1个父节点把后面一个相同的元素没 有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。

综上，得出结论: 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法，而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法

不稳定的排序算法有：快、希、选、堆。（记忆：找到工作就可以“快些选一堆”美女来玩了（并不能））

7.结构体字节对齐问题

内存对齐有哪些原则呢？我总结了一下大致分为三条：

第一条：第一个成员的首地址为0.

第二条：每个成员的首地址是自身大小的整数倍
第二条补充：以4字节对齐为例，如果自身大小大于4字节，都以4字节整数倍为基准对齐。

第三条：最后以结构总体对齐。
第三条补充：以4字节对齐为例，取结构体中最大成员类型倍数，如果超过4字节，都以4字节整数倍为基准对齐。（其中这一条还有个名字叫：“补齐”，补齐的目的就是多个结构变量挨着摆放的时候也满足对齐的要求。）

http://c.biancheng.net/view/243.html
https://www.cnblogs.com/wsq-888/p/jie-gou-ti-dui-qi-gui-ze-ji-ju-li.html

链接：https://www.nowcoder.com/questionTerminal/5c2f7a22343e40179bea3a3cdeace8fb
来源：牛客网

8.static和const关键字的作用

static:

1. 修饰全局变量，修改变量的存储区域和生命周期，使变量存储在静态区，在main函数运行前就分配了空间，可以被模块内所用函数访问，但不能被模块外其它函数访问，变量文件独立。
2. 修饰函数内部局部变量，被函数内部循环利用，当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变。
3. 修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命令函数重名，可以将函数定位为static，函数不被共享。
4. 修饰成员变量，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用。
5. 修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在static函数内不能访问非静态成员，如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>)。相当于类内全局函数，没有虚函数。

const:
1 修饰变量，说明该变量不可以被改变；
2 修饰指针，分为指向常量的指针和指针常量；
3 常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改；
4 const成员变量，如果内置类型，必须显示初始化，或者类内初始化。
5 修饰成员函数，说明该成员函数内不能修改非const成员变量。
6 const引用用作构造函数参数。
7 const函数内部参数，不要被当作返回值的引用返回，

9.动态规划的问题及求解

https://www.cnblogs.com/wuyuegb2312/p/3281264.html
https://www.cnblogs.com/raichen/p/5772056.html

10.IP地址、子网掩码、网络号、主机号、网络地址、主机地址

IP地址：4段十进制，共32位二进制，如：192.168.1.1 二进制就是：11000000｜10101000｜00000001｜00000001

子网掩码可以看出有多少位是网络号，有多少位是主机号： 255.255.255.0 二进制是：11111111 11111111 11111111 00000000

网络号24位，即全是1 主机号8位，即全是0

129.168.1.1 /24 这个、24就是告诉我们网络号是24位，也就相当于告诉我们了子网掩码是：11111111 11111111 11111111 00000000即：255.255.255.0

172.16.10.33/27 中的/27也就是说子网掩码是255.255.255.224 即27个全1 ，11111111 11111111 11111111 11100000

一、根据IP地址和子网掩码求 网络地址 和 广播地址：

   一个主机的IP地址是202.112.14.137，掩码是255.255.255.224，要求计算这个主机所在网络的网络地址和广播地址 

1、根据子网掩码可以知道网络号有多少位，主机号有多少位!

255.255.255.224 转二进制：11111111 11111111 11111111 11100000

网络号有27位，主机号有5位

网络地址就是：把IP地址转成二进制和子网掩码进行与运算（逻辑乘法：0&0=0;0&1=0;1&0=0;1&1=1 ）

11001010 01110000 00001110 10001001

IP地址&子网掩码

11001010 01110000 00001110 10001001

11111111 11111111 11111111 11100000

---

11001010 01110000 00001110 10000000

即：202.112.14.128

广播地址：网络地址的主机位有5位全部变成1 ，10011111 即159 即：202.112.14.159

主机数：2^5-2=30

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

二、根据每个网络的主机数量进行子网地址的规划和计算子网掩码。这也可按上述原则进行计算。比如一个子网有10台主机，那么对于这个子网需要的IP地址是：
10＋1＋1＋1＝13
注意：加的第一个1是指这个网络连接时所需的网关地址，接着的两个1分别是指网络地址和广播地址。因为13小于16（16等于2的4次方），所以主机位为4位。而
256－16＝240
所以该子网掩码为255.255.255.240。
如果一个子网有14台主机，不少人常犯的错误是：依然分配具有16个地址空间的子网，而忘记了给网关分配地址。这样就错误了，因为：
14＋1＋1＋1＝17
17.大于16，所以我们只能分配具有32个地址（32等于2的5次方）空间的子网。这时子网掩码为：255.255.255.224

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

三、 IP地址为128•36•199•3 子网掩码是255•255•240•0。算出网络地址、广播地址、地址范围、主机数。
1）将IP地址和子网掩码换算为二进制，子网掩码连续全1的是网络地址，后面的是主机地址，虚线前为网络地址，虚线后为主机地址
2）IP地址和子网掩码进行与运算，结果是网络地址
3）将运算结果中的网络地址不变，主机地址变为1，结果就是广播地址
4） 地址范围就是含在本网段内的所有主机
网络地址+1即为第一个主机地址，广播地址-1即为最后一个主机地址，由此可以看出
地址范围是： 网络地址+1 至 广播地址-1

128.36.11000111.00000011

&255.255.11110000.00000000

---

128.36.11000000.00000000即：网络地址128.36.192.0 广播地址：128.36.11000000.00000000把主机位有12个零换成1变成：

128.36.11001111.11111111 即：128.36.207.255
本例的网络范围是：128•36•192•1 至 128•36•207•254
5） 主机的数量
主机的数量=2^二进制位数的主机-2
主机的数量=2^12-2=4094
减2是因为主机不包括网络地址和广播地址。
从上面两个例子可以看出不管子网掩码是标准的还是特殊的，计算网络地址、广播地址、地址数时只要把地址换算成二进制，然后从子网掩码处分清楚连续1以前的是网络地址，后是主机地址进行相应计算即可。
++++++++++++++++++++++++++++++++++++++

四、206 110 4 0/18被划分成16个子网，每个子网掩码？

（划分成16个子网，根据子网掩码/18就表示有18个1，就要从的IP地址的主机位借4位来用作网络位！）

子网掩码是255.255.252.0

每个子网可以容纳的主机数是1024台。

下面我来给你详细解答：

206.110.1.0 /18 由最后的那个/18，我们可以知道这个IP已经规定了它的网络位是18位，它默认的子网掩码就是11111111.11111111.11 | 000000.00000000(其中1代表网络位,0代表主机位)

可以看出我们可以操作的位数就是后面的14个0，也就是说我们可以在地面划分出几位作为子网的网络位，进而来划分子网。要求是切分成16个子网，我们知道2的4次方刚好等于16，这就说明子网网络位的位数是4位，那14-4=10就是子网的主机位。所以上面我写的那串二进制就可以变成：11111111.11111111.111111 | 00.00000000(其中1代表网络位,0代表主机位)

换算成十进制就是:255.255.252.0 每个子网可容纳的主机数就是2的10次方,即1024

11.TCP/IP的三次握手 四次挥手

https://www.cnblogs.com/wangcq/p/3520400.html
TCP是面向连接的服务；三次握手（建立连接）和四次挥手（关闭连接）；使用滑动窗口机制进行流量控制；TCP要保证在所有可能的情况下使得所有的数据都能够被投递，当你关闭一个socket时，主动关闭一端的socket将进入TIME_WAIT状态，而被动关闭一方则转入CLOSED状态，这的确能够保证所有的数据都被传输。

介绍一下TCP连接建立与关闭过程中的状态。TCP连接过程是状态的转换，促使状态发生转换的因素包括用户调用、特定数据包以及超时等，具体状态如下所示：
CLOSED ：初始状态，表示没有任何连接。
LISTEN ： Server 端的某个 Socket 正在监听来自远方的 TCP 端口的连接请求。
SYN_SENT ：发送连接请求后等待确认信息。当客户端 Socket 进行 Connect 连接时，会首先发送 SYN 包，随即进入 SYN_SENT 状态，然后等待 Server 端发送三次握手中的第 2 个包。
SYN_RECEIVED ：收到一个连接请求后回送确认信息和对等的连接请求，然后等待确认信息。通常是建立 TCP 连接的三次握手过程中的一个中间状态，表示 Server 端的 Socket 接收到来自 Client 的 SYN 包，并作出回应。 ESTABLISHED ：表示连接已经建立，可以进行数据传输。
FIN_WAIT_1 ：主动关闭连接的一方等待对方返回 ACK 包。若 Socket 在 ESTABLISHED 状态下主动关闭连接并向对方发送 FIN 包（表示己方不再有数据需要发送），则进入 FIN_WAIT_1 状态，等待对方返回 ACK 包，此后还能读取数据，但不能发送数据。在正常情况下，无论对方处于何种状态，都应该马上返回 ACK 包，所以 FIN_WAIT_1 状态一般很难见到。
FIN_WAIT_2 ：主动关闭连接的一方收到对方返回的 ACK 包后，等待对方发送 FIN 包。处于 FIN_WAIT_1 状态下的 Socket 收到了对方返回的 ACK 包后，便进入 FIN_WAIT_2 状态。由于 FIN_WAIT_2 状态下的 Socket 需要等待对方发送的 FIN 包，所有常常可以看到。若在 FIN_WAIT_1 状态下收到对方发送的同时带有 FIN 和 ACK 的包时，则直接进入 TIME_WAIT 状态，无须经过 FIN_WAIT_2 状态。
TIME_WAIT ：主动关闭连接的一方收到对方发送的 FIN 包后返回 ACK 包（表示对方也不再有数据需要发送，此后不能再读取或发送数据），然后等待足够长的时间（ 2MSL ）以确保对方接收到 ACK 包（考虑到丢失 ACK 包的可能和迷路重复数据包的影响），最后回到 CLOSED 状态，释放网络资源。
CLOSE_WAIT ：表示被动关闭连接的一方在等待关闭连接。当收到对方发送的 FIN 包后（表示对方不再有数据需要发送），相应的返回 ACK 包，然后进入 CLOSE_WAIT 状态。在该状态下，若己方还有数据未发送，则可以继续向对方进行发送，但不能再读取数据，直到数据发送完毕。
LAST_ACK ：被动关闭连接的一方在 CLOSE_WAIT 状态下完成数据的发送后便可向对方发送 FIN 包（表示己方不再有数据需要发送），然后等待对方返回 ACK 包。收到 ACK 包后便回到 CLOSED 状态，释放网络资源。
CLOSING ：比较罕见的例外状态。正常情况下，发送 FIN 包后应该先收到（或同时收到）对方的 ACK 包，再收到对方的 FIN 包，而 CLOSING 状态表示发送 FIN 包后并没有收到对方的 ACK 包，却已收到了对方的 FIN 包。有两种情况可能导致这种状态：其一，如果双方几乎在同时关闭连接，那么就可能出现双方同时发送 FIN 包的情况；其二，如果 ACK 包丢失而对方的 FIN 包很快发出，也会出现 FIN 先于 ACK 到达。

1）首先A B端的TCP进程都处于established状态， 当A的应用程序传送完报文段，就会去 主动关闭 连接。A 会停止发送报文段（但是还会接收），并向B发送[FIN = 1,seq=u]数据，之后进入FIN-WAIT-1状态；
2）B接收到A发送的请求之后，会通知应用进程A已经不再发送数据，B会向A发送ACK确认数据[ACK=1,seq=v,ack=u+1 ],B进入 CLOSE-WAIT状态， A接收到B发送的数据之后，A进入FIN-WAIT-2状态；此时A到B方的连接已经关闭了。
3）当B的应用进程发现自己也没有数据需要传送，B应用进程就会发出 被动关闭 的请求，B此时向A发送[FIN=1,ACK=1,seq=w,ack=u+1]数据，并且进入LAST-ACK状态；
4）A接收到B发送的数据之后，向B发送确认数据[ACK =1,seq=u+1,ack=w+1],进入TIME-WAIT状态，等待2MSL之后关闭连接进入CLOSED状态；B接收到A发送的确认之后进入CLOSED状态。B到A方的连接关闭

12.基类中static定义的函数能否为虚函数

不能。成员函数不可同时为virtual和static。
多态实现的基本原理是每个带有virtual函数的类的【实例】要包含一个指针，指向虚函数表(vtbl)。
static函数做为类函数，不与任何【实例】相关，自然无法实现多态了。

内联函数、构造函数、静态成员函数不可以定义为虚函数

1. 内联函数是编译时展开函数体，所以在此时就需要有实体，而虚函数是运行时才有实体，所以内联函数不可以为虚函数。
2. 静态成员函数是属于类的，不属于任何一个类的对象，可以通过作用域以及类的对象访问，本身就是一个实体，所以不能定义为虚函数。
3. 如果构造函数定义为虚函数，则需要通过查找虚函数表来进行调用。但是构造函数是虚函数的情况下是找不到的，因为构造函数自己本身也不存在，创建不了实例，没有实例化对象，则类的成员不能被访问。

13.c++继承关系

1）单一的一般继承（带成员变量、虚函数、虚函数覆盖）

2）单一的虚拟继承（带成员变量、虚函数、虚函数覆盖）

3）多重继承（带成员变量、虚函数、虚函数覆盖）

4）重复多重继承（带成员变量、虚函数、虚函数覆盖）

5）钻石型的虚拟多重继承（带成员变量、虚函数、虚函数覆盖）

https://blog.csdn.net/ywcpig/article/details/52518517

14.在父类的构造函数中调用虚函数为什么不能实现多态

https://mp.weixin.qq.com/s?src=11&timestamp=1564463316&ver=1759&signature=OE1cZh0qBu3qE3ycfhAlyPkbb5HVRCmKPzX5hZtdTxnaZkFOqmqf3QPQA1g7yEH93BDTTozHZjuiARrDvYLwkZAsrTXZAiZb6Yp3Go8eK3Sm4rP0pRM7cmtwPzBMOIfR&new=1

15.new和malloc的区别

相关传送门：https://blog.csdn.net/Hanani_Jia/article/details/82429587

malloc是从堆上动态分配内存，new是从自由存储区为对象动态分配内存。
自由存储区的位置取决于operator new的实现。自由存储区不仅可以为堆，还可以是静态存储区，这都看operator new在哪里为对象分配内存。

一个由C/C++编译的程序占用的内存分为以下几个部分：
1、栈区（stack）— 由编译器自动分配释放 ，存放为运行函数而分配的局部变量、函数参数、返回数据、返回地址等。其操作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束 时可能由OS回收 。分配方式类似于链表。
3、全局区（静态区）（static）—存放全局变量、静态数据、常量。程序结束后由系统释放。 初始化的全局变量和静态变量在一块区域data， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域（BSS，Block Started by Symbol）。 程序结束后由系统释放(在整个程序的执行过程中都是有效的)
4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放。
5、程序代码区—存放函数体（类成员函数和全局函数）的二进制代码。

16. C++中内存泄漏的几种情况

https://www.cnblogs.com/liushui-sky/p/7727865.html

1. 在类的构造函数和析构函数中没有匹配的调用new和delete函数

两种情况下会出现这种内存泄露：一是在堆里创建了对象占用了内存，但是没有显示地释放对象占用的内存；二是在类的构造函数中动态的分配了内存，但是在析构函数中没有释放内存或者没有正确的释放内存

2. 没有正确地清除嵌套的对象指针

3. 在释放对象数组时在delete中没有使用方括号

方括号是告诉编译器这个指针指向的是一个对象数组，同时也告诉编译器正确的对象地址值并调用对象的析构函数，如果没有方括号，那么这个指针就被默认为只指向一个对象，对象数组中的其他对象的析构函数就不会被调用，结果造成了内存泄露。如果在方括号中间放了一个比对象数组大小还大的数字，那么编译器就会调用无效对象（内存溢出）的析构函数，会造成堆的奔溃。如果方括号中间的数字值比对象数组的大小小的话，编译器就不能调用足够多个析构函数，结果会造成内存泄露。

释放单个对象、单个基本数据类型的变量或者是基本数据类型的数组不需要大小参数，释放定义了析构函数的对象数组才需要大小参数。

4. 指向对象的指针数组不等同于对象数组

对象数组是指：数组中存放的是对象，只需要delete []p，即可调用对象数组中的每个对象的析构函数释放空间

指向对象的指针数组是指：数组中存放的是指向对象的指针，不仅要释放每个对象的空间，还要释放每个指针的空间，delete []p只是释放了每个指针，但是并没有释放对象的空间，正确的做法，是通过一个循环，将每个对象释放了，然后再把指针释放了。

5. 缺少拷贝构造函数

两次释放相同的内存是一种错误的做法，同时可能会造成堆的奔溃。

按值传递会调用（拷贝）构造函数，引用传递不会调用。

在C++中，如果没有定义拷贝构造函数，那么编译器就会调用默认的拷贝构造函数，会逐个成员拷贝的方式来复制数据成员，如果是以逐个成员拷贝的方式来复制指针被定义为将一个变量的地址赋给另一个变量。这种隐式的指针复制结果就是两个对象拥有指向同一个动态分配的内存空间的指针。当释放第一个对象的时候，它的析构函数就会释放与该对象有关的动态分配的内存空间。而释放第二个对象的时候，它的析构函数会释放相同的内存，这样是错误的。

所以，如果一个类里面有指针成员变量，要么必须显示的写拷贝构造函数和重载赋值运算符，要么禁用拷贝构造函数和重载赋值运算符

C++中构造函数，拷贝构造函数和赋值函数的区别和实现参见：http://www.cnblogs.com/liushui-sky/p/7728902.html

6. 缺少重载赋值运算符

这种问题跟上述问题类似，也是逐个成员拷贝的方式复制对象，如果这个类的大小是可变的，那么结果就是造成内存泄露，如下图:

7. 关于nonmodifying运算符重载的常见迷思

   a. 返回栈上对象的引用或者指针（也即返回局部对象的引用或者指针）。导致最后返回的是一个空引用或者空指针，因此变成野指针

   b. 返回内部静态对象的引用。

   c. 返回一个泄露内存的动态分配的对象。导致内存泄露，并且无法回收

   解决这一类问题的办法是重载运算符函数的返回值不是类型的引用，二应该是类型的返回值，即不是 int&而是int

8. 没有将基类的析构函数定义为虚函数

当基类指针指向子类对象时，如果基类的析构函数不是virtual，那么子类的析构函数将不会被调用，子类的资源没有正确是释放，因此造成内存泄露

17.在main函数执行前执行一段代码和main之后执行一段代码

在C语言中，如果使用GCC的话，可以通过attribute关键字声明constructor和destructor（C语言中如何在main函数开始前执行函数）

#include <stdio.h>

__attribute((constructor)) void before_main()
{
printf("%s/n",FUNCTION);
}

__attribute((destructor)) void after_main()
{
printf("%s/n",FUNCTION);
}

int main( int argc, char ** argv )
{
printf("%s/n",FUNCTION);
return 0;
}
在C++中，利用全局变量和构造函数的特性，通过全局变量的构造函数执行（C++语言怎么在main函数执行之前执行一段代码）

#include
using namespace std;

class TestClass
{
public:
TestClass();
};

TestClass::TestClass()
{
cout<<“TestClass”<<endl;
}

TestClass Ts;//定义个全局变量，让类里面的代码在main之前执行

int main()
{
cout<<“main”<<endl;

    return 0;

}

18.在accept前调用fork和accept后调用fork的区别

在Linux网络编程中并发服务器的最简单的方式就fork（）子进程处理连接，父进程继续等待新的连接完成。而在fork（）子进程的顺序上有在accept之前和accept之后两种。

通过fork（）创建子进程时，子进程继承父进程环境和上下文的大部分内容的拷贝，其中就包括文件描述符表。

（1）对于父进程在fork（）之前所建立的连接，子进程都会继承，与父进程共享相同的文件偏移量。系统文件表位于系统空间中，不会被fork()复制，但是系统文件表中的条目会保存指向它的文件描述符表的计数，

fork()时需要对这个计数进行维护，以体现子进程对应的新的文件描述符表也指向它。程序关闭文件时，也是将系统文件表条目内部的计数减一，当计数值减为0时，将其删除。

（2）对于父进程在fork（）之后建立连接，此时还没有打开文件描述符，所以子进程没有继承到文件描述符，子进程将会自己建立一条连接，不与父进程共享偏移量，而此时父进程也会建立一条连接，并且文件描述符表中的计数器会增加，当子进程结束后，文件计数器减一，而父进程一直执行，但不会为零，所以这个文件描述符会一直存在，占用资源。

所以在faccept之前fork（）后要在父进程中关闭accept的描述符，并且在fork子进程中关闭listen的描述符；而在accept后调用fork（）则只需要在子进程中关闭listen描述符，父进程中不做处理。

19.c++线程中的几种锁

https://zhuanlan.zhihu.com/p/53910908
互斥锁 条件锁 自旋锁 读写锁 递归锁

20.快排最优时间复杂度，平均时间复杂度和最差时间复杂度分析

https://blog.csdn.net/gettogetto/article/details/58200149

21.十种排序总结

https://www.cnblogs.com/guoyaohua/p/8600214.html

22.C++语言中参数的压栈顺序

要回答这个问题，就不得不谈一谈printf（）函数，printf函数的原型是：printf（const char* format,…）
没错，它是一个不定参函数，那么我们在实际使用中是怎么样知道它的参数个数呢？这就要靠format了，编译器通过format中的%占位符的个数来确定参数的个数。
现在我们假设参数的压栈顺序是从左到右的，这时，函数调用的时候，format最先进栈，之后是各个参数进栈，最后pc进栈，此时，由于format先进栈了，上面压着未知个数的参数，想要知道参数的个数，必须找到format，而要找到format，必须要知道参数的个数，这样就陷入了一个无法求解的死循环了！！
而如果把参数从右到左压栈，情况又是怎么样的？函数调用时，先把若干个参数都压入栈中，再压format，最后压pc，这样一来，栈顶指针加2便找到了format，通过format中的%占位符，取得后面参数的个数，从而正确取得所有参数。
所以，如果不存在…这种不定参的函数，则参数的压栈顺序无论是从左到右还是从右到左都是没关系的。

24. 函数的返回值，C语言函数返回值详解

通常我们希望通过函数调用使主调函数能得到一个确定的值，这就是函数的返回值。函数的返回值是通过函数中的 return 语句获得的。return 语句将被调函数中的一个确定的值带回到主调函数中，供主调函数使用

函数的返回值类型是在定义函数时指定的。return 语句中表达式的类型应与定义函数时指定的返回值类型一致。如果不一致，则以函数定义时的返回值类型为准，对 return 语句中表达式的类型自动进行转换，然后再将它返回给主调函数使用。但是建议初学者在编程的时候，务必要保持它们两个类型一致。

在调用函数时，如果需要从被调函数返回一个值供主调函数使用，那么返回值类型必须定义成非 void 型。此时被调函数中必须包含 return 语句，而且 return 后面必须要有返回值，否则就是语法错误。

如果函数有返回值，那么 return 语句后面的括号可以不要，比如“return（z）；”等价于“return z；”。若不需要返回值则可以不要 return 语句。

需要强调的是，一个函数中可以有多个 return 语句，但并不是所有的 return 语句都起作用。执行到哪个 return 语句，就是哪个 return 语句起作用，该 return 语句后的其他语句就都不会执行了。

return是如何将值返回给主调函数的

我们知道，被调函数运行结束后才会返回主调函数，但是被调函数运行结束后系统为被调函数中的局部变量分配的内存空间就会被释放。也就是说，return 返回的那个值在被调函数运行一结束就被释放掉了，那么它是怎么返回给主调函数的呢？

事实上在执行 return 语句时系统是在内部自动创建了一个临时变量，然后将 return 要返回的那个值赋给这个临时变量。所以当被调函数运行结束后 return 后面的返回值真的就被释放掉了，最后是通过这个临时变量将值返回给主调函数的。而且定义函数时指定的返回值类型实际上指定的就是这个临时变量的类型。这些都是系统自动完成的，了解即可。

这也是为什么当 return 语句中表达式的类型和函数返回值类型不一致时，将 return 的类型转换成函数返回值类型的原因。return 语句实际上就是将其后的值赋给临时变量，所以它要以临时变量的类型为准，即函数返回值的类型。

25. malloc和new的区别

malloc和new从申请的内存所在位置、返回类型安全性、内存分配失败时的返回值、是否需要指定内存大小这四点区分。
1、申请的内存所在位置不同
new操作符从自由存储区（free store）上为对象动态分配内存空间。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。
malloc函数从堆上动态分配内存。堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。
2、返回类型安全性不同
new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。
malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。
3、内存分配失败时的返回值不同
new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL。
malloc分配内存失败时返回NULL。
4、是否需要指定内存大小不同
使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算。
malloc则需要显式地指出所需内存的尺寸。

26. Linux 系统编程fork,wait,exec函数详解

操作系统为正在运行程序的抽象，就是进程

进程的状态包括运行， 就绪，阻塞三种状态。

进程是操作系统资源分配的基本单位。

fork函数创建一个子进程，这个函数有两个返回值

子进程返回O，父进程返回父进程的pid

pid 是一个标志进程的数字，可以用函数getpid() 获得。

父进程调用wait等待子进程的结束,才返回父进程

1. wait()函数用于使父进程（也就是调用wait()的进程）阻塞，直到一个子进程结束或者该进程接收到了一个指定的信号为止。如果该父进程没有子进程或者它的子进程已经结束，则wait()函数就会立即返回。

2. waitpid()的作用和wait()一样，但它并不一定要等待第一个终止的子进程（它可以指定需要等待终止的子进程），它还有若干选项，如可提供一个非阻塞版本的 wait()功能，也能支持作业控制。实际上，wait()函数只是 waitpid()函数的一个特例，在Linux 内部实现 wait()函数时直接调用的就是waitpid()函数。

---

exec()函数族可以让子进程执行与父进程不同的程序，即让子进程执行另一个程序。

这样有什么好处？

例如在shell脚本中，常常有以下重定向操作

wc p3.c > newfile.txt
统计文件p3.c 的字数，并把结果输出重定向到newfile.txt文件。

这个命令的实现是通过在执行wc命令前，先改变程序的运行环境，即关闭标准输出，打开newfile.txt, 这时标准输出就会重定向到newfile.txt。这样就可以使用exec函数实现。

27. STL六大组件

https://www.cnblogs.com/welen/articles/3533008.html

28. C++内存泄漏及解决方法

https://blog.csdn.net/Clever_Pig/article/details/75050398

29. 五种IO模型、IO多路复用之select用法

同步IO 异步IO ：https://zhuanlan.zhihu.com/p/36344554
https://blog.csdn.net/GangStudyIT/article/details/81202242
select poll epoll 函数的应用 https://zhuanlan.zhihu.com/p/39970630

epoll

30.三种单例模式的C++实现

https://www.cnblogs.com/qiaoconglovelife/p/5851163.html

31.网络编程中多线程与多进程的区别

1、进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
2，线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
两者都可以提高程序的并发度，提高程序运行效率和响应时间。
线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。

==根本区别就一点：用多进程每个进程有自己的地址空间(address space)，线程则共享地址空间。==所有其它区别都是由此而来的：
1。速度：线程产生的速度快，线程间的通讯快、切换快等，因为他们在同一个地址空间内。
2。资源利用率：线程的资源利用率比较好也是因为他们在同一个地址空间内。
3。同步问题：线程使用公共变量/内存时需要使用同步机制还是因为他们在同一个地址空间内。

32.strcpy和memcpy的实现 考虑内存重叠

https://blog.csdn.net/qq_37934101/article/details/81538238

33.HTTP中GET与POST的区别

https://zhuanlan.zhihu.com/p/65544106
https://www.w3school.com.cn/tags/html_ref_httpmethods.asp

34. mysql（SQL） redis(NOSQL)区别

Redis、MongoDB、mysql性能比较：
https://blog.csdn.net/Constantdropping/article/details/84447665

（1）类型上

    从类型上来说，mysql是关系型数据库，redis是缓存数据库

（2）作用上

   mysql用于持久化的存储数据到硬盘，功能强大，但是速度较慢

   redis用于存储使用较为频繁的数据到缓存中，读取速度快

（3）需求上

   mysql和redis因为需求的不同，一般都是配合使用。

我们知道，mysql是持久化存储，存放在磁盘里面，检索的话，会涉及到一定的IO，为了解决这个瓶颈，于是出现了缓存，比如现在用的最多的 memcached(简称mc)。首先，用户访问mc，如果未命中，就去访问mysql，之后像内存和硬盘一样，把数据复制到mc一部分。

redis和mc都是缓存，并且都是驻留在内存中运行的，这大大提升了高数据量web访问的访问速度。然而mc只是提供了简单的数据结构，比如 string存储;redis却提供了大量的数据结构，比如string、list、set、hashset、sorted set这些，这使得用户方便了好多，毕竟封装了一层实用的功能，同时实现了同样的效果，当然用redis而慢慢舍弃mc。

内存和硬盘的关系，硬盘放置主体数据用于持久化存储，而内存则是当前运行的那部分数据，CPU访问内存而不是磁盘，这大大提升了运行的速度，当然这是基于程序的局部化访问原理。

推理到redis+mysql，它是内存+磁盘关系的一个映射，mysql放在磁盘，redis放在内存，这样的话，web应用每次只访问redis，如果没有找到的数据，才去访问Mysql。

然而redis+mysql和内存+磁盘的用法最好是不同的。

前者是内存数据库，数据保存在内存中，当然速度快。

后者是关系型数据库，功能强大，数据访问也就慢。

一般来说，写入数据是直接到mysql，读取类的是redis。 这样就说 mysql->redis的同步用的比较多。 mysql作为数据持久化和管理比redis好太多，redis大多只用来做 数据读取缓存、队列、锁、等等的使用。

mysql：数据放在磁盘 redis：数据放在内存

redis适合放一些频繁使用，比较热的数据，因为是放在内存中，读写速度都非常快，一般会应用在下面一些场景：排行榜、计数器、消息队列推送

35. 程序编译的四个阶段

https://blog.csdn.net/dylandong/article/details/60465718

https://blog.csdn.net/weixin_41143631/article/details/81221777

36.fork()、vfork()、clone()的区别

https://blog.csdn.net/gogokongyin/article/details/51178257

37.偏移寻址方式

偏移寻址通过将某个寄存器内容与一个形式地址相加而生成有效地址。下列寻址方式中，不属于偏移寻址方式的是（）。
A 间接寻址
B 基址寻址
C 相对寻址
D 变址寻址

间接寻址不需要寄存器，EA=(A)。基址寻址EA=A+基址寄存器BR内容；相对寻址EA=A+程序计数器PC内容；变址寻址EA﹦A+变址寄存器IX内容。后三者都是将某个寄存器内容与一个形式地址相加而形成有效地址，故选A。

**变址寻址：**把变址寄存器的内容（通常是首地址）与指令 地址码 部分给出的地址（通常是位移量）之和作为 操作数 的地址来获得所需要的操作数就称为变址寻址。
间接寻址： 间接寻址是相对于 直接寻址 而言的，指令地址字段的 形式地址 D不是 操作数 的真正地址，而是操作数地址的指示器，或者说是D单元的内容才是操作数的 有效地址 。

38. 空指针调用一个成员函数会发生什么情况

this指针

https://www.jianshu.com/p/45cf10150e6b
https://blog.csdn.net/u010021282/article/details/53856472

39. linux文件名长度

在x86_64 Linux下，
文件名的最大长度是255个字符(characters)，文件路径的最大长度是4096字符(characters)， 即可以包含16级的最大文件长度的路径。

在 <limits.h>头文件中，有 #define NAME_MAX 255 的定义.

40. 四种智能指针（未完）

shared_ptr、unique_ptr、weak_ptr、auto_ptr

使用堆内存是非常频繁的操作，堆内存的申请和释放都由程序员自己管理。程序员自己管理堆内存可以提高了程序的效率，但是整体来说堆内存的管理是麻烦的，C++11中引入了智能指针的概念，方便管理堆内存。使用普通指针，容易造成堆内存泄露（忘记释放），二次释放，程序发生异常时内存泄露等问题等，使用智能指针能更好的管理堆内存。

• 智能指针是利用了一种叫做RAII（资源获取即初始化）的技术对普通的指针进行封装，这使得智能指针实质是一个类对象，行为表现的却像一个指针。
• 智能指针的作用是防止忘记调用delete释放内存和程序异常的进入catch块忘记释放内存。另外指针的释放时机也是非常有考究的，多次释放同一个指针会造成程序崩溃，这些都可以通过智能指针来解决。

41. b+ b 红黑树

（1）红黑树

红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求:

1. 节点是红色或黑色

2. 根节点是黑色。

3. 每个叶节点（NIL节点，空节点）是黑色的。

4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)

5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

红黑树和avl(二叉平衡树)的比较

1. 如果插入一个node引起了树的不平衡，AVL和RB-Tree(红黑树)都是最多只需要2次旋转操作，即两者都是O(1)；但是在删除node引起树的不平衡时，最坏情况下，AVL需要维护从被删node到root这条路径上所有node的平衡性，因此需要旋转的量级O(logN)，而RB-Tree最多只需3次(因为不需要严格的平衡，从根到叶子的最长的可能路径不多于最短的可能路径的两倍长)旋转以及修改节点的颜色，只需要O(1)的复杂度。
2. 其次，AVL的结构相较RB-Tree来说更为平衡，在插入和删除node更容易引起Tree的unbalance，因此在大量数据需要插入或者删除时，AVL需要rebalance的频率会更高。因此，RB-Tree在需要大量插入和删除node的场景下，效率更高。自然，由于AVL高度平衡，因此AVL的search效率更高。

红黑树实际应用
inux中进程的调度用的是红黑树。 IO多路复用epoll的实现采用红黑树组织管理sockfd，以支持快速的增删改查。ngnix中,用红黑树管理timer,因为红黑树是有序的,可以很快的得到距离当前最小的定时器。 java中TreeMap，jdk1.8的hashmap的实现。

（2） B+树

B+ 树是一种树数据结构，是一个n叉排序树，每个节点通常有多个孩子，一棵B+树包含根节点、内部节点和叶子节点。根节点可能是一个叶子节点，也可能是一个包含两个或两个以上孩子节点的节点。

（ ps:举例说明3阶B-树指的是每个结点最多2个关键字，3个孩子)

B+树是对B树的一种变形树，它与B树的差异在于：

有k个子结点的结点必然有k个关键码；
非叶结点仅具有索引作用，跟记录有关的信息均存放在叶结点中。
树的所有叶结点构成一个有序链表，可以按照关键码排序的次序遍历全部记录，便于区间查找和遍历。

B+ 树的优点在于：
由于B+树在内部节点上不包含数据信息，因此在内存页中能够存放更多的key。 数据存放的更加紧密，具有更好的空间局部性。因此访问叶子节点上关联的数据也具有更好的缓存命中率。
B+树的叶子结点都是相链的，因此对整棵树的便利只需要一次线性遍历叶子结点即可。而且由于数据顺序排列并且相连，所以便于区间查找和搜索。而B树则需要进行每一层的递归遍历。相邻的元素可能在内存中不相邻，所以缓存命中性没有B+树好。

但是B树也有优点，其优点在于，由于B树的每一个节点都包含key和value，因此经常访问的元素可能离根节点更近，因此访问也更迅速。下面是B 树和B+树的区别图：

b+树的应用场景:

B/B+树是为了磁盘或其它存储设备而设计的一种平衡多路查找树(相对于二叉,B树每个内节点有多个分支),与红黑树相比,在相同的的节点的情况下,一颗B/B+树的高度远远小于红黑树的高度(在下面B/B+树的性能分析中会提到).B/B+树上操作的时间通常由存取磁盘的时间和CPU计算时间这两部分构成,而CPU的速度非常快,所以B树的操作效率取决于访问磁盘的次数,关键字总数相同的情况下B树的高度越小，磁盘I/O所花的时间越少.
二叉查找树的结构不适合数据库，因为它的查找效率与层数相关。越处在下层的数据，就需要越多次比较。对于数据库来说，每进入一层，就要从硬盘读取一次数据，这非常致命，因为硬盘的读取时间远远大于数据处理时间，数据库读取硬盘的次数越少越好。这种数据结构，非常有利于减少读取硬盘的次数。假定一个节点可以容纳100个值，那么3层的B树可以容纳100万个数据，如果换成二叉查找树，则需要20层！假定操作系统一次读取一个节点，并且根节点保留在内存中，那么B树在100万个数据中查找目标值，只需要读取两次硬盘。

42. 重载 重写 重定义

1 重载指的是在同一个作用域内，两函数的函数名可以相同，但是参数不能完全相同，可以是参数类型不同或者是参数个数不同，至于返回值，不影响重载。

2 重定义也叫隐藏，指的是在继承关系中，子类实现了一个和父类名字一样的函数，（只关注函数名，和参数与返回值无关）这样的话子类的函数就把父类的同名函数隐藏了。

3 重写指的在继承关系中，子类中定义了一个与父类极其相似的虚函数。 函数名必须相同，参数列表必须相同，返回值可以不相同，但是必须是父子关系的指针或引用。

通过重写，可以实现动态多态，何为动态多态，就是当父类的指针或引用指向被重写的虚函数时，父类的指针或引用指向谁就调用谁的虚函数，而不是说根据类型。

43. static_cast、dynamic_cast、const_cast和reinterpret_cast

C++中的类型转换分为两种：

1. 隐式类型转换；
2. 显式类型转换。
   而对于隐式变换，就是标准的转换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。而关于隐式转换不是今天总结的重点，重点是显式转换。在标准C++中有四个类型转换符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将对它们一一的进行总结。

static_cast
static_cast的转换格式：static_cast (expression)
将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：
1.用于类层次结构中，基类和子类之间指针和引用的转换；
当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
2.用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
3.把void指针转换成目标类型的指针，是及其不安全的；
注：static_cast不能转换掉expression的const、volatile和__unaligned属性。

dynamic_cast
dynamic_cast的转换格式：dynamic_cast (expression)
将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。
dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。

const_cast
const_cast的转换格式：const_cast (expression)
const_cast用来将类型的const、volatile和__unaligned属性移除。常量指针被转换成非常量指针，并且仍然指向原来的对象；常量引用被转换成非常量引用，并且仍然引用原来的对象。
**注：**你不能直接对非指针和非引用的变量使用const_cast操作符去直接移除它的const、volatile和__unaligned属性。

reinterpret_cast
reinterpret_cast的转换格式：reinterpret_cast (expression)
允许将任何指针类型转换为其它的指针类型；听起来很强大，但是也很不靠谱。它主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针，在实际开发中，先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原来的指针值；特别是开辟了系统全局的内存空间，需要在多个应用程序之间使用时，需要彼此共享，传递这个内存空间的指针时，就可以将指针转换成整数值，得到以后，再将整数值转换成指针，进行对应的操作。

总结： C风格转换是“万能的转换”，但需要程序员把握转换的安全性，编译器无能为力；static_cast最接近于C风格转换，但在无关类指针转换时，编译器会报错，提升了安全性；dynamic_cast要求转换类型必须是指针或引用，且在下行转换时要求基类是多态的，如果发现下行转换不安全，dynamic_cast返回一个null指针，dynamic_cast总是认为void*之间的转换是安全的；reinterpret_cast可以对无关类指针进行转换，甚至可以直接将整型值转成指针，这种转换是底层的，有较强的平台依赖性，可移植性差；const_cast可以将常量转成非常量，但不会破坏原常量的const属性，只是返回一个去掉const的变量。

44. 平衡二叉树的最小节点数

• 设二叉树的根结点的层次为1，则高度为h的平衡二叉树的最少结点数为：
  对于 h>=1，N(h) = F(h + 2) -1，其中F(n) 为Fibonacci序列的各项：1, 1, 2, 3, 5, 8, 13…

• 二叉树叶子结点数为n，则度为2的结点数为n-1,如果总节点数为N，度为1的结点数为N-2n+1

45. 分段存储和分页存储

https://blog.csdn.net/qq_37924084/article/details/78360003

46. i++是否是原子性操作

i++ ++i不是原子操作。

1. 什么是操作系统的“原子操作”
   原子操作是不可分割的，在执行完毕不会被任何其它任务或事件中断，分为两种情况（两种都应该满足）

   （1） 在单线程中， 能够在单条指令中完成的操作都可以认为是" 原子操作"，因为中断只能发生于指令之间。

   （2） 在多线程中，不能被其它进程（线程）打断的操作就叫原子操作。

2. 面试的时候经常问的一道题目是i++在两个线程里边分别执行100次，能得到的最大值和最小值分别是多少？（2 -200）

   i++只需要执行一条指令，并不能保证多个线程i++，操作同一个i，可以得到正确的结果。因为还有寄存器的因素，多个cpu对应多个寄存器。每次要先把i从内存复制到寄存器，然后++，然后再把i复制到内存中，这需要至少3步。从这个意义上讲，说i++是原子的并不对。
   如此，假设两个线程的执行步骤如下：

（1）线程A执行第一次i++，取出内存中的i，值为0，存放到寄存器后执行加1，此时CPU1的寄存器中值为1，内存中为0；

（2）线程B执行第一次i++，取出内存中的i，值为0，存放到寄存器后执行加1，此时CPU2的寄存器中值为1，内存中为0；

（3） 线程A继续执行完成第99次i++，并把值放回内存，此时CPU1中寄存器的值为99，内存中为99；

（4）线程B继续执行第一次i++，将其值放回内存，此时CPU2中的寄存器值为1，内存中为1；

（5）线程A执行第100次i++，将内存中的值取回CPU1的寄存器，并执行加1，此时CPU1的寄存器中的值为2，内存中为1；

（6）线程B执行完所有操作，并将其放回内存，此时CPU2的寄存器值为100，内存中为100；

（7） 线程A执行100次操作的最后一部分，将CPU1中的寄存器值放回内存，内存中值为2；

（8） 结束！

所以该题目便可以得出最终结果，最小值为2，最大值为200。

47.在类的成员函数中调用delete this

在类的成员函数中能不能调用delete this？答案是肯定的，能调用，而且很多老一点的库都有这种代码。假设这个成员函数名字叫release，而delete this就在这个release方法中被调用，那么这个对象在调用release方法后，还能进行其他操作，如调用该对象的其他方法么？答案仍然是肯定 的，调用release之后还能调用其他的方法，但是有个前提：被调用的方法不涉及这个对象的数据成员和虚函数。说到这里，相信大家都能明白为什么会这样 了。

根本原因在于delete操作符的功能和类对象的内存模型。当一个类对象声明时，系统会为其分配内存空间。在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当 调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题。

为什么是不可预期的问题？delete this之后不是释放了类对象的内存空间了么，那么这段内存应该已经还给系统，不再属于这个进程。照这个逻辑来看，应该发生指针错误，无访问权限之类的令系统崩溃的问题才对啊？这个问题牵涉到操作系统的内存管理策略。delete this释放了类对象的内存空间，但是内存空间却并不是马上被回收到系统中，可能是缓冲或者其他什么原因，导致这段内存空间暂时并没有被系统收回。此时这段内存是可以访问的，你可以加上100，加上200，但是其中的值却是不确定的。当你获取数据成员，可能得到的是一串很长的未初始化的随机数；访问虚函数表，指针无效的可能性非常高，造成系统崩溃。

大致明白在成员函数中调用delete this会发生什么之后，再来看看另一个问题，如果在类的析构函数中调用delete this，会发生什么？实验告诉我们，会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存” (来自effective c++)。显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。

48.宏定义和const区别

类型和安全检查不同
宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；
const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查

编译器处理不同
宏定义是一个“编译时”概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束与编译时期；
const常量是一个“运行时”概念，在程序运行使用，类似于一个只读行数据

存储方式不同
宏定义是直接替换，不会分配内存，存储与程序的代码段中；
const常量需要进行内存分配，存储与程序的数据段中

定义域不同

    void f1 ()
{

    #define N 12
    const int n 12;
    
}

    void f2 ()
{
    cout<<N <<endl; //正确，N已经定义过，不受定义域限制
    cout<<n <<endl; //错误，n定义域只在f1函数中
}

定义后能否取消
宏定义可以通过#undef来使之前的宏定义失效
const常量定义后将在定义域内永久有效

void f1()
{
  #define N 12
  const int n = 12;
  
  #undef N //取消宏定义后，即使在f1函数中，N也无效了
  #define N 21//取消后可以重新定义
}

是否可以做函数参数
宏定义不能作为参数传递给函数
const常量可以在函数的参数列表中出现

49.哪些函数不能声明虚函数

**普通函数（非成员函数）：**我在前面多态这篇博客里讲到，定义虚函数的主要目的是为了重写达到多态，所以普通函数声明为虚函数没有意义，因此编译器在编译时就绑定了它。

**静态成员函数：**静态成员函数对于每个类都只有一份代码，所有对象都可以共享这份代码，他不归某一个对象所有，所以它也没有动态绑定的必要。

**内联成员函数：**内联函数本就是为了减少函数调用的代价，所以在代码中直接展开。但虚函数一定要创建虚函数表，这两者不可能统一。另外，内联函数在编译时被展开，而虚函数在运行时才动态绑定。

**构造函数：**这个原因很简单，主要从语义上考虑。因为构造函数本来是为了初始化对象成员才产生的，然而虚函数的目的是为了在完全不了解细节的情况下也能正确处理对象，两者根本不能“ 好好相处 ”。因为虚函数要对不同类型的对象产生不同的动作，如果将构造函数定义成虚函数，那么对象都没有产生，怎么完成想要的动作？？

**友元函数：**当我们把一个函数声明为一个类的友元函数时，它只是一个可以访问类内成员的普通函数，并不是这个类的成员函数，自然也不能在自己的类内将它声明为虚函数。

注意：友元本身可以是虚函数！！
如果一个类的友元函数是另一个类成员函数，那么它在自己的类内可以被声明为虚函数。

50. stl容器

https://blog.csdn.net/baidu_37964071/article/details/81410658
序列式容器
list、vector和deque的区别
https://blog.csdn.net/gogokongyin/article/details/51178378
关联式容器
set map mutiset mutimap

容器适配器
基于deque的顺序容器适配器stack、queue、priority_queue

51. c++11的新特性

https://blog.csdn.net/jiange_zh/article/details/79356417

52.