面试问题

江波龙

一面

  1. TCP的拥塞控制
  2. 一组数字分频次高的数据和频次低两类，新进一个数字，如何快速判断是高频次还是低频次？
  3. 如何快速从一组数字中查找一个数？

中兴

一面

1. 什么是内存泄漏？如何解决？

摘自：C++ 内存管理中内存泄漏问题产生原因以及解决方法

内存溢出原因

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

　　两种情况下会出现这种内存泄露：

　　1）在堆里创建了对象占用了内存，但是没有显示地释放对象占用的内存；

　　2）在类的构造函数中动态的分配了内存，但是在析构函数中没有释放内存或者没有正确的释放内存。

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

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

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

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

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

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

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

（5）缺少拷贝构造函数

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

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

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

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

（6）缺少重载赋值运算符

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

（7）关于nonmodifying运算符重载的常见错误

　　1）返回栈上对象的引用或者指针（也即返回局部对象的引用或者指针）。导致最后返回的是一个空引用或者空指针，因此变成野指针（指向被释放的或者访问受限内存的指针）；

　　2）返回内部静态对象的引用；

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

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

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

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

造成野指针的原因：

　　1）指针变量没有被初始化（如果值不定，可以初始化为NULL）；

　　2）指针被free或者delete后，没有置为NULL, free和delete只是把指针所指向的内存给释放掉，并没有把指针本身干掉，此时指针指向的是“垃圾”内存。释放后的指针应该被置为NULL；

　　3）指针操作超越了变量的作用范围，比如返回指向栈内存的指针就是野指针；

　　4）shared_ptr循环引用。

（9）析构的时候使用void*

　　delete掉一个void*类型的指针，导致没有调用到对象的析构函数，析构的所有清理工作都没有去执行从而导致内存的泄露。

（10）构造的时候浅拷贝，释放的时候调用了两侧delete

常见解决办法

（1）shared_ptr共享的智能指针：

　　shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。在最后一个shared_ptr析构的时候，内存才会被释放。

注意事项：

　　1）不要用一个原始指针初始化多个shared_ptr；

　　2）不要再函数实参中创建shared_ptr，在调用函数之前先定义以及初始化它；

　　3）不要将this指针作为shared_ptr返回出来；

　　4）要避免循环引用。

（2）unique_ptr独占的智能指针：

　　1）unique_ptr是一个独占的智能指针，他不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique_ptr赋值给另外一个 unique_ptr；

　　2）unique_ptr不允许复制，但可以通过函数返回给其他的unique_ptr，还可以通过std::move来转移到其他的unique_ptr，这样它本身就不再 拥有原来指针的所有权了；

　　3）如果希望只有一个智能指针管理资源或管理数组就用unique_ptr，如果希望多个智能指针管理同一个资源就用shared_ptr。

（3）weak_ptr弱引用的智能指针：

　　弱引用的智能指针weak_ptr是用来监视shared_ptr的，不会使引用计数加一，它不管理shared_ptr内部的指针，主要是为了监视shared_ptr的生命 周期，更像是shared_ptr的一个助手。 weak_ptr没有重载运算符*和->，因为它不共享指针，不能操作资源，主要是为了通过shared_ptr获得资源的监测权，它的构造不会增加引用计数，它的析构不会减少引用计数，纯粹只是作为一个旁观者来监视shared_ptr中关连的资源是否存在。 weak_ptr还可以用来返回this指针和解决循环引用的问题。

（4）set_new_handler(out_of_memroy);   //注意参数传递的是函数的地址

2. linux的常用指令

3. 引用和指针的区别

  • 指针是一个变量，存储的是一个地址，引用跟原来的变量实质上是同一个东西，是原变量的别名
  • 指针可以有多级，引用只有一级
  • 指针可以为空，引用不能为NULL且在定义时必须初始化
  • 指针在初始化后可以改变指向，而引用在初始化之后不可再改变
  • sizeof指针得到的是本指针的大小，sizeof引用得到的是引用所指向变量的大小
  • 当把指针作为参数进行传递时，也是将实参的一个拷贝传递给形参，两者指向的地址相同，但不是同一个变量，在函数中改变这个变量的指向不影响实参，而引用却可以。
  • 引用本质是一个指针，同样会占4字节内存；指针是具体变量，需要占用存储空间（，具体情况还要具体分析）。
  • 引用在声明时必须初始化为另一变量，一旦出现必须为typename refname &varname形式；指针声明和定义可以分开，可以先只声明指针变量而不初始化，等用到时再指向具体变量。
  • 引用一旦初始化之后就不可以再改变（变量可以被引用为多次，但引用只能作为一个变量引用）；指针变量可以重新指向别的变量。
  • 不存在指向空值的引用，必须有具体实体；但是存在指向空值的指针。

4. 为什么要用extern "C"

见：为什么需要 extern "C" ?

5. 进程间通信方式

见：进程间8种通信方式详解

信号量（Semaphore）和信号（Signal）是计算机科学中两个不同概念，它们用于不同的上下文和目的。

信号量（Semaphore）：

  1. 信号量是一种同步机制，用于管理多个进程或线程对共享资源的访问。
  2. 它通常用于防止多个进程或线程同时访问共享资源，以避免竞态条件和数据不一致性。
  3. 信号量维护一个计数器，可以增加或减少。当进程或线程想要访问共享资源时，它必须首先尝试获取信号量。如果信号量的值大于零，它可以获取资源并将信号量的值减一；如果信号量的值为零，进程或线程将被阻塞，直到信号量的值大于零。
  4. 信号量通常有两个主要操作：P（等待）操作和V（释放）操作，也称为down和up操作。P操作尝试获取信号量，而V操作增加信号量的值。

信号（Signal）：

  1. 信号是一种进程间通信机制，用于向进程发送通知或异步事件。
  2. 它通常用于操作系统和应用程序之间的通信，或者用于处理进程中的异常情况。
  3. 信号是一种轻量级的通信方式，用于中断正在执行的进程并引发某些处理程序或操作。
  4. 常见的信号包括SIGTERM（终止进程）、SIGINT（中断进程）、SIGKILL（强制终止进程）等。这些信号可以由操作系统或其他进程发送给目标进程，以触发相应的行为。

总结：

信号量用于管理资源访问的同步，而信号用于进程间通信和处理异步事件。它们是不同的概念，用于不同的上下文和目的。信号量是一种更高级的同步机制，而信号是一种更底层的通信机制。

6. 写出一个sql语句

二面

1. 职业规划

2. 目前技术上所欠缺的

虹软

一面

1. 图像的项目

2. 如何将100x100的图像放大到200x200

参考链接：图像缩小和放大原理

3. 如何将100x100的图像缩小到50x50

4. 什么是多态？

答：多态性是指同一个操作作用于不同的对象就会产生不同的响应;多态性分为静态多态性和动态多态性，其中函数重载和运算符重载属于静态多态性，虚函数属于动态多态性。
使用指针访问非虚函数（不加virtual）时，编译器根据指针本身的类型决定要调用哪个函数，而不是根据指针指向的对象类型;
使用指针访问虚函数（加了virtual）时，编译器根据指针指向的对象类型决定要调用哪个函数，而不是根据指针本身的类型;

5. 为什么父类的指针指向子类的对象时，会调用子类的方法？

参考链接：
C++ 虚函数表剖析
C++类内存分布

编译器是在构造函数创建这个虚表指针以及虚表的。
那么编译器是如何利用虚表指针与虚表来实现多态的呢？是这样的，当创建一个含有虚函数的父类的对象时，编译器在对象构造时将虚表指针指向父类的虚函数；同样，当创建子类的对象时，编译器在构造函数里将虚表指针（子类只有一个虚表指针，它来自父类）指向子类的虚表（这个虚表里面的虚函数入口地址是子类的）。
所以，如果是调用Base *p = new Derived();生成的是子类的对象，在构造时，子类对象的虚指针指向的是子类的虚表，接着由Derived*到Base*的转换并没有改变虚表指针，所以这时候p->VirtualFunction，实际上是p->vfptr->VirtualFunction，它在构造的时候就已经指向了子类的VirtualFunction，所以调用的是子类的虚函数，这就是多态了。

6. 堆和栈的区别？程序运行时除了堆和栈，还有哪些内存？

