富途证券 8.14

最新推荐文章于 2021-01-08 19:47:49 发布

AquilaEAG

最新推荐文章于 2021-01-08 19:47:49 发布

阅读量493

点赞数

分类专栏：面试记录

本文链接：https://blog.csdn.net/weixin_43202635/article/details/108011512

版权

面试记录专栏收录该内容

30 篇文章 0 订阅

订阅专栏

计算机网络->数据库->操作系统->C++

1.select和epoll区别

select、poll、epoll三者的区别：
1、select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要遍历整个fd集合，而epoll在“醒着”的时候只要判断一下就绪链表是否为空就行了，这节省了大量的CPU时间。这就是回调机制带来的性能提升。

2、select，poll每次调用都要把fd集合从用户态往内核态拷贝一次，并且要把current往设备等待队列中挂一次，而epoll只要一次拷贝，而且把current往等待队列上挂也只挂一次（在epoll_wait的开始，注意这里的等待队列并不是设备等待队列，只是一个epoll内部定义的等待队列）。这也能节省不少的开销。
在这里插入图片描述

https://www.cnblogs.com/aspirant/p/9166944.html

2.进程与线程区别

线程和进程各自有什么区别和优劣呢？

进程是资源分配的最小单位，线程是程序执行的最小单位。
进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、堆栈段和数据段，这种操作非常昂贵。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。不过如何处理好同步与互斥是编写多线程程序的难点。
但是多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。

https://www.jianshu.com/p/2dc01727be45

3.为什么要用extern C?

在C++引用lua的头文件时，我们总会写成：

extern "C" {
    #include "lua.h"
    #include "lualib.h"
    #include "lauxlib.h"
}

为什么要这么做呢？原因是C++的编译器会对程序中符号进行修饰，这个过程在编译器中叫符号修饰（Name Decoration）或者符号改编（Name Mangling）。

同时我们知道C++是能够兼容C的，如果我们有了一个C语言的头文件和其对于的库，在C++中如何使用它呢？在include该头文件的时候当然要加入extern “C”，否则按照C++的符号进行符号修饰，那么在库中就会找不到该符号了。

想一想，如果C++程序要调用一个已经编译好的C程函数时，该怎么操作呢？

如果有一个C函数的声明是这样的：

void foo(int x, bool y)

该函数在C编译器编译后在库中的名字为 “__foo”;

该函数在C++编译器编译后在库中的名字为"__foo_int_bool" ,之所以C++编译器这样操作，是因为C++支持重载和类型安全；

由于在这两种不同编译下，函数的名字不同，所以C++程序不能直接调用C函数，于是C++提供了一个连接交换符号“extern C”来解决这个问题；

extern "C"

{

   void foo(int x,bool y);

  ..................//其他函数

}

这就告诉C++编译器，这是个C连接，应该到库中找名字为“__foo”的函数而不是"__foo_int/_bool"的函数。

4.C++中空类的大小

对于结构体和空类大小是1这个问题，首先这是一个C++问题，在C语言下空结构体大小为0(当然这是编译器相关的)。这里的空类和空结构体是指类或结构体中没有任何成员。

在C++下，空类和空结构体的大小是1字节（编译器相关），这是为什么呢？为什么不是0？

这是因为，C++标准中规定，“no object shall have the same address in memory as any other variable” ，就是任何不同的对象不能拥有相同的内存地址。如果空类大小为0，若我们声明一个这个类的对象数组，那么数组中的每个对象都拥有了相同的地址，这显然是违背标准的。

如果允许C++对象大小为0，那么这里的运算将产生两个问题：（1）不能通过指针区分不同的数组对象；（2）sizeof T为0导致非法的除0操作。这样一来，编译器还需要用一些复杂的代码来处理这些异常情况信息。

为了满足C++标准规定的不同对象不能有相同地址，C++编译器保证任何类型对象大小不能为0。C++编译器会在空类或空结构体中增加一个虚设的字节（有的编译器可能不止一个），以确保不同的对象都具有不同的地址。

