常见腾讯C++面试问题总结

【1】同步通信和异步通信的区别？

答：

1） 同步通信要求接收端时钟频率和发送端时钟频率一致，发送端发送连续的比特流；异步通信时不要求接收端时钟和发送端时钟同步，发送端发送完一个字节后，可经过任意长的时间间隔再发送下一个字节。

2） 同步通信效率高；异步通信效率低。

3） 同步通信较复杂，双方时钟的允许误差较小；异步通信简单，双方时钟可允许一定误差。

【2】TCP协议的作用？三次握手通过什么方法保证通信双方确认的正确？

答：

TCP提供的可靠数据传输服务是依靠接收端TCP软件按序号对收到的数据分组进行逐一确认实现的。这个过程在TCP收发端开始通信时，被称为三次握手初化。

三次握手过程：

第一次握手：client端首先向server端发送一个SYN包，值为1。这是第一个封包，告知server端client端想与server建立TCP连接；

第二次握手：server端接收到client端发送的SYN包后，会回复一个SYN/ACK包，SYN值加1，ACK值随机产生。告知client端server端已收到client端发送的SYN包；

第三次握手：client端收到server端答复的SYN/ACk包后，又会回复一个ACK，ACK值是server端发送来的SYN/ACK包中的ACK值加1。告知server端client端已收到SYN/ACK包。到此为止，三次握手完成，client端和server端可以开始传送数据。

 

四次分手过程：

断开TCP连接，要传送四个封包。比建立TCP连接时多了一次。主要原因是，断开TCP连接是在client端和server端分别发生的。

例设第一个封包由client端发送，则client端会发送一个FIN封包，值为1。告知server端client端要结束连接。

server端收到client端发送的FIN包后，知道client端已完成数据的传送要请求断开TCP连接。server端会发送一个ACK包给client端。告知client端server端已知道正常收到FIN包。

server端把未传送完的数据传送给client端后，也会给client端发送一个FIN，告知client端server端已完成数据传送，可以断开TCP连接。

client端收到server端发送的FIN封包后，会向server端回复一个ACK包，表示已确认server端的FIN封包。至此，TCP连接断开。

 

【3】操作系统执行可执行程序时，内存分配是怎样的？

一个由C/C++编译的程序占用的内存分为以下几个部分：

1） 栈区，由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方法类似于数据结构中的栈。

2） 堆区，一般由程序员分配和释放，若程序员不释放，程序结束时可能由OS回收。注意，它和数据结构中的堆是两回事，分配方式倒是类似于链表。

3） 全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

4） 文字常量区，常量字符串都存放这里，程序结束后由系统释放。

5） 程序代码区，存放函数体的二进制代码。

【4】重载和覆盖的区别是什么？

答：

1） 方法的覆盖是子类和父类之间的关系，是垂直关系。方法的重载是同一个类中方法之间的关系，是水平关系。

2） 覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。

3） 覆盖要求参数列表相同，重载要求参数列表不同。

4） 覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系是根据调用时的实参表与形参表来选择方法体的。

【5】数据库的读脏数据，存放数据库的磁盘出现灾难性事故，有什么方法可以避免？

答：

使用并发控制技术的*技术可以避免读数据的不一致。

 

【6】Windows编程中，消息机制如何实现？

答：

自定义消息一共分为三步，

1） 自定义消息：#define WM_MYMSGWM_USER + 1

2） 在头文件中声明函数：afx_msg void myMsg()；

3） 在消息映射中添加对应关系：ON_MESSAGE(WM_MYMSG， onMyMsg)；

核心：函数原型、关联消息与消息响应函数的宏、函数实现。

 

【7】写一个病毒。

while(1) {int *p = new int[10000000]； }

【8】两个数相乘，小数点后位数没有限制，请写一个高精度算法。

~~~

【9】找出1-10w中没有出现的两个数字。

1） 位图，申请10w个bit的空间，每个bit代表一个数字是否出现过。开始时将这10w个bit都初始化为0，表示所有数字都没有出现过。然后依次读入已经打乱循序的数字，并将对应的bit设为1。当处理完所有数字后，根据为0的bit得出没有出现的数字。

2） 首先计算1到10w的和，平方和。然后计算给定数字的和，平方和。两次的到的数字相减，可以得到这两个数字的和，平方和。所以我们有x + y = n x^2 + y^2 = m 解方程可以得到x和y的值。

