使用pthread中的条件变量和锁，构建了一个可以模拟死锁的脚本，能实现每个线程按顺序执行，从而形成固定死锁场景，方便测试死锁算法性能，代码如下：
1 | #include <stdio.h> |
上面的代码实现的效果为，首先形成一个长依赖路径，路径上的每个事务都更新自己的数据行，例如第一个事务更新第一行数据，第二个事务更新第二行数据，第RING_TRANS_NUM个事务更新第RING_TRANS_NUM行数据，此时通知第一个事务所在的线程去更新第二行数据，第二个事务去更新第三行数据，直到第RING_TRANS_NUM - 1个事务更新第RING_TRANS_NUM行数据。这样就形成了长依赖路径。
然后添加其他依赖，这些依赖依附于上述长依赖路径，本程序中设置其他依赖都更新第二行数据。当这些其他依赖都执行完事务语句时，通知第RING_TRANS_NUM个事务所在的线程去更新第一行数据，最终形成了死锁环。
首先介绍以下几个术语：
推荐使用 github flow 的工作模式，即不在主仓库的分支上开发，而是首先 fork 到自己的 workspace 下。每次开发，首先 checkout 一个分支，开发后 commit，并 push 到自己的仓库内，再向主仓库提 MR。
一般主仓库是组长建立的，保存着所有人开发的代码，为了防止污染导致数据丢失问题，剩下的小组成员需要对主仓库进行 fork，即将其拷贝一份到自己账户下，这样之后的开发工作就可以从自己的仓库开始。
接下来从自己的仓库进行clone。需要注意的是，一般一个仓库都有多个分支，比如有 master 主分支和 develop 分支，所以 clone 时要找到对应的分支，例如要克隆 develop 分支，使用的命令如下：
git clone -b develop ssh链接
命令中 ssh 链接需要填写自己仓库下的 ssh 链接。
在项目的根目录重新打开 git bash，首先输入 git remote -v 来查看现有的仓库
其中的 origin 表示是自己的远程仓库名称，一个用来 fetch，一个用来 push。接下来需要将组长的主仓库添加进来，使用的命令为：
git remote add upstream 主仓库ssh链接
其中upstream是给主仓库起的名字，这个名字可以是任意的。再次查看当前的远程仓库：
由于主仓库是合并开发，因此其代码进度是最快的，在每次开发前，都需要从主仓库拉取最新的代码，例如要从主仓库拉取 develop 分支的最新代码。这里有两种方式，第一种是使用 git fetch + git merge 的组合方式，好处是可以在 fetch 后查看更新，从而在 merge 的时候更方便的解决潜在的代码冲突；第二种方式是使用 git pull，它会立即拉取远程仓库的更新，并且直接合并到你的本地分支，这种情况下会导致合并后的代码产生大量冲突，解决起来很麻烦。因此推荐使用第一种组合方式。使用的命令为：
git fetch upstream develop
由于我们之前已经在本地拉取了 develop 分支，因此上面的 git fetch 命令是不创建本地新分支的方式，然后使用如下代码查看版本的差异
git log -p develop..upstream/develop
或者
git diff develop
然后使用如下代码进行合并
git merge upstream/develop
需要注意的是，合并过程中可能出现冲突的情况，我们可以对冲突的文件进行编辑。冲突的产生是多个用户同时修改了同一个文件的相同区域的内容。具体会发生冲突的情况和解决方法可以查看git中发生冲突的原因和解决方案。
通过输入 git branch 可以查看当前处于哪个分支；输入 git branch -a 可以查看所有的本地分支和远程分支；以及可以输入 git status 来查看当前分支和分支的状态。
有了最新的代码，就可以开始着手写代码了。但是需要注意，不要直接在本地的develop分支上直接写，而是要新建一个分支，使用如下命令：
git checkout -b check # (分支名称，随意)
这样我们就新建了一个check分支，且直接切换到其上，上面的代码其实做了两件事：
git branch check # 新建 check 分支
git checkout check # 切换到 check 分支上
当你想提交代码时，始终要记得，主仓库内的代码可能还是比你的进展要更快，因此你还需要到主仓库中拉取最新的代码，这里需要你先把当前的进度 commit 到本地暂存区，或者使用 git stash，将代码贮藏来保管当前的进度。使用的命令为：
git stash save "save message"
然后切换到 develop 分支上，还是使用 git fetch 和 git merge 去拉取合并最新的代码。贮藏的代码实际上被储存在一个栈上，越晚贮藏的越接近栈顶，可以使用如下代码查看栈中贮藏的信息：
git stash list
可以看到有三个贮藏，使用如下命令可以将栈顶的贮藏重新应用
git stash apply
如果想应用其中一个更早的贮藏，可以通过名字来指定
git stash apply stash@{2}
如上的命令只会尝试应用贮藏的工作，意味着堆栈上还有它，可以使用如下命令将贮藏从堆栈上移除：
git stash drop stash@{2}
或者可以使用如下代码来应用栈顶的贮藏，并且将其从栈顶弹出
git stash pop
最后记得要将 check 分支合并到本地的 develop 分支上，之后的操作都要在 develop 上进行。使用的命令如下：
git checkout develop
git merge check
接下来要将代码提交到本地仓库，首先查看代码的状态
git diff # 可以查看到这次的改动内容，按 q 退出
然后使用跟踪所有的文件
git add .
随后提交到暂存区
git commit -m "add a new txt file"
随后就可以推送到自己的远程仓库
git push origin HEAD:分支名称
这里的 HEAD 指的是当前分支，冒号后面指的是要 push 的分支，如果远程仓库没有，则会自动创建该分支
在自己的远程仓库内，可以向主仓库提交分支合并请求，一般是自己的 develop 分支合并到主仓库的 develop 分支，如下时 gitlab 的示例：
、
接下来可以增加这次合并请求的描述，加 title 和 description等，之后就可以 submit 提交。
分支合并请求通过后，可以选择将本地的 check 分支删除
git branch -d check
如果有项目伙伴因需求更改了项目文件名称或是一些文件夹的名称，需要告知所有在工作中的伙伴停下手中的工作，等待文件名称修改后，push到仓库后，其他伙伴再拉新的代码，再进行工作。
1.关系型数据库：指用关系模型来组织数据信息的数据库
关系模型指的是二维表格模型，而一个关系型数据库便是由二维表以及表之间的关系所构成的一个数据集合。
2.关系型数据库的优势：
4.非关系型数据库概念介绍
非关系型数据库：指非关系型的，分布式系统的，且一般不确保遵照ACID标准的数据储存系统。
非关系型数据库算是一种数据结构化储存的集合，可以是文档或键值对等。
5.非关系型数据库的类型：
1.连接器：建立连接，管理连接、校验用户身份；
2.查询缓存：查询语句如果命中查询缓存则直接返回，否则继续往下执行。MySQL 8.0 已删除该模块；
3.解析 SQL，通过解析器对 SQL 查询语句进行词法分析、语法分析，然后构建语法树，方便后续模块读取表名、字段、语句类型；
4.执行 SQL：执行 SQL 共有三个阶段：
1.MyISAM，B+Tree叶节点的data域存放的是数据记录的地址，在索引检索的时候，首先按照B+Tree搜索算法搜索索引，如果指定的key存在，则取出其data域的值，然后以data域的值为地址读取相应的数据记录，这被称为“非聚簇索引”
2.InnoDB，其数据文件本身就是索引文件，相比MyISAM，索引文件和数据文件是分离的，其表数据文件本身就是按B+Tree组织的一个索引结构，树的节点data域保存了完整的数据记录，这个索引的key是数据表的主键，因此InnoDB表数据文件本身就是主索引，这被称为“聚簇索引”或者聚集索引，而其余的索引都作为辅助索引，辅助索引的data域存储相应记录主键的值而不是地址，这也是和MyISAM不同的地方。
在根据主索引搜索时，直接找到key所在的节点即可取出数据；在根据辅助索引查找时，则需要先取出主键的值，再走一遍主索引。因此，在设计表的时候，不建议使用过长的字段为主键，也不建议使用非单调的字段作为主键，这样会造成主索引频繁分裂。
如果表使用自增主键，那么每次插入新的记录，记录就会顺序添加到当前索引节点的后续位置，当一页写满，就会自动开辟一个新的页。 如果使用非自增主键（如果身份证号或学号等），由于每次插入主键的值近似于随机，因此每次新纪录都要被插到现有索引页得中间某个位置， 频繁的移动、分页操作造成了大量的碎片，得到了不够紧凑的索引结构，后续不得不通过OPTIMIZE TABLE（optimize table）来重建表并优化填充页面。
1.服务层包括连接器、查询缓存、分析器、优化器、执行器等
2.存储引擎层负责数据的存储和提取
Drop、Delete、Truncate都表示删除，但是三者有一些差别： Delete用来删除表的全部或者一部分数据行，执行delete之后，用户需要提交(commmit)或者回滚(rollback)来执行删除或者撤销删除，会触发这个表上所有的delete触发器。 Truncate删除表中的所有数据，这个操作不能回滚，也不会触发这个表上的触发器，TRUNCATE比delete更快，占用的空间更小。 Drop命令从数据库中删除表，所有的数据行，索引和权限也会被删除，所有的DML触发器也不会被触发，这个命令也不能回滚。
因此，在不再需要一张表的时候，用Drop；在想删除部分数据行时候，用Delete；在保留表而删除所有数据的时候用Truncate。
1.文件与数据库都是需要较大的存储，也就是说，它们都不可能全部存储在内存中，故需要存储到磁盘上。而所谓索引，则为了数据的快速定位与查找，那么索引的结构组织要尽量减少查找过程中磁盘I/O的存取次数，因此B+树相比B树更为合适。数据库系统巧妙利用了局部性原理与磁盘预读原理，将一个节点的大小设为等于一个页，这样每个节点只需要一次I/O就可以完全载入
2.最重要的是，B+树还有一个最大的好处：方便扫库。B树必须用中序遍历的方法按序扫库，而B+树直接从叶子结点挨个扫一遍就完了，B+树支持range-query非常方便，而B树不支持，这是数据库选用B+树的最主要原因。
3.B+tree的磁盘读写代价更低：B+tree的内部结点并没有指向关键字具体信息的指针(红色部分)，因此其内部结点相对B树更小。如果把所有同一内部结点的关键字存放在同一块盘中，那么盘块所能容纳的关键字数量也越多。一次性读入内存中的需要查找的关键字也就越多，相对来说IO读写次数也就降低了
通过分表，可以减少数据库的单表负担，将压力分散到不同的表上，同时因为不同的表上的数据量少了，起到提高查询性能，缩短查询时间的作用
1.对索引使用左或者左右模糊匹配：因为B+树是按照索引值有序排列的，只能根据前缀进行比较
2.对索引使用函数：不过可以针对函数计算后的值建立一个索引，从而使得该索引的值是函数计算后的值，就可以通过扫描索引来查询数据
3.对索引使用表达式计算
4.对索引隐式类型转换
5.联合索引非最左匹配
6.WHEREA子句中的OR
事务即为数据库的操作序列，要么完全执行，要么完全不执行。满足ACID属性。
A:原子性：要么全做，要么全不做
C：一致性：即事务操作前后满足完整性约束，比如A给B转账，完成后，A的少了200元，B的多了200元
I：隔离性：事务可以是并发的，隔离性可以保证多个事务并发执行由于使用相同的数据而互不干扰。每个事务都有自己的数据空间。
D：持久性：事务完成后，对数据的修改是永久的，即使系统故障也不会丢失。
事务的操作：开启事务，回滚，提交。其中回滚在数据没有提交之前可以回滚到之前的版本。
1.脏读：一个事务读到了另一个未提交事务修改过的数据（因为此时第二个事务有可能发生回滚操作）
2.不可重复读：在一个事务内多次读取同一个数据，出现了两次读到的数据不一样的情况（比如A在读一个数据时，B修改了这个数据，当A再次读这个数据时，读到的数据和上一次不一样）
3.幻读：在一个事务内多次查询某个符合查询条件的记录数量，前后两次记录数量不一样（比如数据增加或者被删除）
三者的严重程度：脏读 > 不可重复读 > 幻读
1.读未提交：一个事务还没提交时，其所做的变更就可以被其它事务看到（会发生脏读，不可重复读和幻读）
2.读提交：一个事务提交后，它所做的变更才能被其它事务看到（会发生不可重复读和幻读）
3.可重复读：一个事务执行过程中看到的数据，一直跟这个事务启动时看到的数据一样（InnoDB默认的隔离级别）（会发生幻读）
4.串行化：会对记录加上读写锁，后访问的事务必须等前面的事务处理完才能继续执行。
1.全局锁：使得整个数据库处于只读状态
2.表级锁：
1.实现数据恢复：redo log
redo log分为两部分：
2.undo log
和redo log类似，也分为内存缓冲区和磁盘的日志文件，但是undo log记录的是相反的语句，当事务需要回滚的时候，可以从undo log中找到相应的内容进行回滚操作。
3.二者的区别
为了保证数据的持久性，数据库在执行SQL操作数据之前会先记录redo log和undo log
redo log是重做日志，通常是物理日志，记录的是物理数据页的修改，它用来恢复提交后的物理数据页
undo log是回滚日志，用来回滚行记录到某个版本，undo log一般是逻辑日志，根据行的数据变化进行记录
redo/undo log都是写先写到日志缓冲区，再通过缓冲区写到磁盘日志文件中进行持久化保存
undo日志还有一个用途就是用来控制数据的多版本（MVCC）
http请求报文由请求行、请求头部、空行 和 请求包体 4 个部分组成，如下图所示：
GET：当客户端要从服务器中读取某个资源时，使用GET方法。
POST：当客户端给服务器提供信息较多时可以使用POST 方法，POST 方法向服务器提交数据，比如完成表单数据的提交，将数据提交给服务器处理。GET 一般用于获取/查询资源信息，POST 会附带用户数据，一般用于更新资源信息。
如果带参数时，在约定中，GET方法的参数应该放在URL中，POST方法参数应该放在请求体中。例如，如果参数是 name=Java, age = 25，那么GET方法的报文是这样的:
GET /updateInfo?name=JavA&age=25 HTTP/1.1
Host: localhost
POST方法的报文为：
POST /updateInfo HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
name=Javanx&age=25
如果不带参数，最大的区别就是二者请求行的方法名称不同而已。实际上两种方法都是基于TCP连接的，GET也可以有请求包体，POST也不一定要使用请求包体，只要客户端和服务端约定好规范即可。
HTTP响应报文由状态行、响应头部、空行和响应包体4个部分组成，如下图所示：
下面对响应报文格式进行简单的分析：
1.首先看浏览器缓存，若没有则看操作系统缓存，如果没有则去看host文件，如果没有则开始进行对服务器的询问
2.首先客户端询问本地DNS服务器，自己要查找的url的IP地址，如果本地服务器能找到缓存则返回，否则本地服务器会去询问根服务器，根服务器返回给它一个顶级域名服务器的地址；本地服务器会再去询问顶级域名服务器，后者会给它一个权威域名服务器地址，本地服务器再去询问，直到查询到自己要找的url的IP地址，并将其返回给客户端，客户端和目标建立连接
如果有多个网卡，即有多个源IP地址，我们需要判断使用哪个来发送IP数据报
1.根据目的IP地址，和本地路由表中的多个条目的子网掩码进行与运算，得到的结果和路由表中的目的IP地址进行比对，正确的就是我们要选择的网卡，
2。如果没有匹配的网卡，那么选择默认网关，其目标IP地址和子网掩码都是0.0.0.0
3.后续将数据包发送给路由器，路由表中的Gateway就表示路由器的IP地址，即源IP地址
1.阻止重复历史连接的初始化（主要原因）
如果是两步，那么服务端接收到之后就会建立连接，并向客户端发送数据，如果当前建立的连接并不是客户端需要的，那么就白白浪费了这次历史连接的建立，增加了开销。
2.同步双方的初始序列号：如果只有两次，那么服务端的序列号无法被确认，四次的话又可以压缩，所以是三次。
3.避免资源浪费：如果初始SYN发生了网络阻塞，客户端进行了超时重传，那么服务端由于不知道自己发送的SYN+ACK是否被接收到，只能再次建立连接。
初始序列号的产生：M + F
M是一个计时器，每隔4微秒 + 1，F是根据源 IP、目的 IP、源端口、目的端口生成一个随机数值。
如果一个 IP 分片丢失，整个 IP 报文的所有分片都得重传。
因为 IP 层本身没有超时重传机制，它由传输层的 TCP 来负责超时和重传。
经过 TCP 层分片后，如果一个 TCP 分片丢失后，进行重发时也是以 MSS 为单位，而不用重传所有的分片，大大增加了重传的效率
假设客户端没有 TIME_WAIT 状态，而是在发完最后一次回 ACK 报文就直接进入 CLOSE 状态，如果该 ACK 报文丢失了，服务端则重传的 FIN 报文，而这时客户端已经进入到关闭状态了，在收到服务端重传的 FIN 报文后，就会回 RST 报文。
服务端收到这个 RST 并将其解释为一个错误（Connection reset by peer），这对于一个可靠的协议来说不是一个优雅的终止方式。
为了防止这种情况出现，客户端必须等待足够长的时间，确保服务端能够收到 ACK，如果服务端没有收到 ACK，那么就会触发 TCP 重传机制，服务端会重新发送一个 FIN，这样一去一来刚好两个 MSL 的时间。
客户端在收到服务端重传的 FIN 报文时，TIME_WAIT 状态的等待时间，会重置回 2MSL。
因为虽然此时服务端收到了客户端断开连接的请求，此时需要通知进程调用close和shutdown函数来断开连接，而此时可能应用层还有别的任务需要处理，所以需要一个中间状态，然后等调用close或者shutdown函数后，服务端才会变为last_ack状态
1.超时重传：数据包丢失和确认应答丢失
其机制是每一次重传时间增加一倍
2.快速重传：数据驱动，三次同样的ACK就会触发，但是并不知道所需要的ACK后面的需不需要重传
3.SACK：选择性确认，三次同样的ACK触发，TCP头部保存已经收到的数据段信息，只选择没有接收到的数据段重新发送。
4.D-SACK：告知发送方有哪些数据被重复接收了（例如ACK丢失和网络延时），会同时包括ACK和SACK两种，其中ACK表示需要的下一个包序列，SACK表示重复接收到的包，不需要再进行发送
1.概念：无需等待确认应答，而可以继续发送数据的最大值。窗口大小一般由接收方告诉发送方
2.发送窗口中分为两部分，一部分是已经发送但是还没有收到ACK的窗口大小，一部分是还没有发送的可用的发送部分，每当接收到一些ACK之后，窗口就可以向右滑动来增加可用部分
3.接收窗口表示未接收到但可以接收的数据，每次接收到数据后，窗口就可以向右滑动
涉及到的部分是流量控制：发送窗口和接收窗口所存放的数据都是放在系统内存缓冲区的，会在数据传输的过程中不断被系统调整
丢弃连接是Linux内核的默认行为，我们可以通过设置参数tcp_abort_on_overflow的值来修改他的行为
通常情况下，应该将该值设置为0，来应对突发的流量，因为可能过一段时间后，全连接队列就能空出位置来接收客户端重新发送的ack，二者还能够成功建立连接
因为服务端收到客户端的FIN报文时，马上会回复一个ACK报文，但是服务端应用程序可能还有数据要发送，所以并不能马上发送FIN报文，而是将该权限交给应用程序
如果服务端没有数据要发送而且开启了TCP延迟确认的情况，那么第二次挥手和第三次挥手就会合并成一次。
TCP延迟确认的规则：
accept最终返回是从全连接队列中取出一个元素，在前面的过程中实际上已经构建了连接
全连接队列和半连接队列是在服务点listen阶段内核创建的，其中全连接队列是链表，半连接队列是哈希表
没有listen的情况下也可以建立连接，比如两个客户端产生连接或者客户端和自己建立连接，这是因为内核有一个全局的hash表，可以用来存放客户端的连接信息，当消息发出后，经过回环地址重新回来以后，从hash表中取出连接信息，建立连接。
1.如果进程崩溃，那么内核会发送FIN，和另一端进行四次挥手断开连接
2.如果客户端宕机且没有重启，不会发生四次挥手：
实际上拔掉网线不会影响TCP四元组的信息，其连接状态还是存在
1.如果有数据传输
原型：size_t strlen(const char *str)，计算字符串的长度
int my_strlen(const char *str){
int count = 0;
assert(str != nullptr);
while(*str != '\0'){
count++;
str++;
}
return count;
}
原型：char *strcpy(char *dest, const char *src)，将src指向的字符串复制到dest中
char *my_strcpy(char *str_des, const char *str_source){
assert(str_des != nullptr);
assert(str_source != nullptr);
char *ret = str_des;
while((*str_des++ = *str_source++) != '\0'){
;
}
return ret;
}
原型：char *strcat(char *dest, const char *src)，将src指向的字符串追加到dest指向的字符串结尾。
char *my_strcat(char *str_des, const char *str_source){
assert(str_des != nullptr);
assert(str_source != nullptr);
char *ret = str_des;
while(*str_des){
str_des++;
}
while((*str_des++ = *str_source++) != '\0'){
;
}
return ret;
}
原型：int strcmp(const char *str1, const char *str2)，把str1指向的字符串和str2指向的字符串进行比较，小于返回一个小于零的值，大于返回一个大于零的值，相等返回0
int my_strcmp(const char *str1, const char *str2){
while(*str1 && *str2){
if(*str1 == *str2){
str1++;
str2++;
}
else if(*str1 > *str2)return -1;
else return 1;
}
if(*str1)return 1;
if(*str2)return -1;
return 0;
}
原型：char *strchr(const char *str, int c)，在参数str所指向的字符串中搜索第一次出现字符c的位置，如果未找到返回NULL
char *my_strchr(const char *str, char c){
while(*str++ != '\0'){
if(*str == c)return str;
}
return NULL;
}
原型：char *strstr(const char *haystack, const char *needle)，在字符串haystack中查找第一次出现字符串needle的位置，不包括终止符’\0’
char *my_strstr(char *str1, char *str2){
const char *index1;
const char *index2;
if(!str1 || !str2)return str1;
//遍历str1字符串
while(*str1){
index1 = str1;
index2 = str2;
do{
if(!*index2)return str1;
}while(*index1++ == *index2++);
str1++;
}
return NULL;
}
面试中如果要求实现一个shared_ptr，我们可以从最简单的结构写起：
template<class T>
class my_shared_ptr{
private:
T* m_ptr = nullptr;
unsigned int * m_ref_count = nullptr;
//默认构造函数
public:
my_shared_ptr(): m_ptr(nullptr), m_ref_count(nullptr){ }
my_shared_ptr(T* ptr): m_ptr(ptr), m_ref_count(new unsigned int(1)){ }
};
1.为什么m_ref_count这个引用计数要用指针来表示？
因为shared_ptr会被复制来复制去的，对于同一个被引用的对象，其引用计数需要同时更新和共享，使用指针的话就会比较方便。
2.shared_ptr的引用计数是线程安全的吗？
在其源代码中，是线程安全的，因为最后使用了_Atomic_word类型来计数，表明其是一个原子操作，保证了线程安全。
3.shared_ptr储存的指针是线程安全的吗？
并不是，源代码中指针类型是element_type*，其为用户使用时自定义的指针类型，没有保证原子操作。
//拷贝构造函数
my_shared_ptr(const my_shared_ptr & obj){
m_ptr = obj.m_ptr;
m_ref_count = obj.m_ref_count;
if(m_ref_count != nullptr){
(*m_ref_count)++;
}
}
//拷贝重载=运算符
my_shared_ptr& operator=(const my_shared_ptr & obj){
if(obj.m_ptr == m_ptr){
return *this;
}
//先处理原有的指针和引用计数
if(m_ref_count != nullptr){
(*m_ref_count)--;
if(*m_ref_count == 0){
delete m_ptr;
delete m_ref_count;
}
}
m_ptr = obj.m_ptr;
m_ref_count = obj.m_ref_count;
if(m_ref_count != nullptr){
(*m_ref_count)++;
}
return *this;
}
1.为什么拷贝构造的参数是const my_shared_ptr&，而不是const my_shared_ptr
因为我们写的是拷贝构造函数，如果参数为后者，相当于要调用一次拷贝构造，就会无限递归下去。
2.为什么重载=运算符的返回值是my_shared_ptr&，能不能返回void
理论上是可以的，但是为了支持连等a = b = c，还是要返回my_shared_ptr&
//移动语义
//移动构造
my_shared_ptr(my_shared_ptr && dying_obj): m_ptr(nullptr), m_ref_count(nullptr){
//初始化后交换指针和引用计数，相当于清除了dying_obj的内容
dying_obj.swap(*this);
}
//移动赋值
my_shared_ptr & operator=(my_shared_ptr && dying_obj){
//my_shared_ptr(std::move(dying_obj))用移动构造函数创建出一个新的shared_ptr(此时原shared_ptr的内容被清除了)
//再和this交换指针和引用计数
//因为this的内容被交换到了当前的临时创建的my_shared_ptr里，原this指向的引用计数-1
my_shared_ptr(std::move(dying_obj)).swap(*this);
return *this;
}
void swap(my_shared_ptr & other){
std::swap(m_ptr, other.m_ptr);
std::swap(m_ref_count, other.m_ref_count);
}
指针相关的运算符重载和获取引用计数的函数
//重载指针运算符
T* operator->() const{
return m_ptr;
}
//重载解引用运算符
T* operator*() const{
return *m_ptr;
}
T* get() const{
return m_ptr;
}
unsigned int use_count() const{
return *m_ref_count;
}
//析构函数
~my_shared_ptr(){
if(m_ref_count == nullptr){
return;
}
(*m_ref_count)--;
if(*m_ref_count > 0){
return;
}
if(m_ptr != nullptr){
delete m_ptr;
}
delete m_ref_count;
}
1.为什么会推荐使用std::make_shared，而不是直接构造std::shared_ptr
如果直接构造shared_ptr，那么是先分配一块内存给实例化对象，再分配一块内存给引用计数模块（引用计数，删除器等），但是std::make_shared可以一次性分配一整块内存给引用计数模块和实例化对象，这样有两部分优点：
优点一：异常安全
在C++17之前，在某种情况下构造一个std::shared_ptr不一定是安全的，看下面的案例：
void F(const std::shared_ptr
F(std::shared_ptr
std::shared_ptr
一个可能的执行顺序是
1.new Lhs("foo")
2.new Rhs("bar")
3.std::shared_ptr<Lhs>
4.std::shared_ptr<Rhs>
假设在第2步出现了一个异常（比如内存耗尽或者构造函数的异常），那么第一步分配的内存地址就没有保存在任何地方，所以这块内存永远回收不了，导致内存泄露。使用std::make_shared就可以避免这种问题。
2.有没有什么情况下没法使用std::make_shared
有时候我们把构造函数定义为私有，就可以强制用户使用工厂模式A::Create创建shared_ptr，这样可以避免用户直接创建实例或者使用生指针进而管理不善导致内存泄漏。
#include <iostream>
#include <memory>
class A
{
public:
static std::shared_ptr<A> Create(){ return std::shared_ptr<A>(new A(100)); }
int GetId(){ return m_i; }
private:
int m_i;
A(int i): m_i(i){std::cout<<"private ctor called"<<std::endl;};
};
int main()
{
std::shared_ptr<A> s_ptr = A::Create();
std::cout<<s_ptr->GetId()<<std::endl;
//A * p = new A(300); //make_shared无法访问私有构造函数
return 0;
}
在这种情况下，std::make_shared进行placement new操作的时候，会直接调用构造函数，但因为我们的构造函数都是私有的，这时候就会报错。而我们在工厂模式里直接new出来的实例是通过成员函数new操作符operator new访问的私有构造函数，所以没有问题。
1.Linux 中一个进程的虚拟内存分布长什么样？内核空间+用户空间（6 种不同的内存段）
代码段：存放程序代码，运行前就已经确定（编译时确定）
常量区：存放const定义的全局变量，define定义的常量和字符串常量等
数据段：存放已经初始化的全局变量
bss段：存放没有初始化的全局变量或默认为0的全局变量，执行期间会将这一段的内容全部设为0
栈：存放函数参数和局部变量，由系统进行申请和释放，空间较小，先进先出
堆：存放动态分配的内存，由用户自己申请和释放（比如malloc和free）
2.为什么要使用虚拟内存
如果没有虚拟地址，cpu访问的都是真实的物理地址，那么会产生：程序直接访问真实内存，没有顺序没有规则，很容易导致错误的产生，并且无法同时运行多个程序。
有了虚拟地址以后：
Linux将中断问题分为上下两部分
如果有多个CPU核心操作缓存数据，按照写回原则，则会出错，因为当没有发生缓存不命中且对应数据为脏时，缓存中的数据不会写回到内存中，此时其他核心从内存中读取的数据就是错的。为了解决，需要写传播和事务的串行化
1.brk()函数从堆申请内存，具体为将指针从堆的低地址向高地址移动，小于128KB
2.mmap()函数从文件映射区分配内存，大于128KB
malloc分配的是虚拟地址，如果该虚拟地址没有被访问，则不会映射到真实物理地址，如果操作系统访问虚拟地址，通过页表查询发现虚拟地址对应的页没有在物理内存中，就会发生缺页中断，然后才会建立虚拟地址和物理内存之间的映射
不能都使用mmap函数，因为其会发生运行态的切换，而且mmap申请的内存总是会被释放掉，从而每次访问都会缺页中断，导致CPU消耗过大
也不能都使用brk函数，因为其堆指针连续向上增长，会产生内存碎片问题，导致内存泄露
1.如果是malloc使用brk()函数申请的内存，则不会释放掉
2.如果是mmap()函数申请的内存，则会释放掉
其中malloc返回给用户的数据会有一个16字节的信息头，其中保存了该内存块的大小，这样free释放的时候就知道要释放多大的内存块了
应用程序通过 malloc 函数申请内存的时候，实际上申请的是虚拟内存，此时并不会分配物理内存。当应用程序读写了这块虚拟内存，CPU 就会去访问这个虚拟内存， 这时会发现这个虚拟内存没有映射到物理内存，CPU 就会产生缺页中断，进程会从用户态切换到内核态，并将缺页中断交给内核的缺页中断函数处理。缺页中断处理函数会看是否有空闲的物理内存，如果有，就直接分配物理内存，并建立虚拟内存与物理内存之间的映射关系。
如果没有空闲的物理内存，那么内核就会开始进行回收内存的工作，回收的方式主要是两种：直接内存回收和后台内存回收。
1.先来先服务
2.最短作业：优先选择运行时间最短的
3.高响应比优先调度算法：等待时间 + 要求服务时间/ 要求服务时间（无法实现）
4.时间片轮转算法：每个进程被分配一个时间片
5.最高优先级调度算法：静态和动态优先级
6.多级反馈队列：多个队列，每个队列优先级从高到低，新来的任务先加入第一级的队尾，按照先来先服务运行，如果没有运行完则加入第二级的队尾，如果来了一个优先级高的，则先去运行优先级高的任务队列，此时将原任务加入当前队列的队尾
1.匿名管道：通过fork父进程的文件描述符来建立连接，先进先出
2.命名管道：在不相关的进程间也能进行通信，其创建了一个类型为管道的设备文件
3.消息队列：在内核中，不适合比较大的文件传输，同时会带来用户态与内核态之间的数据拷贝开销
4.共享内存：一个虚拟内存，映射到同一块真实物理内存
5.信号量：P操作-1，如果小于0，则阻塞 V操作：如果小于等于0则有进程阻塞，唤醒它，如果大于0，则没有进程阻塞
1.死锁的四个条件
2.如何避免
1.互斥锁：获取不到资源时，将CPU释放，去执行其他进程
2.自旋锁：获取不到资源时，线程会忙等待，直到拿到锁
3.读写锁：当写锁没有被线程持有，那么多个线程可以持有读锁，如果线程持有了读锁，那么其他线程的读锁和写锁都会被阻塞
1.先进先出：选择在内存中保留时间最长的页面
2.最近最久未使用：LRU
3.最不常用：选择访问次数最少的
4.时钟页面：所有页面保存在环形列表中，表针指向最老的页面，如果发生缺页就检查访问位置：如果是0则淘汰，并插入当前页面，如果是1，则置为0，表针向前一个走
1.首次适应算法：空闲分区以地址递增的次序排列，每次都从低地址开始查找空闲分区链或者空闲分区表，找到第一个能满足大小的空闲分区。
2.最佳适应算法：空闲分区按容量递增次序链接，每次分配内存时按顺序查找空闲分区表，找到大小能满足要求的第一个空闲分区。
3.最坏适应算法：空闲分区按容量递减次序链接，每次分配内存时按顺序查找空闲分区表，找到大小能满足要求的第一个空闲分区。
4.邻近适应算法：空闲分区以地址递增的顺序排列（可排成一个循环链表），每次分配内存时从上次查找结束的位置开始查找空闲分区链，找到大小能满足要求的第一个空闲分区。
1.静态链接：函数和数据被编译进一个二进制文件，链接时，链接器从库中复制这些函数和数据，并把他们和应用程序的其他模块组合起来创建最终的可执行文件。
问题描述：允许多个进程同时对数据进行读操作，但是不允许读和写以及写和写操作同时发生。
一个整型变量 count 记录在对数据进行读操作的进程数量，一个互斥量 count_mutex 用于对 count 加锁，一个互斥量 data_mutex 用于对读写的数据加锁。
typedef int semaphore;
semaphore count_mutex = 1;
semaphore data_mutex = 1;
int count = 0;
void reader() {
while(TRUE) {
down(&count_mutex);
count++;
if(count == 1) down(&data_mutex); // 第一个读者需要对数据进行加锁，防止写进程访问
up(&count_mutex);
read();
down(&count_mutex);
count--;
if(count == 0) up(&data_mutex);//最后一个读者要对数据进行解锁，防止写进程无法访问
up(&count_mutex);
}
}
void writer() {
while(TRUE) {
down(&data_mutex);
write();
up(&data_mutex);
}
}
1.中断是硬件产生的，通过中断控制器发给CPU，CPU判断其来自哪个硬件设备，最后发送给内核，由内核进行处理
2.异常由CPU产生，例如缺页异常；当运行除法程序时，当除数为0时，又会产生除0异常等。其会发送给内核，由内核来进行异常处理。
1.用户态：用户可以操作和访问的空间，这个空间通常存放我们用户自己的数据等
2.内核态：是系统内核来操作的一块空间，用来存放系统内核的函数，接口等
3.二者之间的最大区别就是特权级不同：用户态拥有最低的特权级，内核态拥有较高的特权级
4.为什么要分为内核态和用户态：为了安全性。在CPU的一些指令中，有些指令如果用错，将导致整个系统崩溃。分开之后，如果用户需要某些操作，内核为其提供了API，可以通过系统调用陷入内核，让内核去执行操作。
5.什么样的功能应该在内核态下实现：
1.系统调用：其机制核心还是通过操作系统为用户特别开放的一个中断来实现，表现为一个正常的异常（软中断）。
1.应用程序使用malloc申请的内存实际上是虚拟内存，此时并不会分配物理内存，只有当应用程序读取了虚拟内存，CPU会去访问这块虚拟内存，发现并没有映射到物理内存上，CPU就会产生缺页中断，用户态切换到内核态，由缺页中断处理函数去处理
1.内存不足：当系统需要的内存超过了可用的物理内存时，内核会将内存中不常使用的内存页交换到磁盘上为当前进程让出内存，保证正在执行的进程的可用性，这个内存回收的过程是强制的直接内存回收（Direct Page Reclaim）。直接内存回收是同步的过程，会阻塞当前申请内存的进程。
2.内存闲置：应用程序在启动阶段使用的大量内存在启动后往往都不会使用，通过后台运行的守护进程（kSwapd），我们可以将这部分只使用一次的内存交换到磁盘上为其他内存的申请预留空间。kSwapd 是后台进程，所以回收内存的过程是异步的，不会阻塞当前申请内存的进程。
1.用户态的轻量级线程，是线程内部调度的基本单位，只在用户态内进行切换
2.先将寄存器上下文和栈保存，等切换回来的时候再进行恢复
3.同一时间只能执行一个协程，而其他协程处于休眠状态，适合对任务进行分时处理
4.基本没有到内核态切换的开销，可以不加锁的访问全局变量，所以上下文切换的非常快
5.其通信方式是共享队列和消息队列
32位系统下，一个页大小是4KB，虚拟地址4GB，那么可以分为100万个页，一个页表项4B，那么4B * 2 * 2^20 = 4MB，这对应的是一个进程，而多个进程就会有多个页表，导致页表会及其庞大
32位系统两级分页就足够了，64位的系统是4级分页
一方面，有了中断功能，PC系统就可以使CPU和外设同时工作，使系统可以及时地响应外部事件。而且有了中断功能，CPU可允许多个外设同时工作。这样就大大提高了CPU的利用率，也提高了数据输入、输出的速度。 另一方面，有了中断功能，就可以使CPU及时处理各种软硬件故障。计算机在运行过程中，往往会出现事先预料不到的情况或出现一些故障，如电源掉电、存储出错，运算溢出等等。计算机可以利用中断系统自行处理，而不必停机或报告工作人员。
1.存储结构：Cache Line组成，包括头标记和数据块，每次载入数据都是按照Cache Line整个读取
2.访问和存储：索引 + 有效位 + 组标记 + 偏移量，访问步骤如下：
1.如果两个变量属于同一个Cache Line块，而恰好两个CPU核心需要分别修改这两个变量，则会发生Cache Line没有起到缓存的作用，降低了代码执行的速度
2.避免伪共享的方法
将变量设置为内存对齐，用空间换取时间
1.三个运行队列：
Linux 将中断处理程序分为上半部和下半部：
上半部，对应硬中断，由硬件触发中断，用来快速处理中断；
下半部，对应软中断，由内核触发中断，用来异步处理上半部未完成的工作，Linux 中的软中断包括网络收发、定时、调度、RCU 锁等各种类型
1.切换内容：用户空间的虚拟内存，栈，全局变量等；内核空间的堆栈、寄存器等
2.何时发生切换：CPU时间片用完；内存不足，则进程也会被挂起，当有优先级更高的进程运行，当前进程也会被挂起；发生硬件中断的时候也会发生进程的切换
互斥锁加锁失败会发生线程的上下文切换，需要消耗一定的时间，自旋锁是用户态完成加锁和解锁操作，不会主动产生线程上下文切换，运行时间更快，自旋锁通过 CPU 提供的 CAS 函数实现，包含两个步骤：
1.ping发送一个ICMP（Internet Control Messages Protocol），即因特网信报控制协议；接收端回声消息给目的地并报告是否收到所希望的应答。它的原理是：利用网络上机器IP地址的唯一性，给目标IP地址发送一个数据包，通过对方回复的数据包来确定两台网络机器是否连接相通，时延是多少。
2.ping是应用层直接使用网络层ICMP的一个例子，它没有通过运输层的TCP或UDP。所以ICMP属于网络层协议。
3.对于ping命令，我们需要的到达的效果是检查是否联通。那么只需要我们的请求方带上数字标识8（回送请求），如果对方回送的数值是0，那么证明两者是联通的。
4.一个例子：
1.版本：4位，表示是IPV4还是IPV6
2.首部长度：默认20B
3.总长度：首部+数据和的长度，最大65535B，而MTU为1500B
4.标识：用于分片后进行重装
5.标志：MF = 1表示后面还有分片，MF = 0表示是最后一个分片，DF = 0表示允许分片
6.TTL：生存时间，报文经过每个路由器都将减一，当为0时，丢弃该报文
7.协议：6表示TCP，17表示UDP
8.首部校验和：只检验数据报首部
9.源地址和目的地址
用epoll + ET模式读取数据，当检查到监听的socket可以读取数据时，使用recv函数读取上面的数据，当该函数返回-1且errno是EAGAIN或EWOULDBLOCK的时候，表示数据已经全部读取完毕。
这里我使用通过epoll_ctl对该文件描述符注册epolloneshot事件，一个线程处理socket时，其他线程将无法处理，当该线程处理完后，需要通过epoll_ctl重置epolloneshot事件
1.http 1.1中定义了断点续传的相关Range和Content-Range字段。
指针内部保存的是指向的对象的地址信息，而引用是变量的别名；
指针可以随时初始化，而引用被定义之后就要初始化，不可以为空
sizeof引用是被引用的对象的大小，而sizeof指针是指针类型的大小
指针既有顶层const（指针本身不能变），也有底层const（指针指向的对象不能变），而引用只有底层const，顶层const是无意义的。
二者的++操作不同，指针++表示指针运算，而引用++表示变量执行++。
引用只是C++的语法糖，可以看作是自动取地址解引用的常量指针。在汇编层面是一样的。
默认的（继承）访问权限，class是private，struct默认是public
class可以实现模板类，而struct不可以
struct是值类型，而class是引用类型
为了使代码重用性增加，使得代码可以模块化
静态多态：通过重载函数和泛型编程实现，通过基类指针指向的对象不同而调用不同的函数。是在编译器就完成的，编译器根据实参类型来确定。具有更好的类型安全性，因为编译阶段会对所有的绑定类型进行检查。
动态多态：通过虚函数和继承实现，运行时确定。虚函数表保存在只读数据段，编译器将类对象的前四个字节设置为指向虚函数表的指针。
面向对象的三大特征：封装、继承、多态。封装：将客观事物进行抽象，将其属性和方法合成为一个类，类封装了成员变量和成员函数，同时又实现对属性和方法的权限控制，降低与外界的耦合度 继承：子类继承父类的各种属性和方法，同时子类还可以在父类的基础上重新定义和扩展父类的属性和方法，使其具有不同的功能，继承提高了代码的复用性及可维护性 多态：同一调用语句在父类和子类间使用时具有不同的表现形式，可以使用同一段代码处理不行类型的对象，提高代码的复用性
浅拷贝 (Shallow Copy) 只复制某个对象的指针, 而不复制对象本身, 新旧对象还是共享同一块内存。在对象析构后，容易产生指针访问一个不存在的对象，从而产生悬空指针。
深拷贝 (Deep Copy) 在拷贝的过程中会另外创造一个一模一样的对象. 新对象跟原对象不共享内存, 修改新对象不会改到原对象.
隐藏的实质是：在函数查找时，名字查找先于类型检查。如果派生类中成员和基类中的成员同名，就隐藏掉。编译器首先在相应作用域中查找函数，如果找到名字一样的则停止查找。
https://zhuanlan.zhihu.com/p/75172640
虚析构函数的主要作用是为了防止遗漏资源的释放，防止内存泄露。如果基类中的析构函数没有声明为虚函数，基类指针指向派生类对象时，则当基类指针释放时不会调用派生类对象的析构函数，而是调用基类的析构函数，如果派生类析构函数中做了某些释放资源的操作，则这时就会造成内存泄露。
map：内部实现了一个红黑树，该结构具有自动排序的功能，因此 map 内部的所有元素都是有序的，红黑树的每一个节点都代表着 map 的一个元素，因此，对于 map 进行的查找，删除，添加等一系列的操作都相当于是对红黑树进行这样的操作，故红黑树的效率决定了 map 的效率。
unordered_map：内部实现了一个哈希表，因此其元素的排列顺序是杂乱的，无序的。
在那种插入、删除很频繁的场景中，平衡树需要频繁着进行调整，这会使平衡树的性能大打折扣，为了解决这个问题，于是有了红黑树，红黑树具有如下特点：
1、具有二叉查找树的特点；
2、根节点是黑色的；
3、每个叶子节点都是黑色的空节点（NIL），也就是说，叶子节点不存数据；
4、任何相邻的节点都不能同时为红色，也就是说，红色节点是被黑色节点隔开的；
5、每个节点，从该节点到达其可达的叶子节点是所有路径，都包含相同数目的黑色节点。
当 vector 的大小和容量相等（size==capacity）也就是满载时，如果再向其添加元素，那么 vector 就需要扩容。vector 容器扩容的过程需要经历以下 3 步： 1. 完全弃用现有的内存空间，重新申请更大的内存空间； 2. 将旧内存空间中的数据，按原有顺序移动到新的内存空间中； 3. 最后将旧的内存空间释放。 因为 vector 扩容需要申请新的空间，所以扩容以后它的内存地址会发生改变。vector 扩容是非常耗时的，为了降低再次分配内存空间时的成本，每次扩容时 vector 都会申请比用户需求量更多的内存空间（这也就是 vector 容量的由来，即 capacity>=size），以便后期使用。
vector底层使用三个指针来实现，分别是：顺序表头，顺序表的有效长度位置，顺序表末尾。
https://blog.csdn.net/m0_51723227/article/details/121374795#:~:text=%E5%9C%A8%E6%A0%87%E5%87%86C%2B%2B%E4%B8%AD%2C,%2C%E8%BE%BE%E5%88%B0%E5%AD%98%E5%82%A8%E6%95%88%E6%9E%9C.
shared_ptr基于”引用计数”模型实现，多个shared_ptr可指向同一个动态对象，并维护一个共享的引用计数器，记录了引用同一对象的shared_ptr实例的数量。当最后一个指向动态对象的shared_ptr销毁时，会自动销毁其所指对象(通过delete操作符)。
weak_ptr 是为了配合 shared_ptr 而引入的一种智能指针，它指向一个由 shared_ptr 管理的对象而不影响所指对象的生命周期，也就是将一个 weak_ptr 绑定到一个 shared_ptr 不会改变 shared_ptr 的引用计数，依此特性可以解决 shared_ptr 的循环引用问题。 weak_ptr 没有解引用 * 和获取指针 -> 运算符，它只能通过 lock 成员函数去获取对应的 shared_ptr 智能指针对象，从而获取对应的地址和内容。 不论是否有 weak_ptr 指向，一旦最后一个指向对象的 shared_ptr 被销毁，对象就会被释放。
虚函数可以是内联函数，内联是可以修饰虚函数的，但是当虚函数表现多态性的时候不能内联。内联是在编译期建议编译器内联，而虚函数的多态性在运行期，编译器无法知道运行期调用哪个代码，因此虚函数表现为多态性时不可以内联。virtual 唯一可以内联的时候是：编译器知道所调用的对象是哪个类，这只有在编译器具有实际对象而不是对象的指针或引用时才会发生。
STL 中某些容器调用了某些成员方法后会导致迭代器失效。例如 vector 容器，如果调用 reserve() 来增加容器容量，之前创建好的任何迭代器（例如开始迭代器和结束迭代器）都可能会失效，这是因为，为了增加容器的容量，vector 容器的元素可能已经被复制或移到了新的内存地址。
auto 实现自动类型推断，要求进行显示初始化，让编译器能够将变量的类型设置为初始值的类型
decltype 将变量的类型声明为表达式指定的类型。decltype的类型推导并不是像auto一样是从变量声明的初始化表达式获得变量的类型，而是总是以一个普通表达式作为参数，返回该表达式的类型,而且decltype并不会对表达式进行求值。
智能指针和普通指针的区别在于智能指针实际上是对普通指针加了一层封装机制，区别是它负责自动释放所指的对象，这样的一层封装机制的目的是为了使得智能指针可以方便的管理一个对象的生命期。指针是一种数据类型，用于保存内存地址，而智能指针是类模板。
1.static_cast 静态转换 用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换 - 进行上行转换（把派生类的指针或引用转换成基类表示）是安全的 - 进行下行转换（把基类指针或引用转换成派生类表示）时，由于没有动态类型检查，所以是不安全的 用于基本数据类型之间的转换，如把 int 转换成 char，把 char 转换成 int。这种转换的安全性也要开发人员来保证
2.dynamic_cast 动态转换 dynamic_cast 主要用于类层次间的上行转换和下行转换 在类层次间进行上行转换时，dynamic_cast 和 static_cast 的效果是一样的 在进行下行转换时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全
3. const_cast 常量转换 该运算符用来修改类型的const属性 常量指针被转化成非常量指针，并且仍然指向原来的对象 常量引用被转换成非常量引用，并且仍然指向原来的对象 注意:不能直接对非指针和非引用的变量使用 const_cast 操作符
4. reinterpret_cast 重新解释转换 这是最不安全的一种转换机制，最有可能出问题 主要用于将一种数据类型从一种类型转换为另一种类型，它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针
1.new的实现过程是：首先调用名为operator new 的标准库函数，分配足够大的内存来保存指定类型的一个对象，接下来运行该类型的构造函数，用于初始化该对象，最后返回该对象的指针。
2.delete的实现过程：对指针指向的对象运行适当的析构函数，然后调用operator delete的标准库函数释放该对象的内存
一个指针占内存的大小跟编译环境有关，而与机器的位数无关。32位编译环境下为4字节，64位编译环境下为8字节
1.顶层const可以表示任意的对象是常量，这一点对任何数据类型都使用，底层const则与指针和引用的复合类型有关
2.当执行对象的拷贝操作时，顶层const不受什么影响，但是底层const的限制不能被忽略。
3.对于重载，顶层const不构成重载，底层const构成重载
1.列不可再分
2.属性完全依赖于主键（一张表中包含了多种不同的属性，那么必须要分成多张表）
3.属性不依赖于其他非主属性（要求已经分好了多张表的话，一张表中只能有另一张表的ID，而不能有其他任何信息）
1.若继承方式是public，基类成员在派生类中的访问权限保持不变，也就是说，基类中的成员访问权限，在派生类中仍然保持原来的访问权限；
2.若继承方式是private，基类所有成员在派生类中的访问权限都会变为私有(private)权限；
3.若继承方式是protected，基类的共有成员和保护成员在派生类中的访问权限都会变为保护(protected)权限，私有成员在派生类中的访问权限仍然是私有(private)权限。
C++中提供了explicit关键字，在构造函数声明的时候加上explicit关键字，能够禁止隐式转换。如果构造函数只接受一个参数，则它实际上定义了转换为此类类型的隐式转换机制。可以通过将构造函数声明为explicit加以制止隐式类型转换，关键字explicit只对一个实参的构造函数有效，需要多个实参的构造函数不能用于执行隐式转换，所以无需将这些构造函数指定为explicit。
1.数组在内存中是连续存放的，开辟一块连续的内存空间；数组所占存储空间：sizeof（数组名）；数组大小：sizeof(数组名)/sizeof(数组元素数据类型)；
2.用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。
3.在向函数传递参数的时候，如果实参是一个数组，那用于接受的形参为对应的指针。也就是传递过去是数组的首地址而不是整个数组，能够提高效率；
template<typename type1, typename type2>
type1 max(type1 a, type2 b){
return a > b ? a : b;
}
void main(){
cout << max(5.5, 'a') << endl;
}
其实该模板有个比较隐晦的bug，那就是a、b只有在能进行转型的时候才能进行比较，否则 a > b 这一步是会报错的。这个时候往往需要对于 > 号进行重载，这代码量瞬间上来了。
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用为调用它所指向的函数时，我们就说这是回调函数，比如epoll中可以通过回调函数找到对应的红黑树节点。
delete只会调用一次析构函数。
delete[]会调用数组中每个元素的析构函数
1.非静态成员的数据类型大小之和。
2.编译器加入的额外成员变量（如指向虚函数表的指针）。
3.为了边缘对齐优化加入的padding。
4.空类(无非静态数据成员)的对象的size为1,这样可以保证每个实例均有独占的内存地址，当作为基类时, size为0，如果带有虚函数，则大小比1大，因为还需要包含一个虚函数表指针
5.成员函数不占用对象的内存。这是因为所有的函数都是存放在代码区的，不管是全局函数，还是成员函数。
在类对象的内存空间中，只有数据成员和虚函数表指针，并不包含代码内容，类的成员函数单独放在代码段中。在调用成员函数时，隐含传递一个this指针，让成员函数知道当前是哪个对象在调用它。当调用delete this时，类对象的内存空间被释放。在delete this之后进行的其他任何函数调用，只要不涉及到this指针的内容，都能够正常运行。一旦涉及到this指针，如操作数据成员，调用虚函数等，就会出现不可预期的问题
会导致堆栈溢出。原因很简单，delete的本质是“为将被释放的内存调用一个或多个析构函数，然后，释放内存”。显然，delete this会去调用本对象的析构函数，而析构函数中又调用delete this，形成无限递归，造成堆栈溢出，系统崩溃。
1.利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象；
2.每当你定义一个lambda表达式后，编译器会自动生成一个匿名类（这个类当然重载了()运算符），我们称为闭包类型（closure type）。那么在运行时，这个lambda表达式就会返回一个匿名的闭包实例，其实一个右值。所以，我们上面的lambda表达式的结果就是一个闭包。闭包的一个强大之处是其可以通过传值或者引用的方式捕捉其封装作用域内的变量，前面的方括号就是用来定义捕捉模式以及变量，我们又将其称为lambda捕捉块。
3.lambda语法如下：
[capture] （parameters） mutable ->return-type {statement};
4.lambda必须使用尾置返回来指定返回类型，可以忽略参数列表和返回值，但必须永远包含捕获列表和函数体；
1.STL中的hashtable使用的是开链法解决hash冲突问题
2.hashtable中的bucket所维护的list既不是list也不是slist，而是其自己定义的由hashtable_node数据结构组成的linked-list，而bucket聚合体本身使用vector进行存储。hashtable的迭代器只提供前进操作，不提供后退操作
1.由于vector的内存占用空间只增不减，比如你首先分配了10,000个字节，然后erase掉后面9,999个，留下一个有效元素，但是内存占用仍为10,000个。所有内存空间是在vector析构时候才能被系统回收。empty()用来检测容器是否为空的，clear()可以清空所有元素。但是即使clear()，vector所占用的内存空间依然如故，无法保证内存的回收。
2.如果使用vector，可以用swap()来帮助你释放多余内存或者清空全部内存。
1.顺序容器（序列式容器，比如vector、deque）
erase迭代器不仅使所指向被删除的迭代器失效，而且使被删元素之后的所有迭代器失效(list除外)，所以不能使用erase(it++)的方式，但是erase的返回值是下一个有效迭代器；
it = c.erase(it);
2.关联容器(关联式容器，比如map、set、multimap、multiset等)
erase迭代器只是被删除元素的迭代器失效，但是返回值是void，所以要采用erase(it++)的方式删除迭代器；
c.erase(it++)
1.vector和deque：随机访问迭代器
2.stack、queue、priority_queue：无
3.list、(multi)set/map：双向迭代器
unordered_(multi)set/map、forward_list：前向迭代器
1、sizeof会将空字符\0计算在内，而strlen不会将空字符\0计算在内；
2、sizeof会计算到字符串最后一个空字符\0并结束，而strlen如果遇到第一个空字符\0的话就会停止并计算遇到的第一个空字符\0前面的长度。
int main(void)
{
char str[100] = "abcde";
printf("sizeof(str) = %lu\n", sizeof(str)); //字节大小为100
char str1[] = "abcde";
printf("sizeof(str1) = %lu\n", sizeof(str1)); //字节大小为6
char str2[] = "\0abcde";
printf("sizeof(str2) = %lu\n", sizeof(str2)); //字节大小为7
char str3[] = "\0ab\0c de";
printf("sizeof(str3) = %lu\n", sizeof(str3)); //字节大小为9
char str4[] = "abcde";
printf("strlen(str4) = %lu\n", strlen(str4)); //字符串长度为5
char str5[100] = "abcde";
printf("strlen(str5) = %lu\n", strlen(str5)); //字符串长度为5
char str6[] = "\0abcde";
printf("strlen(str6) = %lu\n", strlen(str6)); //字符串长度为0
char str7[] = "ab cde";
printf("strlen(str7) = %lu\n", strlen(str7)); //字符串长度为6
return 0;
}
1.构造函数，构造函数初始化对象，派生类必须知道基类函数干了什么，才能进行构造
2.内联函数，内联函数表示在编译阶段进行函数体的替换操作，而虚函数意味着在运行期间进行类型确定，所以内联函数不能是虚函数；
3.静态函数，静态函数不属于对象属于类，静态成员函数没有this指针，因此静态函数设置为虚函数没有任何意义。
4.友元函数，友元函数不属于类的成员函数，不能被继承。对于没有继承特性的函数没有虚函数的说法。
5.普通函数，普通函数不属于类的成员函数，不具有继承特性，因此普通函数没有虚函数。
如果本类中一个成员变量是别的对象的指针，而且这个指针不是传进来的地址而是这个指针指向的对象，是在本类中(如果是栈里的定位分配，也不用考虑内存)在堆中开辟的空间创建的。并且该指针没有进行过delete操作，那么久需要在析构方法中进行delete操作，此时我们就必须自己写析构函数。
析构函数首先执行函数体，然后销毁成员，成员按照初始化顺序的逆序销毁。注意析构函数本身不直接销毁成员，成员是在析构函数体之后隐含的析构阶段中被销毁的，销毁类类型成员执行它自己的析构函数，销毁内置类型不需要做什么。
根据三/五法则，如果需要定义一个非空的析构函数，那么通常情况下也需要自定义一个拷贝构造函数。即包含动态分配成员或者包含指针成员的类都应该提供拷贝构造函数，并且考虑重载赋值运算符。
1.多态，运行时多态（虚函数表和继承），静态多态（重载和模板编程）
2.如何实现对象只能分配在栈上：c++中，类的对象建立分为两种，
A a;A a = new A;1 | class A{ |
（2）只在堆上分配新对象
即不能直接调用类的构造函数。首先要知道，当对象建立在栈上面时, 是由编译器分配内存空间的，当对象使用完以后，编译器会调用析构函数来释放对象所占的空间。实际上，编译器在为类对象分配栈空间时, 会检查类的析构函数的访问性(其他非静态函数也会检查)，如果类的析构函数是私有的，则编程器不会在栈空间上为类对象分配内存。因此,我们只需要将析构函数设为私有，类对象就无法建立在栈上了。
1
2
3
4
5
6
7class A{
public:
A(){}
void destroy(delete this;)
private:
~A(){}
}
注意，由于new表达式会在分配内存以后调用构造函数，因此构造函数必须是公有的，同时由于delete此时无法访问私有的析构函数，因此必须提供一个destroy函数，来进行内存空间的释放。
3.c++11新特性
auto，智能指针，移动语义（右值引用），完美转发
4.内联函数和宏的区别
5.多线程
半同步半反应线程池
主线程充当异步线程，负责监听所有socket上的事件，若有新请求到来，主线程接收之以得到新的连接socket，然后往epoll内核事件表中注册该socket上的读写事件，并将数据封装成请求对象插入到请求队列中；所有工作线程睡眠在请求队列上，当有任务到来时，通过竞争（如互斥锁）获得任务的接管权
6.Linux进程调度和内存管理
7.设计模式
工厂模式和单例模式，适配器模式和策略模式
8.lambda表达式
9.手撕strcpy（不用任何库函数)
10.快排的 算法原理+手撕代码。
11.读代码说输出结果：一个简单的子类继承父类的代码
子类析构时，首先执行子类析构函数体的代码，然后执行子类成员对象所在类的析构函数，最后按照子类继承各个父类的次序，倒序各个父类的析构函数
https://zhuanlan.zhihu.com/p/371322392
12.栈溢出的原因
内存中栈一般存放，函数地址、函数参数、局部变量等信息存储于栈内存；
1>函数调用层次过深，每调用一次，函数的参数、局部变量等信息就压一次栈。
2>局部变量体积太大