OpenGL笔记

2022-06-28

1.各种缓冲区的作用

颜色缓冲区：就是帧缓冲区（图形设备的内存），需要渲染的场景的每一个像素都最终写入该缓冲区，然后由他渲染到屏幕上显示。

深度缓冲区：与帧缓冲区对应，用于记录上面每个像素的深度值，通过深度缓冲区，我们可以进行深度测试，从而确定像素的遮挡关系，保证渲染正确。（注意区分深度测试和背面剔除）

模板缓冲区：与深度缓冲区类似，通过设置模板，缓冲每个像素的值，我们可以在渲染的时候只渲染，后写入模板缓存对应的值，从而在后续的其他绘制可以通过配置模板缓存的参数来决定是否丢弃该片元，以及如何操作对应该片段对应的模板缓存值。
模板缓冲区可以为屏幕上的每个像素点保存一个无符号的整数值，在渲染过程中，可以用这个值与一个预先设定的参考值相比较，根据比较的结果来决定是否更新相应的像素点的颜色值。模板测试发生在透明度测试之后，深度测试之前，如果模板测试通过，则相应的像素点更新，否则不更新。

累积缓冲区：允许在渲染到颜色缓冲区之后，不是把结果显示到窗口上，而是把内容复制到累积缓冲区，这样就可以把颜色缓冲区与累积缓冲区中的内容反复进行混合，可以用来进行模糊处理和抗锯齿。

2.渲染管线的四个阶段

渲染管线通常被分为四个阶段：应用阶段，几何阶段，光栅化阶段，像素处理阶段。

(1) 应用阶段：应用阶段是指在CPU端进行处理的阶段，包括物理碰撞检测、物理模拟、动画计算等任务，对于3D游戏来说，游戏中包含大量的模型，3D模型中保存着模型的顶点坐标，法线，切线，颜色等数据，这些数据一般通过向量进行存储，CPU从模型中获取这些顶点信息数据，并将这些数据传送给GPU作为最开始的输入数据。然后将数据送到渲染管线中。

(2) 几何阶段：几何阶段主要执行顶点.坐标变换、顶点处理、坐标裁剪等操作，计算对象为顶点数据，即模型的顶点数据，在这个阶段，做的最多的操作就是顶点坐标变换，从模型空间变换到世界空间，然后再从世界空间变换至相机空间。这样在相机坐标系下就能方便地进行裁剪，裁剪的作用是判断顶点是否可见。

(3) 光栅化阶段：相比于屏幕上的像素点，顶点数据要少很多，这就有一个问题：无法实现从顶点数据到屏幕像素上的映射。而为了达到这一目的，就出现了顶点插值运算，即将两个顶点之间的空缺部分通过插值的形式进行填充，以达到能实现从顶点数据到像素上的一一映射，最后将渲染的结果显示到屏幕上。

(4) 像素处理阶段：像素处理阶段包括像素颜色计算、像素变换，透明度混合等操作，处理物体渲染顺序及深度测试等。这个阶段要处理的内容比较多，可以在此阶段中利用一些算法实现非常多的屏幕特效，比如高斯模糊，景深等，此阶段是游戏渲染中应用非常广泛的阶段，但因为计算对象是像素点，因此实现相关特效时比较耗费性能。

流程如下：

![image-20220616094241525](/Users/wujianqiang/Library/Application Support/typora-user-images/image-20220616094241525.png)

顶点数据：一个模型或者图形是由点线面构成的，为了让计算机绘制出这个图形，就必须告诉计算机这些数据的值，顶点数据包括顶点坐标，坐标的切线，法线，颜色等信息，对于OpenGL，这些数据一般都是向量（Vector）结构体，对于游戏引擎，这些数据来自导入的模型当中，在开始渲染之前，CPU会获取这些数据，然后将其传递给GPU，作为最原始数据，做好计算准备。

顶点着色器：顶点着色器（Vertex Shader）在渲染管线中的作用非常大，是渲染管线的第一个可编.程着色器，处理单元是顶点数据。顶点着色器的主要功能是对坐.标进行.变换。将输入的局部坐标变换到世界坐标、观察坐标和裁剪坐标。除此之外当然也可以进行光照着色，但是着色效果远不如在片元着色器中进行光照着色，因为计算量较小。

图元装配：图元装配（Primitive Assembly）是对传入的顶点数据进行重新组装，将顶点着色器的输出作为输入，这一点正验证了渲染的过程是以流水线的形式进行的，图元装配会将顶点装配成指定的图形，与此同时，会进行裁剪、被面剔除等操作，以减少不必要的计算，加速渲染过程。

几何着色器：几何着色器（Geometry Shader）会将图元装配阶段输出的数据作为输入数据。几何着色器不属于可编程阶段，由硬件设备自动完成，其主要作用是对顶点数据进行重构，可以在此阶段产生新的顶点数据，来弥补之前存在的一些问题。以便为接下来要进行的操作做好充分的准备工作。

光栅化：光栅化阶段（Rasterization Stage）的输入数据来自几何着色器的输出数据，光.栅化的意思很容易理解，到目前为止，渲染所处理的数据对象为顶点，无法通过一一对应的方式映射到屏幕上，而为了实现顶点到屏幕像素的一一映射，就出现了光栅化。换而言之，光栅.化的作用就是将两个顶点直接缺少的像素点通过插值的形式进行补充，生成片元着.色器可以处理的片段。此阶段.人为不可干涉，由硬件完成插值计算。在插值的过程中，会将不可见的顶点进行剔除。

片元着色器：片元着色器处理的对象将是像素点的颜色信息，也是最终显示在屏幕上的像素点，在这个过程中，可以处理光照和阴影计算，将处理完的值保存至缓冲区当中。

混合处理阶段：混合处理阶段属于屏幕后期处理范围，这意味着此阶段主要做的任务为屏幕优化操作，通过片元着色器得到的像素，有些不能被显示出来，比如透明度为0的像素点，对于这类像素点，我们需要进行测试，测试的范围包括Alpha测试、模板测试和深度测试等。不能通过测试的像素点将会被丢弃，就不会参与接下来的操作；通过测试的像素点会进入混合阶段。混合阶段主要是要处理透明物体，物体的透明度通过Alpha值来表示，范围是从0.至.1， alpha=1表示完全不透明，alpha=0表示完全透明。测试混合阶段基本不需要进行编程，但是常见的渲染管线接口会开放出一些参数给开发者.做调整。

3.顶点着色器和片元着色器的作用

顶点着色器：顶点着色器（Vertex Shader）在渲染管线中的作用非常大，是渲染管线的第一个可编程着色器，处理单元是顶点数据。顶点着色器的主要功能是对坐标进行变换。将输入的局部坐标变换到世界坐标、观察坐标和裁剪坐标。除此之外当然也可以进行光照着色，但是着色效果远不如在片元着色器中进行光照着色，因为计算量较小。

片元着色器：片元着色器处理的对象是像素点的颜色信息，也是最终显示在屏幕上的像素点，在这个过程中，可以处理光照和阴影计算，将处理完的值保存至缓冲区当中。

4.深度测试问题

为什么需要进行深度测试？

当我们渲染多个物体时，这多个物体之间存在互相遮挡的关系，被遮挡的物体的部分将不可见，也就是它离相机更远，为了告诉计算机被遮挡的物体不需要渲染，我们就需要对物体上的点做深度测试，检测它是否需要渲染。

为了实现上述的检测，就需要深度缓冲，简单而言就是存储物体上点深度值的数组，这个数组一开始值为0，当目前渲染的物体的深度值大于缓冲区中存储的深度值时，就将这个值写入缓冲区，同时通过深度测试，如果与此相反，深度值小于缓冲区中的深度值，就是未通过深度测试，且不写入缓冲区，淘汰掉这个点（不做渲染）。
其中：深度测试函数可以自己定义

函数	描述
GL_ALWAYS	永远通过深度测试
GL_NEVER	永远不通过深度测试
GL_LESS	在片段深度值小于缓冲的深度值时通过测试
GL_EQUAL	在片段深度值等于缓冲区的深度值时通过测试
GL_LEQUAL	在片段深度值小于等于缓冲区的深度值时通过测试
GL_GREATER	在片段深度值大于缓冲区的深度值时通过测试
GL_NOTEQUAL	在片段深度值不等于缓冲区的深度值时通过测试
GL_GEQUAL	在片段深度值大于等于缓冲区的深度值时通过测试

深度测试主要的的两个步骤：

对比缓冲区中的值，判断是否通过测试（Z Test)
是否将该值写入缓冲区(Z Write)

注意：每次渲染一遍之后必须将缓存值清空，不然可能会出现画面错误情况。

清除方式和清除颜色缓存一样：

1	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

深度测试精确度及深度冲突

计算深度值的函数：

在这里插入图片描述

深度测试出现的冲突问题：

当大量物体离摄像机极远时，会出现深度值错误的现象，因为太过集中在1这个值处（深度值往往有16位，24位和32位，其值位于0-1）
当大量物体在同一平面时，会出现深度值相同（因为是float，所以可能每次渲染的结果都不同，造成抖动现象）

对于以上两类问题，应该设置其渲染顺序，相机的近平面和远平面，来达到最佳效果。

5.透明物体和不透明物体的渲染顺序问题

注意：在OpenGL中，透明物体不能写入深度（一个透明物体在一个不透明物体之前，那么理论上，如果写入深度值，那么后面的不透明物体将不可见，但实际是我们是可以通过透明物体看到后面的东西）

这就意味着透明物体要关闭深度写入。如果开启深度测试，则要同时开启混合算法，这样才能看到透明物体后面的其他物体。

进行混合计算的物体要求：必须带有Alpha值的物体（Alpha取值范围：0～1），即颜色类型为RGBA（因此jpg格式的图片不行，因为jpg图片只有rgb值）

混合函数：

result=source∗Fsource+destination∗Fdestination
source：源颜色向量。这是源自纹理的颜色向量。
destination：目标颜色向量。这是当前储存在颜色缓冲中的颜色向量。
Fsource：源因子值。指定了alpha值对源颜色的影响。实例中为红色（1）
Fdestination：目标因子值。指定了alpha值对目标颜色的影响。实例中为绿色（0.6）

1	glBlendFunc(GLenum sfactor, GLenum sfactor)

Fsource和Fdestination的值为以下选项：

选项	值
GL_ZERO	因子等于0，舍去对应的贴图
GL_ONE	因子等于1，全取
GL_SRC_COLOR	因子等于源颜色向量source
GL_ONE_MINUS_SRC_COLOR	因子等于1−C¯source
GL_DST_COLOR	因子等于目标颜色向量C¯destination
GL_ONE_MINUS_DST_COLOR	因子等于1−C¯destination
GL_SRC_ALPHA	因子等于C¯source的alpha分量
GL_ONE_MINUS_SRC_ALPHA	因子等于1− C¯source的alpha分量
GL_DST_ALPHA	因子等于C¯destination的alpha分量
GL_ONE_MINUS_DST_ALPHA	因子等于1− C¯destination的alpha分量
GL_CONSTANT_COLOR	因子等于常数颜色向量C¯constant
GL_ONE_MINUS_CONSTANT_COLOR	因子等于1−C¯constant
GL_CONSTANT_ALPHA	因子等于C¯constant的alpha分量
GL_ONE_MINUS_CONSTANT_ALPHA	因子等于1− C¯constant的alpha分量

一般选则为：

1	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

也可以使用glBlendFuncSeparate为RGB和alpha通道分别设置不同的选项

1	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);

渲染顺序原则：

不透明物体：从前向后的顺序渲染，因为深度值越大，越容易不被遮挡，这里涉及Early-Z技术

透明物体：从后向前渲染，因为透明物体需要和后面的物体进行叠加，同时不写入深度值

⚠️：要想让混合在多个物体上工作，我们需要最先绘制最远的物体，最后绘制最近的物体。

普通不需要混合的物体仍然可以使用深度缓冲正常绘制，因此它们不需要排序。但我们仍要保证它们在绘制（排序的）透明物体之前已经绘制完毕了。

当绘制场景中同时存在透明和不透明物体时：

先绘制所有不透明的物体。从近到远
对所有透明的物体排序。从远到近
按顺序绘制所有透明的物体

举例常见的性能优化：

优化主要从三个方面入手：CPU端优化，数据传输过程和GPU端优化。

在游戏性能遇到瓶颈时，首先要明确是谁拖了后腿，在CPU端还是GPU端，游戏逻辑由CPU执行，如果是UE4蓝图或者C++代码执行效率低，则是CPU端需要优化，如果是渲染速度慢，则需要GPU端进行优化，如果是CPU向GPU发送指令过程慢，则说明要减少Draw Call（CPU向GPU发送渲染指令数量）数量。

游戏有“帧”的概念，一帧的运行时间并不等于CPU渲染时间+CPU向GPU发送渲染指令时间+GPU渲染时间，因为这三项是由三个线程执行的，基本等于其中耗时最长的那一项，因此只要降低耗时最长的一项，就能有效提升帧速率。

由于上述三者之间执行由不同线程执行，但是只有CPU端处理完成后GPU才能进行渲染，因此有以下的执行顺序：

在第0帧时什么也没做，第一帧时CPU处理逻辑，第二帧时CPU线程继续处理逻辑，同时CPU开辟一个线程向GPU发送渲染指令（Draw Call），第三帧时GPU开始处理CPU第二帧发送过来的数据，因此GPU每一帧处理的数据都是CPU前一帧发送过来的数据，这样就达到了看似顺序执行的目的。

CPU端主要处理逻辑，对性能影响最大的便是Tick，如果在Tick里做复杂逻辑，就会使帧速率变低，因此能用事件触发就用事件触发，毕竟游戏中大部分的逻辑都可以通过事件触发，不必每一帧都去刷新，如果必须在每一帧都刷新，比如旋转这种简单的逻辑，可以尝试使用Shader实现。

CPU端常见优化点：

1 减少tick的使用，大部分逻辑都是事件驱动的，能不在tick/update里刷就不要在里面刷

2 尽量减少使用get all class方法，性能较低

3 不要频繁创建销毁物体，对象池了解一下

数据传输（DrawCall）优化

1 尽量使用共享材质

2 减少渲染的物体数量，可以减少模型顶点数量，或者尽量使用LOD以及遮挡剔除

3 尽量使用图集

4 动态/静态批处理

⚠️：数据传输：在渲染物体之前，物体模型顶点数据保存在内存中，CPU通过向GPU发送渲染指令后，数据会复制到显存中，然后进行渲染。在这个过程中，CPU向GPU发送渲染指令的过程，名为Draw Call。OpenGL中的渲染指令是指： glDrawArrays(GL_TRIANGLES, 0, amount_of_vertices);函数

