c++面试汇总

部分转自：https://blog.csdn.net/u014796694/article/details/81210868

目录

一、一个C++源文件从文本到可执行文件经历的过程

二、指针和数组的区别

三、指针和引用的区别

四、malloc和free与new和delete区别

五、智能指针

六、指针常量和常量指针

七、const用途

八、const和define区别

九、函数指针与指针函数

十、阐述extern "C"和extern的作用？

十一、c++特性

十二、虚函数、抽象类、虚表、虚继承

十三、线程、进程、多线程、多进程

十四、UML类图

十五、TCP三次握手和四次挥手

---

一、一个C++源文件从文本到可执行文件经历的过程

1、预处理：对所有的define进行宏替换；处理所有的条件编译#idef等；处理#include指令；删除注释等；bao#pragma

2、编译：将预处理后的文件进行词法分析、语法分析、语义分析以及优化相应的汇编文件

3、优化：

4、汇编：将汇编文件转换成机器能执行的代码

5、链接：包括地址和空间分配，符号决议和重定位

二、指针和数组的区别

1、数组对应着一块内存，而指针是指向一块内存。数组的地址和空间大小在生命周期不会发生改变，内容可能会发生改变，而指针指向的内存大小可以随时发生改变。当指针指向常量字符串时，它的内容不可以改。

2、计算容量的区别：用sizeof计算出数组的元素个数，无法计算指针所指向内存的大小

3、数组名是常量指针，指针是变量指针

4、对数组用&和对指针&的意义不同，此时数组名不在当成指向一个元素的常量指针来使用

三、指针和引用的区别

    1：引用是变量的一个别名，内部实现是只读指针

    2：引用只能在初始化时被赋值，其他时候值不能被改变，指针的值可以在任何时候被改变

    3：引用不能为NULL，指针可以为NULL

    4：引用变量内存单元保存的是被引用变量的地址

    5：“sizeof 引用" = 指向变量的大小 ， "sizeof 指针"= 指针本身的大小

    6：引用可以取地址操作，返回的是被引用变量本身所在的内存单元地址

    7：引用使用在源代码级相当于普通的变量一样使用，做函数参数时，内部传递的实际是变量地址

四、malloc和free与new和delete区别

1、属性：new为关键字，malloc为库函数，需要头文件支持，malloc/free是C/C++标准库函数，new/delete是C++运算符

2、参数：使用new申请内存无需指定内存大小，编译器会自行计算，而malloc需要显示的给出所需内存的大小

3、返回类型：new分配成功返回的是对象类型指针，与对象严格匹配，无需类型转换，故new是符合类型安全性操作符，malloc返回的是void*

4、分配失败：new分配失败，抛出bad_alloc异常，malloc则是返回NULL

5、对于类类型的对象而言，用malloc/free无法满足要求的。对象在创建的时候要自动执行构造函数，消亡之前要调用析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制之内，不能把执行构造函数和析构函数的任务强加给它，因此，C++还需要new/delete。

6、内存区域：new分配的内存在自由储存区，malloc在堆上分配内存

五、智能指针

为什么要使用智能指针：我们知道c++的内存管理是让很多人头疼的事，当我们写一个new语句时，一般就会立即把delete语句直接也写了，但是我们不能避免程序还未执行到delete时就跳转了或者在函数中没有执行到最后的delete语句就返回了，如果我们不在每一个可能跳转或者返回的语句前释放资源，就会造成内存泄露。使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。

       当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

　　智能指针的一种通用实现技术是使用引用计数。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。

　　每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

六、指针常量和常量指针

const int *p;----*p是指针常量，不能通过*p改变它指向的内容

int * const p;----p是常量，初始化后不能再指向其他内容

七、const用途

    主要有三点：

      1：定义只读变量，即常量 

      2：修饰函数的参数和函数的返回值 

      3： 修饰函数的定义体，这里的函数为类的成员函数，被const修饰的成员函数代表不修改成员变量的值

