static的作用:

1.第一条也是最重要的一条：隐藏

当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏

2.static的第二个作用是保持变量内容的持久

3.static的第三个作用是默认初始化为0

虚函数，具体怎么实现

https://blog.csdn.net/weixin_40237626/article/details/82313339

指针和引用的区别：

内存分配：指针是一个实体，需要分配内存空间。引用只是变量的别名，不需要分配内存空间。
初始化：引用在定义的时候必须进行初始化，并且不能够改变。指针在定义的时候不一定要初始化，并且指向的空间可变。
使用级别：有多级指针，但是没有多级引用，只能一级引用。
自增运算：指针和引用的自增运算结果不一样。（指针是指向下一个空间，引用时引用的变量值加1）
使用sizeof时：引用得到的是所指向的变量（对象）的大小，而sizeof 指针得到的是指针本身的大小。
直接与间接访问：引用访问一个变量是直接访问，而指针访问一个变量是间接访问。
野指针：使用指针前最好做类型检查，防止野指针的出现；
参数传递：作为参数时，传指针的实质是传值，传递的值是指针的地址；传引用的实质是传地址，传递的是变量的地址。

new能free么

不可以，new对应delete不可以张冠李戴。
malloc/free,new/delete必需配对使用。
malloc与free是c++、c语言的标准库函数，new、delete是c++的运算符。它们都可用用申请动态内存和释放内存。对于非内部数据类型的对象而言，光用malloc/free无法满足动态对象的要求。对象在创建的同时要自动执行函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。因此c++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

malloc,free和new,delete的区别

编译的概念：编译程序读取源程序（字符流），对之进行词法和语法的分析，将高级语言指令转换为功能等效的汇编代码，再由汇编程序转换为机器语言，并且按照操作系统对可执行文件格式的要求链接生成可执行程序。
编译的完整过程：C源程序－－>预编译处理（.c）－－>编译、优化程序（.asm、.s）－－>汇编程序（.obj、.o、.a）－－>链接程序（.exe等可执行文件）

1. 编译预处理(Preprocess)　

　　读取C源程序，对其中的伪指令（以#开头的指令）和特殊符号进行处理。主要包括四类：宏定义、条件编译指令、头文件和特殊符号。
　　预编译程序所完成的基本上是对源程序的“替代”工作。经过此种替代，生成一个没有宏定义、没有条件编译指令、没有特殊符号的输出文件。这个文件的含义同没有经过预处理的源文件是相同的，但内容有所不同。

2. 编译、优化阶段(Compile)

　　经过预编译得到的输出文件中，只有常量；如数字、字符串、变量的定义，以及C语言的关键字，如main,if,else,for,while,{,}, +,-,*,/等等。
　　编译程序所要作得工作就是通过词法分析和语法分析，在确认所有的指令都符合语法规则之后，将其翻译成等价的中间代码表示或汇编代码。

　　优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关，而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。
　　对于前一种优化，主要的工作是删除公共表达式、循环优化（代码外提、强度削弱、变换循环控制条件、已知量的合并等）、复写传播，以及无用赋值的删除，等等。
　　后一种类型的优化同机器的硬件结构密切相关，最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值，以减少对于内存的访问次数。另外，如何根据机器硬件执行指令的特点（如流水线、RISC、CISC、VLIW等）而对指令进行一些调整使目标代码比较短，执行的效率比较高，也是一个重要的研究课题。
　　经过优化得到的汇编代码必须经过汇编程序的汇编转换成相应的机器指令，方可能被机器执行。

3. 汇编过程(Assemble)

　　汇编过程实际上指把汇编语言代码翻译成目标机器指令的过程。对于被翻译系统处理的每一个C语言源程序，都将最终经过这一处理而得到相应的目标文件。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。
　　目标文件由段组成。通常一个目标文件中至少有两个段：
　　代码段：该段中所包含的主要是程序的指令。该段一般是可读和可执行的，但一般却不可写。
　　数据段：主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读，可写，可执行的。

　　Win32平台上一般生成.obj文件，其拥有PE（Portable Executable，即Windows可执行文件）文件格式，包含的是二进制代码，但是不一定能执行。当编译器将一个工程里的所有.cpp文件以分离的方式编译完毕后，再由链接器进行链接成为一个.exe或.dll文件。