⚠️：批处理：当我们在渲染一个场景时，该场景中包含非常多的简单模型，比如星星，草等，这些模型的顶点数据极少，但是每次单独渲染一个简单模型时都会调用一次Draw Call，渲染的速度很快，但是发送指令的过程是很慢的（CPU告诉GPU该从哪个缓冲读取数据，从哪寻找顶点属性，而且这些都是在相对缓慢的CPU到GPU总线(CPU to GPU Bus)上进行的），这就会使渲染整个场景的速度变得非常慢，但如果我们能将这些星星或者草一次性全部发给GPU去渲染，速度就会非常快，这就是批处理。批处理能节省Draw Call的数量，极大提升渲染速度。

GPU端优化（主要就是简化shader运算）：

1 注意渲染顺序，尤其是透明物体

2 尽量减少光照和阴影的开销，尽量使用烘焙光

3 使用mipmap优化纹理寻址

4 尽量简化shader计算量

5.能在顶点着色器计算，就不在片元着色器计算

6.模版测试（Stencil Test）与模版缓冲（Stencil Buffer）

模板缓冲和我们经常听到的颜色缓冲、深度缓冲几乎是一类东西。如果开启了模板测试，GPU会首先读取（使用读取掩码）模板缓冲区中该片元位置的模板值，然后将该值和读取（使用读取掩码）到的参考值（reference value）进行比较，这个比较函数可以是由开发者指定的，例如小于时舍弃该片元，或者大于等于时舍弃该片元。如果这个片元没有通过这个测试，该片元就会被舍弃。不管一个片元有没有通过模板测试，我们都可以根据模板测试和下面的深度测试结果来修改模板缓冲区，这个修改操作也是由开发者指定的。开发者可以设置不同结果下的修改操作，例如，在失败时模板缓冲区保持不变，通过时将模板缓冲区中对应位置的值加1等。模板测试通常用于限制渲染的区域。另外，模板测试还有一些更高级的用法，如渲染阴影、轮廓渲染等。

7.深度测试（Depth Test）

如果一个片元幸运地通过了模板测试，那么它会进行下一个测试——深度测试（Depth Test）。相信很多读者都听到过这个测试。这个测试同样是可以高度配置的。如果开启了深度测试，GPU会把该片元的深度值和已经存在于深度缓冲区中的深度值进行比较。这个比较函数也是可由开发者设置的，例如小于时舍弃该片元，或者大于等于时舍弃该片元。通常这个比较函数是小于等于的关系，即如果这个片元的深度值大于等于当前深度缓冲区中的值，那么就会舍弃它。这是因为，我们总想只显示出离摄像机最近的物体，而那些被其他物体遮挡的就不需要出现在屏幕上。如果这个片元没有通过这个测试，该片元就会被舍弃。和模板测试有些不同的是，如果一个片元没有通过深度测试，它就没有权利更改深度缓冲区中的值。而如果它通过了测试，开发者还可以指定是否要用这个片元的深度值覆盖掉原有的深度值，这是通过开启/关闭深度写入来做到的。我们在后面的学习中会发现，透明效果和深度测试以及深度写入的关系非常密切。

GBuffer Float[ 720 * 1280 * 4] 中转区：合格通过测试的点会把RGBA值、模板值、深度值等存入GBuffer。

关于GBuffer、FrontBuffer、FrameBuffer：

GBuffer选出来的像素，FrontBuffer只写入GBuffer的RGBA，推到显示器显示，之后退到后台变为FrameBuffer；

FrameBuffer同样也会只写入GBuffer的RGBA，推到显示器显示，之后退到后台变为FrontBuffer。如此交替显示，一帧一帧渲染显示，有了动画。

8.延迟渲染和前向渲染问题

正向渲染(Forward Rendering)
正向渲染是指每执行一次渲染命令，就会对需要渲染的物体进行光照着色，那么当场景中有m个光源，n个需要渲染的物体，那么时间复杂度就是O(m*n)。多光源时不适合使用正向渲染。
延迟渲染(Deferred Rendering)
为了解决正向渲染的不足之处，把渲染物体的光照着色分开计算，即先把所有是物体都渲染完成保存至GBuffer中，然后对GBuffer中的内容进行光照着色，这样只需要执行O(n)+O(m)次，因此适合处理多光源。

延迟渲染的不足之处

显而易见，延迟渲染需要一个临时缓冲区GBuffer，这样就会多浪费空间
又因为GBuffer的存在，延迟渲染不适合MSAA抗锯齿算法，因为多重采样需要使用更大的缓存空间，是GBuffer的四倍或更高，这样一般显卡都没办法提供那么大的空间，因此不适应MSAA。
延迟渲染无法处理混合，即渲染透明物体，因为G缓冲中所有的数据都是从一个单独的片段中来的，而混合需要对多个片段的组合进行操作。
延迟渲染只能对所有模型做统一的光照着色，使用一套光照算法。

9.阴影渲染的原理

阴影绘制的实现基础是Shadow Map算法

Shadow Map算法伪代码：

输入：顶点位置坐标

输出：在灯光空间下是否可见

bool ShadowMap(){
	1）在顶点坐标转换到灯光空间下，需要乘变换矩阵
	2）计算该顶点在灯光空间下的深度
	3）if（该顶点的深度值大于深度贴图中对应点点深度值）
			return false；
		else
			return true；
}

具体绘制过程如下：

1）在顶点坐标转换到灯光空间下，需要乘变换矩阵

将物体顶点数据通过矩阵运算转移到灯光空间下。

从局部空间转移到世界空间，在转移到灯光空间下，对于不同的灯光，有着不同的投影矩阵，这里涉及两种投影方式：正交投影和透视投影。两种投影方式分别对应着不同的投影矩阵及视觉效；

正交投影往往应用于2D游戏中，透视投影应用于3D游戏中，但并不绝对。在灯光坐标下渲染物体阴影:

2）计算该顶点在灯光空间下的深度

在灯光空间下创建一张深度纹理贴图，用于保存物体在灯光空间下的深度信息，此深度贴图则是摄像机的渲染目标。灯管空间下的物体深度信息将被保留在该深度贴图中。

渲染深度贴图的过程比较简单，首先在该视口下的顶点信息进行判断，如果某个顶点的深度值比深度贴图中的值小，就更新贴图数据，反之丢弃掉该数据，直到遍历一遍所有像素点为止。遍历完成后，便得到了深度信息图。

3）判断顶点的深度值与深度贴图中对应点点深度值的大小关系

获取到深度贴图后，如果某个点在光源视角下的深度值大于深度贴图中对应位置的深度值，就说明它被某个物体遮挡，因此是在阴影中的；反之，深度值小于深度贴图中的值，则不在阴影之中。

判断完成该顶点是否需要接收阴影后，需要做的最后一步就是对该顶点乘上阴影的颜色，遍历完一遍该物体的所有顶点后，便可得到该物体接收阴影的效果。

正交投影和透视投影有什么区别

摄像机在渲染管线中作用非常大，在游戏世界里，摄像机担任的角色类似于人的眼睛，摄像机所看到的内容最终会被绘制到屏幕上。为了模拟人的视野，摄像机具有近远平面和视野等属性，通过这些属性，可以绘制出一个视锥体，所有在视锥体内的物体初步判定为视野可见。

摄像机具有的最重要的属性是投影方式：即正交投影和透视投影。正交投影和透视投影两种投影方式的本质区别是投影矩阵的差异以及视锥体的不同。正交投影一般应用于平面或者2D游戏当中，使用正交投影矩阵进行平面映射。而透视投影一般应用于空间或者3D游戏。使用透视投影可以模拟人的视野，物体之间将具备更加贴近现实的遮挡关系，透视投影进行投影的方式是通过透视投影矩阵。

![image-20220616170114129](/Users/wujianqiang/Library/Application Support/typora-user-images/image-20220616170114129.png)

正交投影矩阵应用于一个立方体视口下，不在这个立方体之内的顶点都会被剔除掉。因为正交投影矩阵围成一个立方体，因此为了生成正交矩阵，就需要指定对应的长度、宽和高。当顶点坐标在这个立方体内，则视为视口可见，不会被剔除。

![image-20220616170131906](/Users/wujianqiang/Library/Application Support/typora-user-images/image-20220616170131906.png)

透视投影矩阵定义了一个锥体空间，其中最.重要的参数是FOV（Field of View），就是相机的视野角度。通过该角度和进平面远平面围成一个封闭的锥体，在该锥体范围内的物体将不会被裁剪掉。透视投影广泛应用于3D空间，因为它能模拟人的视角去观察物体。因此在透视矩阵下，物体能表现出深度信息与遮挡关系。

10.多级渐远纹理（mipmap）性能快的原因

在计算机渲染一个物体的时候，对于透视投影情况下，当该物体距离摄像机非常远时，映射到屏幕上的像素点非常少，这就导致采样命中率降低，这样纹理寻址速度会变慢，性能会降低。同时对于高分辨率的物体来说，也会造成不必要的内存浪费。

为了解决上述采样率过低的问题，出现了多级渐远纹理（mipmap）多级渐远纹理是以空间换时间的方案，通过保存原尺寸贴图的四分之一大小，直到最小尺寸为2*2为止。在纹理寻址的过程中，会选择与映射到屏幕时对应的像素点数最接近的一张纹理，然后使用该纹理做纹理寻址。

使用mipmap会造成多用33%的空间，但是使用它的好处也非常明显，换句话说就是使用空间换时间，利大于弊。对于阴影贴图来说，使用mipmap在做纹理寻址时也是一项重要优化。通过mipmap加快阴影映射，在性能上还能有一定程度的提升，但是当场景中物体离摄像机极远时，最好不要使用mipmap，因为这样会导致阴影极度模糊，造成阴影不真实的现象。

OpenGL使用一种叫做多级渐远纹理(Mipmap)的概念来解决这个问题，它简单来说就是一系列的纹理图像，后一个纹理图像是前一个的二分之一。多级渐远纹理背后的理念很简单：距观察者的距离超过一定的阈值，OpenGL会使用不同的多级渐远纹理，即最适合物体的距离的那个。由于距离远，解析度不高也不会被用户注意到。同时，多级渐远纹理另一加分之处是它的性能非常好。

11.采样和走样问题（抗锯齿）

场景的定义在三维空间中是连续的，而最终显示的像素则是一个离散的二维数组，这是计算机屏幕产生锯齿的原因。在计算机处理图形的过程中（渲染管线）有一个非常重要的阶段，就是光栅化，光栅化主要的作用是：将顶点数据的不连续性通过插值计算，将两个顶点之间不存在的点进行弥补，然后实现到屏幕像素点上的一一映射。

抗锯齿算法

⚠️：抗锯齿算法应用于硬件，且在光栅化阶段执行。

SSAA：超级采样抗锯齿 (Super-Sampling Anti-aliasing)，也叫SSAA，其原理比较好理解，就是直接“放大屏幕分辨率”。假设屏幕分辨率为800x600，那么4xSSAA会将屏幕渲染到1600x1200的缓冲区上，然后在下采样到800x600，SSAA可以得到非常好的抗锯齿效果，不过SSAA需要的计算量是非常大的，光栅化和片段着色器都是原来的4倍，渲染缓存的大小也是原来的4倍。4xSSAA就是放大4倍的意思。因为SSAA要浪费大量内存，因此基本没有大量应用。

MSAA：多重采样抗锯齿 (Multi-Sampling Anti-aliasing)，MSAA是对SSAA的改进，放弃了扩大像素分辨率，使用多重采样的方式，既然有多重采样，就有“单重采样”，而传统的采样方式就可以理解为“单重采样”，当然并不存在“单重采样”这个东西了。姑且这样叫它。“单重采样”就是一个像素点与一个采样点进行对应，而“多重采样”则是一个像素点与多个采样点进行对应。⚠️：MSAA不适合延迟渲染，这里说的不适合并不是不支持，延迟渲染也能支持MSAA，但是支持他就会大量浪费空间
PS：延迟渲染是什么,在这里不做过多介绍，总之他为了优化光照着色，需要一个GBuffer，这个就是临时渲染出的结果的缓存因为需要GBuffer，所以MSAA也需要进行临时保存，那么保存临时数据的后果则是浪费大量显存。
前面可知4x MSAA的显存消耗是4x的关系，假设我们按照2k的原生分辨率来做，一个RT就是64 MB，用来做MSAA的那个RT就会是不低于256MB。又因为GBuffer至少存depth，normal，basecolor3张RT，那三个MSAA RT就是768MB，这种消耗非常巨大，因此可以理解为“不支持”

CSAA：覆盖采样抗锯齿（Coverage Sampling Anti-Aliasing，简称CSAA）是NVIDIA在G80及其衍生产品首次推向实用化的AA技术，也是目前NVIDIA GeForce 8/9/G200系列独享的AA技术。CSAA就是在MSAA基础上更进一步的节省显存使用量及带宽，简单说CSAA就是将边缘多边形里需要取样的子像素坐标覆盖掉，把原像素坐标强制安置在硬件和驱动程序预先算好的坐标中。这就好比取样标准统一的MSAA，能够最高效率的执行边缘取样，效能提升非常的显著。比方说16xCSAA取样性能下降幅度仅比4xMSAA略高一点，处理效果却几乎和8xMSAA一样。8xCSAA有着4xMSAA的处理效果，性能消耗却和2xMSAA相同。

FSAA：FSAA(Fast Approximate AA)的核心思想是正常采样一个三角形，如果该三角形存在锯齿，则通过边缘检测查找出边界区域，然后使用没有锯齿的线段去替换有锯齿的边界，该方法和采样无关，因此速度很快。

TAA：TAA(Temporal AA),该方法的核心思想是复用上一帧渲染出的

包围盒问题（常出算法题）

https://blog.csdn.net/Windgs_YF/article/details/87884884#bounds%E5%8C%85%E5%9B%B4%E7%9B%92%E6%A6%82%E8%BF%B0%E4%B8%8E%E5%BA%94%E7%94%A8

12.三种旋转表达（四元数，欧拉角，矩阵）各自的优缺点

一、矩阵旋转：

优点：旋转轴可以是任意向量

缺点：旋转其实只需要知道一个向量+一个角度(共4个信息值)，但矩阵却用了16个元素(矩阵法消耗时间和内存)

二、欧拉角旋转

优点：容易理解，形象直观；表示更方便，只需要三个值(分别对应x、y、z轴的旋转角度)

缺点：欧拉角这种方法是要按照一个固定的坐标轴的顺序旋转的，因此不同的顺序会造成不同结果；欧拉角旋转会造成万向锁现象，这种现象的发生就是由于上述固定的坐标轴旋转顺序造成的。理论上，欧拉角旋转可以靠这种顺序让一个物体旋转到任何一个想要的方向，但如果在旋转中不幸让某些坐标轴重合，就会发生万向锁现象，这时就会丢失一个方向上的旋转能力(两个旋转轴(环)重叠)，也就是说在这种状态下，我们无论怎么旋转(还是按照原先的旋转顺序)，都不可能得到某些想要的结果，除非打破原先的旋转顺序或者同时旋转三个轴。

由于万向锁的存在，欧拉旋转无法实现球面平滑插值。

