面试服务器开发方向 C++ 实习生时，大致会被问到哪些问题？

面试服务器开发方向 C++ 实习生时，大致会被问到哪些问题？

from:

http://www.zhihu.com/question/27840814/answer/38305844http://www.zhihu.com/question/27840814/answer/38305844

问题：

@研究毛，安全后台开发
个人从事安全后台开发，当然是linux环境下的了。举几个常见的问题。
1. 数据结构基础。比如实现一个最简单的哈希表。
2. 操作系统基础。linux进程模型，堆/栈的区别，大概的位置，各往哪个方向生长，各类变量存储在哪些区域；更深一点可能会问动态库与静态库的区别，因为这个在生产环境中常见，动态库映射在进程模型的哪里。其他常见如僵尸进程、线程共享等问题。
3. tcp/ip基础。比如常问三次握手，四次挥手，为什么要四次；time_wait状态相关问题；mtu分片问题。现在一般不会问tcp/ip头大小这么蛋疼的问题了，但可能会问tcp头部几个状态字段，比如syn/psh/fin/rst/urg/ack....在什么情形下会置1，这个就问得比较深了。深入的还有滑动窗口与拥塞控制的大致原理。
4. socket编程。阻塞/非阻塞的区别；事件循环select/poll/epoll；常见的网络库read/write会怎样实现（可以参考muduo）。有面试官会问客户端是否需要bind；tcp/udp 协议编程时的细微区别...
5.工具相关。vim/makefile/gdb/g++ ...
6. c++相关。免不了问虚函数；常见stl实现和操作；extern c 干嘛的。
7. 脚本相关。shell/perl/python 至少会一门吧，运维/部署都需要。
上述列举的都是比较常见，比较简单的问题。不过能把这些答好已经不容易了。

答案：

1、linux进程模型

在现代操作系统中，进程支持多线程。进程是资源管理的最小单元；而线程是程序执行的最小单元。一个进程的组成实体可以分为两大部分：线程集合和资源 集合。进程中的线程是动态的对象；代表了进程指令的执行。资源，包括地址空间、打开的文件、用户信息等等，由进程内的线程共享。线程有自己的私有数据：程 序计数器，栈空间以及寄存器。

现实中有很多需要并发处理的任务，如数据库的服务器端、网络服务器、大容量计算等。一个任务是一个进程，传统的UNIX进程是单线程（执行流）的， 单线程意味着程序必须是顺序执行，单个任务不能并发；既在一个时刻只能运行在一个处理器上，因此不能充分利用多处理器框架的计算机。如果采用多进程的方 法，即把一个任务用多个进程解决，则有如下问题：

a. fork一个子进程的消耗是很大的，fork是一个昂贵的系统调用，即使使用现代的写时复制(copy-on-write)技术。
b. 各个进程拥有自己独立的地址空间，进程间的协作需要复杂的IPC技术，如消息传递和共享内存等。
一个进程在CPU上运行可以有两种运行模式（进程状态）：用户模式和内核模式。如果当前运行的是用户程序（用户代码），那么对应进程就处于用户模式（用户态），如果出现系统调用或者发生中断，那么对应进程就处于内核模式（核心态）。Linux进程通过一个task_struct结构体描述，在linux/sched.h中定义，通过理解该结构，可更清楚的理解linux进程模型。 （http://blog.csdn.net/dlutbrucezhang/article/details/8696296）

2、堆/栈的区别

一个由C/C++编译的程序占用的内存分为以下几个部分  
  1、栈区（stack）—   由编译器自动分配释放   ，存放函数的参数值，局部变量的值等。其  
  操作方式类似于数据结构中的栈。  
  2、堆区（heap）   —   一般由程序员分配释放，   若程序员不释放，程序结束时可能由OS回  
  收   。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。  
  3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的  
  全局变量和静态变量在一块区域，   未初始化的全局变量和未初始化的静态变量在相邻的另  
  一块区域。   -   程序结束后由系统释放。  
  4、文字常量区   —常量字符串就是放在这里的。   程序结束后由系统释放  
  5、程序代码区—存放函数体的二进制代码。  