【10】需要多少只小白鼠才能在24小时内找到毒药有1000瓶水，其中有一瓶有毒，小白鼠只要尝一点带毒的水24小时后就会死亡，至少要多少只小白鼠才能在24小时时鉴别出那瓶水有毒？

最容易想到的就是用1000只小白鼠，每只喝一瓶。但显然这不是最好答案。既然每只小白鼠喝一瓶不是最好答案，那就应该每只小白鼠喝多瓶。那每只应该喝多少瓶呢？首先让我们换种问法，如果x小白鼠，那么24小时内可以从多少瓶水中找出那瓶有毒的？由于每只小白鼠都只有死或者活这两种结果，所以x只小白鼠最大可以表示2^x种结果。如 果让每种结果都对应到某瓶水有毒，那么也就可以从2^x瓶水中找到有毒的那瓶水。那如何来实现这种对应关系呢？ 第一只小白鼠喝第1到2^(x-1)瓶，第二只小白鼠喝第1到第2^(x-2)和第2^(x-1)+1到第2^(x-1) + 2^(x-2)瓶。。。。以此类推。回到此题，总过1000瓶水，所以需要最少10只小白鼠。

 

【11】判断数字是否出现在40亿个数中？给40亿个不重复的unsignedint的整数，没排过序的，然后再给几个数，如何快速判断这几个数是否在那40亿个数当中?

unsignedint 的取值范围是0到2^32-1。我们可以申请连续的2^32/8=512M的内存，用每一个bit对应一个unsigned int数字。首先将512M内存都初始化为0，然后每处理一个数字就将其对应的bit设置为1。当需要查询时，直接找到对应bit，看其值是0还是1即可。

【12】两个整数集合A和B，求其交集两个整数集合A和B，求其交集。

1） 读取整数集合A中的整数，将读到的整数插入到map中，并将对应的值设为1。

2） 读取整数集合B中的整数，如果该整数在map中并且值为1，则将此数加入到交集当中，并将在map中的对应值改为2。通过更改map中的值，避免了将同样的值输出两次。

【13】从10G个数中找到中数 在一个文件中有10G 个整数，乱序排列，要求找出中位数。内存限制为2G。

不妨假设10G个整数是64bit的。 2G内存可以存放256M个64bit整数。我们可以将64bit的整数空间平均分成256M个取值范围，用2G的内存对每个取值范围内出现整数个数进行统计。这样遍历一边10G整数后，我们便知道中数在那个范围内出现，以及这个范围内总共出现了多少个整数。如果中数所在范围出现的整数比较少，我们就可以对这个范围内的整数进行排序，找到中数。如果这个范围内出现的整数比较多，我们还可以采用同样的方法将此范围再次分成多个更小的范围（256M=2^28，所以最多需要3次就可以将此范围缩小到1，也就找到了中数）。

【14】统计论坛在线人数分布。求一个论坛的在线人数，假设有一个论坛，其注册ID有两亿个，每个ID从登陆到退出会向一个日志文件中记下登陆时间和退出时间，要求写一个算法统计一天中论坛的用户在线分布，取样粒度为秒。

答：

一天总共有3600*24 = 86400秒。定义一个长度为86400的整数数组int delta[86400]，每个整数对应这一秒的人数变化值，可能为正也可能为负。开始时将数组元素都初始化为0。然后依次读入每个用户的登录时间和退出时间，将与登录时间对应的整数值加1，将与退 出时间对应的整数值减1。

这样处理一遍后数组中存储了每秒中的人数变化情况。

定义另外一个长度为86400的整数数组int online_num[86400]，每个整数对应这一秒的论坛在线人数。

假设一天开始时论坛在线人数为0，则第1秒的人数online_num[0] = delta[0]。第n+1秒的

人数online_num[n]= online_num[n-1] + delta[n]。

这样我们就获得了一天中任意时间的在线人数。

【15】用UDP协议通讯时怎样得知目标机是否获得了数据包用UDP协议通讯时怎样得知目标机是否获得了数据包？

可以在每个数据包中插入一个唯一的ID，比如timestamp或者递增的int。发送方在发送数据时将此ID和发送时间记录在本地。

接收方在收到数据后将ID再发给发送方作为回应。发送方如果收到回应，则知道接收方已经收到相应的数据包；如果在指定时间内没有收到回应，则数据包可能丢失，需要重复上面的过程重新发送一次，直到确定对方收到。

 

【16】栈（stack）和堆（heap）具体的区别。

答：

1）在申请方式上，