http://www.spongeliu.com/260.html

5.static的作用

全局静态变量

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

静态存储区，在整个程序运行期间一直存在。

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

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

局部静态变量

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

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

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

作用域：作用域仍为局部作用域，当定义它的函数或者语句块结束的时候，作用域结束。但是当局部静态变量离开作用域后，并没有销毁，而是仍然驻留在内存当中，只不过我们不能再对它进行访问，直到该函数再次被调用，并且值不变；

静态函数

在函数返回类型前加static，函数就定义为静态函数。函数的定义和声明在默认情况下都是extern的，但静态函数只是在声明他的文件当中可见，不能被其他文件所用。

函数的实现使用static修饰，那么这个函数只可在本cpp内使用，不会同其他cpp中的同名函数引起冲突；

warning：不要再头文件中声明static的全局函数，不要在cpp内声明非static的全局函数，如果你要在多个cpp中复用该函数，就把它的声明提到头文件里去，否则cpp内部声明需加上static修饰；

类的静态成员

在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用

类的静态函数

静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

https://www.nowcoder.com/tutorial/93/a34ed23d58b84da3a707c70371f59c21

6.类里面的哪些函数不可以做虚函数

类中不能为虚函数的有：（1）构造函数，（2）静态函数，（3）内联函数，（4）友元函数

1、普通函数（非成员函数）：我在前面多态这篇博客里讲到，定义虚函数的主要目的是为了重写达到多态，所以普通函数声明为虚函数没有意义，因此编译器在编译时就绑定了它。

2、静态成员函数：静态成员函数对于每个类都只有一份代码，所有对象都可以共享这份代码，他不归某一个对象所有，所以它也没有动态绑定的必要。

3、内联成员函数：内联函数本就是为了减少函数调用的代价，所以在代码中直接展开。但虚函数一定要创建虚函数表，这两者不可能统一。另外，内联函数在编译时被展开，而虚函数在运行时才动态绑定。

4、构造函数：这个原因很简单，主要从语义上考虑。因为构造函数本来是为了初始化对象成员才产生的，然而虚函数的目的是为了在完全不了解细节的情况下也能正确处理对象，两者根本不能“ 好好相处 ”。因为虚函数要对不同类型的对象产生不同的动作，如果将构造函数定义成虚函数，那么对象都没有产生，怎么完成想要的动作？？

5、友元函数：当我们把一个函数声明为一个类的友元函数时，它只是一个可以访问类内成员的普通函数，并不是这个类的成员函数，自然也不能在自己的类内将它声明为虚函数。

注意：友元本身可以是虚函数！！
如果一个类的友元函数是另一个类成员函数，那么它在自己的类内可以被声明为虚函数。

https://blog.csdn.net/boyaaboy/article/details/102936978

7.ping的原理

一、什么是ping

DOS 命令，一般用于检测网络通与不通，也叫时延，其值越大，速度越慢 PING (Packet Internet Grope)，因特网包探索器，用于测试网络连接量的程序。Ping 发送一个 ICMP 回声请求消息给目的地并报告是否收到所希望的 ICMP 回声应答。

它是用来检查网络是否通畅或者网络连接速度的命令。作为一个生活在网络上的管理员或者黑客来说，ping 命令是第一个必须掌握的 DOS 命令，它所利用的原理是这样的：网络上的机器都有唯一确定的 IP 地址，我们给目标 IP 地址发送一个数据包，对方就要返回一个同样大小的数据包，根据返回的数据包我们可以确定目标主机的存在，可以初步判断目标主机的操作系统等。

二、ping的工作流程

我们以下面一个网络为例：有 A、B、C、D 四台机子，一台路由 RA，子网掩码均为 255.255.255.0，默认路由为 192.168.0.1 [1]

1.在同一网段内