万向锁的简单解决办法：构造一个不同的旋转层级顺序，但是万向锁总是会在某一个顺序发生，调整旋转顺序不是根本解决办法。（Unity使用的是Z-X-Y顺规，即旋转顺序为z轴、x轴、y轴，虽然某些情况下会出现万向锁，但是这种顺规出现万向锁的概率最小）

万向锁解决办法：将欧拉角转换为四元数，对四元数进行Slerp插值，再将这一系列四元数转换为对应的欧拉角，然后作用于需要进行旋转的对象。这种做法缺点在于消耗内存，但是可以使物体任意旋转，灵活度高。

使用欧拉旋转出现旋转路径偏移的根本原因：在万向锁情况下对欧拉角的插值不是线性的。(突变)

静态欧拉角：其旋转轴使用的是静止不同的参考系。

动态欧拉角：使用object本身的坐标系，因而会随着object旋转而旋转。(局部坐标系会随着对象的旋转而旋转)

三、四元数旋转

优点：可以避免万向锁；只需要一个4维的四元数就可以执行绕任意过原点的向量的旋转，方便快捷，在某些实现下比旋转矩阵效率更高；而且四元数旋转可以提供平滑插值。

缺点：比欧拉旋转稍微复杂了一点，因为多了一个维度，理解更困难，不直观。

https://zhuanlan.zhihu.com/p/79894982

13.OpenGL中VA、VAO、VBO和EBO的区别

顶点数组(Vertex Array)

　　VA，顶点数组也是收集好所有的顶点，一次性发送给GPU。不过数据不是存储于GPU中的，绘制速度上没有显示列表快，优点是可以修改数据。

VAO（Vertex Array Object）顶点数组对象

　　VAO的全名是Vertex Array Object，首先，它不是Buffer-Object，所以不用作存储数据；其次，它针对“顶点”而言，也就是说它跟“顶点的绘制”息息相关。（VAO和VA没有任何关系）

　　VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。

　　OpenGL的核心模式要求我们使用VAO，所以它知道该如何处理我们的顶点输入。

VBO（Vertex Buffer Object）顶点缓冲区对象

　　VBO，全称为Vertex Buffer Object，与FBO，PBO并称，但它实际上老不少。就某种意义来说，他就是VA（Vertex Array）的升级版。

　　通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。

EBO（Element Buffer Object）索引缓冲对象

　　在渲染顶点这一话题上我们还有最有一个需要讨论的东西——索引缓冲对象(Element Buffer Object，EBO，也叫Index Buffer Object，IBO)。

　　和顶点缓冲对象一样，EBO也是一个缓冲，它专门储存索引，OpenGL调用这些顶点的索引来决定该绘制哪个顶点。

图元装配的过程

图元装配（Primitive Assembly）是对传入的顶点数据进行重新组装，将顶点着色器的输出作为输入，这一点正验证了渲染的过程是以流水线的形式进行的，图元装配会将顶点装配成指定的图形，与此同时，会进行裁剪、被面剔除等操作，以减少不必要的计算，加速渲染过程。

glDrawArrays与glDrawElements的功能和区别

glDrawArrays 和 glDrawElements 的作用都是从一个数据数组中提取数据渲染基本图元。(render primitives from array data )

他们只是用不同的方式来将客户端中的数据传送到服务器的地址空间中，OpenGL支持3种方式来完成这个操作：

（1）访问单独的数据元素（随机存储）

（2）创建一个单独数组元素的列表（系统存取）

（3）线性的处理数组元素。具体选用的数据访问方式取决于需要处理的问题类型。

glArrayElements()、glDrawElements()和glDrawRangeElements()能够对数据数组进行随机存取，但是glDrawArrays()只能按顺序访问它们。因为前者支持顶点索引的机制。

简单的说来，顶点索引就是把输入的顶点坐标值从0开始编号，并在一个单独的无符号类型数组中保存多个索引值组成的图元信息，从而进一步避免了重复指定顶点数据造成的冗余。

展开全文 >>

FFmpeg面试常见问题

2022-06-28

一、YUV的格式

　　1.planner模式

　　2.packet模式

　　3.半planner模式

　　https://www.jianshu.com/p/538ee63f4c1c YUV格式详解

二、H264基础概念

　　1.SPS

　　　a.profile

　　　b.视频长宽

　　2.PPS

　　　a.I帧

　　　b.P帧

　　　c.B帧

　　3.PTS和DTS

　　　PTS: 显示时间戳，表示解码后显示的时间

　　　DTS: 解码时间戳，表示送入解码器的顺序

　　4.H264存储的两个形态

　　　a.Annex B :

　　　　StartCode ：NALU单元，开头一般是0001或者001

　　　　防竞争字节：为了区分 0 0 0 1，它采用0 0 0 0x3 1作为区分

　　　　多用于网络流媒体中：rtmp、rtp格式

　　　b.AVCC :

　　　　表示NALU长度的前缀，不定长用4、2、1来存储这个NALU的长度

　　　　防竞争字节

　　多用于文件存储中 mp4的格式

1.音频播放过快，视频慢，如何选择丢帧

2.码率和分辨率都会影响视频的清晰度

3.生产者和消费者多多的关系

4.C++死锁的成因：

A.忘记释放锁

B.单线程重复申请锁,对同一个事物加两遍锁

C.双线程多锁申请,都是指对一个事物加锁

D.环形锁申请 A锁B、B锁A

5.sps和pps的区别

SPS是序列参数集 0x67

PPS是图像参数集 0x68

在SPS序列参数集中可以解析出图像的宽，高和帧率等信息。而在h264文件中，最开始的两帧数据就是SPS和PPS，这个h264文件只存在一个SPS帧和一个PPS帧。

7.AAC和PCM的区别

AAC在数据开始时候加了一些参数：采样率、声道、采样大小

FFMPEG:

图片如何合成视频

编码流程：

1.av_register_all

2.为AVFormatContext 分配内存

3.打开文件

4.创建输出码流AVSream

5.找到编码器

6.打开编码器

7.写文件头，没有的就不写入

8.循环编码视频像素数据->视频压缩数据

循环编码音频采样数据->音频压缩数据 ———>AVFrame转化为AVPacket

9.将编码后的视频码流写入文件 ——>AVPacket转化为AVFormat函数

10.关闭编码器

11.写文件尾

12.关闭资源文件

解码流程：

1.av_register_all

2.创建AVFormatContext的对象上下文

3.打开文件

4. avformat_find_stream_info

5.找到解码器

6.打开解码器

7.创建AVCodecContext上下文

8.av_read_frame ：将avPacket数据转换为avFrame数据

glUniform1i() ——>这个可以设置对应纹理的第几层

glTexSubImage2D() 和glTexImage2D区别————>替换纹理的内容

展开全文 >>

项目问题

2022-03-14

项目问题

1 MVC和MVVM的区别

1.1 MVC（Model View Control）：

C可以直接引用V和M，而V和M不能直接引用C，而V和M之间则是双黄线，它们俩谁也不能引用谁，你既不能在M里面写V，也不能在V里面写M。

1.1.1 对于View和Controller的交互

举例：比如按钮点击事件，是View来接收的，但是处理这个事件的应该是Controller，所以View把这个事件传递给了Controller。Controller实际上就是靶子，View只负责传递事件，不负责关心靶子是谁。这是V和C的一种交互方式，叫做target-action。

总结一下，就是主要通过三种方式：action-target用来负责传递特定的事件；dataSource-protocol用来通过回调的形式动态通过数据绘制界面；delegate-protocol提前约定了对一些事件的处理规则，当被规定的事件发生后，就按照协议的规定来进行处理。协议委托可以通过协议方法的参数由V向C传值。比如cell点击事件的协议方法，tableView通过indexPath参数告诉C是哪个cell被点击了。

1.1.2 Model和Controller的交互

M就是数据管理者，你可以理解为它直接和数据库打交道。这里的数据库可能是本地的，也可能是服务器上的，M会从数据库获取数据，也可能把数据上传给数据库。M也将提供属性或者接口来供C访问其持有的数据。我们就拿一个简单的需求作为例子，假如我想在一个模块中显示一段文字，这段文字是从网上获取下来的。

那么使用MVC的话，在C中肯定需要一个UILabel（V）作为属性来显示这段文字，而这段文字由谁来获取呢，肯定是由M来获取了。

1.2 MVVM（Model View ViewModel）：

1.2.1 诞生原因：

由于在MVC模式下，数据解析是放到controller里面进行处理的，而现如今随着产品功能越来越复杂，controller从model中获取到的原始数据需要经过的数据处理也越来越复杂，因此导致了Controller部分越来越臃肿。并且还有相当重要的一点：Controller被设计出来并不是处理数据解析的。因此专门为数据解析创建出了一个新的类：ViewModel。这就是MVVM的诞生。

为什么MVVM这个名字里面，没有Controller的出现（为什么不叫MVCVM，C去哪了）？

你只需要记住两点：

1、Controller的存在感被完全的降低了；

2、VM的出现就是Controller存在感降低的原因。

MVVM中，Controller不再像MVC那样直接持有Model了。想象Controller是一个Boss，数据是一堆文件（Model），如果现在是MVC，那么数据解析（比如整理文件）需要由Boss亲自完成，然而实际上Boss需要的仅仅是整理好的文件而不是那一堆乱七八糟的整理前的文件。所以Boss招聘了一个秘书，现在Boss就不再需要管理原始数据（整理之前的文件）了，他只需要去找秘书：你帮我把文件整理好后给我。
那么这个秘书就首先去拿到文件（原始数据），然后进行整理（数据解析），接下来把整理的结果给Boss。所以秘书就是VM了，并且Controller（Boss）现在只需要直接持有VM而不需要再持有M了。如果再进一步理解C、VM、M之间的关系：因为Controller只需要数据解析的结果而不关心过程，所以就相当于VM把“如何解析Model”给封装起来了，C甚至根本就不需要知道M的存在就能把工作做好。那么我们MVVM中的持有关系就是：C持有VM，VM持有M。
所以在实现MVVM中一种必要的思想就是：

一旦在实现Controller的过程中遇到任何跟Model（或者数据）相关的问题，就找VM要答案。

2.Qt DEMO的架构和功能设计

2.1 架构设计

采用MVC和MVVM混合架构（一开始不知道需求这么多，因此采用MVC架构，后面根据需求将部分功能模块的MVC架构变成MVVM架构）

2.2 功能设计

整个Qt DEMO分为三大功能部分：倒入导入播放转换输出

2.2.1 文件导入

通过饿汉单例模式创建接口的实例话对象

分析导入文件格式和基本信息

3.Qt中用到了哪些设计模式思维

单例模式：

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的，指向本身实例的类属性为静态，通过一个static静态成员方法返回唯一的对象实例

饿汉模式：

饿汉式单例模式，程序启动时就实例化了该对象，并没有推迟到第一次使用该对象时再进行实例化；如果运行过程中没有使用到，该实例对象就被浪费掉了。

class CSingleton {
public:
    static CSingleton* getInstance() {
        return &single;
    }

private:
    static CSingleton single;//直接实例化对象
    CSingleton();
    ~CSingleton();
    CSingleton(const CSingleton&){}

};
CSingleton CSingleton::single;

懒汉模式：

懒汉式单例模式，要使用时候在进行对象的实例化。

class CSingleton {
public:
    static CSingleton* getInstance() {
        if (single == nullptr) {//需要用到再进行实例化
            single = new CSingleton();
        }
        return single;
    }

private:
    static CSingleton* single;
    CSingleton();
    ~CSingleton();
    CSingleton(const CSingleton&){}

    //注意如果没有下面的释放资源类，在main函数中将手动释放资源
    class CRelease {
    public:
        ~CRelease() { delete single; }
    };
    static CRelease release;

};
CSingleton* CSingleton::single = nullptr;
CSingleton::CRelease CSingleton::release;

在多线程情况下的饿汉模式和懒汉模式：

饿汉单例模式的线程安全特性

饿汉单例模式中，单例对象定义成了一个static静态对象，它是在程序启动时，main函数运行之前就初始化好的，因此不存在线程安全问题，可以放心的在多线程环境中使用。

懒汉单例模式的线程安全特性

getInstance是个不可重入函数，也就它在多线程环境中执行，会出现∫问题。因此需要考虑加锁

class CSingleton
{
public:
	static CSingleton* getInstance()
	{
		// 获取互斥锁
		pthread_mutex_lock(&mutex);
		if (nullptr == single)
		{
			single = new CSingleton();
		}
		// 释放互斥锁
		pthread_mutex_unlock(&mutex);
		return single;
	}
private:
	static CSingleton *single;
	CSingleton() 
	~CSingleton() 
	{ 
		pthread_mutex_destroy(&mutex); // 释放锁
	}
	CSingleton(const CSingleton&);

	class CRelease
	{
	public:
		~CRelease() { delete single; }
	};
	static CRelease release;
	
	// 定义线程间的互斥锁
	static pthread_mutex_t mutex;
};
CSingleton* CSingleton::single = nullptr;
CSingleton::CRelease CSingleton::release;
// 互斥锁的初始化
pthread_mutex_t CSingleton::mutex = PTHREAD_MUTEX_INITIALIZER;

4.怎么封装2Dto3D算法

因为2Dto3D源代码丢失，只有编译后的32位的DLL文件，为了在64位的程序中调用该算法，采用Visual Studio提供的ATL来创建进程外COM组件服务。

ATL创建进程外COM组件服务（C++图解说明）_pathfinder1987的博客-CSDN博客_com服务

5.底层SDK用到了哪些设计模式

主要通过类工厂模式音视频流和每个特效filter链接起来

5.1 简单工厂模式：

结构组成：

工厂类(ShoesFactory)：工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。
抽象产品类(Shoes)：是具体产品类的继承的父类或实现的接口。
具体产品类(NiKeShoes\AdidasShoes\LiNingShoes)：工厂类所创建的对象就是此具体产品实例。

优点与不足：

优点： 结构简单，管理方式简单

缺点: 扩展性非常差，新增产品的时候，需要去修改工厂类。

// 音视频流抽象类
class IMediaStream
{
public:
    virtual ~IMediaStream() {}
    virtual (MEDIA_FRAME*) GetSample() = 0;
};

// 视频流
class IVideoStream : public IMediaStream
{
public:
    (MEDIA_FRAME*) GetSample()
    {
      	(MEDIA_FRAME*) pVideoSample=null;
        std::cout << "对该帧进行视频算法处理" << std::endl;
      	//.........//
      	retrun pVideoSample;
    }
};

// 音频流
class IAudioStream : public IMediaStream
{
public:
    (MEDIA_FRAME*) GetSample()
    {
     	 	(MEDIA_FRAME*) pAudioSample=null;
        std::cout << "对该帧进行音频算法处理" << std::endl;
      	//.........//
      	retrun pAudioSample;
    }
};

enum STREAM_TYPE
{
    VIDEO,
    AUDIO
};

// 总厂
class StreamFactory
{
public:
    // 根据Stream类型创建对应的对象
    IMediaStream *CreateStream(STREAM_TYPE type)
    {
        switch (type)
        {
        case VIDEO:
            return new IVideoStream();
            break;
        case AUDIO:
            return new IAudioStream();
            break;
        default:
            return NULL;
            break;
        }
    }
};