栈（stack）：现在很多人都称之为堆栈，这个时候实际上还是指的栈。它由编译器自动管理，无需我们手工控制。 例如，声明函数中的一个局部变量int b 系统自动在栈中为b开辟空间；在调用一个函数时，系统自动的给函数的形参变量在栈中开辟空间。

堆（heap）： 申请和释放由程序员控制，并指明大小。容易产生memory leak。

在C中使用malloc函数。

如：p1 = (char *)malloc(10)；

在C++中用new运算符。

如：p2 = new char[20]；//(char *)malloc(10)；

但是注意p1本身在全局区，而p2本身是在栈中的，只是它们指向的空间是在堆中

2）申请后系统的响应上，

栈（stack）：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆（heap）： 首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序。另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete或free语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

3）申请大小的限制

栈（stack）：在Windows下，栈是由高向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit。

注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。

堆（heap）： 堆是向高地址扩展的数据结构，是不连续的内存区域（空闲部分用链表串联起来）。正是由于系统是用链表来存储空闲内存，自然是不连续的，而链表的遍历方向是由低地址向高地址。一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。由此可见，堆获得的空间比较灵活，也比较大。

4）分配空间的效率上

栈（stack）：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。但程序员无法对其进行控制。

堆（heap）：是C/C++函数库提供的，由new或malloc分配的内存，一般速度比较慢，而且容易产生内存碎片。它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。这样可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。显然，堆的效率比栈要低得多。

5）堆和栈中的存储内容

栈（stack）：在函数调用时，第一个进栈的是主函数中子函数调用后的下一条指令（子函数调用语句的下一条可执行语句）的地址，然后是子函数的各个形参。在大多数的C编译器中，参数是由右往左入栈的，然后是子函数中的局部变量。注意：静态变量是不入栈的。 当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中子函数调用完成的下一条指令，程序由该点继续运行。

堆（heap）：一般是在堆的头部用一个字节存放堆的大小，堆中的具体内容有程序员安排。

6）存取效率的比较

这个应该是显而易见的。拿栈上的数组和堆上的数组来说：

void main()

{

int arr[5]={1，2，3，4，5}；

int *arr1；

arr1=new int[5]；

for (int j=0；j<=4；j++)

{

arr1[j]=j+6；

}

int a=arr[1]；

int b=arr1[1]；

}

上面代码中，arr1（局部变量）是在栈中，但是指向的空间确在堆上，两者的存取效率，当然是arr高。因为arr[1]可以直接访问，但是访问arr1[1]，首先要访问数组的起始地址arr1，然后才能访问到arr1[1]。

总而言之，言而总之：

堆和栈的区别可以用如下的比喻来看出：

使用栈就象我们去饭馆里吃饭，只管点菜（声明变量）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是*度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且*度大。

【17】写string类的构造，析构，拷贝函数——这题大约出现过4次左右，包括编程和程序填空，程序员面试宝典上有这题，也算是个经典笔试题，出现几率极大~

class String

{

public：

String(const char* str = NULL) //构造函数

{

if (str == NULL)

{

m_data = new char[1]； //即使为空字符串也有一个‘\0’

m_data = '\0'；

}

else

{

int length = strlen(str)；

m_data = new char[length + 1]；

strcpy(m_data， str)；

}

}

~String()

{

delete[] m_data；

}

String(const String& other)

{

int length = strlen(other。m_data)；

m_data = new char[length + 1]；

strcpy(m_data， other。m_data)；

}

String& operator=(const String& other)

{

if (this == &other) //防止自复制

{

return *this；

}

delete[] m_data； //释放原有资源

int length = strlen(other。m_data)；

m_data = new char[length + 1]； //加分点：对m_data加NULL 判断

strcpy(m_data， other。m_data)；

return *this； //得分点：返回本对象的引用

}

private：

char* m_data；

}；

 

【18】Linux和OS

netstat ：显示网络状态

tcpdump：主要是截获通过本机网络接口的数据，用以分析。能够截获当前所有通过本机网卡的数据包。它拥有灵活的过滤机制，可以确保得到想要的数据。

ipcs：检查系统上共享内存的分配

ipcrm：手动解除系统上共享内存的分配

cpu内存硬盘等等与系统性能调试相关的命令必须熟练掌握，设置修改权限tcp网络状态查看各进程状态抓包相关等相关命令必须熟练掌握awksed需掌握。

【19】共享内存的使用实现原理（必考必问，然后共享内存段被映射进进程空间之后，存在于进程空间的什么位置？共享内存段最大限制是多少？）