八、const和define区别

(1) 编译器处理方式不同

　　define宏是在预处理阶段展开。const常量是编译运行阶段使用。

(2) 类型和安全检查不同

　　define宏没有类型，不做任何类型检查，仅仅是展开。const常量有具体的类型，在编译阶段会执行类型检查。

(3) 存储方式不同

　　define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。const常量会在内存中分配(可以是堆中也可以是栈中)。

(4)const  可以节省空间，避免不必要的内存分配

例如：  
        #define PI 3.14159 //常量宏  
        const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......  
        double i=Pi; //此时为Pi分配内存，以后不再分配！  
        double I=PI; //编译期间进行宏替换，分配内存  
        double j=Pi; //没有内存分配  
        double J=PI; //再进行宏替换，又一次分配内存！  
        const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而 #define定义的常量在内存中有若干个拷贝。 
(5) 提高了效率

       编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

九、函数指针与指针函数

函数指针：与整型指针类似，整型指针为指向整型的指针，函数指针为指向函数的指针，是指针变量，他与函数名无挂，只与参数列表和返回类型有关；

指针函数：本质是函数，返回值为一个指针。

十、阐述extern "C"和extern的作用？

extern "C"告知编译器以C的形式编译，因为c中没有函数重载，函数在底层的签名是函数名，而c＋＋的函数签名是函数名返回值参数类型1参数类型2__
extern作用声明外部变量，现在现代编译器一般采用按文件编译的方式，因此在编译时，各个文件中定义的全局变量是互相透明的，也就是说，在编译时，全局变量的可见域限制在文件内部。

十一、c++特性

多态、封装、继承。在本博客中其他博文中有具体描述，链接放在如下位置：

多态：https://blog.csdn.net/hi_baymax/article/details/82820519

封装：https://blog.csdn.net/hi_baymax/article/details/82830149

继承：https://blog.csdn.net/hi_baymax/article/details/82829877

十二、虚函数、抽象类、虚表、虚继承

https://blog.csdn.net/hi_baymax/article/details/82424633

十三、线程、进程、多线程、多进程

https://blog.csdn.net/hi_baymax/article/details/82831905

十四、UML类图

转自：https://design-patterns.readthedocs.io/zh_CN/latest/read_uml.html

从一个示例开始

请看以下这个类图，类之间的关系是我们需要关注的：

• 车的类图结构为<>，表示车是一个抽象类；
• 它有两个继承类：小汽车和自行车；它们之间的关系为实现关系，使用带空心箭头的虚线表示；
• 小汽车为与SUV之间也是继承关系，它们之间的关系为泛化关系，使用带空心箭头的实线表示；
• 小汽车与发动机之间是组合关系，使用带实心箭头的实线表示；
• 学生与班级之间是聚合关系，使用带空心箭头的实线表示；
• 学生与身份证之间为关联关系，使用一根实线表示；
• 学生上学需要用到自行车，与自行车是一种依赖关系，使用带箭头的虚线表示；

下面我们将介绍这六种关系；

类之间的关系

泛化关系(generalization)

类的继承结构表现在UML中为：泛化(generalize)与实现(realize)：

继承关系为 is-a的关系；两个对象之间如果可以用 is-a 来表示，就是继承关系：（..是..)

eg：自行车是车、猫是动物

泛化关系用一条带空心箭头的直接表示；如下图表示（A继承自B）；

eg：汽车在现实中有实现，可用汽车定义具体的对象；汽车与SUV之间为泛化关系；

注：最终代码中，泛化关系表现为继承非抽象类；

实现关系(realize)

实现关系用一条带空心箭头的虚线表示；

eg：”车”为一个抽象概念，在现实中并无法直接用来定义对象；只有指明具体的子类(汽车还是自行车)，才 可以用来定义对象（”车”这个类在C++中用抽象类表示，在JAVA中有接口这个概念，更容易理解）