4. 链接程序(Link)

　　由汇编程序生成的目标文件并不能立即就被执行，其中可能还有许多没有解决的问题。
　　例如，某个源文件中的函数可能引用了另一个源文件中定义的某个符号（如变量或者函数调用等）；在程序中可能调用了某个库文件中的函数，等等。所有的这些问题，都需要经链接程序的处理方能得以解决。
　　链接程序的主要工作就是将有关的目标文件彼此相连接，也即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的这些目标文件成为一个能够诶操作系统装入执行的统一整体。
　　根据开发人员指定的同库函数的链接方式的不同，链接处理

可分为两种：
　　（1）静态链接
　　在这种链接方式下，函数的代码将从其所在地静态链接库中被拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合，其中的每个文件含有库中的一个或者一组相关函数的代码。
　　（2）动态链接
　　在此种方式下，函数的代码被放到称作是动态链接库或共享对象的某个目标文件中。链接程序此时所作的只是在最终的可执行程序中记录下共享对象的名字以及其它少量的登记信息。在此可执行文件被执行时，动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。
　　对于可执行文件中的函数调用，可分别采用动态链接或静态链接的方法。使用动态链接能够使最终的可执行文件比较短小，并且当共享对象被多个进程使用时能节约一些内存，因为在内存中只需要保存一份此共享对象的代码。但并不是使用动态链接就一定比使用静态链接要优越。在某些情况下动态链接可能带来一些性能上损害。

多进程与多线程的选择

https://blog.csdn.net/q_l_s/article/details/52608734

 1）需要频繁创建销毁的优先用线程

2）需要进行大量计算的优先使用线程

所谓大量计算，当然就是要耗费很多CPU，切换频繁了，这种情况下线程是最合适的。

游戏服务器TCP与UDP的抉择

https://blog.csdn.net/w00w12l/article/details/45077821

https://www.zhihu.com/question/23356564

TCP的特点：

从原理上，TCP的优势有：

• 简单直接的长连接
• 可靠的信息传输
• 数据包的大小没有限制

TCP最糟糕的特性是它对阻塞的控制。一般来说，TCP假定丢包是由于网络带宽不够造成的，所以发生这种情况的时候，TCP就会减少发包速度。

在3G或WiFi下，一个数据包丢失了，你希望的是立马重发这个数据包，然而TCP的阻塞机制却完全是采用相反的方式来处理！

而且没有任何办法能够绕过这个机制，因为这是TCP协议构建的基础。这就是为什么在3G或者WiFi环境下，ping值能够上升到1000多毫秒的原因。

UDP的特点： 

UDP相对TCP来说既简单又困难。

举个例子来说，UDP是基于数据包构建，这意味着在某些方面需要你完全颠覆在TCP下的观念。UDP只使用一个socket进行通信，不像TCP需要为每一个客户端建立一个socket连接。这些都是UDP非常不错的地方。

但是，大多数情况下你需要的仅仅是一些连接的概念罢了，一些基本的包序功能，以及所谓的连接可靠性。可惜的是，这些功能UDP都没有办法简单的提供给你，而你使用TCP却都可以免费得到。

使用TCP失败的地方：

可靠的UDP也是有延迟的，但是由于它是在UDP的基础之上建立的通信协议，所以可以通过多种方式来减少延迟，不像TCP，所有的东西都要依赖于TCP协议本身而无法被更改。

魔兽世界以及其他的一些游戏是怎么处理延迟问题的呢？

一些类似发起攻击动作和释放技能特效就能够在没有收到服务器确认的情况下就直接执行，比如展现冰冻技能的效果就可以在服务器没有返回数据前在客户端就做出来。

客户端直接开始进行计算而不等待服务端确认是一种典型的隐藏延迟的技术。

这也意味着，我们到底是使用TCP还是UDP取决于我们能否隐藏延迟。

TCP在什么时候失效

一个采用TCP的游戏必须能够处理好突发的延迟问题（纸牌客户端就很典型，对突发性的一秒的延迟，玩家也不会产生什么抱怨）或者是拥有缓解延迟问题的好方法。

如果你运行的是一个无法使用任何减缓延迟措施的游戏呢？玩家对玩家的动作类游戏通常就属于这个范畴，但是这也不仅仅限于动作类游戏。