******************二者区别**********************

 申请方式    

 栈:  由系统自动分配。例如，声明在函数中一个局部变量   int   b;   系统自动在栈中为b开辟空间。
  堆:  需要程序员自己申请，并指明大小，在c中malloc函数， 如p1   =   (char   *)malloc(10); 在C++中用new运算符，如p2   =   new   char[10];    
  但是注意p1、p2本身是在栈中的。   

  申请后系统的响应    

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

  申请大小的限制    

  栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。    
  堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。    

申请效率的比较：    

  栈：由系统自动分配，速度较快。但程序员是无法控制的。    
  堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一块内存，虽然用起来最不方便。但是速度快，也最灵活。  

堆和栈中的存储内容    

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

存取效率的比较    

char   s1[]   =   "aaaaaaaaaaaaaaa";    

char   *s2   =   "bbbbbbbbbbbbbbbbb";    
  aaaaaaaaaaa是在运行时刻赋值的；    
  而bbbbbbbbbbb是在编译时就确定的；    
  但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。    
  比如：    
  #include    
  void   main()    
  {    
  char   a   =   1;    
  char   c[]   =   "1234567890";    
  char   *p   ="1234567890";    
  a   =   c[1];    
  a   =   p[1];    
  return;    
  }    
  对应的汇编代码    
  10:   a   =   c[1];    
  00401067   8A   4D   F1   mov   cl,byte   ptr   [ebp-0Fh]    
  0040106A   88   4D   FC   mov   byte   ptr   [ebp-4],cl    
  11:   a   =   p[1];    
  0040106D   8B   55   EC   mov   edx,dword   ptr   [ebp-14h]    
  00401070   8A   42   01   mov   al,byte   ptr   [edx+1]    
  00401073   88   45   FC   mov   byte   ptr   [ebp-4],al    
  第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到  
  edx中，再根据edx读取字符，显然慢了。    

   小结：    

  堆和栈的区别可以用如下的比喻来看出：    
  使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。    
  使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。   (经典！)  

3、动态库与静态库的区别

http://blog.csdn.net/felixit0120/article/details/7652907

http://www.cnblogs.com/skynet/p/3372855.html

linux下有两种库:动态库和静态库(共享库)

二者的不同点在于代码被载入的时刻不同。

静态库的代码在编译过程中已经被载入可执行程序,因此体积比较大。

动态库(共享库)的代码在可执行程序运行时才载入内存，在编译过程中仅简单的引用，因此代码体积比较小。

不同的应用程序如果调用相同的库,那么在内存中只需要有一份该动态库(共享库)的实例。

静态库和动态库的最大区别,静态情况下,把库直接加载到程序中,而动态库链接的时候,它只是保留接口,将动态库与程序代码独立,这样就可以提高代码的可复用度，和降低程序的耦合度。

静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。

4、僵尸进程和孤儿进程

http://www.cnblogs.com/anker/p/3271773.html

http://coolshell.cn/articles/656.html

http://www.mike.org.cn/articles/treatment-of-zombie-processes-under-linux/

概念：

我们知道在unix/linux中，正常情况下，子进程是通过父进程创建的，子进程在创建新的进程。子进程的结束和父进程的运行是一个异步过程,即父进程永远无法预测子进程 到底什么时候结束。 当一个 进程完成它的工作终止之后，它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态。

　　孤儿进程：一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init进程(进程号为1)所收养，并由init进程对它们完成状态收集工作。

　　僵尸进程：一个进程使用fork创建子进程，如果子进程退出，而父进程并没有调用wait或waitpid获取子进程的状态信息，那么子进程的进程描述符仍然保存在系统中。这种进程称之为僵死进程。

问题及危害

　　unix提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就可以得到。这种机制就是: 在每个进程退出的时候,内核释放该进程所有的资源,包括打开的文件,占用的内存等。 但是仍然为其保留一定的信息(包括进程号the process ID,退出状态the termination status of the process,运行时间the amount of CPU time taken by the process等)。直到父进程通过wait / waitpid来取时才释放。 但这样就导致了问题，如果进程不调用wait / waitpid的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程. 此即为僵尸进程的危害，应当避免。