在主机 A 上运行“Ping 192.168.0.5”后，都发生了些什么呢? 首先，Ping 命令会构建一个固定格式的 ICMP 请求数据包，然后由 ICMP 协议将这个数据包连同地址“192.168.0.5”一起交给IP 层协议（和 ICMP 一样，实际上是一组后台运行的进程），IP 层协议将以地址 “192.168.0.5”作为目的地址，本机 IP 地址作为源地址，加上一些其他的控制信息，构建一个 IP 数据包，并想办法得到 192.168.0.5 的MAC 地址（物理地址，这是数据链路层协议构建数据链路层的传输单元——帧所必需的），以便交给数据链路层构建一个数据帧。关键就在这里，IP 层协议通过机器 B 的 IP 地址和自己的子网掩码，发现它跟自己属同一网络，就直接在本网络内查找这台机器的 MAC,如果以前两机有过通信，在 A 机的 ARP 缓存表应该有 B 机 IP 与其 MAC 的映射关系，如果没有，就发一个 ARP 请求广播，得到 B 机的 MAC, 一并交给数据链路层。后者构建一个数据帧，目的地址是 IP 层传过来的物理地址，源地址则是本机的物理地址，还要附加上一些控制信息，依据以太网的介质访问规则，将它们传送出去。主机 B 收到这个数据帧后，先检查它的目的地址，并和本机的物理地址对比，如符合，则接收；否则丢弃。接收后检查该数据帧，将 IP 数据包从帧中提取出来，交给本机的 IP 层协议。同样，IP 层检查后，将有用的信息提取后交给 ICMP 协议，后者处理后，马上构建一个 ICMP 应答包，发送给主机 A，其过程和主机 A 发送 ICMP 请求包到主机 B 一模一样。

2.不在同一网段内

在主机 A 上运行“Ping 192.168.1.4”后，开始跟上面一样，到了怎样得到 MAC 地址时，IP 协议通过计算发现 D 机与自己不在同一网段内，就直接将交由路由处理，也就是将路由的 MAC 取过来，至于怎样得到路由的 MAC，跟上面一样，先在 ARP 缓存表找，找不到就广播吧。路由得到这个数据帧后，再跟主机 D 进行联系，如果找不到，就向主机 A 返回一个超时的信息。

https://blog.csdn.net/zhuying_linux/article/details/6770730

8.进程间如何通信

liunx六大进程间通信方式
管道，消息队列，共享内存，信号量，socket，信号，文件锁

1，管道

  1，匿名管道：

             概念：在内核中申请一块固定大小的缓冲区，程序拥有写入和读取的权利，一般使用fork函数实现父子进程的通信。

                        

  2，命名管道： 

              概念：在内核中申请一块固定大小的缓冲区，程序拥有写入和读取的权利，没有血缘关系的进程也可以进程间通信。

                             

  3，特点：



            1，面向字节流，

            2，生命周期随内核

            3，自带同步互斥机制。

            4，半双工，单向通信，两个管道实现双向通信。

2，消息队列

1，概念：
		      在内核中创建一队列，队列中每个元素是一个数据报，不同的进程可以通过句柄去访问这个队列。

              消息队列提供了⼀个从⼀个进程向另外⼀个进程发送⼀块数据的⽅法。

              每个数据块都被认为是有⼀个类型，接收者进程接收的数据块可以有不同的类型值                          

                           

              消息队列也有管道⼀样的不⾜，就是每个消息的最⼤⻓度是有上限的（MSGMAX），

              每个消息队 列的总的字节数是有上限的（MSGMNB），系统上消息队列的总数也有⼀个上限（MSGMNI）

2，特点：

          1， 消息队列可以认为是一个全局的一个链表，链表节点钟存放着数据报的类型和内容，有消息队列的标识符进行标记。

          2，消息队列允许一个或多个进程写入或者读取消息。

          3，消息队列的生命周期随内核。

          4，消息队列可实现双向通信。