一种常见的操作是，你快速的移动你的角色通过一张充满战争迷雾的世界地图，但是一旦你探索过，迷雾就会被打开。

为了确保游戏的规则，防止玩家作弊，服务器只能显示玩家当前位置附近的信息。这意味着不像魔兽世界，玩家无法在没有得到服务器响应的情况下，做出完整的动作。战争迷雾的探开必须依靠服务器传过来的响应。

而当出现丢包时，由于拥塞控制的原因，服务器的响应速度就从100-150毫秒上升到1000-2000毫秒

没有任何办法可以绕过TCP的这个设置来避开这个问题。

我们替换了TCP的代码，用了自定义的可靠的UDP来实现，把大量的丢包产生的延迟降到了仅仅只有50毫秒，甚至比以前TCP不丢包的情况一个来回的延迟还要小。当然，这只可能建立在UDP之上，这样我们才对可靠性拥有完全的掌控力。

可靠的UDP一点也不像TCP，要去实现一个特殊的阻塞控制。事实上，这也是你使用可靠UDP代替TCP的最大的原因，避免TCP的阻塞控制。

底线

那么到底是用UDP还是TCP呢？

• 如果是由客户端间歇性的发起无状态的查询，并且偶尔发生延迟是可以容忍，那么使用HTTP/HTTPS吧。
• 如果客户端和服务器都可以独立发包，但是偶尔发生延迟可以容忍（比如：在线的纸牌游戏，许多MMO类的游戏），那么使用TCP长连接吧。
• 如果客户端和服务器都可以独立发包，而且无法忍受延迟（比如：大多数的多人动作类游戏，一些MMO类游戏），那么使用UDP吧。

死锁条件？怎么解决？具体形容一下怎么个情况是死锁

必要条件

互斥：每个资源要么已经分配给了一个进程，要么就是可用的。
占有和等待：已经得到了某个资源的进程可以再请求新的资源。
不可抢占：已经分配给一个进程的资源不能强制性地被抢占，它只能被占有它的进程显式地释放。
环路等待：有两个或者两个以上的进程组成一条环路，该环路中的每个进程都在等待下一个进程所占有的资源。

处理方法
主要有以下四种方法：
鸵鸟策略
死锁检测与死锁恢复
死锁预防
死锁避免

select、poll、epoll

 HTTP1.0与HTTP1.1的区别

1. 缓存处理，在HTTP1.0中主要使用header里的If-Modified-Since,Expires来做为缓存判断的标准，HTTP1.1则引入了更多的缓存控制策略例如Entity tag，If-Unmodified-Since, If-Match, If-None-Match等更多可供选择的缓存头来控制缓存策略。

2. 带宽优化及网络连接的使用，HTTP1.0中，存在一些浪费带宽的现象，例如客户端只是需要某个对象的一部分，而服务器却将整个对象送过来了，并且不支持断点续传功能，HTTP1.1则在请求头引入了range头域，它允许只请求资源的某个部分，即返回码是206（Partial Content），这样就方便了开发者自由的选择以便于充分利用带宽和连接。

3. 错误通知的管理，在HTTP1.1中新增了24个错误状态响应码，如409（Conflict）表示请求的资源与资源的当前状态发生冲突；410（Gone）表示服务器上的某个资源被永久性的删除。

4. Host头处理，在HTTP1.0中认为每台服务器都绑定一个唯一的IP地址，因此，请求消息中的URL并没有传递主机名（hostname）。但随着虚拟主机技术的发展，在一台物理服务器上可以存在多个虚拟主机（Multi-homed Web Servers），并且它们共享一个IP地址。HTTP1.1的请求消息和响应消息都应支持Host头域，且请求消息中如果没有Host头域会报告一个错误（400 Bad Request）。

5. 长连接，HTTP 1.1支持长连接（PersistentConnection）和请求的流水线（Pipelining）处理，在一个TCP连接上可以传送多个HTTP请求和响应，减少了建立和关闭连接的消耗和延迟，在HTTP1.1中默认开启Connection： keep-alive，一定程度上弥补了HTTP1.0每次请求都要创建连接的缺点。

HTTP2.0