共享内存定义：共享内存是最快的可用IPC（进程间通信）形式。它允许多个不相关的进程去访问同一部分逻辑内存。共享内存是由IPC为一个进程创建的一个特殊的地址范围，它将出现在进程的地址空间中。其他进程可以把同一段共享内存段“连接到”它们自己的地址空间里去。所有进程都可以访问共享内存中的地址。如果一个进程向这段共享内存写了数据，所做的改动会立刻被有访问同一段共享内存的其他进程看到。因此共享内存对于数据的传输是非常高效的。

共享内存的原理：共享内存是最有用的进程间通信方式之一，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。 c++进程内存空间分布（注意各部分的内存地址谁高谁低，注意栈从高到低分配，堆从低到高分配）。

【20】ELF是什么？其大小与程序中全局变量的是否初始化有什么关系（注意未初始化的数据放在bss段）

可执行文件：包含了代码和数据。具有可执行的程序。

可重定位文件：包含了代码和数据（这些数据是和其他重定位文件和共享的object文件一起连接时使用的）

共享object文件（又可叫做共享库）：包含了代码和数据（这些数据是在连接时候被连接器ld和运行时动态连接器使用的）。

使创建共享库容易，使动态装载和共享库的结合更加容易。在ELF下，在C++中，全局的构造函数和析构函数在共享库和静态库中用同样方法处理。

【21】如何定位内存泄漏？

内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的、大小任意的（内存块的大小可以在程序运行期决定）、使用完后必须显示释放的内存。应用程序一般使用malloc、realloc、new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块。否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。

C++程序缺乏相应的手段来检测内存信息，只能使用top指令观察进程的动态内存总额。而且程序退出时，我们无法获知任何内存泄漏信息

使用Linux命令回收内存，可以使用ps、kill两个命令检测内存使用情况和进行回收。在使用超级用户权限时使用命令“ps”，它会列出所有正在运行的程序名称和对应的进程号（PID）。kill命令的工作原理是向Linux操作系统的内核送出一个系统操作信号和程序的进程号（PID）。

【22】动态链接和静态链接的区别？

动态链接是指在生成可执行文件时不将所有程序用到的函数链接到一个文件，因为有许多函数在操作系统带的dll文件中，当程序运行时直接从操作系统中找。而静态链接就是把所有用到的函数全部链接到exe文件中。动态链接是只建立一个引用的接口，而真正的代码和数据存放在另外的可执行模块中，在运行时再装入；而静态链接是把所有的代码和数据都复制到本模块中，运行时就不再需要库了。

【23】多进程和多线程的区别？

{ 必须从cpu调度，上下文切换，数据共享，多核cup利用率，资源占用，等等各方面回答，然后有一个问题必须会被问到：哪些东西是一个线程私有的？答案中必须包含寄存器，否则悲催。}

 

 

 

 

【24】列出常见的信号，信号怎么处理？

 

 

 

【25】说出你所知道的linux系统的各类同步机制（重点），什么是死锁？如何避免死锁？

死锁的条件。

1、互斥条件（Mutual exclusion）：资源不能被共享，只能由一个进程使用。

2、请求与保持条件（Hold and wait）：已经得到资源的进程可以再次申请新的资源。

3、非剥夺条件（No pre-emption）：已经分配的资源不能从相应的进程中被强制地剥夺。4、循环等待条件（Circular wait）：系统中若干进程组成环路，该环路中每个进程都在等待相邻进程正占用的资源。

处理死锁的策略：

1。忽略该问题。例如鸵鸟算法，该算法可以应用在极少发生死锁的的情况下。为什么叫鸵鸟算法呢，因为传说中鸵鸟看到危险就把头埋在地底下，可能鸵鸟觉得看不到危险也就没危险了吧。跟掩耳盗铃有点像。

2。检测死锁并且恢复。

3。仔细地对资源进行动态分配，以避免死锁。

4。通过破除死锁四个必要条件之一，来防止死锁产生。

【26】exit()与_exit()的区别？

_exit终止调用进程，但不关闭文件，不清除输出缓存，也不调用出口函数。

exit函数将终止调用进程。在退出程序之前，所有文件关闭，缓冲输出内容将刷新定义，并调用所有已刷新的“出口函数”（由atexit定义）。

exit()与_exit()有不少区别在使用fork()，特别是vfork()时变得很突出。

exit()与_exit()的基本区别在于前一个调用实施与调用库里用户状态结构(user-mode constructs)有关的清除工作(clean-up)，而且调用用户自定义的清除程序。