int main()
{
    StreamFactory streamFactory;

    // 从总工厂对象创建视频流对象
    IMediaStream *pIVideoStream = streamFactory.CreateStream(VIDEO);
    if (pIVideoStream != NULL)
    {
        // 从视频流中得到一帧数据
        (MEDIA_FRAME*) pVideoSample = pIVideoStream->GetSample();
				
      	//..................//
      
        // 释放资源
        delete pIVideoStream;
        pIVideoStream = NULL;
    }

    // 从总工厂对象创建音频流对象
    IMediaStream *pIAudioStream  = streamFactory.CreateStream(ADIDAS)
    if (pIAudioStream != NULL)
    {
        // 从音频流中得到一帧数据
        (MEDIA_FRAME*) pAudioSample = pAdidasShoes->Show();
				
      	//..................//
      
        // 释放资源
        delete pIAudioStream;
        pIAudioStream = NULL;
    }

    return 0;
}

5.2 工厂方法模式

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

结构组成：

抽象工厂类厂（ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
具体工厂类（NiKeProducer\AdidasProducer\LiNingProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。
抽象产品类（Shoes）：它是具体产品继承的父类（基类）。
具体产品类（NiKeShoes\AdidasShoes\LiNingShoes）：具体工厂所创建的对象，就是此类。

优点与不足：

优点： 工厂方法模式抽象出了工厂类，并把具体产品对象的创建放到具体工厂类实现。实现了一个工厂生产一类产品，不需要修改工厂类，只需要增加新的具体工厂类即可。

缺点： 每新增一个产品，就需要增加一个对应的产品的具体工厂类。相比简单工厂模式而言，工厂方法模式需要更多的类定义。

⚠️：抽象工厂类，提供了创建具体工厂类的纯虚函数，并通过具体工厂类来返回具体产品类

// 总厂
class StreamFactory
{
public:
    virtual IMediaStream *CreateStream() = 0;
    virtual ~StreamFactory() {}
};

// 视频流生产者/生产链
class VideoStreamProducer : public StreamFactory
{
public:
    IMediaStream *CreateStream()
    {
        return new IVideoStream();
    }
};

// 音频流生产者/生产链
class AudioStreamProducer : public ShoesFactory
{
public:
    IMediaStream *CreateStream()
    {
        return new IAudioStream();
    }
};

///////////////////////此段代码与5.1中相同////////////////////////////
// 音视频流抽象类
class IMediaStream
{
public:
    virtual ~IMediaStream() {}
    virtual (MEDIA_FRAME*) GetSample() = 0;
};

// 视频流
class IVideoStream : public IMediaStream
{
public:
    (MEDIA_FRAME*) GetSample()
    {
      	(MEDIA_FRAME*) pVideoSample=null;
        std::cout << "对该帧进行视频算法处理" << std::endl;
      	//.........//
      	retrun pVideoSample;
    }
};

// 音频流
class IAudioStream : public IMediaStream
{
public:
    (MEDIA_FRAME*) GetSample()
    {
     	 	(MEDIA_FRAME*) pAudioSample=null;
        std::cout << "对该帧进行音频算法处理" << std::endl;
      	//.........//
      	retrun pAudioSample;
    }
};
///////////////////////此段代码与5.1中相同////////////////////////////

int main()
{
    // ================ 生产视频流的流程 ==================== //
    // 总厂开设视频流生产线
    StreamFactory *pVideoStreamProducer = new VideoStreamProducer();
    // 视频流生产线产出视频
    IMediaStream *pIVideoStream = pVideoStreamProducer->CreateStream();
    // 从视频流中得到一帧数据
    (MEDIA_FRAME*) pVideoSample = pIVideoStream->GetSample();
    // 释放资源
    delete pIVideoStream;
    delete pVideoStreamProducer;

    // ================ 生产音频流的流程 ==================== //
    // 总厂开设音频流生产者
    StreamFactory *pAudioStreamProducer = new AudioStreamProducer();
    // 音频流生产线产出音频
   	IMediaStream *pIaudioStream = pAudioStreamProducer->CreateStream();
    // 从音频流中得到一帧音频数据
    (MEDIA_FRAME*) paudioSample = pIaudioStream->GetSample();
    // 释放资源
    delete pIaudioStream;
    delete pAudioStreamProducer;

    return 0;
}

5.3 抽象工厂模式

上面两种模式不管工厂怎么拆分抽象，都只是针对一类产品，如果需要多种产品，那就需要使用抽象工厂模式。抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

结构组成（和工厂方法模式一样）：

抽象工厂类厂（ShoesFactory）：工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
具体工厂类（NiKeProducer）：继承于抽象工厂，实现创建对应具体产品对象的方式。
抽象产品类（Shoes\Clothe）：它是具体产品继承的父类（基类）。
具体产品类（NiKeShoes\NiKeClothe）：具体工厂所创建的对象，就是此类。

优点与不足：

优点： 提供一个接口，可以创建多个产品族中的产品对象，同一类的多个产品对象不需要创建多个工厂。

缺点： 相比简单工厂模式而言，抽象工厂模式需要更多的类定义。

// 基类 视频流
class VideoStream
{
public:
    virtual (MEDIA_FRAME*) GetSample() = 0;
    virtual ~VideoStream() {}
};

// 基类 音频流
class AudioStream
{
public:
    virtual (MEDIA_FRAME*) GetSample() = 0;
    virtual ~AudioStream() {}
};

// 画面旋转后的视频流
class VideoStreamRotateFilter : public VideoStream
{
public:
    (MEDIA_FRAME*) GetSample()
    {
    		(MEDIA_FRAME*) pVideoSample = null;
        std::cout << "进行视频画面旋转处理" << std::endl;
        
        //.................//
        
        return pVideoSample;
    }
};

// 降噪处理后的音频流
class AudioStreamDenoiseFilter : public AudioStream
{
public:
     (MEDIA_FRAME*) GetSample()
    {
        (MEDIA_FRAME*) pAudioSample = null;
        std::cout << "进行音频降噪处理" << std::endl;
        
        //.................//
        
        return pAudioSample;
    }
};


// 总厂
class StreamFactory
{
public:
    virtual VideoStream *CreateStream() = 0;
		virtual AudioStream *CreateStream() = 0;
    virtual ~Factory() {}
};

// 音视频流生产者/生产链
class VideoAudioProducer : public StreamFactory
{
public:
    VideoStream *CreateStream()
    {
        return new VideoStreamRotateFilter();//画面旋转后的视频流
    }
	
		AudioStream *CreateStream()
    {
        return new AudioStreamDenoiseFilter();// 降噪处理后的音频流
    }
};

int main()
{
    // ================ 生产音视频流程 ==================== //
    // 音视频流生产厂开设音视频特效生产线
    StreamFactory *pVideoAudioStreamProducer = new VideoAudioProducer();
    
		// 音视频生产线产出画面旋转后的视频流
    VideoStream *pVideoStream = pVideoAudioStreamProducer->CreateStream();
		// 音视频生产线产出降噪处理后的音频流
    AudioStream *pAudioStream = pVideoAudioStreamProducer->CreateStream();
    
		// 得到旋转后的一帧视频流数据
    (MEDIA_FRAME*) pVideoSample =pVideoStream->GetSample();
		// 得到降噪后的一帧音频流数据
    (MEDIA_FRAME*) pAudioSample = pAudioStream->GetSample();
	
    // 释放资源
    delete pVideoStream;
		delete pAudioStream;
    delete pVideoAudioStreamProducer;
		pVideoStream =null;
		pAudioStream =null;
		pVideoAudioStreamProducer =null;
		
    return 0;
}

5.4 三种工厂模式总结：

特点：

简单工厂模式：一个工厂N个产品
工厂模式：N个工厂N个产品
抽象工厂模式：N个工厂M个产品

缺点（相对）：

简单工厂模式：违背了开放封闭原则（改动源码），产品多了会比较杂
工厂模式：产品多了会很杂，代码量稍大，产品多了会比较杂
抽象工厂模式：违背了开放封闭原则（改动源码），代码量大，产品多了会比较非常杂

优点（相对）：

简单工厂模式：代码量小，方便添加新的产品
工厂模式：不违背了开放封闭原则（不改动源码），方便添加新的产品
抽象工厂模式：模式灵活，调用方便

6.合并转换功能用到了哪些设计模式，以及如何进行合并转换的

合并转换的功能是：将多个音视频文件合并成一个，并进行编码输出。这里用到了观察者模式

具体思路是：

在视频，音频轨道各设置一个观察者，通过DTS，PTS来检查当前文件的视频，音频幕是否转换完成。当且仅当视频流轨道，音频流轨道均转换完成后，才进行下一个文件的音视频转换工作；若视频流轨道先转换完成的话，那么就对视频流进行插入黑帧，直到音频流轨道转换完成；若是音频流轨道先转换完成的话，那么就对音频流进行插入静音数据处理，直到视频流轨道转换完成。通过这种插帧补数据的方式让每个文件音视频流对齐。

⚠️：⾳频中DTS和PTS是相同的。
		视频中由于B帧需要双向预测，B帧依赖于其前和其后的帧，
		因此含B帧的视频解码顺序与显示顺序不同，即DTS与PTS不同。
		当然，不含B帧的视频，其DTS和PTS是相同的。

观察者模式原理：

观察者模式分为两个角色：观察者和监听者
观察者：

通知对于该事件感兴趣的监听者去处理
注册

监听者：处理事件

目标 Subject （事件）提供依赖于它的观察者 Observer 的注册（Attach）和注销（Detach）操作，并且提供了使得依赖于它的所有观察者同步的操作（Notify）。观察者 Observer 则提供一个 Update 操作，注意这里的 Observer 的 Update 操作并不在 Observer 改变了 Subject 事件目标状态的时候就对自己进行更新，这个更新操作要延迟到 Subject 对象发出 Notify 通知所有Observer 进行修改（调用 Update）。
观察者模式的使用场景：
1、当一个抽象模型有两个方面，其中一个方面依赖于另一个方面。可将这二者封装在独立的对象中以使它们可以各自独立的改变和复用；
2、当一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变；
3、当一个对象必须通知其他对象，而它又不能假定其它对象是谁，即这些对像都是松耦合的。

#include <iostream>
#include <string>
#include <map>
#include <vector>
 
using namespace std;
 
class StreamListener//监听者
{
public:
	StreamListener(string name):mname(name){}
	virtual void handleMessage(int message)const=0;
protected:
	string mname;
};
class VideoStreamListener:public StreamListener
{
public:
	VideoStreamListener(string name):StreamListener(name){}
	virtual void handleMessage(int message)const
	{
		switch(message)
		{
		case 1:
			cout<<mname<<"video stream conversion completed!"<<endl;
			break;
		case 2:
			cout<<mname<<"auido stream conversion completed!"<<endl;
			break;
		default:
			cout<<mname<<"error info!"<<endl;
			break;
		}
	}
};
class AudioStreamListener:public StreamListener
{
public:
	AudioStreamListener(string name):StreamListener(name){}
	virtual void handleMessage(int message)const
	{
		switch(message)
		{
		case 1:
			cout<<mname<<"video stream conversion completed!"<<endl;
			break;
		case 2:
			cout<<mname<<"auido stream conversion completed!"<<endl;
			break;
		default:
			cout<<mname<<"error info!"<<endl;
			break;
		}
	}
};

 
class StreamObserve
{
public:
	typedef map<int,vector<const StreamListener*>> _Mty;//一个事件对应一组监听者集合
	typedef vector<const StreamListener*> _Vty;
	void notify(int message)
	{
		_Mty::iterator fit = mymap.find(message);
		if(fit!=mymap.end())
		{
			_Vty::iterator it=fit->second.begin();
			while(it!=fit->second.end())
			{
				(*it)->handleMessage(message);
				it++;
			}
		}
	}
	void registerMessage(int message,const StreamListener* pls)//注册事件及其监听者
	{
		_Mty::iterator fit=mymap.find(message);
		if(fit != mymap.end())
		{
			fit->second.push_back(pls);
		}
		else
		{
			_Vty vec;
			vec.push_back(pls);
			mymap[message]=vec;
		}
	}
private:
	map<int,vector<const StreamListener*>>mymap;
};
int main()
{
  
  //生成两个监听者对象分别用于监听音视频流轨道
	VideoStreamListener videoStreamListener("videoStreamListener");
	AudioStreamListener audioStreamListener("audioStreamListener");
 
	StreamObserve streamObserve;
  //注册视频流轨道监听者及其对应感兴趣的事件
	streamObserve.registerMessage(1,&videoStreamListener);
	streamObserve.registerMessage(2,&videoStreamListener);
  
  //注册音频流轨道监听者及其对应感兴趣的事件
	streamObserve.registerMessage(1,&audioStreamListener);
	streamObserve.registerMessage(2,&audioStreamListener);

	streamObserve.notify(1);
  //传入事件1，根据上述注册，需要调动videoStreamListener和audioStreamListener去处理事件1
	
  return 0;
}

展开全文 >>

C++面试问题总结

2022-03-01

C++面试问题总结

https://www.nowcoder.com/discuss/124724

new和malloc的区别

答：

new是操作符，malloc是库函数
new在调用时先分配内存，然后调用构造函数，释放时调用析构函数
new自动分配内存，而malloc需要程序员指定大小
new可以被重载，malloc不行
new发生错误时抛出异常，malloc返回null

delete与 delete []区别

delete只会调用一次析构函数，而delete[]会调用每一个成员的析构函数。在More Effective C++中有更为详细的解释：“当delete操作符用于数组时，它为每个数组元素调用析构函数，然后调用operator delete来释放内存。”delete与new配套，delete []与new []配套

struct和class区别

答：

struct一般用于描述数据结构集合，而class是对一个对象数据的封装

本质区别在于strict默认继承访问权限为public，而class默认继承访问权限为private

结构体struct在C++和C中的区别

答：

C++的struct在声明时哭具备成员函数，静态函数，并且可以进行数据成员的初始化
C++的struct可以从其他类或者结构体中继承
C的strict默认访问权限全为public，不可以修改

static作用

对变量：

1.局部变量：

在局部变量之前加上关键字static，局部变量就被定义成为一个局部静态变量。

1）内存中的位置：静态存储区

2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

3）作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域随之结束。

这边需要注意的是：当static用来修饰局部变量的时候，它就改变了局部变量的存储位置（从原来的栈中存放改为静态存储区）及其生命周期（局部静态变量在离开作用域之后，并没有被销毁，而是仍然驻留在内存当中，直到程序结束，只不过我们不能再对他进行访问），但未改变其作用域。

2.全局变量

在全局变量之前加上关键字static，全局变量就被定义成为一个全局静态变量。

1）内存中的位置：静态存储区（静态存储区在整个程序运行期间都存在）

2）初始化：未经初始化的全局静态变量会被程序自动初始化为0（自动对象的值是任意的，除非他被显示初始化）