HTTP/1.x 缺陷
HTTP/1.x 实现简单是以牺牲性能为代价的：
客户端需要使用多个连接才能实现并发和缩短延迟；
不会压缩请求和响应首部，从而导致不必要的网络流量；
不支持有效的资源优先级，致使底层 TCP 连接的利用率低下。

HTTP2.0与HTTP1.x的区别：

1.二进制分帧层
HTTP/2.0 将报文分成 HEADERS 帧和 DATA 帧（一个报文拆分成两部分分别传送），它们都是二进制格式的,HTTP1.x的解析是基于文本。。

在通信过程中，只会有一个 TCP 连接存在，它承载了任意数量的双向数据流（Stream）。

消息（Message）是与逻辑请求或响应对应的完整的一系列帧。
帧（Frame）是最小的通信单位，来自不同数据流的帧可以交错发送，然后再根据每个帧头的数据流标识符重新组装。

 2.服务端推送

HTTP/2.0 在客户端请求一个资源时，会把相关的资源一起发送给客户端，客户端就不需要再次发起请求了。例如客户端请求 page.html 页面，服务端就把 script.js 和 style.css 等与之相关的资源一起发给客户端。

3.首部压缩
HTTP/1.1 的首部带有大量信息，而且每次都要重复发送。
HTTP/2.0 要求客户端和服务器同时维护和更新一个包含之前见过的首部字段表，从而避免了重复传输。
不仅如此，HTTP/2.0 也使用 Huffman 编码对首部字段进行压缩。

HTTPS

HTTP 有以下安全性问题：
使用明文进行通信，内容可能会被窃听；
不验证通信方的身份，通信方的身份有可能遭遇伪装；
无法证明报文的完整性，报文有可能遭篡改。

加密：

1. 对称密钥加密
对称密钥加密（Symmetric-Key Encryption），加密和解密使用同一密钥。
优点：运算速度快；
缺点：无法安全地将密钥传输给通信方。

2.非对称密钥加密
非对称密钥加密，又称公开密钥加密（Public-Key Encryption），加密和解密使用不同的密钥。
公开密钥所有人都可以获得，通信发送方获得接收方的公开密钥之后，就可以使用公开密钥进行加密，接收方收到通信内容后使用私有密钥解密。
非对称密钥除了用来加密，还可以用来进行签名。因为私有密钥无法被其他人获取，因此通信发送方使用其私有密钥进行签名，通信接收方使用发送方的公开密钥对签名进行解密，就能判断这个签名是否正确。
优点：可以更安全地将公开密钥传输给通信发送方；
缺点：运算速度慢。

真正使用时，实际上是先用发送方得到接收方非对称密钥加密的公开密钥，然后用这个公开密钥将其对称密钥进行加密，接受方收到后解密得到对称密钥，之后就以这个对称密钥进行通信。

认证
通过使用 证书 来对通信方进行认证。
数字证书认证机构（CA，Certificate Authority）是客户端与服务器双方都可信赖的第三方机构。
服务器的运营人员向 CA 提出公开密钥的申请，CA 在判明提出申请者的身份之后，会对已申请的公开密钥做数字签名，然后分配这个已签名的公开密钥，并将该公开密钥放入公开密钥证书后绑定在一起。
进行 HTTPS 通信时，服务器会把证书发送给客户端。客户端取得其中的公开密钥之后，先使用数字签名进行验证，如果验证通过，就可以开始通信了。

 首先看为什么要认证?

细心的人可能已经注意到了如果使用非对称加密算法，我们的客户端A，B需要一开始就持有公钥，要不没法开展加密行为啊。

这下，我们又遇到新问题了，如何让A、B客户端安全地得到公钥？

client获取公钥最最直接的方法是服务器端server将公钥发送给每一个client用户，但这个时候就出现了公钥被劫持的问题，如上图，client请求公钥，在请求返回的过程中被×××劫持，那么我们将采用劫持后的假秘钥进行通信，则后续的通讯过程都是采用假秘钥进行，数据库的风险仍然存在。在获取公钥的过程中，我们又引出了一个新的话题：如何安全的获取公钥，并确保公钥的获取是安全的， 那就需要用到终极武器了：SSL 证书（需要购买）和CA机构

解决:

在第 ② 步时服务器发送了一个SSL证书给客户端，SSL 证书中包含的具体内容有证书的颁发机构、有效期、公钥、证书持有者、签名，通过第三方的校验保证了身份的合法，解决了公钥获取的安全性（中间人的公钥没有第三方的保证）

以浏览器为例说明如下整个的校验过程：

（1）首先浏览器读取证书中的证书所有者、有效期等信息进行一一校验

（2）浏览器开始查找操作系统中已内置的受信任的证书发布机构CA，与服务器发来的证书中的颁发者CA比对，用于校验证书是否为合法机构颁发 

（3）如果找不到，浏览器就会报错，说明服务器发来的证书是不可信任的。

（4）如果找到，那么浏览器就会从操作系统中取出  颁发者CA  的公钥，然后对服务器发来的证书里面的签名进行解密

（5）浏览器使用相同的hash算法计算出服务器发来的证书的hash值，将这个计算的hash值与证书中签名做对比

（6）对比结果一致，则证明服务器发来的证书合法，没有被冒充

（7）此时浏览器就可以读取证书中的公钥，用于后续加密了

图里的DATA相当于要发送的公钥。

首先服务器向CA请求，CA对这个公钥进行数字签名，然后放入证书。

服务器将这个证书发送给对端，对端接收到后首先判断CA是不是合法机构，如果是就拿出一个CA的公钥，对签名进行解密，解密得到数字签名。然后将数据（也就是公钥）进行hash，将得到的结果与数字签名进行对比，如果相同则证明合法，就可以用这个公钥进行对称密钥的加密了。

完整性保护
SSL 提供报文摘要功能来进行完整性保护。
HTTP 也提供了 MD5 报文摘要功能，但不是安全的。例如报文内容被篡改之后，同时重新计算 MD5 的值，通信接收方是无法意识到发生了篡改。
HTTPS 的报文摘要功能之所以安全，是因为它结合了加密和认证这两个操作。试想一下，加密之后的报文，遭到篡改之后，也很难重新计算报文摘要，因为无法轻易获取明文。

URL输入过程

memcpy,memmove,memset,strcpy,strncpy,strlcpy等等

strcpy与memcpy:

区别:

strcpy与memcpy不同存在于：strcpy只复制字符串，而memcpy可以复制任何内容（字符数组、结构体、类）等。strcpy不需要指定长度由结束符”\0”而结束战斗的，memcpy由第三个参数所决定

strcpy:

功能：char   *strcpy(char   *dest,char   *src);

把src所指由NULL结束的字符串复制到dest所指的数组中

src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。

问题：

strcpy只是复制字符串，但不限制复制的数量。很容易造成缓冲溢出，也就是说，不过dest有没有足够的空间来容纳src的字符串，它都会把src指向的字符串全部复制到从dest开始的内存

内存重叠的问题：

char s[10]="hello";

strcpy(s, s+1); //应返回ello，

//strcpy(s+1, s); //应返回hhello，但实际会报错，因为dst与src重叠了，把\'\0\'覆盖了

当dst在src和src的结尾之间时会出现问题：

比如hello,dst=ello,src=hello:先把h赋值到e，整体变为hhllo,现在src为hllo,dst为llo;再复制一次,变为hhhllo....持续到dst指向\'\0\'而现在src指向的是h，然后这次复制相当于把字符串的\0覆盖了，也就是说这个复制永远不会停下来。最后变为hhhhhhhhhhhhhhhhhhhhh直到复制到不可访问的内存

这是由于src后面准备复制到dst中的数据被dst所覆盖的原因

不考虑内存重叠的stcpy的实现：