参考链接：c语言内存分区-（堆，栈，全局/静态存储区，自由存储区，代码区）与可执行程序的三段-（Text段，Data段，Bss段）
答：c语言五大内存分区:
栈区（stack）:存放函数形参和局部变量（auto类型），由编译器自动分配和释放
堆区（heap）:该区由程序员申请后使用，需要手动释放否则会造成内存泄漏。如果程序员没有手动释放，那么程序结束时可能由OS回收。
全局/静态存储区：存放全局变量和静态变量（包括静态全局变量与静态局部变量），初始化的全局变量和静态局部变量放在一块，未初始化的放在另一块
文字常量区：常量在统一运行被创建，常量区的内存是只读的，程序结束后由系统释放。
程序代码区：存放程序的二进制代码，内存由系统管理

7. 进程与线程的区别

线程是进程当中的一条执行流程。

同一个进程内多个线程之间可以共享代码段、数据段、打开的文件等资源，但每个线程各自都有一套独立的寄存器和栈，这样可以确保线程的控制流是相对独立的。

线程与进程的比较如下：

  • 进程是资源（包括内存、打开的文件等）分配的单位，线程是 CPU 调度的单位；
  • 进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈；
  • 线程同样具有就绪、阻塞、执行三种基本状态，同样具有状态之间的转换关系；
  • 线程能减少并发执行的时间和空间开销；

对于，线程相比进程能减少开销，体现在：

  • 线程的创建时间比进程快，因为进程在创建的过程中，还需要资源管理信息，比如内存管理信息、文件管理信息，而线程在创建的过程中，不会涉及这些资源管理信息，而是共享它们；
  • 线程的终止时间比进程快，因为线程释放的资源相比进程少很多；
  • 同一个进程内的线程切换比进程切换快，因为线程具有相同的地址空间（虚拟内存共享），这意味着同一个进程的线程都具有同一个页表，那么在切换的时候不需要切换页表。而对于进程之间的切换，切换的时候要把页表给切换掉，而页表的切换过程开销是比较大的；
  • 由于同一进程的各线程间共享内存和文件资源，那么在线程之间数据传递的时候，就不需要经过内核了，这就使得线程之间的数据交互效率更高了；

所以，不管是时间效率，还是空间效率线程比进程都要高。

朗坤智慧

一面

1. 图像的项目

2. http和https的区别

  • HTTP 是超文本传输协议，信息是明文传输，存在安全风险的问题。HTTPS 则解决 HTTP 不安全的缺陷，在 TCP 和 HTTP 网络层之间加入了 SSL/TLS 安全协议，使得报文能够加密传输。

  • HTTP 连接建立相对简单， TCP 三次握手之后便可进行 HTTP 的报文传输。而 HTTPS 在 TCP 三次握手之后，还需进行 SSL/TLS 的握手过程，才可进入加密报文传输。

  • 两者的默认端口不一样，HTTP 默认端口号是 80，HTTPS 默认端口号是 443。

  • HTTPS 协议需要向 CA（证书权威机构）申请数字证书，来保证服务器的身份是可信的。

3. get请求和post请求

GET 的语义是从服务器获取指定的资源，这个资源可以是静态的文本、页面、图片视频等。GET 请求的参数位置一般是写在 URL 中。GET 方法是安全、幂等、可被缓存的。

POST 的语义是根据请求负荷（报文body）对指定的资源做出处理，具体的处理方式视资源类型而不同。POST 请求携带数据的位置一般是写在报文 body 中。POST 不安全，不幂等，（大部分实现）不可缓存。

埃夫特

一面

1. C++服务端项目

2. select和epoll的区别

3. C++多态，虚函数表

4. 如何压测的？

使用Webbench进行压测，其原理如下：
父进程fork若干个子进程，每个子进程在用户要求时间或默认的时间内对目标web循环发出实际访问请求，父子进程通过管道进行通信，子进程通过管道写端向父进程传递在若干次请求访问完毕后记录到的总信息，父进程通过管道读端读取子进程发来的相关信息，子进程在时间到后结束，父进程在所有子进程退出后统计并给用户显示最后的测试结果，然后退出。

5. 时间轮定时器的粒度？

6. 浅拷贝和深拷贝？如果读取/写入已经被析构的内存会怎样？除了使用深拷贝，还有什么方式？（智能指针？）

7. 项目中如何解决粘包、拆包问题？

答：没有解决。http机制解决了这个问题。
使用状态机实现的。这就不需要处理粘包。如果你的http解析，是先按照行解析header，然后再解析body，当然就要处理粘包了。

8. 同步如何实现的？

9. 职业规划？

苏小研

一面

1. 野指针

2. 什么情况会造成内存泄漏？如何应对？有什么工具检测？

3. c与c++的区别？

4. 使用new申请的内存可以用free释放吗？

【C/C++面经_基础语法_(6)】

5. 覆盖和重载的区别？

6. vector和list区别?在查找上的时间复杂度？map如何扩容的？

7. tcp和udp的区别？

8. public,protected,private继承？

9. static关键字

10. 引用和指针的区别？

11. Linux中获取进程号的指令？

在Linux中，你可以使用以下指令来获取进程的进程号（Process ID，PID）：

  1. pidof 命令：
    使用 pidof 命令，你可以通过进程的名称来获取相应进程的PID。例如，要获取一个名为 "myprocess" 的进程的PID，你可以运行以下命令：

    pidof myprocess

这将返回 "myprocess" 进程的PID。

  1. pgrep 命令：
    pgrep 命令允许你根据不同的选项来查找并返回匹配进程的PID。例如，要获取一个名为 "myprocess" 的进程的PID，你可以运行：

    pgrep myprocess

如果有多个匹配的进程，pgrep 将返回它们的PID。

  1. ps 命令：
    ps 命令用于显示当前正在运行的进程列表，并且可以与 grep 命令结合使用来过滤特定进程的信息。例如，要获取一个名为 "myprocess" 的进程的PID，你可以运行以下命令：

    ps aux | grep myprocess

这将列出所有包含 "myprocess" 名称的进程，并在输出中显示它们的PID。
这些是在Linux中获取进程号的几种常见方法。你可以根据你的需求选择其中一种方法来查找和获取特定进程的PID。

12. Linux的常用目录及含义？

Linux系统中有许多常用的系统目录，每个目录都有特定的用途和含义。以下是一些常见的Linux目录及其含义：

  1. /（根目录）: 根目录是整个文件系统的起点，所有其他目录和文件都位于根目录下。

  2. /bin: 含义: 存放系统启动和修复时需要的二进制可执行文件，如ls、cp等。

  3. /boot: 包含启动Linux系统所需的引导文件和内核镜像。

  4. /dev: 包含设备文件，用于与硬件设备进行通信，如磁盘驱动器、键盘、鼠标等。

  5. /etc: 包含系统的配置文件，如网络配置、用户信息、服务配置等。

  6. /home: 存放用户的主目录，每个用户通常有一个子目录，用于存放其个人文件。

  7. /lib: 包含系统库文件，用于支持系统中运行的二进制文件。

  8. /media: 用于挂载可移动媒体设备，如USB驱动器、光盘等。

  9. /mnt: 临时挂载点，用于挂载其他文件系统或存储设备。

  10. /opt: 通常用于安装第三方软件，以及一些大型应用程序的安装目录。

  11. /proc: 包含运行中的进程信息和内核参数，以文件和目录的形式呈现。

  12. /root: 超级用户（管理员）的主目录。

  13. /sbin: 存放系统管理员使用的系统管理工具，这些工具通常只有管理员才能运行。

  14. /srv: 用于存放服务相关的数据文件，通常由一些服务程序使用。

  15. /tmp: 用于存放临时文件，通常在系统重启时会清空。

  16. /usr: 存放用户可执行文件、库文件、头文件和文档等。

  17. /var: 存放经常变化的文件，如日志文件、缓存文件、邮件队列等。

这些是Linux系统中一些常见的目录及其含义。每个目录都有其特定的用途，有助于组织和管理系统的文件和数据。

13. 项目中线程池如何实现的？

14. 七层模型？应用层常见的协议？

15. 快速排序和堆排序

上海爱数

一面

1. IO模型。阻塞IO/非阻塞IO/异步IO？

浅聊Linux的五种IO模型

2. 线程和进程区别？进程间通信方式

线程与进程的比较如下：

  • 进程是资源（包括内存、打开的文件等）分配的单位，线程是 CPU 调度的单位；
  • 进程拥有一个完整的资源平台，而线程只独享必不可少的资源，如寄存器和栈；
  • 线程同样具有就绪、阻塞、执行三种基本状态，同样具有状态之间的转换关系；
  • 线程能减少并发执行的时间和空间开销；