　　孤儿进程是没有父进程的进程，孤儿进程这个重任就落到了init进程身上，init进程就好像是一个民政局，专门负责处理孤儿进程的善后工作。每当出现一个孤儿进程的时候，内核就把孤 儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉地结束了其生命周期的时候，init进程就会代表党和政府出面处理它的一切善后工作。因此孤儿进程并不会有什么危害。

僵尸进程清除的方法

　　1.改写父进程，在子进程死后要为它收尸。具体做法是接管SIGCHLD信号。子进程死后，会发送SIGCHLD信号给父进程，父进程收到此信号后，执行waitpid()函数为子进程收尸。这是基于这样的原理：就算父进程没有调用wait，内核也会向它发送SIGCHLD消息，尽管对的默认处理是忽略，如果想响应这个消息，可以设置一个处理函数。

　　SIGCHLD信号：子进程结束时, 父进程会收到这个信号。如果父进程没有处理这个信号，也没有等待(wait)子进程，子进程虽然终止，但是还会在内核进程表中占有表项，这时的子进程称为僵尸进程。这种情况我们应该避免(父进程或者忽略SIGCHILD信号，或者捕捉它，或者wait它派生的子进程，或者父进程先终止，这时子进程的终止自动由init进程来接管)。

　　2. kill -18 PPID　(PPID是其父进程)

　　这个信号是告诉父进程，该子进程已经死亡了，请收回分配给他的资源。

　　SIGCONT也是一个有意思的信号。如前所述，当进程停止的时候，这个信号用来告诉进程恢复运行。该信号的有趣的地方在于：它不能被忽略或阻塞，但可以被捕获。缺省行为是丢弃该信号。

　　３.终止父进程

　　如果方法2不能终止，可采用终止其父进程的方法(如果其父进程不需要的话)父进程死后，僵尸进程成为”孤儿进程”，过继给1号进程init，init始终会负责清理僵尸进程．它产生的所有僵尸进程也跟着消失。

　　先看其父进程又无其他子进程，如果有，可能需要先kill其他子进程，也就是兄弟进程。方法是：

　　kill –15 PID1 PID2　(PID1,PID2是僵尸进程的父进程的其它子进程)。

　　然后再kill父进程：kill –15 PPID

　　这样僵尸进程就可能被完全杀掉了。

5、线程共享资源

http://blog.sina.com.cn/s/blog_5dc7bbf80100wren.html

在一个进程的线程共享堆区，而进程中的线程各自维护自己的堆栈。

线程共享的环境包括：进程代码段、进程的公有数据(利用这些共享的数据，线程很容易实现相互之间的通讯)、进程打开的文件描述符、信号的处理器、进程的当前目录和进程用户ID和进程组ID。

6、tcp/ip三次握手，四次挥手

http://blog.csdn.net/xifeijian/article/details/12777187

http://blog.chinaunix.net/uid-22312037-id-3575121.html

为什么需要“三次握手”

     在谢希仁著《计算机网络》第四版中讲“三次握手”的目的是“ 为了防止已失效的连接请求报文段突然又传送到了服务端，因而产生错误 ”。在另一部经典的《计算机网络》一书中讲“三次握手”的目的是为了解决“网络中存在延迟的重复分组”的问题。这两种不用的表述其实阐明的是同一个问题。

    谢希仁版《计算机网络》中的例子是这样的，“已失效的连接请求报文段”的产生在这样一种情况下：client发出的第一个连接请求报文段并没有丢失，而是在某个网络结点长时间的滞留了，以致延误到连接释放以后的某个时间才到达server。 本来这是一个早已失效的报文段。但server收到此失效的连接请求报文段后，就误认为是client再次发出的一个新的连接请求。于是就向client发出确认报文段，同意建立连接。假设不采用“三次握手”，那么只要server发出确认，新的连接就建立了。由于现在client并没有发出建立连接的请求，因此不会理睬server的确认，也不会向server发送数据。但server却以为新的运输连接已经建立，并一直等待client发来数据。这样，server的很多资源就白白浪费掉了。 采用“三次握手”的办法可以防止上述现象发生。例如刚才那种情况，client不会向server的确认发出确认。server由于收不到确认，就知道client并没有要求建立连接。”。 主要目的防止server端一直等待，浪费资源。