【27】守护进程？

守护进程（Daemon）是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。Linux的大多数服务器就是用守护进程实现的。比如，Internet服务器inetd，Web服务器httpd等。同时，守护进程完成许多系统任务。比如，作业规划进程crond，打印进程lpd等。

守护进程的编程本身并不复杂，复杂的是各种版本的Unix的实现机制不尽相同，造成不同Unix环境下守护进程的编程规则并不一致。需要注意，照搬某些书上的规则（特别是BSD4。3和低版本的SystemV）到Linux会出现错误的。下面将给出Linux下守护进程的编程要点和详细实例。

一．守护进程及其特性

守护进程最重要的特性是后台运行。在这一点上DOS下的常驻内存程序TSR与之相似。其次，守护进程必须与其运行前的环境隔离开来。这些环境包括未关闭的文件描述符，控制终端，会话和进程组，工作目录以及文件创建掩模等。这些环境通常是守护进程从执行它的父进程（特别是shell）中继承下来的。最后，守护进程的启动方式有其特殊之处。它可以在Linux系统启动时从启动脚本/etc/rc。d中启动，可以由作业规划进程crond启动，还可以由用户终端（shell）执行。

总之，除开这些特殊性以外，守护进程与普通进程基本上没有什么区别。因此，编写守护进程实际上是把一个普通进程按照上述的守护进程的特性改造成为守护进程。如果对进程有比较深入的认识就更容易理解和编程了。

二．守护进程的编程要点

前面讲过，不同Unix环境下守护进程的编程规则并不一致。所幸的是守护进程的编程原则其实都一样，区别在于具体的实现细节不同。这个原则就是要满足守护进程的特性。同时，Linux是基于SyetemV的SVR4并遵循Posix标准，实现起来与BSD4相比更方便。编程要点如下：

1。在后台运行。

为避免挂起控制终端将Daemon放入后台执行。方法是在进程中调用fork使父进程终止，让Daemon在子进程中后台执行。if(pid=fork())exit(0)；//是父进程，结束父进程，子进程继续。

2。脱离控制终端，登录会话和进程组。有必要先介绍一下Linux中的进程与控制终端，登录会话和进程组之间的关系：进程属于一个进程组，进程组号（GID）就是进程组长的进程号（PID）。登录会话可以包含多个进程组。这些进程组共享一个控制终端。这个控制终端通常是创建进程的登录终端。控制终端，登录会话和进程组通常是从父进程继承下来的。我们的目的就是要摆脱它们，使之不受它们的影响。方法是在第1点的基础上，调用setsid()使进程成为会话组长：setsid()；

说明：当进程是会话组长时setsid()调用失败。但第一点已经保证进程不是会话组长。setsid()调用成功后，进程成为新的会话组长和新的进程组长，并与原来的登录会话和进程组脱离。由于会话过程对控制终端的独占性，进程同时与控制终端脱离。

3。禁止进程重新打开控制终端

现在，进程已经成为无终端的会话组长。但它可以重新申请打开一个控制终端。可以通过使进程不再成为会话组长来禁止进程重新打开控制终端：

if(pid=fork())exit(0)；//结束第一子进程，第二子进程继续（第二子进程不再是会话组长）

4。关闭打开的文件描述符

进程从创建它的父进程那里继承了打开的文件描述符。如不关闭，将会浪费系统资源，造成进程所在的文件系统无法卸下以及引起无法预料的错误。按如下方法关闭它们：