3，信号量

    1，概念

                  在内核中创建一个信号量集合（本质是个数组），数组的元素（信号量）都是1，使用P操作进行-1，使用V操作+1，

                  （1） P(sv)：如果sv的值⼤大于零，就给它减1；如果它的值为零，就挂起该进程的执⾏ 。
                  （2） V(sv)：如果有其他进程因等待sv而被挂起，就让它恢复运⾏，如果没有进程因等待sv⽽挂起，就给它加1。

                       PV操作用于同一进程，实现互斥。

                      PV操作用于不同进程，实现同步。

     2，功能：

                    对临界资源进行保护。

4，共享内存

   1，概念：

              将同一块物理内存一块映射到不同的进程的虚拟地址空间中，实现不同进程间对同一资源的共享。

              共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。

    2，特点：

             1，不用从用户态到内核态的频繁切换和拷贝数据，直接从内存中读取就可以。

             2，共享内存是临界资源，所以需要操作时必须要保证原子性。使用信号量或者互斥锁都可以。

             3，生命周期随内核。

5，总结

所有的以上的方式都是生命周期随内核，不手动释就不会消失。

https://blog.csdn.net/csdn_kou/article/details/82908922

8.线程间如何通信

一：两个进程间的两个线程通信，相当于进程间通信

二：一个进程中的两个线程间通信

通信方式：

1.互斥锁

mutex;