3次握手过程状态： 

           LISTEN: 这个也是非常容易理解的一个状态，表示服务器端的某个SOCKET处于监听状态，可以接受连接了。 
          SYN_SENT: 当客户端SOCKET执行CONNECT连接时，它首先发送SYN报文，因此也随即它会进入到了SYN_SENT状态，并等待服务端的发送三次握手中的第2个报文。SYN_SENT状态表示客户端已发送SYN报文。（发送端）

SYN_RCVD: 这个状态与SYN_SENT遥想呼应这个状态表示接受到了SYN报文，在正常情况下，这个状态是服务器端的SOCKET在建立TCP连接时的三次握手会话过程中的一个中间状态，很短暂，基本上用netstat你是很难看到这种状态的，除非你特意写了一个客户端测试程序，故意将三次TCP握手过程中最后一个 ACK报文不予发送。因此这种状态时，当收到客户端的ACK报文后，它会进入到ESTABLISHED状态。（服务器端）

ESTABLISHED：这个容易理解了，表示连接已经建立了。

4次挥手过程状态：（可参考下图）

由于TCP连接时全双工的，因此，每个方向都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
        （1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。
        （2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。
        （3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。
        （4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。
        上面是一方主动关闭，另一方被动关闭的情况，实际中还会出现同时发起主动关闭的情况，具体流程如下图：

图4 同时挥手

      

为什么建立连接是三次握手，而关闭连接却是四次挥手呢？

    这是因为服务端在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。而关闭连接时，当收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，己方也未必全部数据都发送给对方了，所以己方可以立即close，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送。

              FIN_WAIT_1 : 这个状态要好好解释一下，其实FIN_WAIT_1和FIN_WAIT_2状态的真正含义都是表示等待对方的FIN报文。而这两种状态的区别是： FIN_WAIT_1状态实际上是当SOCKET在ESTABLISHED状态时，它想主动关闭连接，向对方发送了FIN报文，此时该SOCKET即进入到FIN_WAIT_1状态。而当对方回应ACK报文后，则进入到FIN_WAIT_2状态 ，当然在实际的正常情况下，无论对方何种情况下，都应该马上回应ACK报文，所以FIN_WAIT_1状态一般是比较难见到的，而FIN_WAIT_2状态还有时常常可以用netstat看到。（主动方）
            FIN_WAIT_2 ：上面已经详细解释了这种状态，实际上FIN_WAIT_2状态下的SOCKET，表示 半连接 ，也即有一方要求close连接，但另外还告诉对方，我暂时还有点数据需要传送给你(ACK信息)，稍后再关闭连接。（主动方）
          TIME_WAIT :  表示收到了对方的FIN报文，并发送出了ACK报文 ，就等2MSL后即可回到CLOSED可用状态了。如果FIN_WAIT_1状态下， 收到了对方同时带FIN标志和ACK标志的报文时，可以直接进入到TIME_WAIT状态，而无须经过FIN_WAIT_2状态 。（主动方）
          CLOSING（比较少见） : 这种状态比较特殊，实际情况中应该是很少见，属于一种比较罕见的例外状态。正常情况下，当你发送FIN报文后，按理来说是应该先收到（或同时收到）对方的 ACK报文，再收到对方的FIN报文。但是CLOSING状态表示你发送FIN报文后，并没有收到对方的ACK报文，反而却也收到了对方的FIN报文。什么情况下会出现此种情况呢？其实细想一下，也不难得出结论：那就是如果双方几乎在同时close一个SOCKET的话，那么就出现了双方同时发送FIN报文的情况，也即 会出现CLOSING状态，表示双方都正在关闭SOCKET连接 。
          CLOSE_WAIT : 这种状态的含义其实是表示在等待关闭。怎么理解呢？ 当对方close一个SOCKET后发送FIN报文给自己，你系统毫无疑问地会回应一个ACK报文给对方，此时则进入到CLOSE_WAIT状态。接下来呢，实际上你真正需要考虑的事情是察看你是否还有数据发送给对方，如果没有的话，那么你也就可以 close这个SOCKET，发送FIN报文给对方，也即关闭连接。 所以你 在CLOSE_WAIT状态下，需要完成的事情是等待你去关闭连接。 （被动方）
          LAST_ACK: 这个状态还是比较容易好理解的，它是被动关闭一方在发送FIN报文后，最后等待对方的ACK报文。当收到ACK报文后，也即可以进入到CLOSED可用状态了。（被动方）