char * strcpy(char *dst,const char *src)   //[1]
{
    assert(dst != NULL && src != NULL);    //[2]

    char *ret = dst;  //[3]

    while ((*dst++=*src++)!=\'\0\'); //[4]

    return ret;
}

　　也就是说，如果dst位于src~src+strlen(src)+1之间（+1是\'\0\'），则由于会覆盖\'\0\'而导致无法停止

因此对于这时，要从后往前拷贝，复制前统计长度，用长度来控制停止。

char * strcpy(char *dst,const char *src)
{
    assert(dst != NULL && src != NULL);
  
     int cnt=strlen(src)+1;
 
    char *ret = dst; 

    if (dst >= src && dst <= src+cnt-1) //内存重叠，从高地址开始复制
    {
        dst = dst+cnt-1;
        src = src+cnt-1;
        while (cnt--)
            *dst-- = *src--;
    }
    else    //正常情况，从低地址开始复制
    {
        while (cnt--)
            *dst++ = *src++;
    }
    

    return ret;
}

memcpy:

void *memcpy(void *destin, void *source, unsigned n);

功能:

将src逐字节拷贝到dst，拷贝n个字节

memcpy不会添加\'\0\'，只是机械地拷贝,由n来决定停止。

问题：
同样，当出现内存重叠时，如dst在src和src+strlen(stc)+1中间时:src后面还没有复制到dst中的数据会被覆盖掉

解决办法也是从高地址往低地址拷贝

void *memcpy(void *dest, const void *src, size_t count)
{
 char *d;
 const char *s;
 
 if (dest > (src+size)) || (dest < src))
    {
    d = dest;
    s = src;
    while (count--)
        *d++ = *s++;        
    }
 else /* overlap */
    {
    d = (char *)(dest + count - 1); /* offset of pointer is from 0 */
    s = (char *)(src + count -1);
    while (count --)
        *d-- = *s--;
    }
  
 return dest;

memmove:

void *memmove( void* dest, const void* src, size_t count );

功能：

memmove用于拷贝字节，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中，但复制后源内容会被更改。但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

void* memmove(void* dest, const void* src, size_t n)
{
    char * d  = (char*) dest;
    const char * s = (const char*) src;
  
    if (s>d)
    {
         // start at beginning of s
         while (n--)
            *d++ = *s++;
    }
    else if (s<d)
    {
        // start at end of s
        d = d+n-1;
        s = s+n-1;
  
        while (n--)
           *d-- = *s--;
    }
	
    return dest;
}

memset:

功能：

void *memSet(void *s, int c, size_t n)
{
	if (NULL == s || n < 0)
		return NULL;
	char * tmpS = (char *)s;
	while(n-- > 0)
		*tmpS++ = c;
		return s; 
}

char *strncpy(char *dst, const char *src, size_t len)
{
    assert(des != NULL && src != NULL);
    int offset = 0;
    char *ret = dst;
    char *tmp;
    if(strlen(src) < len)
    {
        offset = len - strlen(src);//补齐0的个数
        len = strlen(src);//复制的个数
    }
    if(dst >= src && dst <= src + len -1)
    {
        dst = dst + len - 1;
        src = src + len - 1;
        tmp = dst;//记录补0的位置
        while(len--)
            *dst-- = *src--;
    }
    else
    {
        while(len++)
            *dst++ = *src++;
        tmp = dst;
    }
    while(offset--)
        *tmp++ = \'\0\';//补0
    return ret;
}

 实现：

size_t Test_strlcpy(char *dest, const char *src, size_t size)
{
    size_t ret = strlen(src);

    if (size) {
        //这句判断大赞，起码有效防止源字符串的越界问题
        size_t len = (ret >= size) ? size - 1 : ret;//防止缓冲区溢出，如果不够则只复制到缓冲区满.ret等于size也要考虑到size-1里，因为\'\0\'是后面统一加的
        memcpy(dest, src, len);
        dest[len] = \'\0\';
    }
    return ret;
}

哈希冲突怎么解决

1.开放定址法：

Hi=(H(key)+di)Mod m;m为哈希表长度

分为三种：

1).线性探测再散列：

di={1,2,3,4,5,...m-1}

2).二次探测再散列：
di={1,-1,4,-4,9,-9....,k^2,-k^2},k<=m/2;

3).伪随机探测再序列

2.再哈希

Hi=RHi(key) i=1,2,3,4...k

换其他的哈希方法来计算地址，直到可以生成不冲突的哈希

3.开链法：

链表

拉链法中链表太长了应该如何解决

当bucket中有3/4的有负载时，要进行rehash,重建一个2倍大小的bucket数组，由于重建后hash长度变了，所以要重新对其中的值进行哈希并开链。

当链表长度超过8，要将链表转为红黑树。

为什么临界值是8？

理想情况下随机hashCode算法下所有bin中节点的分布频率会遵循泊松分布，我们可以看到，一个bin中链表长度达到8个元素的概率为0.00000006，几乎是不可能事件

而且n=8时，8与log28=3差距不算太大，综合考虑建树产生的消耗。