对于，线程相比进程能减少开销，体现在：

  • 线程的创建时间比进程快，因为进程在创建的过程中，还需要资源管理信息，比如内存管理信息、文件管理信息，而线程在创建的过程中，不会涉及这些资源管理信息，而是共享它们；
  • 线程的终止时间比进程快，因为线程释放的资源相比进程少很多；
  • 同一个进程内的线程切换比进程切换快，因为线程具有相同的地址空间（虚拟内存共享），这意味着同一个进程的线程都具有同一个页表，那么在切换的时候不需要切换页表。而对于进程之间的切换，切换的时候要把页表给切换掉，而页表的切换过程开销是比较大的；
  • 由于同一进程的各线程间共享内存和文件资源，那么在线程之间数据传递的时候，就不需要经过内核了，这就使得线程之间的数据交互效率更高了；

所以，不管是时间效率，还是空间效率线程比进程都要高。

3. 三次握手过程，当服务端第二次发送丢失了，会怎样？

4. 数据库的范式

当谈到数据库设计时，使用老师、学生、课程和成绩的例子是常见的。让我们通过一个简单的示例来说明如何设计这个数据库。

未规范化数据：

Table: StudentCourses

StudentID StudentName TeacherName Course Grade
1 Alice Mr. Smith Math A
2 Bob Mrs. Johnson History B
3 Carol Mr. Brown Math C
1 Alice Mr. Smith History B
2 Bob Mrs. Johnson Math D

这个示例中的数据表未遵循任何范式，存在冗余数据，例如老师的名字和课程名字重复。现在，让我们应用各个范式来改进这个数据库。

第一范式（1NF）：

1NF 要求每个单元格包含原子值。在这里，每个单元格已经包含原子值，所以它已经满足1NF。
第二范式（2NF）：

2NF 要求非主键列完全依赖于主键。在这里，可以将数据分为三个表：Students、Teachers和Courses。

Table: Students

StudentID StudentName
1 Alice
2 Bob
3 Carol

Table: Teachers

TeacherName Course
Mr. Smith Math
Mrs. Johnson History
Mr. Brown Math

Table: Grades
| StudentID | TeacherName | Grade |
|----------|--------|
| 1 | Mr. Smith | A |
| 2 | Mrs. Johnson| B |
| 3 | Mr. Brown | C |
| 1 | Mr. Smith | B |
| 2 | Mrs. Johnson| D |

这种方式遵循2NF，因为现在每个表都有一个主键，并且非主键列完全依赖于主键。

第三范式（3NF）：

3NF 要求消除传递依赖。在这里，TeacherName 依赖于 Course，但不依赖于 StudentID。我们可以创建一个名为 Courses 的表来解决这个问题。
Table: Courses

Course TeacherName
Math Mr. Smith
History Mrs. Johnson

然后在 Grades 表中使用 Course 作为外键，而不是直接存储老师的名字。

这就是如何使用范式来规范化数据库，减少数据冗余并确保数据的一致性。这种设计也更容易维护和查询。

5. 为什么有了malloc还需要new？

在C++中，malloc 和 new 都用于在堆内存上分配内存空间，但它们之间存在一些重要的区别，主要涉及到以下几个方面：

  1. 类型安全：
  • malloc 是C语言的标准库函数，它分配一块内存区域，并返回一个void*指针。它不了解分配内存的类型，因此需要进行显式的类型转换，而这可能导致类型不匹配的错误。
  • new 是C++的操作符，它在分配内存的同时会调用相应类型的构造函数，确保类型安全。它返回的是分配内存的指针，而不需要显式类型转换。
  1. 构造和析构对象：
  • 使用 new 分配的内存可以确保在对象构造时调用构造函数，并在对象销毁时调用析构函数。这对于管理对象的生命周期非常重要。
  • 使用 malloc 分配的内存不会自动调用对象的构造和析构函数，这可能导致资源泄漏或未定义的行为。
  1. 内存分配失败处理：
  • malloc 在分配内存失败时返回 nullptr（在C++中可以使用 nullptr 或 NULL 来表示空指针）。
  • new 在分配内存失败时会抛出 std::bad_alloc 异常。这允许更容易处理内存分配失败的情况，可以使用异常处理机制来处理。
  1. 数组分配：
  • malloc 分配的内存可以用于分配数组，但没有自动处理数组中元素的构造和析构。
  • new 可以使用 new[] 来分配数组，它会在每个数组元素上调用构造函数，并在销毁数组时调用析构函数，提供了更好的数组管理功能。

总的来说，虽然 malloc 和 new 都用于分配内存，但在C++中，new 更安全、更方便，并与对象的生命周期管理更加兼容。除非你处理一些与C接口相关的情况，或者有特定的需求，否则在C++中通常更推荐使用 new 或使用STL容器，如std::vector，来管理动态内存分配和对象的生命周期。

6. 当析构函数不声明为虚函数时，会怎样？

当析构函数（Destructor）不声明为虚函数时，主要影响涉及继承和多态的情况。让我解释一下影响和情况：

  1. 内存泄漏的风险：如果您有一个基类指针指向派生类对象，而析构函数不是虚函数，那么在销毁该基类指针时，只会调用基类的析构函数，而不会调用派生类的析构函数。这可能导致资源（如内存、文件句柄等）无法正确释放，从而引发内存泄漏或资源泄漏。
  2. 切断多态链：C++中，虚函数机制是实现多态的关键。当基类的析构函数不声明为虚函数时，派生类对象将在使用基类指针进行销毁时无法触发多态。这可能导致您无法利用运行时多态性，而丧失了一些面向对象编程的优势。
  3. 错误的销毁对象：如果基类析构函数不是虚函数，但您使用基类指针来销毁一个派生类对象，可能会导致部分对象未正确释放。这可能会导致对象的部分资源泄漏，或者导致未定义行为。

为了解决这些问题，通常建议将基类的析构函数声明为虚函数。这将允许在派生类对象上使用基类指针时正确调用派生类的析构函数，确保资源正确释放，并允许多态性的使用。

7. reactor模式

Reactor模式是一种事件处理模式，常用于构建高性能的网络服务。它的核心思想是将事件驱动的编程模型应用于处理并发请求，而不是为每个请求分配一个独立的线程或进程。这可以显著提高系统的性能和可伸缩性。Reactor模式通常包括以下关键组件和概念：

  • 事件源（Event Source）：事件源是可以触发事件的资源，通常是套接字、文件描述符、计时器、信号等。这些事件源可以是可读、可写、可连接等等。

  • 事件处理器（Event Handler）：事件处理器是用于处理特定类型事件的组件。它包含了处理事件的逻辑，例如处理输入请求、处理输出响应、建立连接等。

  • 事件循环（Event Loop）：事件循环是Reactor模式的核心部分。它负责监听多个事件源，当事件发生时，调用适当的事件处理器来处理事件。事件循环是一个无限循环，它不断地检查事件源是否有事件发生。

  • Demultiplexer（事件分发器）：Demultiplexer是一个用于管理事件源的组件（如epoll），它可以非阻塞地等待多个事件源的事件，然后通知事件循环来处理这些事件。

Reactor模式的工作流程如下：

  • 事件源向Demultiplexer注册自己，指定感兴趣的事件类型（例如，读事件、写事件）。

  • Demultiplexer等待事件，当事件发生时，它通知事件循环。

  • 事件循环根据事件类型找到相应的事件处理器，并调用相应的处理方法。

  • 事件处理器执行相应的操作，处理事件，然后返回。

  • 事件循环继续等待事件，重复上述过程。

Reactor模式的主要优点包括：

  • 高性能：通过使用非阻塞I/O和事件驱动的方式，Reactor模式可以处理大量并发连接而不需要为每个连接创建一个线程。

  • 可伸缩性：由于事件循环处理所有事件，系统的可伸缩性更好，可以轻松地应对增加的负载。

  • 简化编程：Reactor模式提供了一个清晰的事件处理模型，使得编写异步、高并发的程序更容易。

  • 良好的资源利用率：由于没有创建大量线程，系统资源利用更加高效。

Reactors模式有多个变种，包括Proactor模式、多Reactor模式等，每种变种在事件处理、多线程支持、性能等方面有不同的特点和应用场景。

8. 智能指针的原理，是否出现过循环引用的问题？

c++ 智能指针及循环引用问题

9. 项目中遇到的困难

10. 介绍一下项目中的半同步/半反应堆线程池如何实现的？