lock_guard (在构造函数里加锁，在析构函数里解锁）

unique_lock 自动加锁、解锁

2.读写锁

shared_lock

3.信号量

c++11中未实现，可以自己使用mutex和conditon_variable 实现

代码实现如下：

#pragma once
#include <mutex>
#include <condition_variable>
class Semaphore
{
public:
 explicit Semaphore(unsigned int count); //用无符号数表示信号量资源 
 ~Semaphore();
public:
 void wait();
 void signal();
private:
 int m_count; //计数器必须是有符号数 
 std::mutex m_mutex;
 std::condition_variable m_condition_variable;
};
 
#include "Semaphore.h"
Semaphore::Semaphore(unsigned int count) :m_count(count) {
}
Semaphore::~Semaphore()
{
}
void Semaphore::wait() {
 std::unique_lock<std::mutex> unique_lock(m_mutex);
 --m_count;
 while (m_count < 0) {
  m_condition_variable.wait(unique_lock);
 }
}
void Semaphore::signal() {
 std::lock_guard<std::mutex> lg(m_mutex);
 if (++m_count < 1) {
  m_condition_variable.notify_one();
 }
}

4.条件变量

condition_variable

https://www.bbsmax.com/A/pRdBgqyazn/

9.如何保证线程安全

1、互斥同步

互斥同步是最常见的一种并发正确性保障手段。同步是指在多线程并发访问共享数据时，保证共享数据在同一时刻只被一个线程使用（同一时刻，只有一个线程在操作共享数据）。而互斥是实现同步的一种手段，临界区、互斥量和信号量都是主要的互斥实现方式。因此，在这4个字里面，互斥是因，同步是果；互斥是方法，同步是目的。

在java中，最基本的互斥同步手段就是synchronized关键字，synchronized关键字编译之后，会在同步块的前后分别形成monitorenter和monitorexit这两个字节码质量，这两个字节码指令都需要一个reference类型的参数来指明要锁定和解锁的对象。

此外，ReentrantLock也是通过互斥来实现同步。在基本用法上，ReentrantLock与synchronized很相似，他们都具备一样的线程重入特性。

互斥同步最主要的问题就是进行线程阻塞和唤醒所带来的性能问题，因此这种同步也成为阻塞同步。从处理问题的方式上说，互斥同步属于一种悲观的并发策略，总是认为只要不去做正确地同步措施（例如加锁），那就肯定会出现问题，无论共享数据是否真的会出现竞争，它都要进行加锁。

2、非阻塞同步

随着硬件指令集的发展，出现了基于冲突检测的乐观并发策略，通俗地说，就是先进行操作，如果没有其他线程争用共享数据，那操作就成功了；如果共享数据有争用，产生了冲突，那就再采用其他的补偿措施。（最常见的补偿错误就是不断地重试，直到成功为止），这种乐观的并发策略的许多实现都不需要把线程挂起，因此这种同步操作称为非阻塞同步。

非阻塞的实现CAS（compareandswap）：CAS指令需要有3个操作数，分别是内存地址（在java中理解为变量的内存地址，用V表示）、旧的预期值（用A表示）和新值（用B表示）。CAS指令执行时，CAS指令指令时，当且仅当V处的值符合旧预期值A时，处理器用B更新V处的值，否则它就不执行更新，但是无论是否更新了V处的值，都会返回V的旧值，上述的处理过程是一个原子操作。

CAS缺点：

ABA问题：因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。

ABA问题的解决思路就是使用版本号。在变量前面追加版本号，每次变量更新的时候把版本号加一，那么A-B-A就变成了1A-2B-3C。JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

3、无需同步方案

要保证线程安全，并不是一定就要进行同步，两者没有因果关系。同步只是保证共享数据争用时的正确性的手段，如果一个方法本来就不涉及共享数据，那它自然就无需任何同步操作去保证正确性，因此会有一些代码天生就是线程安全的。

1）可重入代码

可重入代码（ReentrantCode）也称为纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码，而在控制权返回后，原来的程序不会出现任何错误。所有的可重入代码都是线程安全的，但是并非所有的线程安全的代码都是可重入的。

可重入代码的特点是不依赖存储在堆上的数据和公用的系统资源、用到的状态量都是由参数中传入、不调用非可重入的方法等。

（类比：synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时时可以再次得到该对象的锁）

2）线程本地存储

如果一段代码中所需的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行？如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内。这样无需同步也能保证线程之间不出现数据的争用问题。

符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的消费过程尽量在一个线程中消费完。其中最重要的一个应用实例就是经典的Web交互模型中的“一个请求对应一个服务器线程（Thread-per-Request）”的处理方式，这种处理方式的广泛应用使得很多Web服务器应用都可以使用线程本地存储来解决线程安全问题。

https://blog.csdn.net/qq_26545305/article/details/79516610

10.Linux上如何使用命令来查看文件第100行到第200行的记录信息？

1.head命令查看文件中的前200行

head -n 200 filename

2.tail 命令查看文件中的后100行

tail -n 100 filename

3.查看文件100行到200行

head -n 200 filename | tail -n 100

4.从100行开始显示文件

tail -n +100 filename

5.显示除后100行的文件内容

head -n -100 filename

11.你了解的排序算法有哪些，怎么工作的？复杂度是多少？排序是否稳定？

12.C++中的哈希表介绍下？

13.手撕代码：单链表反转

现在假设定义pre、phead、temp三个指针变量，用phead指向链表的头结点，而pre代表phead的前一个节点。具体实现代码如下：
实现代码


TreeNode* InvertList(TreeNode* head){
	TreeNode* pre,phead,temp;
	phead = head;  //将phead指向链表头，做游标使用
	pre = NULL;  //pre为头指针之前的节点
	
	while(phead != NULL){
		temp = pre;
		pre = phead;
		phead = phead->next;
		pre->next = temp;  //pre接到之前的节点 
	}
	
	return pre; 
}

以下用两个图加深理解：
1.执行while循环以前，链表和各个指针变量的情况：
在这里插入图片描述

2.第一次执行while循环，链表和各个指针变量的情况：
在这里插入图片描述

然后依次往下，最后实现链表反转。

AquilaEAG

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
富途证券 8.14

计算机网络->数据库->操作系统->C++1.select和epoll区别select、poll、epoll三者的区别：1、select，poll实现需要自己不断轮询所有fd集合，直到设备就绪，期间可能要睡眠和唤醒多次交替。而epoll其实也需要调用epoll_wait不断轮询就绪链表，期间也可能多次睡眠和唤醒交替，但是它是设备就绪时，调用回调函数，把就绪fd放入就绪链表中，并唤醒在epoll_wait中进入睡眠的进程。虽然都要睡眠和交替，但是select和poll在“醒着”的时候要
复制链接

扫一扫

专栏目录