CLOSED: 表示连接中断。

**************************************socket编程*************************************************

7. 阻塞/非阻塞的区别

http://blog.csdn.net/hguisu/article/details/7453390

“阻塞”与"非阻塞"与"同步"与“异步"不能简单的从字面理解，提供一个从分布式系统角度的回答。

1.同步与异步

同步和异步关注的是消息通信机制 (synchronous communication/ asynchronous communication)

所谓同步，就是在发出一个*调用*时，在没有得到结果之前，该*调用*就不返回。但是一旦调用返回，就得到返回值了。
换句话说，就是由*调用者*主动等待这个*调用*的结果。

而异步则是相反，*调用*在发出之后，这个调用就直接返回了，所以没有返回结果。换句话说，当一个异步过程调用发出后，调用者不会立刻得到结果。而是在*调用*发出后，*被调用者*通过状态、通知来通知调用者，或通过回调函数处理这个调用。

典型的异步编程模型比如Node.js

举个通俗的例子：
你打电话问书店老板有没有《分布式系统》这本书，如果是同步通信机制，书店老板会说，你稍等，”我查一下"，然后开始查啊查，等查好了（可能是5秒，也可能是一天）告诉你结果（返回结果）。
而异步通信机制，书店老板直接告诉你我查一下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。然后查好了，他会主动打电话给你。在这里老板通过“回电”这种方式来回调。

2. 阻塞与非阻塞

阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态.

阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

还是上面的例子，
你打电话问书店老板有没有《分布式系统》这本书，你如果是阻塞式调用，你会一直把自己“挂起”，直到得到这本书有没有的结果，如果是非阻塞式调用，你不管老板有没有告诉你，你自己先一边去玩了， 当然你也要偶尔过几分钟check一下老板有没有返回结果。
在这里阻塞与非阻塞与是否同步异步无关。跟老板通过什么方式回答你结果无关。

这阻塞非阻塞与同步异步IO机制，都是伴随计算机系统发展，用来解决一些出现的问题。阻塞非阻塞、同步异步可以组合，但是没必要组合，应该说是不同的IO机制，没必要纠结怎么区分，如果定要组合心里才爽，可以 这样认为：阻塞非阻塞都是同步，异步就没什么阻塞不阻塞了，都异步了还阻塞啥，肯定是非阻塞了。(异步非阻塞听起来多别扭)

unix网络编程中说到：

将IO模型分为五类：阻塞IO，非阻塞IO，IO复用，信号驱动，异步IO
其中阻塞IO就是那种recv, read，一直等，等到有了拷贝了数据才返回；
非阻塞就是不用等，立即返回，设置描述符为非阻塞就行了，但是要进程自己一直检查是否可读；
IO复用其实也是阻塞的，不过可以用来等很多描述符；
信号驱动采用信号机制等待；
异步IO就不用等待了，当他告知你的时候，已经可以返回了，数据都拷贝好了。

8、事件循环select/poll/epoll

https://www.haiyun.me/archives/1056.html

http://blog.csdn.net/shltsh/article/details/39323603

http://blog.csdn.net/tianmohust/article/details/6677985

http://www.cnblogs.com/Anker/p/3265058.html