3）作用域：全局静态变量在声明他的文件之外是不可见的。准确地讲从定义之处开始到文件结尾。

注：static修饰全局变量，并未改变其存储位置及生命周期，而是改变了其作用域，使当前文件外的源文件无法访问该变量，好处如下：（1）不会被其他文件所访问，修改（2）其他文件中可以使用相同名字的变量，不会发生冲突。对全局函数也是有隐藏作用。而普通全局变量只要定义了，任何地方都能使用，使用前需要声明所有的.c文件，只能定义一次普通全局变量，但是可以声明多次（外部链接）。注意：全局变量的作用域是全局范围，但是在某个文件中使用时，必须先声明。

对类中的：

1.成员变量

　　　用static修饰类的数据成员实际使其成为类的全局变量，会被类的所有对象共享，包括派生类的对象。因此，static成员必须在类外进行初始化(\初始化格式： int base::var=10;)*，而不能在构造函数内进行初始化，不过也可以用const修饰static数据成员在类内初始化。因为静态成员属于整个类，而不属于某个对象，如果在类内初始化，会导致每个对象都包含该静态成员，这是矛盾的。*

特点：

1.不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。

2.静态数据成员可以成为成员函数的可选参数，而普通数据成员则不可以。

3.静态数据成员的类型可以是所属类的类型，而普通数据成员则不可以。普通数据成员的只能声明为所属类类型的指针或引用。

2.成员函数

用static修饰成员函数，使这个类只存在这一份函数，所有对象共享该函数，不含this指针。
静态成员是可以独立访问的，也就是说，无须创建任何对象实例就可以访问。base::func(5,3);当static成员函数在类外定义时不需要加static修饰符。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。因为静态成员函数不含this指针。

const关键字的作用

const的作用：

1.限定变量为不可修改。

2.限定成员函数不可以修改任何数据成员。

（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；

（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；

（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；

（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；

（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。

const与指针：

const char *p 表示指向的内容不能改变。

char * const p，就是将P声明为常指针，它的地址不能改变，是固定的，但是它的内容可以改变。

const和define区别

#define 是在编译的预处理阶段起作用，而 const 是在编译、运行的时候起作用。
#define 只是简单的字符串替换，没有类型检查。而 const 有对应的数据类型，是要进行判断的，可以避免一些低级的错误。
#define 只是进行展开，有多少地方使用，就替换多少次，它定义的宏常量在内存中有若干个备份； const 定义的只读变量在程序运行过程中只有一份备份。
const 常量可以进行调试的，define 是不能进行调试的，因为在预编译阶段就已经替换掉了。
编译器通常不为普通 const 常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高

为什么不可以同时用const和static修饰成员函数？

C++编译器在实现const的成员函数的时候为了确保该函数不能修改类的实例的状态，会在函数中添加一个隐式的参数const this*。但当一个成员为static的时候，该函数是没有this指针的。也就是说此时const的用法和static是冲突的。

我们也可以这样理解：两者的语意是矛盾的。static的作用是表示该函数只作用在类型的静态变量上，与类的实例没有关系；而const的作用是确保函数不能修改类的实例的状态，与类型的静态变量没有关系。因此不能同时用它们。

说说什么是函数指针，如何定义函数指针，有什么使用场景

答：函数指针是：指向函数的指针变量。每个函数都有一个入口地址，该入口地址就是函数指针所指向的地址

使用场景：一般用于回调函数，在播放器中，一般用于获取当前播放时长和一些播放信息。

函数指针和指针函数的区别

函数指针定义：函数指针是指向函数的指针变量。因此“函数指针”本身首先应是指针变量，只不过该指针变量指向函数。这正如用指针变量可指向整型变量、字符型、数组一样，这里是指向函数。

指针函数定义：指针函数的落脚点是一个函数，这个函数的返回值是一个指针，与普通函数类似，只是返回的数据类型不一样而已。

指针和引用的区别

本质上的区别是，指针是一个新的变量，只是这个变量存储的是另一个变量的地址，我们通过访问这个地址来修改变量。

而引用只是一个别名，还是变量本身。对引用进行的任何操作就是对变量本身进行操作，因此以达到修改变量的目的。

注：

(1)指针：指针是一个变量，只不过这个变量存储的是一个地址，指向内存的一个存储单元；而引用跟原来的变量实质上是同一个东西，只不过是原变量的一个别名而已。如：
int a=1;int *p=&a;
int a=1;int &b=a;
上面定义了一个整形变量和一个指针变量p，该指针变量指向a的存储单元，即p的值是a存储单元的地址。

而下面2句定义了一个整形变量a和这个整形a的引用b，事实上a和b是同一个东西，在内存占有同一个存储单元。

(2)可以有const指针，但是没有const引用（const引用可读不可改，与绑定对象是否为const无关）

注：引用可以指向常量，也可以指向变量。例如int &a=b，使引用a指向变量b。而为了让引用指向常量，必须使用常量引用，如const int &a=1; 它代表的是引用a指向一个const int型，这个int型的值不能被改变，而不是引用a的指向不能被改变，因为引用的指向本来就是不可变的，无需加const声明。即指针存在常量指针int const *p和指针常量int *const p，而引用只存在常量引用int const &a，不存在引用常量int& const a。

(3)指针可以有多级，但是引用只能是一级（int **p；合法而 int &&a是不合法的）

(4)指针的值可以为空，但是引用的值不能为NULL，并且引用在定义的时候必须初始化；

(5)指针的值在初始化后可以改变，即指向其它的存储单元，而引用在进行初始化后就不会再改变了。

(6)”sizeof引用”得到的是所指向的变量(对象)的大小，而”sizeof指针”得到的是指针本身的大小；

(7)指针和引用的自增(++)运算意义不一样；

(8)指针使用时需要解引用（*），引用则不需要；

野指针如何产生，如何避免

答：产生原因：一般是因为释放内存后没有把指针及时的置空

避免方法：

初始化的时候置空(void *p=NULL;)
申请内存的时候判空（assert(p);）
指针释放后置空（free(p);p=NULL;）

悬空指针与野指针区别

悬空指针：当所指向的对象被释放或者收回，但是没有让指针指向NULL；
野指针：那些未初始化的指针，或者说是指向位置地址的指针

Inline内联函数和宏函数的区别

inline：在c/c++中，为了解决一些频繁调用的小函数大量消耗栈空间（栈内存）的问题，特别的引入了inline修饰符，表示为内联函数。

主要区别在于：宏函数是在预编译时候把所有宏名用宏体代替，简单来说就是字符串的代替；而内联函数则是在编译的时候进行代码插入，编译器会在每处调用内联函数的地方将内联函数展开，这样子可以省去函数的调用开销，提高效率

decltype和volatile作用：

decltype:从表达式中推断出要定义变量的类型，但却不想用表达式的值去初始化变量。还有可能是函数的返回类型为某表达式的的值类型。

volatile：volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

堆和栈的区别

答：

1、堆栈空间分配区别

栈（操作系统）：由操作系统（编译器）自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

堆（操作系统）：一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。

2、堆栈缓存方式区别

栈使用的是一级缓存，它们通常都是被调用时处于存储空间中，调用完毕立即释放。

堆则是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。

3、堆栈数据结构区别

堆（数据结构）：堆可以被看成是一棵树，如：堆排序。

栈（数据结构）：一种先进后出的数据结构。

内存泄漏产生的主要原因

答：内存泄漏一般是指堆内存的泄漏，也就是程序在运行过程中动态申请的内存空间不再使用后没有及时释放，导致那块内存不能被再次使用。更广义的内存泄漏还包括未对系统资源的及时释放，比如句柄、socket等没有使用相应的函数释放掉，导致系统资源的浪费。

一般出现内存泄露的主要原因是：

new或malloc后没有delete或者free
子类继承父类时，父类的析构函数不是虚函数
windows句柄资源没有释放掉

如果父类的析构函数不是虚函数，则不会触发动态绑定（多态），结果就是只会调用父类的析构函数，而不会调用子类的析构函数，从而可能导致子类的内存泄漏（如果子类析构函数中存在free delete 等释放内存操作时）。也就是说当我们想去借助父类指针去销毁子类对象的时候，不能去销毁子类对象时，如果没有虚析构函数，那么释放一个由基类指针指向的派生类对象时，不会触发动态绑定，则只会调用基类的析构函数，不会调用派生类的。派生类中申请的空间则得不到释放导致内存泄漏。这也就是为什么基类需要虚析构函数的原因

C++的内存分区

栈区（stack）：主要存放函数参数以及局部变量，由系统自动分配释放。
堆区（heap）：由用户通过 malloc/new 手动申请，手动释放。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
全局/静态区：存放全局变量、静态变量；程序结束后由系统释放。
字符串常量区：字符串常量就放在这里，程序结束后由系统释放。
代码区：存放程序的二进制代码。

简述什么是面向对象编程

答：面向对象是一种编程思维，把一切东西都看成是一个个对象。每个对象都拥有各自的属性，把这些对象的拥有的属性变量和操作这些属性变量的函数打包成一个个类来进行表示。

面向过程：根据业务逻辑从上到下写代码
面向对象：将数据和函数绑定在一起，进行封装，这样能够更快速的开发程序，减少重复代码的重写过程

简述面向对象三大特性

封装将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互
继承
多态用父类的指针指向子类的实例，然后通过父类的指针调用实际子类的成员函数，实现多态（有两种方式：重写和重载）

重写：派生类存在和父类相同的函数（函数名，参数列表，返回值类型都一样），只是派生类中的该函数的函数体与父类中该函数的函数体不同（花括号内的东西不一样）

重载：同一个访问区间中存在不同参数列的同名函数

什么是多态？多态有什么用途？

C++ 多态有两种：静态多态（早绑定）、动态多态（晚绑定）。静态多态是通过函数重载实现的；动态多态是通过虚函数实现的。

1.定义：“一个接口，多种方法”，程序在运行时才决定要调用的函数。

