常见面试问题2

编程基础和操作系统

1. 编程基础

概念辨析

多态：类的多态和函数的多态

一个实体同时具备多种形式，在特定情况下，表现不同的状态，对应不同的属性和方法。C++中主要体现在运行和编译两个方面。C中通过钩子函数挂接才能达成同样的效果。

C++中主要通过虚函数实现，也可以通过抽象类、覆盖（重写）、模板。（重载和多态无关）

封装：

将抽象的道德数据和行为或功能相结合，形成有机整体“类”，数据和函数都是类的成员。

封装增强了安全性，简化了编程。

重载和重写：

重载overloading：不同的函数，相同的函数名不同的参数个数或者类型。调用的时候根据参数来区别。对权限没有要求。

重写overriding（覆盖）：在派生类中重新对基类中的虚函数重新实现。函数名和参数都一样，只是函数的实现体不一样。调用的时候根据对象的类型来区别。被重写的方法不能拥有比父类更严格的权限。

重写是子类和父类之间的关系，是垂直关系，发生在继承中。重载是同一个类中的方法之间的关系，是水平关系，发生在一个类中。

虚函数：

用virtual关键字申明的函数，虚函数一定是类的成员函数。虚函数理解教程

纯虚函数是虚函数再加上=0

纯虚函数：virtual void fun()=0;即抽象类，必须在子类中实现这个函数，即先有名称，没有内容，在派生类实现内容。

继承派生：

闭包、垃圾回收的概念和过程：

java中的概念 不懂

例题：多集成中派生类对象结构

例题：虚函数表构成

存在虚函数的类都有一个一维的虚函数表叫做虚表，类的对象有一个指向虚表开始位置的虚指针。虚表和类对应，虚表指针和对象对应。

例题：虚函数实现多态的原理

在基类函数前加上virtual关键字，在派生类中重写该函数，运行时根据对象的实际类型来调用相应函数。如果对象类型是派生类，那么就调用派生类的函数，如果对象类型是基类，那么就调用基类的函数。

例题：构造函数可以定义为私有吗？

将构造函数声明为私有,可以确保本类以外的地方都不能实例化这个类 。

标准的单例模式就是构造函数私有。

1
2
3
4
5
6
7

 class A{
 	private:
 	A() {}
	static A a;
	public:
	static A& Instance() { return a; }
};

编程语言的区别

JAVA/C/C++/SCALA

C是面向过程的。JAVA和C++是面向对象的。SCALA比较新。

面向对象编程与函数式编程

面向对象编程：封装、继承、多态；相对于面向过程而言的

基于对象编程：支持类但不支持多态，不提供抽象、继承和重载等有关面向对象语言的功能。

例题： C++弱指针，智能指针weak_ptr 防止内存泄漏

STL提供的智能指针一共有四种：auto_ptr(已经淘汰)、unique_ptr、shared_ptr和weak_ptr。

unique_ptr：

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

weak_ptr：是一个引用计数型智能指针，不增加对象的引用计数，即弱引用。弱引用并不修改该对象的引用计数，这意味着弱引用并不对对象的内存进行管理，只要把循环引用的乙方使用弱引用即可解除循环引用。

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

strong_ptr是强引用，只要有一个指向对象的shared_ptr存在，该对象就不会被析构，直到指向对象的最后一个shared_ptr析构或是reset()时才会被销毁。利用weak_ptr可以解决常见的空悬指针问题以及循环引用问题。

例题：C++的内存和memory leak，编译过程中的内存分配

内存泄漏(memory leak)是指由于疏忽或错误造成了程序未能释放掉不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

（1）堆内存泄漏 （Heap leak）。对内存指的是程序运行中根据需要分配通过malloc,realloc new等从堆中分配的一块内存，再是完成后必须通过调用对应的 free或者delete 删掉。如果程序的设计的错误导致这部分内存没有被释放，那么此后这块内存将不会被使用，就会产生Heap
Leak.
（2）系统资源泄露（Resource Leak）.主要指程序使用系统分配的资源比如 Bitmap,handle ,SOCKET等没有使用相应的函数释放掉，导致系统资源的浪费，严重可导致系统效能降低，系统运行不稳定。

例题： const的使用（指针数组和数组指针辨析）

1
2
3
4
5
6
7
8

const int *p;  //修饰int 即*p指向的内容不变
int const *p;  //修饰int 即*p指向的内容不变
int* const p;  //修饰int* 即*p不能改变指向的地址
const int* const p;  //都不能变

const int a = 10;
const int &b = a;
const int &c = 20;

2. 操作系统

进程和线程：一个进程可能包括多个线程

线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，可以使用多线程对进行运算提速。

进程之间通信：

管道：半双工；只用于具有亲缘关系的进程；特殊的文件，可以read、write但只存在内存中；速度慢，容量有限

FIFO：命名管道；任何进程间都能通讯，但速度慢

socket：

消息队列：消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标识； 容量受到系统限制，且要注意第一次读的时候，要考虑上一次没有读完数据的问题