select，poll，epoll都是IO多路复用的机制。I/O多路复用就通过一种机制，可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己负责进行读写，异步I/O的实现会负责把数据从内核拷贝到用户空间。

9、常见的网络库read/write会怎样实现（可以参考muduo）

http://blog.csdn.net/jnu_simba/article/details/8951098

http://blog.csdn.net/solstice/article/details/6329080

10、客户端是否需要bind

http://blog.chinaunix.net/uid-23193900-id-3199173.html

 有连接的socket客户端通过调用Connect函数在socket数据结构中保存本地和远端信息，无须调用bind()，因为这种情况下只需知道目的机器的IP地址，而客户通过哪个端口与服务器建立连接并不需要关心，socket执行体为你的程序自动选择一个未被占用的端口，并通知你的程序数据什么时候打开端口。（当然也有特殊情况，linux系统中rlogin命令应当调用bind函数绑定一个未用的保留端口号，还有当客户端需要用指定的网络设备接口和端口号进行通信等等）

总之：
1.需要在建连前就知道端口的话，需要 bind 
2.需要通过指定的端口来通讯的话，需要 bind

  首先，服务器和客户端都可以bind，bind并不是服务器的专利。

客户端进程bind端口：  由进程选择一个端口去连服务器，（如果默认情况下，调用bind函数时，内核指定的端口是同一个，那么调用多个调用了bind（）的client程序，会出现端口被占用的错误）注意这里的端口是客户端的端口。如果不分配就表示交给内核去选择一个可用端口。

客户端进程bind IP地址：相当于为发送出去的IP数据报分配了源IP地址，但交给进程分配IP地址的时候（就是这样写明了bind IP地址的时候）这个IP地址必须是主机的一个接口，不能分配一个不存在的IP。如果不分配就表示由内核根据所用的输出接口来选择源IP地址。

  一般情况下客户端是不用调用bind函数的，一切都交给内核搞定，YES！

  服务端进程bind端口：基本是必须要做的事情，比如一个服务器启动时（比如freebsd），它会一个一个的捆绑众所周知的端口来提供服务，同样，如果bind了一个端口就表示我这个服务器会在这个端口提供一些“特殊服务”。

  服务端进程bind IP地址：目的是限制了服务端进程创建的socket只接受那些目的地为此IP地址的客户链接，一般一个服务器程序里都有

servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 只是针对IP4，IP6代码不太一样

这样一句话，意思就是：我不指定客户端的IP，随便连，来者不拒！

总之只要你bind时候没有指定哪一项（置为0），内核会帮你选择。

11、tcp/udp 协议编程时的细微区别

http://shmilyaw-hotmail-com.iteye.com/blog/1556187

12、. c++相关：虚函数；常见stl实现和操作；extern c 用途

http://blog.csdn.net/weiwangchao_/article/details/4681813

1、在cpp文件中调用c文件中实现的函数的时候，需要用extern "C"声明该函数，否则cpp会按名字改编后的函数名去找该函数而找不到。(这是作用）

   c文件中有一函数：
              void Transfer(int a; char b);
   cpp文件中必须用extern "C"声明该函数如下才可以实行调用：
            extern "C" void Transfer(int a; char b);

2、在cpp文件中实现的函数，c文件若要调用，就必须在cpp文件中用extern "C"来声明该函数，否则cpp在编译过程中就会对其进行名字改编，c文件就找不到该函数的原型。(这是作用）

  cpp文件中有一函数：
               void Transfer(int a; char b);
   但必须用extern "C"来声明后，如下：
                extern "C" void Transfer(int a; char b);
   c文件才可以调用void Transfer(int a; char b)函数。 

总结：以上讲的是两个方面，1中讲cpp调用c，2中讲c调用cpp。 

extern "C" 目的：实现C++与C及其它语言的混合编程。大体上，你可以把extern和include   的区别当做是“零售”与“批发”的区别。include是批发，而extern则是零售。

被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

未加extern “C”声明时的编译方式

首先看看C++中对类似C的函数是怎样编译的。

作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。