for(i=0；i关闭打开的文件描述符close(i)；>5。改变当前工作目录

进程活动时，其工作目录所在的文件系统不能卸下。一般需要将工作目录改变到根目录。对于需要转储核心，写运行日志的进程将工作目录改变到特定目录如/tmpchdir("/")6。重设文件创建掩模

进程从创建它的父进程那里继承了文件创建掩模。它可能修改守护进程所创建的文件的存取位。为防止这一点，将文件创建掩模清除：umask(0)；7。处理SIGCHLD信号

处理SIGCHLD信号并不是必须的。但对于某些进程，特别是服务器进程往往在请求到来时生成子进程处理请求。如果父进程不等待子进程结束，子进程将成为僵尸进程（zombie）从而占用系统资源。如果父进程等待子进程结束，将增加父进程的负担，影响服务器进程的并发性能。在Linux下可以简单地将SIGCHLD信号的操作设为SIG_IGN。signal(SIGCHLD，SIG_IGN)；

这样，内核在子进程结束时不会产生僵尸进程。这一点与BSD4不同，BSD4下必须显式等待子进程结束才能释放僵尸进程。

三．守护进程实例

守护进程实例包括两部分：主程序test。c和初始化程序init。c。主程序每隔一分钟向/tmp目录中的日志test。log报告运行状态。初始化程序中的init_daemon函数负责生成守护进程。读者可以利用init_daemon函数生成自己的守护进程。

【28】Linux的内存管理机制？

Linux虚拟内存的实现需要6种机制的支持：地址映射机制、内存分配回收机制、缓存和刷新机制、请求页机制、交换机制和内存共享机制。

内存管理程序通过映射机制把用户程序的逻辑地址映射到物理地址。当用户程序运行时，如果发现程序中要用的虚地址没有对应的物理内存，就发出了请求页要求。如果有空闲的内存可供分配，就请求分配内存(于是用到了内存的分配和回收)，并把正在使用的物理页记录在缓存中(使用了缓存机制)。如果没有足够的内存可供分配，那么就调用交换机制；腾出一部分内存。另外，在地址映射中要通过TLB(翻译后援存储器)来寻找物理页；交换机制中也要用到交换缓存，并且把物理页内容交换到交换文件中，也要修改页表来映射文件地址。

【29】Linux的任务调度机制？

 

 

【30】标准库函数和系统调用的区别？

1、系统调用和库函数的关系

系统调用通过软中断int0x80从用户态进入内核态。函数库中的某些函数调用了系统调用。函数库中的函数可以没有调用系统调用，也可以调用多个系统调用。编程人员可以通过函数库调用系统调用。

高级编程也可以直接采用int0x80进入系统调用，而不必通过函数库作为中介。如果是在核心编程，也可以通过int0x80进入系统调用，此时不能使用函数库。因为函数库中的函数是内核访问不到的。

 

2、从用户调用库函数到系统调用执行的流程。

1)假设用户调用ssize_twrite(intfields,contvoid*buff,size_tnbytes);库函数。

2)库函数会执行int0x80中断。因为中断使得进程从用户态进入内核态，所以参数通过寄存器传送。

3)0x80中断对应的中断例程被称为systemcallhandler。其工作是：

i.存储大多数寄存器到内核堆栈中。这是汇编代码写的。

ii.执行真正的系统调用函数――systemcallserviceroutine。这是C代码。

iii.通过ret_from_sys_call()返回，回到用户态的库函数。这是汇编代码。

 

1、系统调用

系统调用提供的函数如open,close,read,write,ioctl等，需包含头文件unistd.h。以write为例：其函数原型为size_twrite(intfd,constvoid*buf,size_tnbytes)，其操作对象为文件描述符或文件句柄fd(filedescriptor)，要想写一个文件，必须先以可写权限用open系统调用打开一个文件，获得所打开文件的fd，例如fd=open(/"/dev/video/",O_RDWR)。fd是一个整型值，每新打开一个文件，所获得的fd为当前最大fd加1。Linux系统默认分配了3个文件描述符值：0－standardinput，1－standardoutput，2－standarderror。系统调用通常用于底层文件访问（low-levelfileaccess），例如在驱动程序中对设备文件的直接访问。

系统调用是操作系统相关的，因此一般没有跨操作系统的可移植性。

系统调用发生在内核空间，因此如果在用户空间的一般应用程序中使用系统调用来进行文件操作，会有用户空间到内核空间切换的开销。事实上，即使在用户空间使用库函数来对文件进行操作，因为文件总是存在于存储介质上，因此不管是读写操作，都是对硬件（存储器）的操作，都必然会引起系统调用。也就是说，库函数对文件的操作实际上是通过系统调用来实现的。例如C库函数fwrite()就是通过write()系统调用来实现的。

这样的话，使用库函数也有系统调用的开销，为什么不直接使用系统调用呢？这是因为，读写文件通常是大量的数据（这种大量是相对于底层驱动的系统调用所实现的数据操作单位而言），这时，使用库函数就可以大大减少系统调用的次数。这一结果又缘于缓冲区技术。在用户空间和内核空间，对文件操作都使用了缓冲区，例如用fwrite写文件，都是先将内容写到用户空间缓冲区，当用户空间缓冲区满或者写操作结束时，才将用户缓冲区的内容写到内核缓冲区，同样的道理，当内核缓冲区满或写结束时才将内核缓冲区内容写到文件对应的硬件媒介。