"半同步/半反应堆"是一种多线程并发模型，用于构建高性能的服务器应用程序。它结合了同步I/O和异步I/O的特点，以提高服务器的性能和可伸缩性。下面是实现半同步/半反应堆线程池的一般步骤：

  1. 创建线程池：首先，创建一个线程池，其中包含多个线程。这些线程用于处理同步I/O和异步I/O事件。
  2. 主线程：有一个主线程，通常被称为"主反应堆"。主线程主要负责监听新的客户端连接请求，然后将这些连接分派给工作线程处理。这是半同步的一部分，因为主线程会阻塞等待新连接的到来。
  3. 工作线程：有多个工作线程，通常被称为"工作反应堆"。这些线程负责处理已建立的连接上的同步I/O操作和异步I/O事件。这是半反应堆的一部分，因为工作线程是异步地处理I/O事件的。
  4. 事件循环：每个工作线程都有一个事件循环，它用于监听和处理I/O事件。事件循环通常使用事件驱动的方式，如Reactor模式或Proactor模式。当一个新的I/O事件发生时，工作线程会处理它。
  5. 任务队列：在半反应堆的部分，工作线程可能需要执行一些计算密集型的任务，而不仅仅是I/O操作。为此，可以使用一个任务队列，工作线程从队列中获取任务并执行。这允许工作线程继续处理其他I/O事件，而不会阻塞。
  6. 线程同步：线程池中的线程需要进行适当的线程同步，以避免竞态条件和数据访问冲突。这通常涉及使用互斥锁（mutex）或其他线程同步机制。
  7. 性能优化：为了提高性能，可以使用技术如非阻塞I/O、事件复用（如epoll或kqueue）、多路复用等。还可以通过调整线程池中线程的数量来优化性能。

总的来说，半同步/半反应堆线程池是一种复杂的多线程编程模型，需要处理多个并发连接和I/O操作。它结合了同步和异步的特点，允许服务器应用程序高效地处理大量并发请求。实现该模型通常需要仔细的线程管理和事件驱动编程。

二面

1. TCP三次握手的过程及状态码？

TCP（Transmission Control Protocol）的三次握手是建立TCP连接的过程，它确保通信的双方都愿意建立连接。以下是TCP三次握手的过程和相关状态码：

  1. 客户端发送请求（SYN）：
  • 客户端首先向服务器发送一个TCP报文段，其中包含一个SYN（同步）标志位。这表示客户端希望建立连接。
  • 状态码：客户端进入"SYN_SENT"状态。
  1. 服务器回应（SYN-ACK）：
  • 服务器收到客户端的SYN后，确认收到，并向客户端发送一个包含SYN和ACK（确认）标志位的TCP报文段。这表示服务器愿意建立连接，并确认了客户端的请求。
  • 状态码：服务器进入"SYN_RECEIVED"状态。
  1. 客户端确认（ACK）：
  • 客户端接收到服务器的SYN-ACK后，发送一个确认（ACK）标志位的TCP报文段给服务器。这表示客户端也同意建立连接。
  • 状态码：客户端进入"ESTABLISHED"状态，服务器进入"ESTABLISHED"状态。

此时，TCP连接已成功建立，通信双方可以开始交换数据。这个过程的状态码表示了每个主机在连接建立的不同阶段的状态。

  • "SYN_SENT"：客户端已发送SYN，等待服务器的确认。
  • "SYN_RECEIVED"：服务器已收到客户端的SYN，并发送了自己的SYN，等待客户端的确认。
  • "ESTABLISHED"：连接已成功建立，通信双方可以进行数据传输。

这个三次握手过程是TCP连接的建立阶段。在连接结束时，会使用四次挥手来关闭连接。这种握手和挥手的过程是TCP协议的重要特征，确保了数据的可靠传输和连接的可控关闭。

2. TCP四次挥手时如果最后一次没有收到会怎样？

3. 服务端与客户端通信过程中，客户端突然关闭会怎样？

客户端端口号会被占用，使用netstat可查看。

联想

一面

1. ping的底层实现？ICMP?

2. 虚基类

3. 什么场景中使用set、vector、map？

4. 子进程fork自父进程继承哪些东西？哪些是需要自己设置的？

linux fork出的子进程从父进程继承些什么不继承什么

二面

1. cookie和session的区别

你真的了解 Cookie 和 Session 吗?

2. 中断

联通软件研究院

一面

1. 如何判断链表有环？

2. 如何判断两个链表是否相交？

两个指针，一个指针走完就到另一个链表起点。

3. 快速排序

亚信安全

一面

1. 项目

2. ARP协议

图解ARP协议（一）

3. ping的底层协议

ICMP协议与ping命令

4. 互斥锁、自旋锁、读写锁的区别

互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景

米哈游

一面

主要考察基础知识，包括C++、数据结构、操作系统、网络等

1. 红黑树特性

红黑树的定义

  • 每个节点或者是黑色，或者是红色。
  • 根节点是黑色。
  • 每个叶子节点（空节点）是黑色。
  • 如果一个节点是红色的，则它的子节点必须是黑色的
  • 从任意一个节点到叶子节点，经过的黑色节点是一样的。

漫画：什么是红黑树？ - 程序员小灰的文章 - 知乎

为什么有了平衡树还需要红黑树？

  • 虽然二叉平衡树解决了二叉查找树退化为近似链表的缺点，能够把查找时间控制在 O(logn)，不过却不是最佳的，因为平衡树要求每个节点的左子树和右子树的高度差至多等于1，这个要求实在是太严了，导致每次进行插入/删除节点的时候，几乎都会破坏平衡树的第二个规则，进而我们都需要通过左旋和右旋来进行调整，使之再次成为一颗符合要求的平衡树。显然，如果在那种插入、删除很频繁的场景中，平衡树需要频繁着进行调整，这会使平衡树的性能大打折扣，为了解决这个问题，于是有了红黑树。

记一次腾讯面试：有了二叉查找树、平衡树（AVL）为啥还需要红黑树？ - 帅地的文章 - 知乎

2. epoll和select、poll的差别及优缺点

3. ET和LT、Reactor和Proactor

Reactor和Proactor的区别

Reactor模式和Proactor模式是两种不同的事件处理模式，主要用于构建高性能的网络应用程序。它们在事件驱动编程中有着不同的角色和工作方式。

Reactor模式：
  1. 角色分配：
  • Reactor：负责监听所有事件源（如套接字、文件描述符等），并根据事件的类型（读、写等）将事件分派给相应的处理器（也叫处理函数或回调函数）。
  • 处理器：负责具体处理事件的逻辑，Reactor将事件分派给合适的处理器进行处理。

  1. 工作流程：
    Reactor等待事件的发生，当事件发生时，Reactor负责调用相应的处理器来处理这个事件。

  2. 并发性：
    Reactor模式通常使用单线程或少数几个线程。一个线程可以管理多个事件源，通过非阻塞I/O等技术处理并发请求。

  3. 适用场景：
    Reactor适用于I/O密集型的应用，例如网络服务器，它能够处理大量的并发连接请求。

Proactor模式：
  1. 角色分配：
  • Proactor：负责管理所有事件源，包括发起I/O操作（如读、写等），并在I/O操作完成后通知相应的处理器。
  • 处理器：在I/O操作完成后被调用，用于处理操作的结果。

  1. 工作流程：
    Proactor负责发起I/O请求，然后继续执行其他任务，当I/O操作完成后，Proactor将结果通知相应的处理器。

  2. 并发性：
    Proactor模式通常使用多线程。Proactor负责I/O操作的管理，允许主线程或其他线程继续执行其他任务，提高了并发性。

  3. 适用场景：
    Proactor适用于计算密集型的应用，例如数据库系统，它能够处理大量的并发I/O操作，而无需阻塞主线程或其他任务的执行。

总结来说，Reactor模式中，Reactor负责事件的监听和分发，而处理器负责具体的事件处理。而在Proactor模式中，Proactor负责I/O操作的管理和结果通知，处理器则负责处理操作的结果。选择使用哪种模式通常取决于应用程序的性质和需求。

4. TCP与udp的区别，重点介绍tcp的拥塞控制

5. 虚拟内存和物理内存的区别,及内存页面置换算法（LRU等）

6. 哈希表的结构、如何避免冲突

哈希表（Hash Table），也被称为散列表，是一种用于存储键值对的数据结构，它使用哈希函数将键映射到存储桶中的位置。这允许我们快速检索和插入数据，因为通过哈希函数计算的位置可以直接访问，而无需遍历整个数据集。