2.实现：C++多态性主要是通过虚函数实现的，虚函数允许子类重写override(注意和overload的区别，overload是重载，是允许同名函数的表现，这些函数参数列表/类型不同）。

注：多态与非多态的实质区别就是函数地址是静态绑定还是动态绑定。如果函数的调用在编译器编译期间就可以确定函数的调用地址，并产生代码，说明地址是静态绑定的；如果函数调用的地址是需要在运行期间才确定，属于动态绑定。

3.目的：接口重用。封装可以使得代码模块化，继承可以扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。

4.用法：声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。

用一句话概括：在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。

关于重载、重写、隐藏的区别

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

Override(覆盖或重写)：是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
注：重写基类虚函数的时候，会自动转换这个函数为virtual函数，不管有没有加virtual，因此重写的时候不加virtual也是可以的，不过为了易读性，还是加上比较好。

Overwrite(重写)：隐藏，是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

构造函数类型以及作用

构造函数一共有三类：默认构造函数（无参构造函数）、一般构造函数、拷贝构造函数

默认构造函数（无参构造函数）：如果创建一个类你没有写任何构造函数,则系统会自动生成默认的构造函数，或者写了一个不带任何形参的构造函数
一般构造函数：一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
拷贝构造函数：拷贝构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中。参数（对象的引用）是不可变的（const类型）。此函数经常用在函数调用时用户定义类型的值传递及返回。

深浅拷贝的区别

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员(new对象)，那么浅拷贝就会出问题了
在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间

参考链接：https://www.cnblogs.com/alantu2018/p/8459250.html

错误写法：

// ConsoleApplication2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "iostream"
using namespace std;
class Rect
{
public:
	Rect()      // 构造函数，p指向堆中分配的一空间
	{
		p = new int(100);
	}
	~Rect()     // 析构函数，释放动态分配的空间
	{
		if (p != NULL)
		{
			delete p;//在释放rect2时候就会报错（ 在使用rect1复制rect2时，由于执行的是浅拷贝，只是将成员的值进行赋值，这时 rect1.p = rect2.p，也即这两个指针指向了堆里的同一个空间）
		}
	}
private:
	int width;
	int height;
	int *p;     // 一指针成员
};

int main()
{
	Rect rect1;
	Rect rect2(rect1);   // 复制对象（浅拷贝）
	return 0;
}

正确写法：

#include "stdafx.h"
#include "iostream"
using namespace std;
class Rect
{
public:
	Rect()      // 构造函数，p指向堆中分配的一空间
	{
		p = new int(100);
	}
	Rect(const Rect& r)
	{
		width = r.width;
		height = r.height;
		p = new int;    // 为新对象重新动态分配空间
		*p = *(r.p);
	}
	~Rect()     // 析构函数，释放动态分配的空间
	{
		if (p != NULL)
		{
			delete p;
		}
	}
private:
	int width;
	int height;
	int *p;     // 一指针成员
};

int main()
{
	Rect rect1;
	Rect rect2(rect1);   // 深拷贝（此时rect1的p和rect2的p各自指向一段内存空间，但它们指向的空间具有相同的内容，这就是所谓的“深拷贝”）
	return 0;
}

什么是默认拷贝构造函数

很多时候在我们都不知道拷贝构造函数的情况下，传递对象给函数参数或者函数返回对象都能很好的进行，这是因为编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值

虚函数和纯虚函数区别

虚函数是允许被其子类重新定义的成员函数。

虚函数的声明：virtual returntype func(parameter);引入虚函数的目的是为了动态绑定；

纯虚函数声明：virtual returntype func(parameter)=0；引入纯虚函数是为了派生接口。（使派生类仅仅只是继承函数的接口）

定义一个函数为虚函数，不代表函数为不被实现的函数。
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。
定义一个函数为纯虚函数，才代表函数没有被实现。
定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加 =0:

例如：

1	virtual void funtion()=0

引入原因

在很多情况下，基类本身生成对象是不合情理的。为了解决这个问题，方便使用类的多态性，引入了纯虚函数的概念，将函数定义为纯虚函数（方法：virtual ReturnType Function()= 0;）纯虚函数不能再在基类中实现，编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。称带有纯虚函数的类为抽象类。

特点：

- 当想在基类中抽象出一个方法，且该基类只做能被继承，而不能被实例化；（避免类被实例化且在编译时候被发现，可以采用此方法），也就是说声明了纯虚函数的类是一个抽象类。所以，用户不能创建类的实例，只能创建它的派生类的实例。

　　- 这个方法必须在派生类(derived class)中被实现；

目的：使派生类仅仅只是继承函数的接口。相当于在告诉子类的设计者，“你必须提供一个纯虚函数的实现，虽然我不知道你会怎样实现它”。

基类为什么需要虚析构函数？

防止内存泄漏。当我们想去借助父类指针去销毁子类对象的时候，不能去销毁子类对象时，如果没有虚析构函数，那么释放一个由基类指针指向的派生类对象时，不会触发动态绑定，则只会调用基类的析构函数，不会调用派生类的。派生类中申请的空间则得不到释放导致内存泄漏。

哪些函数不能成为虚函数？

不能被继承的函数和不能被重写的函数。

1）普通函数

普通函数不属于成员函数，是不能被继承的。普通函数只能被重载，不能被重写，因此声明为虚函数没有意义。因为编译器会在编译时绑定函数。

而多态体现在运行时绑定。通常通过基类指针指向子类对象实现多态。

2）友元函数

友元函数不属于类的成员函数，不能被继承。对于没有继承特性的函数没有虚函数的说法。

3）构造函数

首先说下什么是构造函数，构造函数是用来初始化对象的。假如子类可以继承基类构造函数，那么子类对象的构造将使用基类的构造函数，而基类构造函数并不知道子类的有什么成员，显然是不符合语义的。从另外一个角度来讲，多态是通过基类指针指向子类对象来实现多态的，在对象构造之前并没有对象产生，因此无法使用多态特性，这是矛盾的。因此构造函数不允许继承。

4）内联成员函数

我们需要知道内联函数就是为了在代码中直接展开，减少函数调用花费的代价。也就是说内联函数是在编译时展开的。而虚函数是为了实现多态，是在运行时绑定的。因此显然内联函数和多态的特性相违背。

5）静态成员函数

首先静态成员函数理论是可继承的。但是静态成员函数是编译时确定的，无法动态绑定，不支持多态，因此不能被重写，也就不能被声明为虚函数。、

什么是虚函数表

虚函数表：

多态是由虚函数实现的，而虚函数主要是通过虚函数表（V-Table）来实现的。

如果一个类中包含虚函数（virtual修饰的函数），那么这个类就会包含一张虚函数表，虚函数表存储的每一项是一个虚函数的地址。

这个类的每一个对象都会包含一个虚指针（虚指针存在于对象实例地址的最前面，保证虚函数表有最高的性能），这个虚指针指向虚函数表。

注：对象不包含虚函数表，只有虚指针，类才包含虚函数表，派生类会生成一个兼容基类的虚函数表。

原始基类的虚函数表

下图是原始基类的对象，可以看到虚指针在地址的最前面，指向基类的虚函数表（假设基类定义了3个虚函数）

单继承时的虚函数（无重写基类虚函数）

　　假设现在派生类继承基类，并且重新定义了3个虚函数，派生类会自己产生一个兼容基类虚函数表的属于自己的虚函数表。

　　 Derive Class继承了Base Class中的3个虚函数，准确说是该函数的实体地址被拷贝到Derive Class的虚函数列表中，派生新增的虚函数置于虚函数列表后面，并按声明顺序摆放。

单继承时的虚函数（重写基类虚函数）

　　现在派生类重写基类的x函数，可以看到这个派生类构建自己的虚函数表的时候，修改了base::x()这一项，指向了自己的虚函数。

多重继承时的虚函数（class Derived :public Base1,public Base2）

　　这个派生类多重继承了两个基类base1，base2，因此它有两个虚函数表。

　　它的对象会有多个虚指针（据说和编译器相关），指向不同的虚函数表。

详细解释可以参考博客：https://www.cnblogs.com/jin521/p/5602190.html

什么是菱形继承，如何解决

菱形继承：假设我们有类B和类C，它们都继承了相同的类A。另外我们还有类D，类D通过多重继承机制继承了类B和类C。因为上述图表的形状类似于钻石（或者菱形），因此这个问题被形象地称为钻石问题（菱形继承问题）
解决方法：继承时候改成虚基类，D把A放到了对象组的最下面，这个A同时属于B和C，通过虚基表指针指向虚继表，虚基表中存储的偏移量（头部），通过偏移量可以找到公共的A空间。

class A{
public:
	int m_a = 0;
};
//class B:public A{
class B :virtual public A{//改成虚基类，就能解决钻石问题
public:
	int m_b = 1;
};
//class C:public A{
class C :virtual public A{//改成虚基类，就能解决钻石问题
public:
	int m_c = 2;
};
class D :public B, public C{
public:
	int m_d = 3;
};
int main(){
	D d;
	d.m_d = 40;//正确
	d.m_c = 20;//正确

	//d.m_a=10;
	//继承采用class B:public A和class C:public A的话编译错误，对m_a的访问不明确

	//d.B::m_a=10;
	//d.C::m_a=12;
	//改为这样占了两个空间 但是两个m_a并不一样，违背了继承的初衷

	
	d.m_a = 100;
	//改成class B :virtual public A和class C :virtual public A的虚拟继承后编译正确
	return 0;
}

虚函数表存放的内容什么时候写入

在构造函数内部我们已经可以通过人为的方式，修改虚表指针的指向了，因此，我们有理由相信，在此之前虚表指针与虚表已经建立了联系。也就是说虚函数表是跟随类的，因此在编译阶段就应该初始化好这张表。而虚函数表指针是跟随对象产生的，所以应该要在编译阶段，由编译器在构造函数内部添加一段隐藏代码，隐藏代码的功能是把虚函数表的地址赋值给虚函数表指针。当对象在运行阶段被创建时，调用构造函数，在构造函数内部完成虚函数表指针的赋值操作，也就是把虚函数表写入对象的时机。

仿函数

仿函数（functor），就是使一个类的使用看上去像一个函数。其实现就是在一个类中实现一个operator(),这个类就具有了类似函数的行为，就是一个仿函数类了。

有些功能的的代码，会在不同的成员函数中用到，想复用这些代码有两种方法：

公共的函数：这是一个解决方法，不过函数用到的一些变量，就可能成为公共的全局变量，再说为了复用这么一片代码，就要单立出一个函数，也不是很好维护。
仿函数，写一个简单类，除了那些维护一个类的成员函数外，就只是实现一个operator()，在类实例化时，就将要用的，非参数的元素传入类中

示例代码：

class MyAdd
{
public:
	int operator()(int a, int b) { return a + b; }	//重载了（）运算符
};

int main(int argc, char** argv)
{
	MyAdd abcd;
	cout << MyAdd()(4,5) << endl;	//通过产生临时对象，进行调用
	cout << abcd(3, 4) << endl;		//先定义一个函数对象，通过函数对象进行调用
}

函数模板和类模版

函数模板

格式：

template <typename type> return-type function-name(parameter list)
{
   // 函数的主体
}

在这里，type 是函数所使用的数据类型的占位符名称。这个名称可以在函数定义中使用。

下面是函数模板的实例，返回两个数中的最大值：

#include <iostream>
#include <string>
 
using namespace std;
 
template <typename T>
inline T const& Max (T const& a, T const& b) 
{ 
    return a < b ? b:a; 
} 
int main ()
{
 
    int i = 39;
    int j = 20;
    cout << "Max(i, j): " << Max(i, j) << endl; 
 
    double f1 = 13.5; 
    double f2 = 20.7; 
    cout << "Max(f1, f2): " << Max(f1, f2) << endl; 
 
    string s1 = "Hello"; 
    string s2 = "World"; 
    cout << "Max(s1, s2): " << Max(s1, s2) << endl; 
 
    return 0;
}

输出结果如下：
	Max(i, j): 39
	Max(f1, f2): 20.7
	Max(s1, s2): World

类模板

格式：

template <class type> class class-name {
.
.
.
}

在这里，type 是占位符类型名称，可以在类被实例化的时候进行指定。您可以使用一个逗号分隔的列表来定义多个泛型数据类型。

下面的实例定义了类 Stack<>，并实现了泛型方法来对元素进行入栈出栈操作：

#include <iostream>
#include <vector>
#include <cstdlib>
#include <string>
#include <stdexcept>
 
using namespace std;
 
template <class T>
class Stack { 
  private: 
    vector<T> elems;     // 元素 
 
  public: 
    void push(T const&);  // 入栈
    void pop();               // 出栈
    T top() const;            // 返回栈顶元素
    bool empty() const{       // 如果为空则返回真。
        return elems.empty(); 
    } 
}; 
 
template <class T>
void Stack<T>::push (T const& elem) 
{ 
    // 追加传入元素的副本
    elems.push_back(elem);    
} 
 
template <class T>
void Stack<T>::pop () 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::pop(): empty stack"); 
    }
    // 删除最后一个元素
    elems.pop_back();         
} 
 
template <class T>
T Stack<T>::top () const 
{ 
    if (elems.empty()) { 
        throw out_of_range("Stack<>::top(): empty stack"); 
    }
    // 返回最后一个元素的副本 
    return elems.back();      
} 
 
int main() 
{ 
    try { 
        Stack<int>         intStack;  // int 类型的栈 
        Stack<string> stringStack;    // string 类型的栈 
 
        // 操作 int 类型的栈 
        intStack.push(7); 
        cout << intStack.top() <<endl; 
 
        // 操作 string 类型的栈 
        stringStack.push("hello"); 
        cout << stringStack.top() << std::endl; 
        stringStack.pop(); 
        stringStack.pop(); 
    } 
    catch (exception const& ex) { 
        cerr << "Exception: " << ex.what() <<endl; 
        return -1;
    } 
}

输出结果：
	7
	hello
	Exception: Stack<>::pop(): empty stack

19.类模板和模板类的区别

sizeof和strlen的区别？

功能不同：

sizeof是操作符，参数为任意类型，主要计算类型占用内存大小。

strlen（）是函数，其函数原型为：extern unsigned int strlen(char s）;其参数为char,strlen只能计算以”\0”结尾字符串的长度，计算结果不包括”\0”

32位，64位系统中，各种常用内置数据类型占用的字节数？

除*与long 不同其余均相同。

32位操作系统

char ：1个字节(固定)

(即指针变量): 4个字节(32位机的寻址空间是4个字节。同理64位编译器)(变化)

short int : 2个字节(固定)

int： 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 4个字节

unsigned long: 4个字节(变化*,其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)

64位操作系统

char ：1个字节(固定)

*(即指针变量): 8个字节

short int : 2个字节(固定)

int： 4个字节(固定)

unsigned int : 4个字节(固定)

float: 4个字节(固定)

double: 8个字节(固定)

long: 8个字节

unsigned long: 8个字节(变化*其实就是寻址控件的地址长度数值)

long long: 8个字节(固定)

STL相关问题

STL基本组成部分

通常认为，STL是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如表 1 所示。

STL的组成	含义
容器	一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。
算法	STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件中，少部分位于头文件中。
迭代器	在 C++ STL 中，对容器中数据的读和写，是通过迭代器完成的，扮演着容器和算法之间的胶合剂。
函数对象	如果一个类将 () 运算符重载为成员函数，这个类就称为函数对象类，这个类的对象就是函数对象（又称仿函数）。
适配器	可以使一个类的接口（模板的参数）适配成用户指定的形式，从而让原本不能在一起工作的两个类工作在一起。值得一提的是，容器、迭代器和函数都有适配器。
内存分配器	为容器类模板提供自定义的内存申请和释放功能，由于往往只有高级用户才有改变内存分配策略的需求，因此内存分配器对于一般用户来说，并不常用。

STL常见的容器和实现原理

1.array ：固定大小的顺序容器，它们保存了一个以严格的线性顺序排列的特定数量的元素

2.vector动态数组：

原理：连续的内存空间
性能：查找删除与数组性能一样，增加元素引发扩容时会有性能压力，一般为当前大小的两倍，然后把原数组的内容拷贝过去，接着释放原来的空间

size()表示数组中元素个数有多少，capacity()表示数组有多大容量

3.list 链表：

原理：双向链表
性能：常量性能的增删，不支持随机访问

4.deque：

原理：双端数组
性能：可以对头端进行插入删除操作
deque内部工作原理：deque内部有一个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。

4.map, multimap：

原理：以Key建立的红黑树
区别：multimap不存在at操作

红黑树虽然本质上是一棵二叉查找树，但它在二叉查找树的基础上增加了着色和相关的性质使得红黑树相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)

5.set，multiset:

原理：红黑树

红黑规则：

节点不是黑色，就是红色（非黑即红）
根节点为黑色
叶节点为黑色（叶节点是指末梢的空节点 Nil或Null）
一个节点为红色，则其两个子节点必须是黑色的（根到叶子的所有路径，不可能存在两个连续的红色节点）
每个节点到叶子节点的所有路径，都包含相同数目的黑色节点（相同的黑色高度）

6.unordered_map：

所有无序容器的底层实现都是Hash Map

原理：序容器存储键值对时，会先申请一整块连续的存储空间，但此空间并不用来直接存储键值对，而是存储各个链表的头指针，我们称其为桶，各键值对真正的存储位置是各个链表的节点。如图：

Pi表示存储的各个键值对

STL 标准库通常选用 vector 容器存储各个链表的头指针\

插入：将Key带入hash函数，会得到一个hash值（一个整数，用 H 表示）；将 H 和无序容器拥有桶()的数量 n 做整除运算（即 H % n），该结果即表示应将此键值对存储到的桶的编号；建立一个新节点存储此键值对，同时将该节点链接到相应编号的桶上。负载因子：容器存储的总键值对 / 桶数负载因子越大，意味着容器越满，即各链表中挂载着越多的键值对，这无疑会降低容器查找目标键值对的效率；反之，负载因子越小，容器肯定越空，但并不一定各个链表中挂载的键值对就越少。默认情况下，无序容器的最大负载因子为 1.0。如果操作无序容器过程中，使得最大复杂因子超过了默认值，则容器会自动增加桶数，并重新进行哈希，以此来减小负载因子的值。需要注意的是，此过程会导致容器迭代器失效，但指向单个键值对的引用或者指针仍然有效。这就是为什么在操作无序容器过程中，键值对的存储顺序有时会“莫名”的发生变动。
查找：将Key利用hash函数计算得到hash值H；H%n得到桶号码在这个桶的链表中找到key 获取其value

迭代器作用，什么时候失效

STL容器分为序列式容器和关联式容器：

序列式容器：
- vector、list、deque等
关联式容器：
- set、map、unordered_map、unordered_map等

对于序列式容器（list除外），对某节点操作时，会使对应节点及其后续迭代器失效

vector

push_back()：在元素末尾添加元素，当还有空间时，只会使尾迭代器失效。当空间已满，会将原数组拷贝到扩容后的新数组，使原迭代器全部失效。
pop_back()：尾删除，会使尾迭代器失效。
insert()：当有剩余空间时，会使插入点及以后的迭代器失效，无剩余空间时，所有迭代器全部失效
erase()：删除点及其以后的迭代器全部失效

deque

push_back()：使尾迭代器失效
push_front()：使头迭代器失效
pop_back()：使尾迭代器失效
pop_front()：使头迭代器失效
insert()和erase()：判断插入或删除点前后的元素数量，如果前方元素数量较少，则将前方所有元素向前移动，使插入点及其以前的迭代器全部失效。如果后方元素数量较少，则将后方所有元素向后移动，使插入点及其以后的迭代器全部失效。

list

由于list是用指针连接各个节点的，所以对节点进行操作时，只会使当前的迭代器失效，不会影响其他迭代器。

关联式容器

同list，只会影响当前节点的迭代器，不会对其他迭代器产生影响。

Vector具体原理：