注：最终代码中，实现关系表现为继承抽象类；

聚合关系(aggregation)

聚合关系用一条带空心菱形箭头的直线表示，如下图表示A聚合到B上，或者说B由A组成；

聚合关系用于表示实体对象之间的关系，表示整体由部分构成的语义；例如一个部门由多个员工组成；

与组合关系不同的是，整体和部分不是强依赖的，即使整体不存在了，部分仍然存在；例如， 部门撤销了，人员不会消失，他们依然存在；

组合关系(composition)

组合关系用一条带实心菱形箭头直线表示，如下图表示A组成B，或者B由A组成；

与聚合关系一样，组合关系同样表示整体由部分构成的语义；比如公司由多个部门组成；

但组合关系是一种强依赖的特殊聚合关系，如果整体不存在了，则部分也不存在了；例如， 公司不存在了，部门也将不存在了；

关联关系(association)

关联关系是用一条直线表示的；它描述不同类的对象之间的结构关系；它是一种静态关系， 通常与运行状态无关，一般由常识等因素决定的；它一般用来定义对象之间静态的、天然的结构； 所以，关联关系是一种“强关联”的关系；

比如，乘车人和车票之间就是一种关联关系；学生和学校就是一种关联关系；

关联关系默认不强调方向，表示对象间相互知道；如果特别强调方向，如下图，表示A知道B，但 B不知道A；

注：在最终代码中，关联对象通常是以成员变量的形式实现的；

依赖关系(dependency)

依赖关系是用一套带箭头的虚线表示的；如下图表示A依赖于B；他描述一个对象在运行期间会用到另一个对象的关系；

与关联关系不同的是，它是一种临时性的关系，通常在运行期间产生，并且随着运行时的变化； 依赖关系也可能发生变化；

显然，依赖也有方向，双向依赖是一种非常糟糕的结构，我们总是应该保持单向依赖，杜绝双向依赖的产生；

注：在最终代码中，依赖关系体现为类构造方法及类方法的传入参数，箭头的指向为调用关系；依赖关系除了临时知道对方外，还是“使用”对方的方法和属性。

十五、TCP三次握手和四次挥手

https://blog.csdn.net/hi_baymax/article/details/82622699

以下回答转自：https://blog.csdn.net/yu876876/article/details/81560122

问题：为什么建立连接是三次握手，四次不可以吗

第一次握手：
    Client什么都不能确认   
    Server确认了对方发送正常

第二次握手：
    Client确认：自己发送/接收正常，对方发送/接收正常
    Server确认：自己接收正常 ，对方发送正常

第三次握手：
    Client确认：自己发送/接收正常， 对方发送/接收正常
    Server确认：自己发送/接收正常，对方发送/接收正常

所以通过三次握手确认双方收发功能都正常，四次也可以但是显得比较多余。

问题：TCP三次握手，如果两次握手会怎么样
设计上的缺陷 
 
有这样一种情况，当A发送一个消息给B，但是由于网络原因，消息被阻塞在了某个节点，然后阻塞的时间超出设定的时间，A会认为这个消息丢失了，然后重新发送消息。

当A和B通信完成后，这个被A认为失效的消息，到达了B 
对于B而言，以为这是一个新的请求链接消息，就向A发送确认， 
对于A而言，它认为没有给B再次发送消息（因为上次的通话已经结束）所有A不会理睬B的这个确认，但是B则会一直等待A的消息

这就导致了B的时间被浪费（对于服务器而言，CPU等资源是一种浪费），这样是不可行的，这就是为什么不能两次握手的原因了。

所以有了三次握手的修订 
第三次握手看似多余其实不然，这主要是为了防止已失效的请求报文段突然又传送到了服务端而产生连接的误判

问题：为什么建立连接是三次握手，而关闭连接却是四次挥手呢？
建立连接

因为服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。

关闭连接

