C++ 方向面试考点总结（持续更新中）

互斥条件: 一个资源一次只能被一个进程所访问，即一段时间内，某资源只能被被一个进程所拥有，其他资源想要访问时，只能等待。
请求与保持条件：进程已经申请并拥有了一个资源，这时又申请其他新的资源时，该资源被其他进程所占有，此时请求进程被阻塞，但自己已经获得的资源不会释放。
不可剥夺条件：当前进程获得的资源在未使用完毕之前，是不能被其他进程强行夺走，只能由获得该资源的进程自己主动释放。
循环等待条件：若干进程之间形成首尾相接的循环等待资源关系。

打破死锁的必要条件

打破请求与保持条件：进程一开始就静态分配每个进程所需要的全部资源，或者动态分配，即每个进程在申请所需要的新资源时主动先释放自己已经占有的资源。

打破不可剥夺条件：一个进程不能获得所需要的全部资源时就要处于等待状态，等待期间所占有的资源就要被隐式的释放到系统资源列表中，方便被其他进程所使用，而等待的进程只有重新获得自己原有的资源以及新申请的资源，才可以重新启动。

打破循环等待条件：采用资源有序分配的思想，即将系统中的资源标号，将紧缺的，稀少的资源采用较大的编号，在申请资源时，必须按照编号的顺序进行，一个进程必须按照从小到大的顺序申请资源。

3 线程、进程与协程的区别？

进程直观点说，保存在硬盘上的程序运行以后，会在内存空间里形成一个独立的内存体，这个内存体有自己独立的地址空间，有自己的堆，上级挂靠单位是操作系统。操作系统会以进程为单位，分配系统资源（CPU时间片、内存等资源），进程是资源分配的最小单位。

线程 有时被称为轻量级进程(Lightweight Process，LWP），是操作系统调度（CPU调度）执行的最小单位

【区别】：

调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位；
并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行；
拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源。进程所维护的是程序所包含的资源（静态资源），如：地址空间，打开的文件句柄集，文件系统状态，信号处理handler等；线程所维护的运行相关的资源（动态资源），如：运行栈，调度相关的控制信息，待处理的信号集等；
系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。但是进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个进程死掉就等于所有的线程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。进程的创建、切换、和销毁开销都很大
一个进程崩溃，其他进程不受影响，一个线程崩溃，进程内的其他线程会都崩溃
通讯：进程之间通讯复杂，线程之间由于代码段和数据段共享，所以通讯简单。

协程是一种比线程更加轻量级的存在，协程不是被操作系统内核所管理，而完全是由程序所控制（也就是在用户态执行）。这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

协程在子程序内部是可中断的，然后转而执行别的子程序，在适当的时候再返回来接着执行。

子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。所以子程序调用是通过栈实现的，一个线程就是执行一个子程序。子程序调用总是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不同。

（转：https://blog.csdn.net/daaikuaichuan/article/details/82951084）

4进程间有哪些通讯方式？

不同主机之间： socket

同一个主机之间：

管道： PINE , FIFO
系统IPC：消息队列，信号，信号量，共享内存

5线程之间通讯方式？

临界区，互斥量，信号量，事件（信号）

6 C++ 内存分配

7 C++中 << >> 和 “ ” 引用文件有什么区别？

8数据库索引的好处和坏处？

9 各种排序算法的时间复杂度性能分析

1 归并排序

void merge(int arr[], int l, int m, int r) 
{ 
    int i, j, k; 
    int n1 = m - l + 1; 
    int n2 =  r - m; 
 
    int L[n1], R[n2]; 
 
    for (i = 0; i < n1; i++) 
        L[i] = arr[l + i]; 
    for (j = 0; j < n2; j++) 
        R[j] = arr[m + 1+ j]; 
 
    i = 0; 
    j = 0; 
    k = l; 
    while (i < n1 && j < n2) 
    { 
        if (L[i] <= R[j]) 
        { 
            arr[k] = L[i]; 
            i++; 
        } 
        else
        { 
            arr[k] = R[j]; 
            j++; 
        } 
        k++; 
    } 
  
    while (i < n1) 
    { 
        arr[k] = L[i]; 
        i++; 
        k++; 
    } 
  
    while (j < n2) 
    { 
        arr[k] = R[j]; 
        j++; 
        k++; 
    } 
} 
  
void mergeSort(int arr[], int l, int r) 
{ 
    if (l < r) 
    { 
        int m = l+(r-l)/2; 
  
        mergeSort(arr, l, m); 
        mergeSort(arr, m+1, r); 
  
        merge(arr, l, m, r); 
    } 
}

2 冒泡排序

void bubbleSort(vector<int>& a)
{
      bool swapp = true;
      while(swapp){
        swapp = false;
        for (size_t i = 0; i < a.size()-1; i++) {
            if (a[i]>a[i+1] ){
                swap(a[i],a[i+1]);
                                /*a[i] += a[i+1];
                                a[i+1] = a[i] - a[i+1];
                                a[i] -=a[i+1];
                                */
                swapp = true;
            }
        }
    }
}

3 选择排序

void selectionSort(vector<int>& arr) {
    int len = arr.size();
    int minIndex, temp;
    for (var i = 0; i < len - 1; i++) {
        minIndex = i;
        for (var j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        swap(arr[i], arr[minIndex]);
    }
    return;
}

4 快速排序

#include<iostream>
using namespace std;
void quickSort(int a[], int m,int n);
int partion(int a[], int m, int n);
int main()
{
	int a[] = { 6,1,2,7,9,3,4,5,10,8 };
	int m = 0;
	int n = (sizeof(a) / 4)-1;
	quickSort(a, m,n);
	for (int i = 0; i < 10; i++)
	{
		cout << a[i] << " ";
	}
}
void quickSort(int a[], int l, int r)
{
	if (l < r)
	{
		int q = partion(a, l, r);
		quickSort(a, l, q - 1 );
		quickSort(a, q + 1, r);
	}
}
int partion(int a[], int begin, int end)
{
	int stone = a[begin];
	while (begin < end)
	{
		while (begin < end && a[end] > stone)
		{
			end--;
		}
		swap(a[begin], a[end]);
		while (begin < end && a[begin] <= stone)
		{
			begin++;
		}
		swap(a[begin], a[end]);
	}
	return begin;
}