1.vector是动态数组，所以和数组一样拥有一段连续的内存空间，并且起始地址不变。
2.因为vector地址空间是连续的，所以能高效的进行随机访问，时间复杂度为o(1)。
3.在vector中插入和删除元素，需要对现有元素进行复制、移动，时间复杂度为o(n)。
4.如果vector中存储的对象很大，或者构造函数复杂，那么插入等开销会很大。因为拷贝现有对象时需要调用拷贝构造函数。

vector扩容原理说明

新增元素：Vector通过一个连续的数组存放元素，如果集合已满，在新增数据的时候，就要分配一块更大的内存，将原来的数据复制过来，释放之前的内存，在插入新增的元素；
对vector的任何操作，一旦引起空间重新配置，指向原vector的所有迭代器就都失效了；
初始时刻vector的capacity为0，塞入第一个元素后capacity增加为1；
不同的编译器实现的扩容方式不一样，VS2015中以1.5倍扩容，GCC以2倍扩容。

vector在push_back以成倍增长可以在均摊后达到O(1)的事件复杂度，相对于增长指定大小的O(n)时间复杂度更好。
为了防止申请内存的浪费，现在使用较多的有2倍与1.5倍的增长方式，而1.5倍的增长方式可以更好的实现对内存的重复利用，因为更好。

vector扩容为什么以2倍增长

1、时间和空间的权衡，简单来说，空间分配的多，平摊时间复杂度低，但浪费空间也多。
2、均摊添加每个元素的开销最小。

vector扩容为什么以1.5倍增长

当 k =1.5 时，在几次扩展以后，可以重用之前的内存空间了。

理想分配方案是是在第N次分配的时候能重用之前N-1次释放的内存，如果按照1.5分配，1，1.5，3，4.5……当你需要分配4.5时，前面已分配5.5，你可以直接利用，把旧数据move过去。但选择两倍的增长比如像这样：1，2，4，8，16，32，… 每次需要申请的空间都大于用到前面释放的内存(4>2+1)，无法重用。

vector常用接口：

• 清空vector可以使用成员函数c.clear()
• 判断vector是否为空，可以使用成员函数empty()，如果为空返回true，否则返回false
• vector输出最后一个元素的引用可以用back()成员函数，如果容器为空，则行为未定义
• vector输出第一个元素的引用可以用front()成员函数，如果容器为空，则行为未定义
• vector支持用下标访问元素，类似数组一样c[n]其中n是一个无符号整数，如果n大于容器的长度，那么行为未定义
• vector为了防止越界访问，其中有成员函数c.at(n)，返回下标为n的元素的引用。如果下标越界，那么抛出out_of_range的异常
• pop_back()成员函数用来删除vector中的最后一个元素，如果容器为空会出现未定义行为。
• c.erase(it)成员函数，删除迭代器it所指向的元素，返回一个指向被删除元素之后的迭代器，如果it指向最后一个元素，那么返回以为尾后迭代器（通常是end()）。若it就是end()，那么行为未定义。
• c.erase(beg,ed)删除[beg,ed)范围的元素，同时返回最后一个元素的后面的迭代器，如果ed就是尾后迭代器，那么还返回一个尾后迭代器。

vector中begin和end函数返回的是什么？

begin返回的是第一个元素的迭代器，end返回的是最后一个元素后面位置的迭代器。前闭后开区间【）

vector中的reserve和resize的区别

reserve是直接扩充到已经确定的大小，可以减少多次开辟、释放空间的问题（优化push_back），就可以提高效率，其次还可以减少多次要拷贝数据的问题。reserve只是保证vector中的空间大小（capacity）最少达到参数所指定的大小n。reserve()只有一个参数。
resize()可以改变有效空间的大小，也有改变默认值的功能。capacity的大小也会随着改变。resize()可以有多个参数。

vector的reserve和capacity的区别？

reserve()用于让容器预留空间，避免再次分配内存；capacity()返回在重新进行分配以前所能容纳的元素数量。

vector中的size和capacity的区别

size表示当前vector中有多少个元素（finish - start）;
capacity函数则表示它已经分配的内存中可以容纳多少元素（end_of_storage - start）;

vector迭代器失效的情况

当插入一个元素到vector中，由于引起了内存重新分配，所以指向原内存的迭代器全部失效。当删除容器中一个元素后,该迭代器所指向的元素已经被删除，那么也造成迭代器失效。erase方法会返回下一个有效的迭代器，所以当我们要删除某个元素时，需要it=vec.erase(it)。

正确释放vector的内存(clear(), swap(), shrink_to_fit())

vec.clear()：清空内容，但是不释放内存。
vector().swap(vec)：清空内容，且释放内存，想得到一个全新的vector。 vec.shrink_to_fit()：请求容器降低其capacity和size匹配。 vec.clear();vec.shrink_to_fit();：清空内容，且释放内存。

vector中erase方法与算法（algorithn）中的remove方法区别

vector中erase方法真正删除了元素，迭代器不能访问了。
remove只是简单地将元素移到了容器的最后面，迭代器还是可以访问到。因为algorithm通过迭代器进行操作，不知道容器的内部结构，所以无法进行真正的删除。

vector与list区别

https://www.cnblogs.com/shijingjing07/p/5587719.html

vector与deque的区别：

vector对于头部的插入删除效率低，数据量越大效率越低。
deque相对而言，对头部的插入删除速度会比vector块。
vector访问元素时的速度会比deque快，这和两者的内部实现有关。

List原理

list是由双向链表实现的，因此内存空间是不连续的。
list的随机访问效率不好，需要遍历元素，时间复杂度为o(n)。
3.底层是双向链表，所以每个元素有两个指针的额外空间开销。
4.在任何位置都能高效地插入和删除元素。只要改变元素的指针值，不需要拷贝元素。

vector、list、queue选择原则：

需要对数据高效地随机访问(存取)，而不在乎插入和删除的效率，采用vector
需要大量插入、删除数据，而不关心随机访问数据，采用list
需要随机访问数据，而且关心前后增删数据的能力，采用deque
对数据中间的增删操作比较多:采用list，建议在排序的基础上，批量进行增删可以对运行效率提供最大的保证

map的底层实现

容器的数据结构是采用红黑树进行管理，插入的元素健位不允许重复，所使用的节点元素的比较函数，只对元素的健值进行比较，元素的各项数据可通过健值检索出来。map容器是一种关联容器。

map和unordered_map的实现机理：

map:是基于红黑树来实现的（红黑树是非常严格的平衡二叉搜索树），红黑树具有自动排序功能，红黑树的每一个节点都代表着map中的一个元素，因此对于map的查找，删除和插入操作都是对红黑树的操作。
unordered_map:是基于哈希表来实现的，查找的时间复杂度是O(1),在海量数据处理中有着广泛的应用。

map和unordered_map的优缺点

map的优点：（1）map是有序的（2）基于红黑树实现，查找的时间复杂度是O(n)
map的缺点：空间占用率比较高，因为内部实现了红黑树，虽然提高了运行效率，但是每个节点都要保存父亲节点和孩子节点和红黑树的性质，使得每一个节点都占用大量的空间。
适用的情况：对于要有序的结构，适用map
unordered_map的优点：因为内部是哈希表来实现的，所以查找效率会非常高
unordered_map的缺点：哈希表的建立比较费时
适用的情况：对于查找问题，适用unordered_map会更好一点。

map插入元素方法

map<int, string> mapStudent;
1 mapStudent.insert(pair<int, string>(1, “student_one”));
2 mapStudent.insert(map<int, string>::value_type (1, “student_one”));
3 mapStudent[1] = “student_one”;
以上三种用法，虽然都可以实现数据的插入，但是它们是有区别的，当然了第一种和第二种在效果上是完成一样的，用insert函数插入数据，在数据的插入上涉及到集合的唯一性这个概念，即当map中有这个关键字时，insert操作是插入数据不了的，但是用数组方式就不同了，它可以覆盖以前该关键字对应的值

为什么map和set的插入删除效率比其他序列容器高

因为不需要内存拷贝和内存移动

当数据元素增多时（从10000到20000），map的set的查找速度会怎样变化？

红黑树采用二分查找法，时间复杂度为logn，所以从10000增到20000时，查找次数从log10000=14次到 log20000=15次，多了1次而已。

map 、set、multiset、multimap的特点

set和multiset会根据特定的排序准则自动将元素排序，set中元素不允许重复，multiset可以重复。 map和multimap将key和value组成的pair作为元素，根据key的排序准则自动将元素排序（因为红黑树也是二叉搜索树，所以map默认是按key排序的），map中元素的key不允许重复，multimap可以重复。 map和set的增删改查速度为都是logn，是比较高效的。

为什么map和set每次insert之后，以前保存的iterator不会失效？

存储的是结点，不需要内存拷贝和内存移动。插入操作只是结点指针换来换去，结点内存没有改变。而iterator就像指向结点的指针，内存没变，指向内存的指针也不会变。 6

为何map和set不能像vector一样有个reserve函数来预分配数据?

在map和set内部存储的已经不是元素本身了，而是包含元素的结点。也就是说map内部使用的Alloc并不是 map声明的时候从参数中传入的Alloc。

set底层实现

底层是红黑树，set会根据待定的排序准则，自动将元素排序。不允许元素重复。

set, multiset (map,multimap)

set和multiset会根据特定的排序准则自动将元素排序，set中元素不允许重复，multiset可以重复。因为是排序的，所以set中的元素不能被修改，只能删除后再添加。

set的底层实现实现为什么不用哈希表而使用红黑树？

set中元素是经过排序的，红黑树也是有序的，哈希是无序的如果只是单纯的查找元素的话，那么肯定要选哈希表了，因为哈希表在的最好查找时间复杂度为O(1)，并且如果用到set中那么查找时间复杂度的一直是O（1），因为set中是不允许有元素重复的。而红黑树的查找时间复杂度为O(lgn)

hash表

hash表的实现，包括STL中的哈希桶长度常数。
hash表的实现主要涉及两个问题：散列函数和碰撞处理。
1）hash function （散列函数）。最常见的散列函数：f(x) = x % TableSize .
2）碰撞问题（不同元素的散列值相同）。解决碰撞问题的方法有许多种，包括线性探测、二次探测、开链等做法。SGL版本使用开链法，使用一个链表保持相同散列值的元素。

你怎样理解迭代器？

Iterator(迭代器)用于提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示，相当于智能指针。

迭代器失效问题

vector 迭代器
当插入一个元素后，插入点之前的迭代器如果未扩容则不受影响，插入点之后的迭代器失效；
当插入一个元素后，capacity 如果有变化，则容器需要重新分配内存，所有迭代器都会失效；
当进行删除操作后，指向删除点及之后元素的迭代器全部失效。
deque 迭代器
在容器 begin/end 插入操作所有迭代器不受影响；
在容器非 begin/end 的位置插入和删除操作都会使指向该容器元素的所有迭代器失效。
在容器 begin/end 删除元素会使指向被删除元素的迭代器失效；
List/forward_list 迭代器
list insert 操作不会使 list 迭代器失效；
list erase 操作会使当前指向被删除元素的迭代器失效，其它迭代器正常。
set 迭代器
set 的 insert 操作不会使 set 迭代器失效；
set erase操作会使当前指向被删除元素的迭代器失效，其它迭代器正常。
map 迭代器
map 的 insert 操作不会使 map 迭代器失效；
map erase 删除操作会使当前指向被删除元素的迭代器失效

vector为何每次insert之后，以前保存的iterator不会失效?

答:iterator这里就相当于指向节点的指针，内存没有变，指向内存的指针怎么会失效呢(当然被删除的那个元素本身已经失效了)。相对于vector来说，每一次删除和插入，指针都有可能失效，调用push_back在尾部插入也是如此。因为为了保证内部数据的连续存放，iterator指向的那块内存在删除和插入过程中可能已经被其他内存覆盖或者内存已经被释放了。即使时push_back的时候，容器内部空间可能不够，需要一块新的更大的内存，只有把以前的内存释放，申请新的更大的内存，复制已有的数据元素到新的内存，最后把需要插入的元素放到最后，那么以前的内存指针自然就不可用了。特别时在和find等算法在一起使用的时候，牢记这个原则:不要使用过期的iterator。

vector、list、map、deque用erase（it）后，迭代器的变化。

vector和deque是序列式容器，其内存分别是连续空间和分段连续空间，删除迭代器it后，其后面的迭代器都失效了，此时it及其后面的迭代器会自动加1，使it指向被删除元素的下一个元素。
list删除迭代器it时，其后面的迭代器都不会失效，将前面和后面连接起来即可。
map也是只能使当前删除的迭代器失效，其后面的迭代器依然有效。

不允许有遍历行为的容器有哪些（不提供迭代器）？

1）queue，除了头部外，没有其他方法存取deque的其他元素。
2）stack（底层以deque实现），除了最顶端外，没有任何其他方法可以存取stack的其他元素。
3）heap，所有元素都必须遵循特别的排序规则，不提供遍历功能。

stl中alloc

SGI 版本STL的默认配置器std::alloc。参见：《STL源码剖析》
1）考虑到小型区块所可能造成的内存碎片问题，SGI设计了双层配置器。第一级配置器直接使用malloc()和free()；第二级则视情况采取不同的策略：当配置区块超过128bytes时，视为“足够大”，便调用第一级配置器；当配置区块小于128bytes时，视之为“过小”，为了降低额外负担，便采用memory pool（内存池）整理方式，而不在求助于第一级配置器。
2）内存池的核心：内存池和16个自由链表（各自管理8,16，…，128bytes的小额区块）。在分配一个小区块时，首先在所属自由链表中寻找，如果找到，直接抽出分配；若所属自由链表为空，则请求内存池为所属自由链表分配空间；默认情况下，为该自由链表分配20个区块，若内存池剩余容量不足，则分配可分配的最大容量；若内存池连一个区块都无法分配，则调用chunk_alloc为内存池分配一大块区块；若内存不足，则尝试调用malloc分配，否则返回bad_alloc异常。

STL线程不安全的情况

在对同一个容器进行多线程的读写、写操作时；
在每次调用容器的成员函数期间都要锁定该容器；
在每个容器返回的迭代器（例如通过调用begin或end）的生存期之内都要锁定该容器；在每个在容器上调用的算法执行期间锁定该容器。

priority_queue的底层原理

priority_queue：优先队列，其底层是用堆来实现的。在优先队列中，队首元素一定是当前队列中优先级最高的那一个。

说几个C++11的新特性

auto类型推导
空指针常量nullptr
范围for循环
lambda函数
override 和 final 关键字
线程支持、智能指针等

（1）auto

C++11中引入auto第一种作用是为了自动类型推导

auto的自动类型推导，用于从初始化表达式中推断出变量的数据类型。通过auto的自动类型推导，可以大大简化我们的编程工作

auto实际上实在编译时对变量进行了类型推导，所以不会对程序的运行效率造成不良影响

另外，似乎auto并不会影响编译速度，因为编译时本来也要右侧推导然后判断与左侧是否匹配。

使用auto实现任意两个数的加法

clipboard

decltype实际上有点像auto的反函数，auto可以让你声明一个变量，而decltype则可以从一个变量或表达式中得到类型