当收到对方的FIN报文时，仅表示对方不再发送数据但还能接收收据，我们也未必把全部数据都发给了对方，所以我们可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方表示同意关闭连接。因此我们的ACK和FIN一般会分开发送。

十六、TCP和UDP的区别

转自：https://www.cnblogs.com/-wang-cheng/p/5421988.html

1. TCP是面向连接(Connection oriented)的协议，UDP是无连接(Connection less)协议；

    TCP用三次握手建立连接：1) Client向server发送SYN；2) Server接收到SYN，回复Client一个SYN-ACK；3) Client接收到SYN_ACK，回复Server一个ACK。到此，连接建成。UDP发送数据前不需要建立连接。

2. TCP可靠，UDP不可靠；

    TCP丢包会自动重传，UDP不会。

3. TCP有序，UDP无序；

    消息在传输过程中可能会乱序，后发送的消息可能会先到达，TCP会对其进行重排序，UDP不会。

4. TCP无界，UDP有界；

    TCP通过字节流传输，UDP中每一个包都是单独的。

5. TCP有流量控制（拥塞控制），UDP没有；

    主要靠三次握手实现。以及慢开始、拥塞避免、快重传、快恢复

6. TCP传输慢，UDP传输快；

    因为TCP需要建立连接、保证可靠性和有序性，所以比较耗时。这就是为什么视频流、广播电视、在线多媒体游戏等选择使用UDP。

7. TCP是重量级的，UDP是轻量级的；

    TCP要建立连接、保证可靠性和有序性，就会传输更多的信息，如TCP的包头比较大。

8. TCP需要更多资源，UDP则要好上很多

9. 应用场合不同：TCP一般应用在对可靠性要求比较高的场合，例如http,ftp等等。而UDP一般应用在对实时性要求较高场合，例如视频直播，大文件传输等等

小结：

TCP是面向连接的、可靠的、有序的、速度慢的协议；UDP是无连接的、不可靠的、无序的、速度快的协议。

TCP开销比UDP大，TCP头部需要20字节，UDP头部只要8个字节。

TCP无界有拥塞控制，TCP有界无拥塞控制。

补充：

基于TCP的协议有：HTTP/HTTPS，Telnet，FTP，SMTP。

基于UDP的协议有：DHCP，DNS，SNMP，TFTP，BOOTP。

TCP: 
TCP编程的服务器端一般步骤是： 
　　1、创建一个socket，用函数socket()； 
　　2、设置socket属性，用函数setsockopt(); * 可选 
　　3、绑定IP地址、端口等信息到socket上，用函数bind(); 
　　4、开启监听，用函数listen()； 
　　5、接收客户端上来的连接，用函数accept()； 
　　6、收发数据，用函数send()和recv()，或者read()和write(); 
　　7、关闭网络连接； 
　　8、关闭监听； 

TCP编程的客户端一般步骤是： 
　　1、创建一个socket，用函数socket()； 
　　2、设置socket属性，用函数setsockopt();* 可选 
　　3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选 
　　4、设置要连接的对方的IP地址和端口等属性； 
　　5、连接服务器，用函数connect()； 
　　6、收发数据，用函数send()和recv()，或者read()和write(); 
　　7、关闭网络连接；

UDP:
与之对应的UDP编程步骤要简单许多，分别如下： 
UDP编程的服务器端一般步骤是： 
　　1、创建一个socket，用函数socket()； 
　　2、设置socket属性，用函数setsockopt();* 可选 
　　3、绑定IP地址、端口等信息到socket上，用函数bind(); 
　　4、循环接收数据，用函数recvfrom(); 
　　5、关闭网络连接； 

UDP编程的客户端一般步骤是： 
　　1、创建一个socket，用函数socket()； 
　　2、设置socket属性，用函数setsockopt();* 可选 
　　3、绑定IP地址、端口等信息到socket上，用函数bind();* 可选 
　　4、设置对方的IP地址和端口等属性; 
　　5、发送数据，用函数sendto(); 
　　6、关闭网络连接；