CPU读取数据

CPU缓存（Cache Memory）位于CPU与内存之间的临时存储器，它的容量比内存小但交换速度快。在缓存中的数据是内存中的一小部分，但这一小部分是短时间内CPU即将访问的，当CPU调用大量数据时，就可避开内存直接从缓存中调用，从而加快读取速度。由此可见，在CPU中加入缓存是一种高效的解决方案，这样整个内存储器（缓存+内存）就变成了既有缓存的高速度，又有内存的大容量的存储系统了。缓存对CPU的性能影响很大，主要是因为CPU的数据交换顺序和CPU与缓存间的带宽引起的。

缓存的工作原理是当CPU要读取一个数据时，首先从缓存中查找，如果找到就立即读取并送给CPU处理；如果没有找到，就用相对慢的速度从内存中读取并送给CPU处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。

正是这样的读取机制使CPU读取缓存的命中率非常高（大多数CPU可达90%左右），也就是说CPU下一次要读取的数据90%都在缓存中，只有大约10%需要从内存读取。这大大节省了CPU直接读取内存的时间，也使CPU读取数据时基本无需等待。总的来说，CPU读取数据的顺序是先缓存后内存。

如何选取N个不重复的随机数？复杂度要低（洗牌算法）

time的头文件为time.h

rand和srand头文件为stdlib.h

比如5 200 9 12 33 44

第一次随机选中200,将200与44交换。

下一次就只在0~4间选取

在下一次就只在0~3件选取

第一次概率为1/n

第二次的概率为，第一次没选中这个数的概率，也就是(n-1)/n;乘上第二次被选中的概率，也就是1/(n-1),为1/n

第三次为(n-1)/n*(n-2)/(n-1)*1/(n-2)=1/n

....

void shuffle(vector<int> arr,int k)
{
	int count=0;
	for(int i=0;i<k;i++)
	{
		srand(time(NULL));
		int idx=rand()%(arr.size()-count);
		swap(arr[idx],arr[arr.size()-1-count]);
		count++;
	}
}

LRU缓存

vector的push_back手撕

逆波兰表达式的转换与求值

https://www.cnblogs.com/hantalk/p/8734511.html

转换为逆波兰表达式：

\'（\'与\'）\'有最高的优先级;*,/有次级的优先级;+,-最低优先级

遇到字母直接输出；

遇到的运算符，如果比栈顶的运算符优先级低，且栈顶不为(,则输出栈顶内的元素直到栈顶的优先级小于当前运算符，然后将运算符push进栈：因为当前的运算符优先级低，所以数字应该优先与优先级高的向结合。

遇到\')\',则输出栈内元素直到栈顶为(,再将(pop掉。

最后，如果栈不为空，则将栈内元素依次输出

class Solution
{
public:
	string Trans(string in)
	{
		stack<char> aux;
		int p1=0;
		string ans;
		while(p1<in.size())
		{
			if(isNum(in[p1]))//a+b*c+(d*e+f)*g
				ans+=in[p1];
			else
			{
				if(aux.empty())
					aux.push(in[p1]);
				else if(in[p1]==\')\')//遇到),pop到栈顶为(
				{
					while(aux.top()!=\'(\')
					{
						ans+=aux.top();
						aux.pop();
					}
					aux.pop();
				}
				else
				{
					while(!aux.empty()&&Jugde(aux.top())>=Jugde(in[p1])&&aux.top()!=\'(\')//只有当前运算符优先级比栈顶低，且栈顶不为(
					{
						ans+=aux.top();
						aux.pop();
					}
					aux.push(in[p1]);
				}

			}
			p1++;
		}
		while(!aux.empty())
		{
			ans+=aux.top();
			aux.pop();
		}
		return ans;
	}
	bool isNum(char str)//判断是否是字母
	{
		if(str!=\'(\'&&str!=\')\'&&str!=\'+\'&&str!=\'-\'
			&&str!=\'*\'&&str!=\'/\')
			return true;
		else
			return false;
	}
	int Jugde(char str)//评判优先级 
	{
		if(str==\'(\'||str==\')\')
			return 2;
		else if(str==\'*\'||str==\'/\')
			return 1;
		else
			return 0;
	}
};

二层，三层转发（ping的过程）