1 2	int x = 3; decltype(x) y = x;

（2）nullptr空指针

nullptr是为了解决原来C++中NULL的二义性问题而引进的一种新的类型，因为NULL实际上代表的是0，以往我们使用NULL表示空指针。它实际上是个为0的int值

（3）for容器遍历

在C++11 中for循环可以使用类似java的简化的for循环，可以用于遍历数组，容器，string以及由begin和end函数定义的序列（即有Iterator），示例代码如下：

map<string, int> m{{"a", 1}, {"b", 2}, {"c", 3}};
for (auto p : m){
    cout<<p.first<<" : "<<p.second<<endl;
}

（4）lambda表达式

使用lambda表达式统计字符串个数，以及大写字母个数

clipboard[3]

（5）override、final

override表示重写基类的虚函数

final表示禁止重写基类虚函数

clipboard[4]

（6）move构造函数

C++11中，std::move()函数位于头文件中，这个函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，通过右值引用使用该值，实现移动语义。注意:被转化的左值，其声明周期并没有随着左右值的转化而改变，即std::move转化的左值变量lvalue不会被销毁。

clipboard[6]

左值：指向稳定的内存空间

右值：指向临时的内存空间

clipboard[5]

（7）线程库

C++11中最重要的特性就是对线程进行支持了，使得C++在并行编程时不需要依赖第三方库，而且在原子操作中还引入了原子类的概念。要使用标准库中的线程，必须包含< thread >头文件，该头文件声明了 std::thread 线程类。

线程的启动

C++线程库通过构造一个线程对象来启动一个线程，该线程对象中就包含了线程运行时的上下文环境，比如:线程函数、线程栈、线程起始状态等以及线程ID等，所有操作全部封装在一起，最后在底层统一传递给 _beginthreadex() 创建线程函数来实现 (注意 : _beginthreadex是windows中创建线程的底层c函数)。 std::thread()创建一个新的线程可以接受任意的可调用对象类型(带参数或者不带参数)，包括lambda表达式(带变量捕获或者不带)，函数，函数对象，以及函数指针。

// 使用lambda表达式作为线程函数创建线程 
int main()
{
	int n1 = 500;
	int n2 = 600;

	thread t([&](int addNum) {
		n1 += addNum;
		n2 += addNum;
		}, 500);
	t.join();

	std::cout << n1 << ' ' << n2 << std::endl;	// 1000 1100
	return 0;
}

线程的结束

启动了一个线程后，当这个线程结束的时候，如何去回收线程所使用的资源呢?thread库给我们两种选择:

加入式:join()
join():会主动地等待线程的终止。在调用进程中join()，当新的线程终止时，join()会清理相关的资源，然后返回，调用线程再继续向下执行。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程的对象每次你只能使用一次join()，当你调用的join()之后joinable()就将返回false了。
分离式:detach()
detach:会从调用线程中分离出新的线程，之后不能再与新线程交互。就像是你和你女朋友分手，那之后你们就不会再有联系(交互)了，而她的之后消费的各种资源也就不需要你去买单了(清理资源)。此时调用joinable()必然是返回false。分离的线程会在后台运行，其所有权和控制权将会交给 c++运行库。同时，C++运行库保证，当线程退出时，其相关资源的能够正确的回收。

注意:必须在thread对象销毁之前做出选择，这是因为线程可能在你加入或分离线程之前，就已经结束了，之后如果再去分离它，线程可能会在thread对象销毁之后继续运行下去。

原子性操作库(atomic)

多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。C++98中传统的解决方式:可以对共享修改的数据可以加锁保护。虽然加锁可以解决，但是加锁有一个缺陷就是:只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。因此C++11中引入了原子操作。

展开全文 >>

进程内COM接口的代码实现

2021-02-15

进程内COM接口的代码实现

深入CoCreateInstance()：

客户端程序调用CoCreateInstance()，传递组件对象类的CLSID以及所要接口的IID。
COM库在HKEY_CLASSES_ROOT\CLSID.键值下查找服务器的CLSID键值，这个键值包含服务器的注册信息。
COM库读取服务器DLL的全路径并将DLL加载到客户端的进程空间。
COM库调用在服务器中DllGetClassObject()函数为所请求的组件对象类请求类工厂。
服务器创建一个类工厂并将它从DllGetClassObject()返回。
COM库在类工厂中调用CreateInstance()方法创建客户端程序请求的COM对象。
CreateInstance()返回一个接口指针到客户端程序。

步骤

1.创建一个COM接口

.h文件：

more >>

展开全文 >>

2020年在万兴担任音视频开发工程师时的年度总结报告

2021-02-09

文件下载地址如下所示：

https://github.com/qiangwu666/-/

展开全文 >>

进程通信——管道通信

2021-01-12

进程通信——管道通信

服务器端：

#include <Windows.h>
#include <iostream>
using namespace std;
 
#define BUF_SIZE 4096
HANDLE h_Mypipe = NULL;

//步骤1：定义管道名，点表示当前主机，pipe表示管道
#define MY_NAMED_PIPE   L"\\\\.\\pipe\\Named_Pipe"
 
int main(int argc, char ** argv)
{
	//步骤2：创建命名管道
	h_Mypipe = CreateNamedPipe(
		MY_NAMED_PIPE, //为命名管道创建名称
		PIPE_ACCESS_DUPLEX, //管道访问方式：PIPE_ACCESS_DUPLEX指双向模式
		PIPE_TYPE_MESSAGE | //命名管道句柄的写入方式：以数据块的方式写入管道
		PIPE_READMODE_MESSAGE | //命名管道句柄的读取方式：以数据块的方式从管道读取
		PIPE_WAIT, //命名管道句柄的等待方式：阻塞方式
		PIPE_UNLIMITED_INSTANCES, //管道所能创建的最大实例个数：1~255，
		0, //管道的输出缓冲区容量，0表示默认大小
		0, //管道的输入缓冲区容量，0表示默认大小 1000, //管道的默认等待超时，单位毫秒
		NULL //管道的安全性，NULL表示windows提供的默认安全
    );
 
	//INVALID_HANDLE_VALUE是CreateNamedPipe返回值，表示创建失败
	if (h_Mypipe == INVALID_HANDLE_VALUE)
	{
		cout << "Create Named_Pipe Failed..." << endl;
		return 1;
	}
 
	//步骤3：等待客户端的连接
	if (!ConnectNamedPipe(h_Mypipe, NULL))
	{
		cout << "Connect Failed..." << endl;
		return 1;
	}
	else
		cout << "Connect Successed..." << endl;
 
	DWORD wLen = 0;
	DWORD rLen = 0;
	char szBuffer[BUF_SIZE] = { 0 };
 
	//步骤4：读写管道
	while (1)
	{
		//向客户端发送数据
		cin.getline(szBuffer, BUF_SIZE);
		cout << "服务器端发送数据：" << szBuffer<< endl;
		if (!WriteFile(h_Mypipe, szBuffer, strlen(szBuffer) + 1, &wLen, NULL))
			cout << "Write Failed..." << endl;
		else
			cout<<"服务器端发送成功：共"<< wLen<<"byte"<<endl;
		//清除缓冲区
		//memset(szBuffer, 0, BUF_SIZE);
		//读取客户端数据
		if (!ReadFile(h_Mypipe, szBuffer, BUF_SIZE, &rLen, NULL))
			cout << "Read Failed..." << endl;
		else
			cout << "服务器接收客户端数据：" << szBuffer << ", 共" << rLen << "byte" << endl;
	}
 
	//步骤5：关闭管道
	DisconnectNamedPipe(h_Mypipe);
	CloseHandle(h_Mypipe);
	return 0;
}

more >>

展开全文 >>

进程通信——共享内存

2021-01-11

进程通信——共享内存

写入端

#include <iostream>
#include <Windows.h>
 
using namespace std;
#define BUF_SIZE 4096//数据传输大小
HANDLE H_Mutex = NULL;
HANDLE H_Event = NULL;
 
int main(int argc,char ** argv)
{
	//步骤1：创建共享文件句柄
	HANDLE shared_file = CreateFileMapping(
		INVALID_HANDLE_VALUE,//物理文件句柄
		NULL,  //默认安全级别
		PAGE_READWRITE,      //PAGE_READWRITE表示可读可写，PAGE_READONLY表示只读，PAGE_WRITECOPY表示只写
		0,  //高位文件大小
		BUF_SIZE,  //低位文件大小
		L"ShareMemory"  //共享内存名称
	);  
	
	if (shared_file == NULL)
	{
		cout<<"Could not create file mapping object..."<<endl;
		return 1;
	}
	//步骤2：映射缓存区视图，得到指向共享内存的指针
	LPVOID lpBUF = MapViewOfFile(
		shared_file, //已创建的文件映射对象句柄
		FILE_MAP_ALL_ACCESS,//访问模式:可读写
		0, //文件偏移的高32位
		0, //文件偏移的低32位
		BUF_SIZE //映射视图的大小
	);
	if (lpBUF == NULL)
	{
		cout << "Could not create file mapping object..." << endl;
		CloseHandle(shared_file);
		return 1;
	}
	H_Mutex = CreateMutex(NULL, FALSE, L"sm_mutex");
	H_Event = CreateEvent(NULL, FALSE, FALSE, L"sm_event");
 
	//步骤3：操作共享内存
	char Buffer[97];
	while (1)
	{
		cout << "A proccess:Please input the content to the process B" << endl;
		cin.getline(Buffer,97);
		cout << "Buffer: " <<Buffer<< endl;
		WaitForSingleObject(H_Mutex, INFINITE); //使用互斥体加锁
		memcpy(lpBUF, Buffer, strlen(Buffer)+1);
		ReleaseMutex(H_Mutex); //放锁
		SetEvent(H_Event);
	}
 
	CloseHandle(H_Mutex);
	CloseHandle(H_Event);
	//步骤4：解除映射和关闭句柄
	UnmapViewOfFile(lpBUF);
	CloseHandle(shared_file);
	return 0;
}

more >>

展开全文 >>

总结下C++中模块(Dll)对外暴露接口的方式

2020-12-16

总结下C++中模块(Dll)对外暴露接口的方式：

(1)导出API函数的方式

这种方式是Windows中调用DLL接口的最基本方式，GDI32.dll, User32.dll都是用这种方式对外暴露系统API的。

优点：

导出函数没有语言限制，什么语言都能调用；

缺点：

这种方式是面向过程的，外部如果要支持多实例等不是很方便，另外它要求的回调函数(callback)只能是普通C函数，C++中我们通常用类静态成员函数，很不方便。

当然，我们通过封装其实也可以让这种方式支持多实例。

通过一个抽象句柄HComponent，比如:

more >>

展开全文 >>

QT工作学习笔记

2020-08-16

QT工作学习笔记

1 2	menu->exec(QCursor::pos()); //QCursor::pos()：获取鼠标绝对位置，在用户右键后在当前位置显示菜单选项

menu->exec()和menu->popup的区别：

https://www.cnblogs.com/qianguyihao/p/4133292.html

1	QApplication::setOverrideCursor(Qt::WaitCursor);//设置鼠标为等待光标

Qt中foreach及QList的使用

QList是一个最常用的容器类，用它定义一个对象通常是
QList list;
其中int代表给定的类型，也就是说现在定义了一个有符号整形的容器，让后给里面装值
list<<2<<3<<4<<6;
现在就可以使用foreach(int i,list)这样就可以遍历整个容器了

它告诉QT不要定义moc关键字signals,slots和emit，因为这些名字可能将被用于第三方库，例如Boost。你只需简单的用QT宏将他们替换为 Q_SIGNALS, Q_SLOTS，和 Q_EMIT，就可以继续使用信号和槽了。

QDateTime日期操作

resizeColumnToContents

more >>

展开全文 >>

1.各种缓冲区的作用

2.渲染管线的四个阶段

渲染管线通常被分为四个阶段：应用阶段，几何阶段，光栅化阶段，像素处理阶段。

3.顶点着色器和片元着色器的作用

4.深度测试问题

为什么需要进行深度测试？

深度测试主要的的两个步骤：

深度测试精确度及深度冲突

5.透明物体和不透明物体的渲染顺序问题

渲染顺序原则：

当绘制场景中同时存在透明和不透明物体时：

举例常见的性能优化：

优化主要从三个方面入手：CPU端优化，数据传输过程和GPU端优化。

CPU端常见优化点：

数据传输（DrawCall）优化

GPU端优化（主要就是简化shader运算）：

6.模版测试（Stencil Test）与模版缓冲（Stencil Buffer）

7.深度测试（Depth Test）

8.延迟渲染和前向渲染问题

正向渲染(Forward Rendering)

延迟渲染(Deferred Rendering)

延迟渲染的不足之处

9.阴影渲染的原理

阴影绘制的实现基础是Shadow Map算法

具体绘制过程如下：

1）在顶点坐标转换到灯光空间下，需要乘变换矩阵

2）计算该顶点在灯光空间下的深度

3）判断顶点的深度值与深度贴图中对应点点深度值的大小关系

判断完成该顶点是否需要接收阴影后，需要做的最后一步就是对该顶点乘上阴影的颜色，遍历完一遍该物体的所有顶点后，便可得到该物体接收阴影的效果。

正交投影和透视投影有什么区别

10.多级渐远纹理（mipmap）性能快的原因

11.采样和走样问题（抗锯齿）

抗锯齿算法

包围盒问题（常出算法题）

12.三种旋转表达（四元数，欧拉角，矩阵）各自的优缺点

13.OpenGL中VA、VAO、VBO和EBO的区别

顶点数组(Vertex Array)

VAO（Vertex Array Object）顶点数组对象

VBO（Vertex Buffer Object）顶点缓冲区对象

EBO（Element Buffer Object）索引缓冲对象

图元装配的过程

glDrawArrays与glDrawElements的功能和区别

项目问题

1 MVC和MVVM的区别

1.1 MVC（Model View Control）：

1.1.1 对于View和Controller的交互

1.1.2 Model和Controller的交互

1.2 MVVM（Model View ViewModel）：

1.2.1 诞生原因：

为什么MVVM这个名字里面，没有Controller的出现（为什么不叫MVCVM，C去哪了）？

2.Qt DEMO的架构和功能设计

2.1 架构设计

2.2 功能设计

2.2.1 文件导入

3.Qt中用到了哪些设计模式思维

单例模式：

饿汉模式：

懒汉模式：

在多线程情况下的饿汉模式和懒汉模式：

饿汉单例模式的线程安全特性

懒汉单例模式的线程安全特性

4.怎么封装2Dto3D算法

5.底层SDK用到了哪些设计模式

5.1 简单工厂模式：

结构组成：

优点与不足：

5.2 工厂方法模式

结构组成：

优点与不足：

5.3 抽象工厂模式

结构组成（和工厂方法模式一样）：

优点与不足：

5.4 三种工厂模式总结：

特点：

缺点（相对）：

优点（相对）：

6.合并转换功能用到了哪些设计模式，以及如何进行合并转换的

具体思路是：

C++面试问题总结

new和malloc的区别