信号量：不能传递复杂消息，只能用来同步

共享内存区：能够很容易控制容量，速度快，但要保持同步，比如一个进程在写的时候，另一个进程要注意读写的问题，相当于线程中的线程安全，当然，共享内存区同样可以用作线程间通讯，不过没这个必要，线程间本来就已经共享了同一进程内的一块内存

例题：线程如何创建？如何实现互斥？线程池怎么创建？有几个线程？都执行一个函数吗？线程锁？

有两种常见的创建线程的方法，一种是继承Thread类，一种是实现Runnable的接口，Thread类其实也是实现了Runnable接口。但是创建这两种线程在运行结束后都会被虚拟机销毁，如果线程数量多的话，频繁的创建和销毁线程会大大浪费时间和内存，因为线程执行完毕后死亡，线程对象变成垃圾。使用线程池可以让线程运行完后不立即销毁而是重复使用，继续执行其他的任务。参考执棋手的博客

C++中的多线程类Thread。头文件为#include,通过std::thread应用。

构造函数 ThreadPool()：

开启一定数量的线程，每开启一个线程，让该线程进入死循环，对接下来的操作，先利用互斥锁先加锁，再利用条件锁判断线程任务列表是否为空，若为空即阻塞该线程（就是没人办理业务时进入待机状态）。接下来，从任务列表中取任务，然后解开互斥锁，让其执行完后再重复以上操作。对于开启的每一个线程都是如此。

添加任务函数 enqueue()：

先获取任务，加互斥锁，将该任务加入任务列表，解锁，然后唤醒一个任务，让其进行等待。

析构函数 ~ThreadPool()：

唤醒所有的工作，让线程一个个的执行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include blablabla

typedef struct {
    int first;
    int last;
    int result;
} MY_ARGS;

void* myfun(void* args){
    int i = 0;
    MY_ARGS* my_args = (MY_ARGS*) args;
    int first = my_args -> first;
    int last = my_args -> last;
    pthread_mutex_lock(&lock);
    for (i = 0; i < 10000; i++){
        s = s + arr[i]; 
    }
    my_args -> result = s;
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main (){
    int i;
    pthread_t th1;
    pthread_t th2;
    pthread_mutex_init(&lock, NULL);
    MY_ARGS args1 = {0, 2500, 0};
    MY_ARGS args2 = {2500, 5000, 0};
    
    pthread_create(&th1, NULL, myfunc, &args1);
    pthread_create(&th2, NULL, myfunc, &args2);
    pthread_join(th1, NULL);
    pthread_join(th2, NULL);

return 0;
}

例题：在Windows的一个磁盘下新建文件夹的系统操作过程

例题：在Linux系统中如果已知一个进程名，怎么输出PID号？ （ps和top命令？

ps -ef |grep “name” | grep -v grep

ps -ef | awk ‘/[n]ame/{print $2}’

ps -x | awk ‘/[n]ame/{print $2}’

pgrep -f name

例题：Linux的进程调度

在处理器资源有限的系统中，所有进程都以轮流占用处理器的方式交叉运行。为使每个进程都有运行的机会，调度器为每个进程分配了一个占用处理器的时间额度，这个额度叫做进程的“时间片”，其初值就存放在进程控制块的counter域中。进程每占用处理器一次，系统就将这次所占用时间从counter中扣除，因为counter反映了进程时间片的剩余情况，所以叫做剩余时间片。

Linux调度的主要思想为：调度器大致以所有进程时间片的总和为一个调度周期；在每个调度周期内可以发生若干次调度，每次调度时，所有进程都以counter为资本竞争处理器控制权，counter值大者胜出，优先运行；凡是已耗尽时间片（即counter=0）的，则立即退出本周期的竞争；当所有未被阻塞进程的时间片都耗尽，那就不等了。然后，由调度器重新为进程分配时间片，开始下一个调度周期。

目前，标准Linux系统支持非实时（普通）和实时两种进程。与此相对应的，Linux有两种进程调度策略：普通进程调度和实时进程调度。因此，在每个进程的进程控制块中都有一个域policy，用来指明该进程为何种进程，应该使用何种调度策略。

Linux调度的总体思想是：实时进程优先于普通进程，实时进程以进程的紧急程度为优先顺序，并为实时进程赋予固定的优先级；普通进程则以保证所有进程能平均占用处理器时间为原则。所以其具体做法就是：

• 对于实时进程来说，总的思想是为实时进程赋予远大于普通进程的固定权重参数weight，以确保实时进程的优先级。在此基础上，还分为两种做法：一种与时间片无关，另一种与时间片有关；
• 对于普通进程来说，原则上以相等的weight作为所有进程的初始权重值，即nice=0，然后在每次进行进程调度时，根据剩余时间片对weight动态调整。

例题：日志分析用到的shell命令

CSDN上的一个总结博客

例题：Linux地址管理，分段，分页

例题：进程内存总大小，虚拟内存和物理内存，砖石继承