2、库函数调用

标准C库函数提供的文件操作函数如fopen,fread,fwrite,fclose,fflush,fseek等，需包含头文件stdio.h。以fwrite为例，其函数原型为

size_tfwrite(constvoid*buffer,size_tsize,size_titem_num,FILE*pf)，其操作对象为文件指针FILE*pf，要想写一个文件，必须先以可写权限用fopen函数打开一个文件，获得所打开文件的FILE结构指针pf，例如pf=fopen(/"~/proj/filename/",/"w/")。实际上，由于库函数对文件的操作最终是通过系统调用实现的，因此，每打开一个文件所获得的FILE结构指针都有一个内核空间的文件描述符fd与之对应。同样有相应的预定义的FILE指针：stdin－standardinput，stdout－standardoutput，stderr－standarderror。库函数调用通常用于应用程序中对一般文件的访问。库函数调用是系统无关的，因此可移植性好。由于库函数调用是基于C库的，因此也就不可能用于内核空间的驱动程序中对设备的操作

 

【31】关于C语言：

宏定义和展开（必须精通） 位操作（必须精通） 指针操作和计算（必须精通） 内存分配（必须精通） sizeof必考各类库函数必须非常熟练的实现哪些库函数属于高危函数，为什么？（strcpy等等）。

【32】虚函数的作用和实现原理（必问必考，实现原理必须很熟）。

有虚函数的类内部有一个称为“虚表”的指针（有多少个虚函数就有多少个指针），这个就是用来指向这个类虚函数。也就是用它来确定调用该那个函数。实际上在编译的时候，编译器会自动加入“虚表”。虚表的使用方法是这样的：如果派生类在自己的定义中没有修改基类的虚函数，就指向基类的虚函数；如果派生类改写了基类的虚函数（就是自己重新定义），这时虚表则将原来指向基类的虚函数的地址替换为指向自身虚函数的指针。那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异而采用不同的策略。

每个类都有自己的vtbl，vtbl的作用就是保存自己类中虚函数的地址，我们可以把vtbl形象地看成一个数组，这个数组的每个元素存放的就是虚函数的地址，虚函数的效率低，其原因就是，在调用虚函数之前，还调用了获得虚函数地址的代码。

 

【33】sizeof求类大小。

注意：成员变量，函数，虚函数，继承等等对大小的影响。

【34】指针和引用的区别？

相同点：

1。都是地址的概念；

2。指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。

区别：

1。指针是一个实体，而引用仅是个别名；

2。引用使用时无需解引用(*)，指针需要解引用；

3。引用只能在定义时被初始化一次，之后不可变；指针可变；

4。引用没有const，指针有const；

5。引用不能为空，指针可以为空；

6。“sizeof引用”得到的是所指向的变量(对象)的大小，而“sizeof指针”得到的是指针本身(所指向的变量或对象的地址)的大小；

7。指针和引用的自增(++)运算意义不一样；

8。从内存分配上看：程序为指针变量分配内存区域，而引用不需要分配内存区域。

 

【35】extern C的作用？

必须将编译器的函数名修饰的机制解答的很透彻。

 

 

 

 

【36】volatile的作用？

必须将cpu的寄存器缓存机制回答的很透彻

volatile的本意是“易变的”。

因为访问寄存器要比访问内存单元快的多，所以编译器一般都会作减少存取内存的优化，但有可能会读脏数据。当要求使用volatile声明变量值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。精确地说就是，遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问；如果不使用volatile，则编译器将对所声明的语句进行优化。（简洁的说就是：volatile关键词影响编译器编译的结果，用volatile声明的变量表示该变量随时可能发生变化，与该变量有关的运算，不要进行编译优化，以免出错）。

volatile的本质：

1> 编译器的优化。

在本次线程内， 当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后，再取变量值时，就直接从寄存器中取值；当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致。 当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致。 当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致。

2>volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人

 

【37】select服务器端的实现，select与epoll的区别？

select的本质是采用32个整数的32位，即32*32= 1024来标识，fd值为1-1024。当fd的值超过1024限制时，就必须修改FD_SETSIZE的大小。这个时候就可以标识32*max值范围的fd。

对于单进程多线程，每个线程处理多个fd的情况，select是不适合的。

1。所有的线程均是从1-32*max进行扫描，每个线程处理的均是一段fd值，这样做有点浪费。

2。1024上限问题，一个处理多个用户的进程，fd值远远大于1024。

 