哈希表的结构通常包括以下要素：

  1. 哈希函数（Hash Function）：
    哈希函数接受一个键作为输入，然后计算出一个整数值，这个值通常被称为哈希码或哈希值。
    好的哈希函数应该将不同的键映射到不同的哈希值，同时应该是高效计算的。
  2. 存储桶（Buckets）：
    存储桶是哈希表内部的数组或链表结构，用于存储键值对。
    当多个键通过哈希函数映射到相同的哈希值时，它们被存储在同一个存储桶中。
  3. 冲突处理策略：
    冲突是指多个键被映射到同一个哈希值的情况。哈希表需要一种策略来处理这些冲突。
    常见的冲突处理策略包括链地址法（Chaining）和开放寻址法（Open Addressing）。

  • 链地址法：在每个存储桶中使用一个链表或其他数据结构来存储所有映射到相同哈希值的键值对。

  • 开放寻址法：当发生冲突时，它尝试在其他存储桶中找到可用的位置，通常有三种方法，包括线性探测、二次探测和双重散列。以下是它们的介绍：

    • 线性探测：

      • 线性探测是一种简单的开放寻址方法，用于解决哈希表冲突。当发生冲突时，线性探测会依次检查下一个存储桶，直到找到一个可用的存储桶。
      • 具体步骤：如果哈希函数将键映射到存储桶i，而该存储桶已经被占用，线性探测会尝试存储桶i+1，然后i+2，以此类推，直到找到一个空闲的存储桶。
      • 优点：实现简单，容易理解。
      • 缺点：可能会导致"一次聚集"问题，即多个连续的冲突，使得插入和查找操作变得低效。此外，线性探测可能会导致存储桶的不均匀使用。

    • 二次探测：

      • 二次探测是另一种开放寻址方法，解决哈希表冲突。与线性探测不同，它不是简单地逐一检查存储桶，而是使用二次探测序列来查找可用的存储桶。
      • 具体步骤：如果哈希函数将键映射到存储桶i，而该存储桶已经被占用，二次探测将尝试存储桶i + c^2，然后i - c^2，其中c是一个常数，通常是正整数。这创建了一个二次探测序列。
      • 优点：相对于线性探测，它能够更均匀地分布存储桶的使用，减少"一次聚集"问题的可能性。
      • 缺点：仍然可能导致聚集问题，且需要处理常数c的选择问题。

    • 双重散列：

      • 双重散列是一种复杂但有效的开放寻址方法。它使用两个不同的哈希函数来处理冲突。
      • 具体步骤：当哈希冲突发生时，首先使用第一个哈希函数确定一个存储桶，如果该存储桶已被占用，然后通过第二个哈希函数找到下一个存储桶，以此类推，直到找到一个空闲的存储桶。
      • 优点：相对于线性探测和二次探测，它更有效地减少聚集问题的风险，因为它使用不同的哈希函数来查找下一个存储桶。
      • 缺点：实现相对较复杂，需要选择和管理两个哈希函数。

选择适当的开放寻址方法取决于应用的需求和性能要求。每种方法都有其优点和缺点，应根据具体情况选择。双重散列通常是一个强大的选择，因为它能够有效地减少聚集问题的发生。

如何避免冲突，或者说如何减少冲突的发生：

  1. 好的哈希函数：
    选择一个高质量的哈希函数是关键。一个好的哈希函数应该尽可能均匀地分布键，以降低冲突的概率。

  2. 足够大的存储桶：
    哈希表的存储桶数量应足够大，以容纳预期的键值对数量。如果存储桶太少，冲突的概率会增加。

  3. 冲突处理策略：
    选择适合问题的冲突处理策略。链地址法在插入时只需添加一个新节点，而开放寻址法可能需要多次探测。

  4. 重新哈希：
    在数据集大小变化较大时，可以考虑重新哈希。这意味着创建一个更大的哈希表，然后将数据从旧表迁移到新表，以降低冲突的概率。
    总之，哈希表是一种强大的数据结构，但冲突处理是其中一个需要仔细考虑的方面。通过选择合适的哈希函数、存储桶数量和冲突处理策略，可以降低冲突的发生，从而提高哈希表的性能。

7. 算法题：翻转m~n位置的链表

8. C++封装、继承、多态的特性

C++是一种多范式编程语言，它支持面向对象编程（OOP）的特性，包括封装、继承和多态。这些特性有助于创建模块化、可维护和可扩展的代码。下面是关于C++中封装、继承和多态的主要特性的详细解释：

  1. 封装（Encapsulation）：
  • 封装是面向对象编程的基本原则之一。它允许将数据和函数操作数据的实现细节封装在一个类中，同时提供公共接口以供其他类使用。
  • C++中使用类来实现封装。类包含数据成员（通常是私有的）和成员函数（可以是公共的、私有的或受保护的）。
  • 数据成员通常被声明为私有，以限制对它们的直接访问，而通过成员函数来提供对数据的控制和操作。这可以增加数据的安全性和可维护性。
  1. 继承（Inheritance）：
  • 继承是一种机制，允许创建一个新类（子类）从一个现有类（基类）继承属性和方法。
  • 基类包含一组通用属性和方法，子类可以继承并重用这些成员。
  • 子类可以添加新成员或重写基类的成员，以满足特定的需求。
  • 继承有助于实现代码重用和构建类的层次结构，其中基类通常是更一般化的，而子类是更具体的。
  1. 多态（Polymorphism）：
  • 多态是一种能力，允许不同类型的对象对相同的消息或函数调用做出不同的响应。
  • C++中的多态通常通过虚函数和虚表实现。基类可以定义虚函数，而派生类可以覆盖（重写）这些虚函数以提供特定实现。
  • 当使用基类指针或引用调用虚函数时，实际执行的是对象的实际类型所对应的函数。这被称为运行时多态。
  • 多态有助于编写通用代码，使其适用于不同类型的对象，而无需在编写代码时知道对象的具体类型。

总之，C++中的封装、继承和多态是面向对象编程的关键概念，它们有助于实现代码的模块化、可维护性和可扩展性，同时提供了更好的抽象和代码复用机制。

9. C++多态的实现,虚表是与对象相关的还是类相关的

C++中的多态是通过虚函数和虚表来实现的。虚函数允许子类重写基类的函数，而虚表则是一张用于存储虚函数指针的表，它是与类相关的，而不是与对象相关的。

以下是关于多态和虚表的一些重要概念：

  1. 虚函数：
  • 虚函数是在基类中声明为虚函数的函数，可以被子类重写（覆盖）以提供不同的实现。
  • 声明一个函数为虚函数的方式是在函数声明前面加上 virtual 关键字，如 virtual void someFunction();。
  • 当通过基类指针或引用调用虚函数时，实际调用的是对象的实际类型所对应的函数，而不是基类的函数。
  1. 虚表：
  • 虚表是与类相关的，而不是与对象相关的。每个类（包括抽象类）都有一个对应的虚表。
  • 虚表是一个指针数组，其中存储了该类的虚函数的地址。当对象被创建时，会分配一个指向该类虚表的指针。
  • 虚表使得在运行时能够动态地查找和调用正确的虚函数，实现多态。
  1. 多态：
  • 多态是指同一函数调用可以在不同的对象上表现出不同的行为。这是通过虚函数和虚表来实现的。
  • 在多态中，通过基类指针或引用调用虚函数，实际执行的是派生类的虚函数。
  • 多态允许你编写通用的代码，通过基类指针或引用操作派生类对象，而无需关心对象的具体类型。

10. 有哪些内存区域

参考：(内存管理-4.1 为什么要有虚拟内存-linux内存布局)[https://xiaolincoding.com/os/3_memory/vmem.html#linux-内存布局]

用户空间内存，从低到高分别是 6 种不同的内存段：

  • 代码段，包括二进制可执行代码；
  • 数据段，包括已初始化的静态常量和全局变量；
  • BSS 段，包括未初始化的静态变量和全局变量；
  • 堆段，包括动态分配的内存，从低地址开始向上增长；
  • 文件映射段，包括动态库、共享内存等，从低地址开始向上增长（跟硬件和内核版本有关 (opens new window)）；
  • 栈段，包括局部变量和函数调用的上下文等。栈的大小是固定的，一般是 8 MB。当然系统也提供了参数，以便我们自定义大小；

注：不要忘了bss段、文件映射段

云道智造

一面

1. 写在头文件和cpp文件的区别

头文件和源文件之间的分离有多个优点，包括：

  • 模块化：可以将程序分成小的模块，便于维护和扩展。
  • 可重用性：头文件可以在多个源文件中包含，以便其他源文件可以重复使用相同的声明。
  • 编译效率：当只修改源文件而不改变头文件时，只需重新编译源文件，不必重新编译包含头文件的所有源文件。
  • 可读性：头文件提供了代码的接口和声明，源文件包含了具体实现，使代码更具可读性和可维护性。
    通常，头文件中包含的内容应该尽量保持简洁和接口相关，而实际的实现应该放在源文件中。这有助于使代码更清晰和易于管理。

2. 模板如何写，以及优缺点

优点：

  • 代码重用： 模板允许你编写通用的代码，减少了重复的工作，提高了代码的可重用性。
  • 类型安全： 模板可以提供类型安全性，编译器会检查类型匹配，防止不匹配的数据类型被使用。
  • 性能： 模板生成的代码在编译时进行类型实例化，因此可以在不牺牲性能的情况下提供通用性。
  • STL支持： C++标准模板库（STL）是C++标准库的一部分，大量使用了模板，提供了各种数据结构和算法，使开发更加高效。

缺点：

  • 编译时间增加： 使用模板可能导致编译时间增加，因为编译器需要为每种使用的类型生成实例化的代码。
  • 错误信息复杂： 当使用模板时，编译器可能生成复杂的错误信息，对于初学者来说可能难以理解。
  • 隐式实例化： 模板的隐式实例化可能导致不必要的代码膨胀，特别是在处理复杂的模板时。

总的来说，模板是一个非常有用的C++特性，但需要小心使用，以避免性能问题和复杂的代码。当需要编写通用代码时，模板是一个非常强大的工具。

3. qt信号槽的实现原理

当你在Qt中使用信号（Signals）与槽（Slots）机制时，你其实是在使用一种基于观察者模式（Observer Pattern）的设计模式。这个机制允许一个对象（信号发射者）在特定事件发生时通知其他对象（槽函数接受者）做出响应。这种设计模式的核心思想是：当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

在Qt中，信号是对象状态变化的标志，槽则是响应这些状态变化的函数。这个机制的实现原理是基于C++的特性：Qt通过宏、元对象系统（Meta-Object System）和C++的函数指针来实现信号与槽的连接。

  1. 元对象系统（Meta-Object System）：Qt的元对象系统是一种运行时类型信息（RTTI）系统，它在编译阶段通过元对象编译器（MOC，Meta-Object Compiler）为每个包含信号与槽的类生成元对象信息。这些信息包括类的方法、信号、槽等。元对象系统使得Qt可以在运行时了解类的结构。
  2. 信号的声明：当你在Qt类中声明一个信号时，它实际上是一个特殊的成员函数，这个函数被MOC识别并记录在类的元对象信息中。信号是不含实现的，它只是一个标记，表示在某个事件发生时应该发射（触发）这个信号。
   signals:
       void mySignal();
  1. 槽的声明：槽函数是普通的成员函数，它也被MOC记录在类的元对象信息中。槽函数是用来响应信号的，当信号被发射时，连接到这个信号的槽函数会被调用。
   public slots:
       void mySlot();
  1. 连接信号与槽：在运行时，你可以通过QObject::connect()函数将信号与槽函数连接起来。当信号被发射时，与之连接的槽函数将被调用。connect()函数的背后，Qt使用了函数指针和元对象系统来建立信号与槽之间的关联。
   QObject::connect(sender, SIGNAL(mySignal()), receiver, SLOT(mySlot()));

总的来说，Qt的信号与槽机制的实现依赖于元对象系统，它通过在运行时动态了解和连接类的成员函数，使得对象之间的通信变得非常灵活。当信号触发时，连接到这个信号的槽函数将被自动调用，实现了对象之间的松耦合通信。这种设计模式使得Qt程序的组织和扩展变得更加容易。

4. 观察者模式

观察者模式（Observer Pattern）是一种常见的软件设计模式，它用于定义对象之间的一对多依赖关系，以便一个对象的状态变化可以通知所有依赖它的对象并自动更新它们的状态。观察者模式通常用于实现分布式事件处理系统，以确保对象之间的松耦合，其中一个对象（被观察者或主题）的状态变化会通知其他对象（观察者）。

观察者模式涉及以下几个关键角色：

  1. 被观察者（Subject）： 被观察者是具有状态的对象，它维护一组观察者对象，并在状态变化时通知这些观察者。被观察者提供注册、删除和通知观察者的方法。
  2. 观察者（Observer）： 观察者是依赖于被观察者的对象。它们实现了一个接口或抽象类，其中包括一个更新方法，被观察者在状态发生变化时会调用这个方法来通知观察者。多个观察者可以注册到同一个被观察者上。
  3. 具体被观察者（Concrete Subject）： 具体被观察者是被观察者接口的实现，它包括状态以及观察者列表，并负责在状态变化时通知观察者。
  4. 具体观察者（Concrete Observer）： 具体观察者是观察者接口的实现，它定义了在状态变化时需要执行的具体操作。

观察者模式的工作方式如下：

  1. 被观察者对象维护一个观察者列表，通常是一个集合或列表。
  2. 观察者对象通过注册到被观察者对象，将自己添加到观察者列表中。
  3. 当被观察者对象的状态发生变化时，它会遍历观察者列表，并调用每个观察者的更新方法，将状态变化通知给它们。
  4. 每个观察者在接收到通知后执行相应的操作，以响应状态的变化。

观察者模式的优点包括松耦合、可扩展性和可重用性。它允许在不改变被观察者和观察者之间关系的情况下添加新的观察者。这使得观察者模式在事件处理、GUI编程、发布-订阅系统等领域得到广泛应用。

在C++中实现观察者模式需要以下步骤：

  1. 定义观察者接口（Observer）：
class Observer {
public:
    virtual void update() = 0; // 观察者需要实现的更新方法
};
  1. 定义被观察者接口（Subject）：
class Subject {
public:
    virtual void registerObserver(Observer* observer) = 0;
    virtual void removeObserver(Observer* observer) = 0;
    virtual void notifyObservers() = 0;
};
  1. 实现具体观察者类（Concrete Observer）：
class ConcreteObserver : public Observer {
public:
    void update() override {
        // 具体的更新操作
    }
};
  1. 实现具体被观察者类（Concrete Subject）：
class ConcreteSubject : public Subject {
private:
    std::vector<Observer*> observers;
public:
    void registerObserver(Observer* observer) override {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) override {
        // 在实际应用中可能需要实现移除观察者的逻辑
    }

    void notifyObservers() override {
        for (Observer* observer : observers) {
            observer->update();
        }
    }
};
  1. 在主程序中使用观察者模式：
int main() {
    ConcreteSubject subject;

    ConcreteObserver observer1;
    ConcreteObserver observer2;

    subject.registerObserver(&observer1);
    subject.registerObserver(&observer2);

    // 当被观察者状态发生变化时
    subject.notifyObservers();

    return 0;
}

这是一个简单的C++实现观察者模式的示例。在实际应用中，可以根据具体情况进行扩展和优化。例如，可以添加更多的功能，如在观察者中传递状态信息等。同时，也需要注意内存管理，确保在适当的时候释放观察者对象。

5. 使用git进行版本控制时需要注意哪些

使用Git进行版本控制是一种强大而普遍的实践，但需要注意一些关键方面以确保有效的版本控制和协作。以下是使用Git时需要注意的一些重要方面：

  1. 初始化仓库：在开始使用Git之前，确保在项目文件夹中初始化Git仓库。使用git init命令来创建一个新的Git仓库。
  2. 配置Git：在全局和项目级别配置你的Git，包括用户名和邮箱。这可以通过以下命令完成：
   git config --global user.name "Your Name"
   git config --global user.email "your.email@example.com"
  1. 版本控制文件：确保将项目中的所有需要版本控制的文件和文件夹添加到Git仓库中。使用git add命令来跟踪新文件，使用git commit来提交更改。
  2. 提交早，提交常：频繁地提交代码更改是良好的实践。每次提交应该表示一个相关的、有意义的更改集。这使得跟踪和撤销更改更加容易。
  3. 编写有意义的提交信息：在提交时编写清晰、有意义的提交信息，描述你做了什么修改和为什么修改。这有助于你和其他开发人员理解代码历史。
  4. 分支管理：学会创建和管理分支。分支使你可以同时处理多个任务，而不干扰主要的开发流程。使用git branch和git checkout命令来创建和切换分支。
  5. 合并和冲突解决：当你的分支准备好时，将其合并回主分支。有时可能会发生冲突，需要手动解决。学习使用git merge和git rebase命令以及合并工具来处理这些情况。
  6. 避免敏感数据泄露：不要将敏感数据（如密码、API密钥等）存储在公共的Git存储库中。使用.gitignore文件排除这些文件。
  7. 协作与远程仓库：如果你与其他开发人员协作，确保理解如何与远程仓库互动。学会使用git clone、git push和git pull等命令。
  8. 备份和分支策略：定期备份你的Git存储库，特别是在进行重大更改之前。也制定适合你的项目的分支策略，以管理开发和发布。
  9. 学习Git工具：Git有许多强大的工具和功能，如git stash、git cherry-pick、git reflog等。学习这些工具可以帮助你更好地管理你的项目。
  10. 文档和学习资源：Git有广泛的文档和学习资源，包括官方文档、书籍、教程和在线课程。利用这些资源来提高你的Git技能。
  11. 实验和学习：Git可以有很多复杂的方面，所以不要害怕尝试新的功能或命令。学习通过实验和错误来提高你的Git技能。

总之，Git是一个强大的版本控制工具，但也可以有一些复杂的部分。通过仔细学习和实践，你可以更好地利用Git来管理和协作开发项目。

6. stl库中容器的简介介绍

7. C++11新特性有哪些？

C++11引入了许多重要的新特性，这些特性扩展了C++语言的功能性和表达能力，使得代码更容易编写、更安全、更高效。以下是一些C++11的主要新特性：

  1. 自动类型推导：引入了auto关键字，允许编译器根据初始化表达式的类型来推断变量的类型。例如：
   auto x = 42;  // x被推断为int
  1. 范围for循环：引入了范围for循环，用于遍历容器和其他可迭代对象。这简化了循环的语法。
   for (const auto& element : container) {
       // 使用element进行操作
   }
  1. 新的初始化语法：引入了统一的初始化语法，使用花括号{}进行初始化，这在消除了某些初始化问题上更安全和一致。
   int arr[] = {1, 2, 3};
  1. 移动语义：引入了右值引用（&&）和移动构造函数，允许高效地转移资源而不是复制它们，提高性能。
   std::vector<int> source;
   std::vector<int> dest = std::move(source); // 移动source的内容到dest
  1. 智能指针：引入了std::shared_ptr和std::unique_ptr，以改进内存管理和避免内存泄漏。
   std::shared_ptr<int> sptr = std::make_shared<int>(42);
   std::unique_ptr<int> uptr = std::make_unique<int>(42);
  1. 新容器：引入了std::array和std::unordered_map等新容器类型，提供更多的选择来满足不同的需求。
  2. Lambda 表达式：允许在函数内部定义匿名函数，简化了函数对象的创建。
   auto add = [](int a, int b) { return a + b; };
  1. 线程支持：引入了标准库中的多线程支持，包括std::thread和相关的同步原语，用于多线程编程。
  2. 并发数据结构：引入了std::atomic和std::mutex等工具，用于更安全地处理并发操作。
  3. 类型别名：引入了using关键字，用于创建类型别名，提高代码的可读性和可维护性。
  4. 新的标准库特性：C++11引入了一些新的标准库组件，如<thread>、<chrono>、<regex>等，以增强标准库的功能。
  5. 其他语言改进：C++11还引入了其他一些语言改进，如继承构造函数、删除函数、显示override和final关键字等，以提高代码的可读性和安全性。

这些新特性使C++11成为一种更现代、更强大的编程语言，改进了开发的效率、代码的质量和程序的性能。不过，需要注意的是，C++11也引入了一些新的概念和复杂性，需要开发人员适应和理解。

8. 虚函数与纯虚函数的区别？

9. 如何不让一个类实例化？

要防止一个类被实例化，你可以使用以下几种方法：

  1. 抽象类（Abstract Class）：将类声明为抽象类，这意味着你不能直接实例化该类。在C++中，你可以使用纯虚函数（虚函数后面加=0）来创建一个抽象类。例如：
   class AbstractClass {
   public:
       virtual void someFunction() = 0;
   };

不能实例化抽象类，但可以派生出具体类并实现虚函数。

  1. 删除构造函数：将类的构造函数声明为私有或删除，以防止类被实例化。例如：
   class NoInstanceClass {
   private:
       NoInstanceClass() = default;
   };

或者使用 = delete 删除构造函数，这样任何尝试实例化该类的操作都会导致编译错误。

class NoInstanceClass {
   public:
       NoInstanceClass() = delete;
   };
  1. 单例模式：创建一个类，确保只有一个实例，并提供访问该实例的方法。这种方式虽然允许实例化，但在程序中只有一个实例可用。单例模式可防止多次实例化。
   class Singleton {
   public:
       static Singleton&amp; getInstance() {
           static Singleton instance;
           return instance;
       }
   private:
       Singleton() {}
   };
  1. 命名空间：将类放在命名空间中，这样你必须使用命名空间限定符来访问它，而不是通过类名直接实例化。例如：
   namespace NoInstantiation {
       class SomeClass {
       public:
           void someFunction() { /* 实现 */ }
       };
   }

要访问该类，你需要使用 NoInstantiation::SomeClass。
这些方法中，抽象类和删除构造函数是直接禁止实例化的方式，而单例模式和命名空间则提供了更灵活的控制，防止不需要的实例化。选择哪种方法取决于你的设计需求和目标。

10. git中checkout和pull的区别

checkout 和 pull 是 Git 中两个不同的命令，用于不同的目的：

  1. checkout:
  • checkout 用于切换分支、恢复文件或检查特定的提交。
  • 切换分支时，可以使用 git checkout <branch-name> 来切换到指定分支。
  • 恢复文件时，可以使用 git checkout -- <file> 来丢弃未提交的更改并还原文件到最新提交的状态。
  • 检查特定提交时，可以使用 git checkout <commit> 来进入“分离头指针”状态，查看特定提交的内容。
  1. pull:
  • pull 用于从远程仓库中获取更新并将其合并到当前分支。
  • git pull 等同于运行 git fetch 获取远程仓库的更新，然后运行 git merge 或 git rebase 将这些更新合并到当前分支。
  • 通常，git pull 用于在本地分支中更新与远程分支同名的分支。
  1. 总结区别：
  • checkout 主要用于分支切换、文件恢复和查看历史提交。
  • pull 主要用于从远程仓库获取更新并合并到当前分支。

需要注意的是，pull 可能会导致合并冲突，因此在使用 pull 前应确保你的本地分支与远程分支同步。如果你不希望自动合并，可以使用 git fetch 获取更新，然后手动选择是否要合并或进行其他操作，以更好地控制合并的行为。

网藤

哪些东西是线程独有的？

在多线程编程中，每个线程都有自己的私有空间和状态，包括线程栈、寄存器状态和程序计数器。以下是线程间独有的东西：

  1. 线程栈（Thread Stack）：每个线程都有自己的栈空间，用于存储局部变量、函数调用信息和其他临时数据。线程的栈是线程私有的，不同线程之间不能直接访问对方的栈。
  2. 寄存器状态（Register State）：线程在执行时会使用CPU的寄存器来保存变量和中间计算结果。每个线程有自己的寄存器状态，不同线程之间的寄存器状态是相互独立的。
  3. 程序计数器（Program Counter）：程序计数器是一个指示当前正在执行的指令的地址的寄存器。每个线程都有自己的程序计数器，用于跟踪线程的执行位置。不同线程的程序计数器是相互独立的。
  4. 线程局部存储（Thread-Local Storage）：有些编程语言和操作系统提供了线程局部存储的机制，允许每个线程拥有自己的私有变量。这些变量在不同线程间是隔离的，每个线程都有自己的拷贝。
  5. 信号处理设置（Signal Handling Setup）：在Unix/Linux系统中，每个线程都可以有自己独立的信号处理设置。不同线程可以捕获和处理不同的信号。

总的来说，线程的栈、寄存器状态、程序计数器、线程局部存储和信号处理设置是线程间独有的，它们在不同线程之间是相互独立的。这种隔离性是多线程编程中非常重要的，因为它确保了线程间的数据隔离和安全性。

如果我一定要使用指针指向某一线程的局部变量，然后另一个线程通过该指针访问，该怎么办

如果你确实需要在一个线程中访问另一个线程的局部变量，通常需要采用一些复杂的方法，因为线程的栈是私有的。这种操作需要小心谨慎，因为不当的访问可能导致程序崩溃或数据不一致。以下是一种可能的方法：

  1. 使用全局或共享的数据结构：在线程之间共享数据时，可以使用全局变量或共享的数据结构，而不是直接访问局部变量。这些数据应该由多个线程共享，并且需要使用适当的同步机制来保护对它们的访问，以避免竞态条件和数据竞争。
  2. 线程间通信：使用线程间通信机制，如消息队列、互斥锁、条件变量等，来传递数据和信号。这允许线程之间安全地交换信息，而不必直接访问对方的栈。
  3. 使用线程库或编程语言特性：某些线程库和编程语言提供了机制来共享数据或访问其他线程的局部变量。例如，Java的ThreadLocal允许在不同线程中存储线程本地变量。但即使使用这些机制，也需要小心确保数据安全和一致性。
  4. 避免直接访问局部变量：尽量避免直接访问其他线程的局部变量。这通常是一个不建议的做法，因为它容易引发不确定的行为和难以调试的问题。

总的来说，为了确保程序的正确性和可维护性，建议避免直接访问其他线程的局部变量，而是使用线程安全的机制来实现线程间的数据共享和通信。这将有助于避免潜在的问题和提高多线程程序的可靠性。

如何检测内存泄漏，原理是什么

内存泄漏是指在程序运行时分配内存但未释放该内存，导致系统中的可用内存逐渐减少，最终可能导致程序崩溃或性能下降。检测内存泄漏的目标是找到程序中未释放的内存块，以便及时修复这些问题。有多种工具和技术可以用于检测内存泄漏，其中一些常见的包括：

  1. 静态分析工具：这些工具分析源代码而不运行程序。它们可以检测代码中的潜在内存泄漏问题，例如未释放动态分配的内存或没有对资源（如文件句柄）进行适当的关闭操作。静态分析工具可以在编译时或集成到集成开发环境 (IDE) 中使用。
  2. 动态内存分析工具：这些工具在程序运行时监视内存分配和释放操作。它们可以跟踪分配的内存块，并在内存泄漏发生时提供报告。一些流行的动态内存分析工具包括 Valgrind（用于C/C++）、Dr. Memory、AddressSanitizer（Clang/LLVM工具）等。
  3. 内存分析库：一些编程语言和框架提供内置的内存分析库。例如，C++中的<memory>头文件提供了std::shared_ptr和std::unique_ptr等智能指针，它们可以帮助自动管理内存，并减少内存泄漏的风险。
  4. 自定义内存分配器：你可以实现自定义的内存分配器，以跟踪内存分配和释放操作，从而帮助检测内存泄漏。这需要对程序的内存管理进行深入了解，并可以是一种高级技术。

内存泄漏检测的原理基本上是追踪内存的分配和释放。动态内存分析工具和自定义内存分配器通常会在分配时记录分配的内存块，并在释放时检查内存块是否被释放。如果发现内存块没有被释放，工具或库会生成报告，指出可能的泄漏点，包括文件名、行号和调用栈信息。
总的来说，内存泄漏检测工具帮助开发者找到程序中未释放的内存，提供信息来定位和修复这些问题。这对于确保程序的稳定性和性能至关重要，特别是长时间运行的应用程序。

如何确定是否死锁了？

确定是否发生了死锁是多线程编程中的一个关键问题。死锁是指多个线程或进程在等待资源（如锁）时相互阻塞，无法继续执行下去。以下是一些方法和技巧，可以帮助你确定是否发生了死锁：

  1. 观察程序状态：
  • 如果程序似乎在某一点上不再响应，可能是死锁的迹象。死锁时，线程或进程通常会长时间阻塞，不再执行任何操作。
  • 查看程序的日志、输出或用户界面，以确定是否存在异常情况。
  1. 使用工具：
  • 使用专门的工具来检测死锁，如操作系统提供的工具或第三方工具。例如，Linux系统提供了top、htop等命令，可以显示系统中的线程和进程状态，包括是否有死锁。
  • 在Java中，你可以使用工具如jstack或VisualVM来分析线程状态和死锁情况。
  1. 分析资源争用：
  • 死锁通常涉及多个线程争用共享资源，如锁、文件、数据库连接等。分析程序的资源争用情况可能有助于确定潜在的死锁点。
  • 使用工具或编写自己的代码来跟踪锁的状态和线程占用情况。
  1. 审查代码：
  • 仔细审查程序的多线程代码，尤其是锁的使用。确保锁的获取和释放操作按照正确的顺序进行。
  • 检查是否存在可能导致死锁的循环等待情况。
  1. 采用预防性措施：
  • 使用线程安全的数据结构和编程模式，以减少死锁的风险。
  • 使用超时机制，当尝试获取锁或资源时，设置最大等待时间，超时后采取适当的措施，如放弃操作或重试。
  1. 模拟和测试：
  • 在开发和测试阶段，模拟和测试不同情况下的多线程并发操作，以检测潜在的死锁情况。
  • 使用单元测试、集成测试和性能测试来评估程序的多线程行为。

注意，死锁通常是多线程编程中比较复杂的问题，其根本原因可能不容易发现。因此，持续的代码审查、测试和监控都是预防和解决死锁问题的重要步骤。如果怀疑发生了死锁，及时的分析和排查将有助于减少其影响并提高程序的稳定性。

地平线

一面

1. 指针函数和函数指针的区别，回调函数是哪个？

指针函数

指针函数是一种特殊类型的函数，它返回一个指针（通常是指向其他数据类型的指针），而不是返回常规的数据值。这允许你在函数中创建和返回指向数据或对象的指针，而不是实际的数据。这在编程中非常有用，因为它可以帮助你动态分配内存，创建灵活的数据结构，以及在不同部分的程序中共享数据。

下面是指针函数的一些关键概念：

  1. 指针函数的声明：指针函数的声明方式与常规函数类似，只不过它的返回类型是一个指针。例如，一个返回整数指针的指针函数的声明如下：
int* myPointerFunction();

这表示myPointerFunction是一个函数，它将返回一个指向整数的指针。

  1. 指针函数的定义：在函数定义中，你需要确保返回的是指向正确数据类型的指针。下面是一个简单的示例，展示如何定义一个指针函数：
int* myPointerFunction() {
    int *ptr = (int*)malloc(sizeof(int));
    *ptr = 42;
    return ptr;
}

这个函数动态分配了一个整数的内存，将其值设置为42，然后返回一个指向这个整数的指针。

  1. 指针函数的调用：调用指针函数与常规函数类似。你可以使用函数名后跟一对括号来调用它，就像调用常规函数一样。例如：
int *result = myPointerFunction();
printf("Value: %d", *result);
free(result);  // 记得释放动态分配的内存

这将调用myPointerFunction，将其返回的指针赋给result，然后你可以通过*result来访问指向的整数。

  1. 内存管理：使用指针函数时要特别小心内存管理。由于你通常会在指针函数中动态分配内存，确保在不再需要指针指向的内存时释放它，以避免内存泄漏。

指针函数非常有用，特别是在需要创建动态数据结构、返回动态分配内存的函数或操作复杂数据对象时。但是，使用指针函数也需要小心，因为不正确的使用可能导致内存泄漏或悬空指针错误。因此，在编写和使用指针函数时，应格外注意内存管理和错误检查。

函数指针

函数指针是指向函数的指针变量，允许你在程序运行时动态地选择调用不同的函数。函数指针是C和C++等编程语言中强大且有用的概念，它可以用于实现回调函数、动态函数调用、函数表和多态等多种编程技巧。以下是关于函数指针的详细介绍：

  1. 函数指针的声明：函数指针的声明方式包括返回类型和参数类型，与函数原型相匹配。例如，一个指向返回整数的函数指针，带有两个整数参数的声明如下：
int (*functionPtr)(int, int);

这里functionPtr是一个函数指针，它可以指向一个返回整数，带有两个整数参数的函数。

  1. 函数指针的初始化：函数指针可以指向具体的函数。你可以将函数的地址分配给函数指针，以便在稍后调用它。例如：
int add(int a, int b) {
    return a + b;
}

int (*functionPtr)(int, int) = add;

现在，functionPtr指向了名为add的函数。

  1. 通过函数指针调用函数：你可以使用函数指针来调用它所指向的函数，就像调用普通函数一样。例如：
int result = functionPtr(3, 4);  // 调用add函数

这将调用add函数，传递参数3和4，并将结果存储在result中。

  1. 函数指针的应用：

回调函数：函数指针经常用于回调函数，允许你在某些事件发生时调用用户定义的函数。
函数表：在某些情况下，你可以使用函数指针数组来创建函数表，根据索引来选择要调用的函数。
动态函数调用：函数指针允许你在运行时选择要调用的函数，这在某些情境下非常有用。
多态：在面向对象编程中，函数指针可以用于实现多态，允许不同类的对象具有相同的接口并通过函数指针调用不同的实现。
函数指针与参数列表：确保函数指针的参数列表与它所指向的函数匹配，否则会导致未定义行为或编译错误。

NULL指针检查：在使用函数指针之前，最好进行NULL指针检查，以避免悬空指针引发的问题。

函数指针是一种高级编程技巧，通常在需要更灵活的函数调用方式或需要实现回调机制的情况下使用。要小心确保函数指针的类型匹配，以避免运行时错误。

posted @ 2022-09-22 17:21  围城chen  阅读(16)  评论(0)  编辑  收藏  举报