所以这个时候应该采用poll， poll传递的是数组头指针和该数组的长度，只要数组的长度不是很长，性能还是很不错的，因为poll一次在内核中申请4K（一个页的大小来存放fd），尽量控制在4K以内。

 

epoll还是poll的一种优化，返回后不需要对所有的fd进行遍历，在内核中维持了fd的列表。select和poll是将这个内核列表维持在用户态，然后传递到内核中。但是只有在2。6的内核才支持。

epoll更适合于处理大量的fd ，且活跃fd不是很多的情况，毕竟fd较多还是一个串行的操作。

epoll哪些触发模式，有啥区别？（必须非常详尽的解释水平触发和边缘触发的区别，以及边缘触发在编程中要做哪些更多的确认）

epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。

epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。

另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

 

【38】大规模连接上来说，并发模型怎么设计？

 

 

 

 

 

【39】什么是滑动窗口？

滑动窗口(Sliding window )是一种流量控制技术。滑动窗口协议是用来改善吞吐量的一种技术，即容许发送方在接收任何应答之前传送附加的包。接收方告诉发送方在某一时刻能送多少包（称窗口尺寸）。TCP中采用滑动窗口来进行传输控制，滑动窗口的大小意味着接收方还有多大的缓冲区可以用于接收数据。发送方可以通过滑动窗口的大小来确定应该发送多少字节的数据。当滑动窗口为0时，发送方一般不能再发送数据报，但有两种情况除外，一种情况是可以发送紧急数据，例如，允许用户终止在远端机上的运行进程。另一种情况是发送方可以发送一个1字节的数据报来通知接收方重新声明它希望接收的下一字节及发送方的滑动窗口大小。滑动窗口协议的基本原理就是在任意时刻，发送方都维持了一个连续的允许发送的帧的序号，称为发送窗口；同时，接收方也维持了一个连续的允许接收的帧的序号，称为接收窗口。发送窗口和接收窗口的序号的上下界不一定要一样，甚至大小也可以不同。不同的滑动窗口协议窗口大小一般不同。发送方窗口内的序列号代表了那些已经被发送，但是还没有被确认的帧，或者是那些可以被发送的帧。

 

【40】connect会阻塞，怎么解决？

最通常的方法是加定时器，也可以采用非阻塞模式。

设置非阻塞，返回之后用select检测状态) 如果select返回可读，结果只读到0字节，什么情况？

某个套接字集合中没有准备好，可能会select内存用FD_CLR清该位为0；

keepalive 是什么东东？如何使用？

设置Keepalive参数，检测已中断的客户连接

 

【41】TCP的connect函数与UDP的connect函数区别？

1）UDP中可以使用connect系统调用。

2）UDP中connect操作与TCP中connect操作有着本质区别。TCP中调用connect会引起三次握手，client与server建立连接。UDP中调用connect内核仅仅把对端ip&port记录下来。

3）UDP中可以多次调用connect，TCP只能调用一次connect。UDP多次调用connect有两种用途：1，指定一个新的ip&port连接。2，断开之前的ip&port的连接。指定新连接，直接设置connect第二个参数即可。断开连接，需要将connect第二个参数中的sin_family设置成AF_UNSPEC即可。

4）UDP中使用connect可以提高效率。原因如下：普通的UDP发送两个报文内核做了如下：#1：建立连接#2：发送报文#3：断开连接#4：建立连接#5：发送报文#6：断开连接。采用connect方式的UDP发送两个报文内核如下处理：#1：建立连接#2：发送报文#3：发送报文另外一点，每次发送报文内核都可能要做路由查询。5：采用connect的UDP发送接受报文可以调用send，write和recv，read操作。当然也可以调用sendto，recvfrom。调用sendto的时候第五个参数必须是NULL，第六个参数是0。调用recvfrom，recv，read系统调用只能获取到先前connect的ip&port发送的报文。

5）UDP中使用connect的好处：1：会提升效率。前面已经描述了。2：高并发服务中会增加系统稳定性。原因：假设clientA通过非connect的UDP与serverB，C通信。B，C提供相同服务。为了负载均衡，我们让A与B，C交替通信。A与B通信IPa：PORTa<---->IPb：PORTbA与C通信IPa：PORTa'<---->IPc：PORTc假设PORTa与PORTa'相同了(在大并发情况下会发生这种情况)，那么就有可能出现A等待B的报文，却收到了C的报文。导致收报错误。解决方法内就是采用connect的UDP通信方式。在A中创建两个udp，然后分别connect到B，C。