个人不熟悉的面试题目（c++，数据结构）

个人不熟悉的面试题目（c++，数据结构）

有直接整理他人资源，也有自己整理

参考：

http://blog.csdn.net/sichuanpb/article/details/72897046

1.new、delete、malloc、free关系

都是在堆(heap)上进行动态的内存操作。

new和delete可用于申请动态内存和释放内存，new可以执行构造函数，delete会调用对象的析构函数。

malloc与free是C++/C语言的标准库函数,对于非内部数据类型的对象而言，不能够把和析构函数的任务强加于malloc/free。用malloc/free无法满足动态对象的要求。

库函数是依赖于库的，没有库就没有它，也就是一定程度上独立于语言的。

new/delete不是库函数,而是运算符可以被重载，运算符是语言自身的特性，它有固定的语义。

2.C++有哪些性质（面向对象的三个基本特征）

封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现接口重用！

封装：将客观事物抽象成类，每个类对自身的数据和方法实行。封装是实现信息隐蔽的一种技术，其目的是使类的定义和实现分离。

继承：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

类继承是在编译时刻静态定义的。

多态：是对于不同对象接收相同消息时产生不同的动作。允许将子类类型的指针赋值给父类类型的指针。      

在程序运行时的多态性通过继承和虚函数来体现；

在程序编译时多态性体现在函数和运算符的重载上

3.声明和使用“引用”要注意哪些问题？

1）声明一个引用的时候，切记要对其进行初始化。

2）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。

3）不能建立数组的引用。

4. UML中的五种关系的区别？

1）依赖

依赖关系用虚线加箭头表示,如图所示:

上图表示:Animal类依赖于Water类（动物依赖于水）。

 依赖是类的五种关系中耦合最小的一种关系。因为依赖关系在生成代码的时候，这两个关系类都不会增加属性。

依赖关系的三种表现形式：

①     Water类是全局的，则Animal类可以调用它

②     Water类是Animal类的某个方法中的变量，则Animal类可以调用它

持有Water类的是Animal的一个方法（函数）而不是Animal类

③     Water类是作为Animal类中某个方法的参数或者返回值时。

2）关联

关联是实线加箭头表示。表示类之间的耦合度比依赖要强。

例：水与气候是关联的，表示图如下

生成代码如下：

可见生成的代码中，Water类的属性中增加了Climate类。

关联既有单向关联又有双向关联。

单向关联：Water类和Climate类单向关联（如下图），则Water类称为源类，Climate类称为目标类。

源类了解目标类的所有的属性和方法，但目标类并不了解源类的信息。

关联关系又可以细化为聚合关系和组合关系

聚合关系下：雁群类（GooseGroup）和大雁类（Goose）代码如下：

组合关系下：大雁类（Goose）和翅膀类（Wings）代码如下：

这两种关系的区别在于：

①构造函数不同

     聚合类的构造函数中包含了另一个类作为参数。

雁群类（GooseGroup）的构造函数中要用到大雁（Goose）作为参数传递进来。大雁类（Goose）可以脱离雁群类而独立存在。

     组合类的构造函数中包含了另一个类的实例化。

表明大雁类在实例化之前，一定要先实例化翅膀类（Wings），这两个类紧密的耦合在一起，同生共灭。翅膀类（Wings）是不可以脱离大雁类（Goose）而独立存在

②     信息的封装性不同

在聚合关系中，客户端可以同时了解雁群类和大雁类，因为他们都是独立的

而在组合关系中，客户端只认识大雁类，根本就不知道翅膀类的存在，因为翅膀类被严密的封装在大雁类中。

3）泛化（继承）

泛化就是一个类继承另一个类所有的描述，并且可以根据需要对父类进行拓展，是面向对象的重要特征之一。

泛化使用一根实线加箭头，泛化关系图

 

泛化的用处：①实现了代码的复用

                     ②实现了多态

4）实现

 主要针对接口和抽象类而言，实现接口和抽象类的类必须要实现他们的方法。

实现关系表示为：虚线加箭头，关系图如下：

 

接口只包含方法、委托或事件的签名。方法的实现是在实现接口的类中完成的。

5.有哪几种情况只能用intialization list（初始化列表） 而不能用assignment?

答案：当类中含有const、reference（引用） 成员变量；基类的构造函数都需要初始化表。

http://blog.csdn.net/jenghau/article/details/4752735

总结起来，可以初始化的情况有如下四个地方：
1、在类的定义中进行的，只有const 且 static 且 integral 的变量。
2、在类的构造函数初始化列表中， 包括const对象和Reference对象。
3、在类的定义之外初始化的，包括static变量。因为它是属于类的唯一变量。
4、普通的变量可以在构造函数的内部，通过赋值方式进行。当然这样效率不高

6. 描述内存分配方式以及它们的区别?

1） 从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

7. 比较C++中的4种类型转换方式？

1）reinterpret_cast 

reinterpret_cast (expression)  
该函数将一个类型的指针转换为另一个类型的指针. 
这种转换不用修改指针变量值存放格式(不改变指针变量值),只需在编译时重新解释指针的类型就可做到. 
reinterpret_cast 可以将指针值转换为一个整型数,但不能用于非指针类型的转换.

如：int i; char *ptr="hello freind!"; i=reinterpret_cast(ptr);

2）const_cast 
该函数用于去除指针变量的常量属性，将它转换为一个对应指针类型的普通变量。反过来，
也可以将一个非常量的指针变量转换为一个常指针变量。 这种转换是在编译期间做出的类型更改

出于安全性考虑，const_cast无法将非指针的常量转换为普通变量。

class C {};
const C *a = new C;
C *b = const_cast(a);

3）static_cast 
以实现C++中内置基本数据类型之间的相互转换，enum、struct、 int、char、float等。它不能进行无关类型(如非基类和子类)指针之间的转换。

该函数主要用于基本类型之间和具有继承关系的类型之间的转换，不一定包含虚函数。
这种转换一般会更改变量的内部表示方式，因此，static_cast应用于指针类型转换没有太大意义。

4）dynamic_cast 

dynamic_cast < type-id > ( expression )    该运算符把expression转换成type-id类型的对象。

Type-id必须是类的指针、类的引用或者void * ；
如果type-id是类指针类型，那么expression也必须是一个指针，
并且基类中要有虚函数，因为虚函数表中包含运行时类型检查需要运行时类型信息
如果type-id是一个引用，那么expression也必须是一个引用。

'dynamic_cast'只用于对象的指针和引用。与static_cast不同，该函数只能在继承类对象的指针之间或引用之间进行类型转换。进行转换时，会根据当前运行时类型信息，判断类型对象之间的转换是否合法。dynamic_cast的指针转换失败，可通过是否为null检测，引用转换失败则抛出一个bad_cast异常。

主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换

例子：

class Base { virtual dummy() {} };
class Derived : public Base {};

Base* b1 = new Derived;
Base* b2 = new Base;

Derived* d1 = dynamic_cast(b1);          // succeeds
Derived* d2 = dynamic_cast(b2);          // fails: returns 'NULL'

若：

Derived d1 = dynamic_cast(b1);          // succeeds
Derived d2 = dynamic_cast(b2);          // fails: exception thrown

它与static_cast相对，是动态转换。 
这种转换是在运行时进行转换分析的，并非在编译时进行，明显区别于上面三个类型转换操作。 

class A{public:virtual ~A() { }};

class B : public A{public:virtual ~B() {  }};

class C: public A{public: virtual ~C() {  }};

class D: public B, public C{};

注意转换的层次性，不能跨层次转换

      D *pd = new D;
      B *pb = dynamic_cast(pd);
      A *pa = dynamic_cast(pb);

交叉转换
      C *pc = dynamic_cast(pb); 

如果对无继承关系或者没有虚函数的对象指针进行转换、基本类型指针转换以及基类指针转换为派生类指针，都不能通过编译。

8.KMP算法。O(m+n)

http://www.61mon.com/index.php/archives/183/

KMP算法对于朴素匹配算法的改进是引入了一个跳转表next[]。

一个基本事实是，当空格与D不匹配时，你其实知道前面六个字符是"ABCDAB"。KMP算法的想法是，设法利用这个已知信息，不要把"搜索位置"移回已经比较过的位置，继续把它向后移，这样就提高了效率。

  i 0123 4567

字符串ABCD ABD\0

next[i]    -1     0      0      00120

next[i]

为该字符i之前（不包括该字符） 前缀，后缀最长相等长度。（i=0时，next（i）可为-1或0，后面相应加1）

已知空格与D不匹配时，前面六个字符"ABCDAB"是匹配的。查表可知，最后一个匹配字符B对应的"部分匹配值"为2，因此按照下面的公式算出向后移动的位数：

　　移动位数 = 已匹配的字符数 - 对应的部分匹配值

因为 6 - 2 等于4，所以将搜索词向后移动4位。

因为空格与Ｃ不匹配，搜索词还要继续往后移。这时，已匹配的字符数为2（"AB"），对应的"部分匹配值"为0。所以，移动位数 = 2 - 0，结果为 2，于是将搜索词向后移2位。

因为空格与A不匹配，继续后移一位。

逐位比较，直到发现C与D不匹配。于是，移动位数 = 6 - 2，继续将搜索词向后移动4位。

逐位比较，直到搜索词的最后一位，发现完全匹配，于是搜索完成。如果还要继续搜索（即找出全部匹配），移动位数 = 7 - 0，再将搜索词向后移动7位，这里就不再重复了。

KMP 优化

nectval(i):

出现失配的字符为b位，next（b）所指元素与失配元素又相等，则nextval（b）取所指元素的nextval值。

9.多重继承的内存分配问题

1）同时继承多个基类：

class Derive : public Base1, public Base2, public Base3 

图画已经很清晰了，当我们申请一个Derive的对象时，由于该对象存在三个父类于是在它的地址空间中就存放了三张虚表，但是我们会发现对于Drive本身的虚函数就放在第一张虚表内！(上图中有点小错误就是第三张虚表内的函数前缀改为Base3)
分布情况如下：
base1的虚表；
继承自base1的属性值；
base2的虚表；
继承自base2的属性值；
base3的虚表；
继承自base3的属性值；
子类自身的属性值；

2）多重继承

（1）不采用虚继承：（错误）

class B1: public B

class B2: public B

class D:public B1,B2

内存空间分布：
1、B1的虚函数表空间（其中存放了重定义的基类的虚函数、 基类的虚函数、自己内部的虚函数的入口地址 和来自父类的B1虚函数地址）
2、基类的数据成员(B)
3、父类的数据成员(B1)
4、B2的虚函数表空间（自己重定义的虚函数、基类的虚函数、来自父类B2的虚函数地址）
5、基类的数据成员(B)
6、父类的数据成员(B2)
7、自己的数据成员（放在了整个数据空间的末尾 ）

子类继承了拥有同一个基类的父类时，他将保有两个父类继承来的两份基类B的数据副本

（2）采用虚继承

解决在一般继承之中，存在的基类多副本的问题，但是虚继承中的子类多了一张基类的虚函数表

在虚继承的情况下内存空间分布：
1、B1的虚函数表（子类重定义的基类的虚函数、重定义的B1的虚函数、子类自己的虚函数）
2、继承自B1的数据成员
3、B2的虚函数表（子类重定义的基类的数据成员、重定义的B2的虚函数）
4、继承自B2的数据成员
5、子类自己的数据成员（D）
6、基类的虚函数表（子类重定义的虚函数、基类的虚函数）
7、基类的数据成员(B)

10.编写一个标准strcpy函数

　　char * strcpy( char *strDest, const char *strSrc )
　　{
　　assert( (strDest != NULL) &&(strSrc != NULL) ); 
　　char *address = strDest;
　　while( (*strDest++ = * strSrc++) != ‘\0’ );

循环也可写成：

while (*src!='\0') *dst++=*src++;

循环体结束后，strDest字符串的末尾加上'\0'。

　　return address;
　　}

1）第二个参数加const

2）判断两个参数是否为空

3）strDest长度应大于strSrc（数组形式）？？？ 指针形式用检查么？？？

4）为了实现链式操作，将目的地址返回

10.编写一个String类

已知String类定义如下：
class String
{
public:
String(const char *str = NULL); // 通用构造函数
String(const String &another); // 拷贝构造函数
~ String(); // 析构函数
String & operater =(const String &rhs); // 赋值函数
private:
char *m_data; // 用于保存字符串
};

 String::String(const char *str)
 {
 if ( str == NULL ) //strlen在参数为NULL时会抛异常才会有这步判断
 {
 m_data = new char[1] ;
 m_data[0] = '\0' ;
 }
 else
 {
 m_data = new char[strlen(str) + 1];
 strcpy(m_data,str);
 }
 }
 //拷贝构造函数

 String::String(const String &another)
 {
 m_data = new char[strlen(another.m_data) + 1];
 strcpy(m_data,other.m_data);
 }
 //赋值操作符重载

 String& String::operator =(const String &rhs)
 {
 if ( this == &rhs)
     return *this ;
 delete []m_data; //删除原来的数据，新开一块内存
 m_data = new char[strlen(rhs.m_data) + 1];
 strcpy(m_data,rhs.m_data);
 return *this ;
 }

重载 operator=

1)检查自赋值

2）返回为 *this的引用

3)赋值运算符重载函数不能被继承

4）深拷贝（释放原有空间，申请新空间，数据复制）

 //析构函数

 String::~String()
 {
 delete []m_data ;
 }

11.TCP/IP的五层结构图

（1）OSI七层模型
OSI中的层 功能 TCP/IP协议族 
应用层 文件传输，电子邮件，文件服务，虚拟终端 TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet 
表示层 数据格式化，代码转换，数据加密 没有协议 
会话层 解除或建立与别的接点的联系 没有协议 
传输层 提供端对端的接口 TCP，UDP 
网络层 为数据包选择路由 IP，ICMP，RIP，OSPF，BGP，IGMP 
数据链路层 传输有地址的帧以及错误检测功能 SLIP，CSLIP，PPP，ARP，RARP，MTU 
物理层 以二进制数据形式在物理媒体上传输数据 ISO2110，IEEE802，IEEE802.2

（2）TCP/IP五层模型的协议 

应用层 ：相当于OSI模型的会话层、表示层和应用层，它向用户提供一组常用的应用层协议 ,其中包括：Telnet、SMTP、DNS等。此外，在应用层中还包含有用户应用程序，它们均是建立在TCP/IP协议组之上 的专用程序。
传输层 ：该层提供TCP（传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）两个协议，它们 都建立在IP协议的基础上，其中TCP提供可靠的面向连接服务，UDP提供简单的无连接服务。传输层提供端到端，即 应用程序之间的通信，主要功能是数据格式化、数据确认和丢失重传等。
网络层 ：该层包括以下协议：IP（网际协议）、ICMP（Internet Control Message Protocol,因特 网控制报文协议）、ARP（Address Resolution Protocol，地址解析协议）、RARP（Reverse Address Resolution Protocol，反向地址解析协议）。该层负责相同或不同网络中计算机之间的通信,主要处理数据报和路由。在IP层中 ，ARP协议用于将IP地址转换成物理地址,RARP协议用于将物理地址转换成IP地址，ICMP协议用于报告差错和传送控 制信息。IP协议在TCP/IP协议组中处于核心地位。
数据链路层 ：
物理层 ：

12.TCP与UDP  IP协议

http://blog.chinaunix.net/uid-26833883-id-3627644.html

TCP (Transmission Control Protocol)和UDP(User Datagram Protocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输，它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复 用。通过面向连接、端到端和可靠的数据包发送。通俗说，它是事先为所发送的数据开辟出连接好的通道，然后再进行数据发送；而UDP则不为IP提供可靠性、 流控或差错恢复功能。一般来说，TCP对应的是可靠性要求高的应用，而UDP对应的则是可靠性要求低、传输经济的应用。TCP支持的应用协议主要 有：Telnet、FTP、SMTP等；UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系 统）、TFTP（通用文件传输协议）等.

TCP/IP协议与低层的数据链路层和物理层无关，这也是TCP/IP的重要特点

IP是TCP / IP协议族中最为核心的协议。所有的TCP、UDP、ICMP及IGMP数据都以IP数据

报格式传输。它的特点如下:

不可靠：的意思是它不能保证 I P数据报能成功地到达目的地。 I P仅提供最好

的传输服务。如果发生某种错误时，如某个路由器暂时用完了缓冲区， I P有一个简单的错误

处理算法：丢弃该数据报，然后发送 I C M P消息报给信源端。任何要求的可靠性必须由上层来

提供（如T C P） 。

无连接：这个术语的意思是I P并不维护任何关于后续数据报的状态信息。

每个数据报的处理是相互独立的。这也说明， I P数据报可以不按发送顺序接收。如果一信源

向相同的信宿发送两个连续的数据报（先是 A，然后是B） ，每个数据报都是独立地进行路由

选择，可能选择不同的路线，因此B可能在A到达之前先到达。

13.TCP三次握手和四次挥手

三次握手：

a.请求端(通常称为客户)发送一个SYN段指明客户打算连接的服务器的端口，以及初始序号(ISN,在这个例子中为1415531521)。这个SYN段为报文段1。

b.服务器发回包含服务器的初始序号的SYN报文段(报文段2)作为应答。同时，将确认序号设置为客户的ISN加1以对客户的SYN报文段进行确认。一个SYN将占用一个序号

c.客户必须将确认序号设置为服务器的ISN加1以对服务器的SYN报文段进行确认(报文段3)

这三个报文段完成连接的建立。这个过程也称为三次握手(three-way handshake)

四次挥手：

a.现在的网络通信都是基于socket实现的，当客户端将自己的socket进行关闭时，内核协议栈会向服务器自动发送一个FIN置位的包，请求断开连接。我们称首先发起断开请求的一方称为主动断开方。

b.服务器端收到请客端的FIN断开请求后，内核协议栈会立即发送一个ACK包作为应答，表示已经收到客户端的请求

c.服务器运行一段时间后，关闭了自己的socket。这个时候内核协议栈会向客户端发送一个FIN置位的包，请求断开连接

d.客户端收到服务端发来的FIN断开请求后，会发送一个ACK做出应答，表示已经收到服务端的请求

TCP可靠性的保证

TCP采用一种名为“带重传功能的肯定确认（positive acknowledge with retransmission）”的技术作为提供可靠数据传输服务的基础。这项技术要求接收方收到数据之后向源站回送确认信息ACK。发送方对发出的每个分组都保存一份记录，在发送下一个分组之前等待确认信息。发送方还在送出分组的同时启动一个定时器，并在定时器的定时期满而确认信息还没有到达的情况下，重发刚才发出的分组。图3-5表示带重传功能的肯定确认协议传输数据的情况，图3-6表示分组丢失引起超时和重传。为了避免由于网络延迟引起迟到的确认和重复的确认，协议规定在确认信息中稍带一个分组的序号，使接收方能正确将分组与确认关联起来。

从图 3-5可以看出，虽然网络具有同时进行双向通信的能力，但由于在接到前一个分组的确认信息之前必须推迟下一个分组的发送，简单的肯定确认协议浪费了大量宝贵的网络带宽。为此， TCP使用滑动窗口的机制来提高网络吞吐量，同时解决端到端的流量控制。

(4)滑动窗口技术

滑动窗口技术是简单的带重传的肯定确认机制的一个更复杂的变形，它允许发送方在等待一个确认信息之前可以发送多个分组。如图 3-7所示，发送方要发送一个分组序列，滑动窗口协议在分组序列中放置一个固定长度的窗口，然后将窗口内的所有分组都发送出去；当发送方收到对窗口内第一个分组的确认信息时，它可以向后滑动并发送下一个分组；随着确认的不断到达，窗口也在不断的向后滑动。

14.用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题）

#define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL

我在这想看到几件事情：

1). #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等）

2). 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。

3). 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。

4). 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。

15.static 全局变量、局部变量、函数与普通全局变量、局部变量、函数

static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？

答 、全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。

从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。

static函数与普通函数作用域不同，仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件

static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;

static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；

static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

程序的局部变量存在于（堆栈）中，全局变量存在于（静态区 ）中，动态申请数据存在于（ 堆）中。

16.关键字static的作用是什么？

这个简单的问题很少有人能回答完全。在C语言中，关键字static有三个明显的作用：

1). 在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。

2). 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。

3). 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用。

大多数应试者能正确回答第一部分，一部分能正确回答第二部分，同是很少的人能懂得第三部分。这是一个应试者的严重的缺点，因为他显然不懂得本地化数据和代码范围的好处和重要性。

17.关键字const是什么含意？

我只要一听到被面试者说：“const意味着常数”，我就知道我正在和一个业余者打交道。去年Dan Saks已经在他的文章里完全概括了const的所有用法，因此ESP(译者：Embedded Systems Programming)的每一位读者应该非常熟悉const能做什么和不能做什么.如果你从没有读到那篇文章，只要能说出const意味着“只读”就可以了。尽管这个答案不是完全的答案，但我接受它作为一个正确的答案。（如果你想知道更详细的答案，仔细读一下Saks的文章吧。）如果应试者能正确回答这个问题，我将问他一个附加的问题：下面的声明都是什么意思？

const int a;

int const a;

const int *a; a指向常数

int * const a;  a是常指针

int const * a const;

前两个的作用是一样，a是一个常整型数。第三个意味着a是一个指向常整型数的指针（也就是，整型数是不可修改的，但指针可以）。第四个意思a是一个指向整型数的常指针（也就是说，指针指向的整型数是可以修改的，但指针是不可修改的）。最后一个意味着a是一个指向常整型数的常指针（也就是说，指针指向的整型数是不可修改的，同时指针也是不可修改的）。如果应试者能正确回答这些问题，那么他就给我留下了一个好印象。顺带提一句，也许你可能会问，即使不用关键字 const，也还是能很容易写出功能正确的程序，那么我为什么还要如此看重关键字const呢？我也如下的几下理由：

1). 关键字const的作用是为给读你代码的人传达非常有用的信息，实际上，声明一个参数为常量是为了告诉了用户这个参数的应用目的。如果你曾花很多时间清理其它人留下的垃圾，你就会很快学会感谢这点多余的信息。（当然，懂得用const的程序员很少会留下的垃圾让别人来清理的。）

2). 通过给优化器一些附加的信息，使用关键字const也许能产生更紧凑的代码。

3). 合理地使用关键字const可以使编译器很自然地保护那些不希望被改变的参数，防止其被无意的代码修改。简而言之，这样可以减少bug的出现。

const vector::iterator it=v.begin(); 类似于T* const 即迭代器不可变动 （++it；错误）

vector::const_iterator it=v.begin(); 类似于const T* 即迭代器所指不可变动（*it=10；错误）

18.关键字volatile有什么含意 并给出三个不同的例子。

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1). 并行设备的硬件寄存器（如：状态寄存器）

2). 一个中断服务子程序中会访问到的非自动变量(Non-automatic variables)

3). 多线程应用中被几个任务共享的变量

回答不出这个问题的人是不会被雇佣的。我认为这是区分C程序员和嵌入式系统程序员的最基本的问题。嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所用这些都要求volatile变量。不懂得volatile内容将会带来灾难。

假设被面试者正确地回答了这是问题（嗯，怀疑这否会是这样），我将稍微深究一下，看一下这家伙是不是直正懂得volatile完全的重要性。

1). 一个参数既可以是const还可以是volatile吗？解释为什么。

2). 一个指针可以是volatile 吗？解释为什么。

3). 下面的函数有什么错误：

int square(volatile int *ptr)

{

return *ptr * *ptr;

}

下面是答案：

1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2). 是的。尽管这并不很常见。一个例子是当一个中服务子程序修该一个指向一个buffer的指针时。

3). 这段代码的有个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

int square(volatile int *ptr)

{

int a,b;

a = *ptr;

b = *ptr;

return a * b;

}

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代码可能返不是你所期望的平方值！正确的代码如下：

long square(volatile int *ptr)

{

int a;

a = *ptr;

return a * a;

}

reinterpret_cast

 

19.top K问题

http://doc.okbase.net/zyq522376829/archive/169290.html 

        在大规模数据处理中，经常会遇到的一类问题：在海量数据中找出出现频率最好的前k个数，或者从海量数据中找出最大的前k个数，这类问题通常被称为top K问题。例如，在搜索引擎中，统计搜索最热门的10个查询词；在歌曲库中统计下载最高的前10首歌等。

        针对top K类问题，通常比较好的方案是分治+Trie树/hash+小顶堆（就是上面提到的最小堆），即先将数据集按照Hash方法分解成多个小数据集，然后使用Trie树或者Hash统计每个小数据集中的query词频，之后用小顶堆求出每个数据集中出现频率最高的前K个数，最后在所有top K中求出最终的top K。

eg：有1亿个浮点数，如果找出期中最大的10000个？

        最容易想到的方法是将数据全部排序，然后在排序后的集合中进行查找，最快的排序算法的时间复杂度一般为O（nlogn），如快速排序。但是在32位的机器上，每个float类型占4个字节，1亿个浮点数就要占用400MB的存储空间，对于一些可用内存小于400M的计算机而言，很显然是不能一次将全部数据读入内存进行排序的。其实即使内存能够满足要求（我机器内存都是8GB），该方法也并不高效，因为题目的目的是寻找出最大的10000个数即可，而排序却是将所有的元素都排序了，做了很多的无用功。

        第二种方法为局部淘汰法，该方法与排序方法类似，用一个容器保存前10000个数，然后将剩余的所有数字——与容器内的最小数字相比，如果所有后续的元素都比容器内的10000个数还小，那么容器内这个10000个数就是最大10000个数。如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这1亿个数，得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为O（n+m^2），其中m为容器的大小，即10000。

        第三种方法是分治法，将1亿个数据分成100份，每份100万个数据，找到每份数据中最大的10000个，最后在剩下的100*10000个数据里面找出最大的10000个。如果100万数据选择足够理想，那么可以过滤掉1亿数据里面99%的数据。100万个数据里面查找最大的10000个数据的方法如下：用快速排序的方法，将数据分为2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大的那堆个数N大于10000个，继续对大堆快速排序一次分成2堆，如果大堆个数N小于10000个，就在小的那堆里面快速排序一次，找第10000-n大的数字；递归以上过程，就可以找到第1w大的数。参考上面的找出第1w大数字，就可以类似的方法找到前10000大数字了。此种方法需要每次的内存空间为10^6*4=4MB，一共需要101次这样的比较。

        第四种方法是Hash法。如果这1亿个书里面有很多重复的数，先通过Hash法，把这1亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，然后通过分治法或最小堆法查找最大的10000个数。

        第五种方法采用最小堆。首先读入前10000个数来创建大小为10000的最小堆，建堆的时间复杂度为O（mlogm）（m为数组的大小即为10000），然后遍历后续的数字，并于堆顶（最小）数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至1亿个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有10000个数字。该算法的时间复杂度为O（nmlogm），空间复杂度是10000（常数）。

实际运行：

        实际上，最优的解决方案应该是最符合实际设计需求的方案，在时间应用中，可能有足够大的内存，那么直接将数据扔到内存中一次性处理即可，也可能机器有多个核，这样可以采用多线程处理整个数据集。

       下面针对不容的应用场景，分析了适合相应应用场景的解决方案。

（1）单机+单核+足够大内存

        如果需要查找10亿个查询次（每个占8B）中出现频率最高的10个，考虑到每个查询词占8B，则10亿个查询次所需的内存大约是10^9 * 8B=8GB内存。如果有这么大内存，直接在内存中对查询次进行排序，顺序遍历找出10个出现频率最大的即可。这种方法简单快速，使用。然后，也可以先用HashMap求出每个词出现的频率，然后求出频率最大的10个词。

（2）单机+多核+足够大内存

        这时可以直接在内存总使用Hash方法将数据划分成n个partition，每个partition交给一个线程处理，线程的处理逻辑同（1）类似，最后一个线程将结果归并。

        该方法存在一个瓶颈会明显影响效率，即数据倾斜。每个线程的处理速度可能不同，快的线程需要等待慢的线程，最终的处理速度取决于慢的线程。而针对此问题，解决的方法是，将数据划分成c×n个partition（c>1），每个线程处理完当前partition后主动取下一个partition继续处理，知道所有数据处理完毕，最后由一个线程进行归并。

（3）单机+单核+受限内存

        这种情况下，需要将原数据文件切割成一个一个小文件，如次啊用hash(x)%M，将原文件中的数据切割成M小文件，如果小文件仍大于内存大小，继续采用Hash的方法对数据文件进行分割，知道每个小文件小于内存大小，这样每个文件可放到内存中处理。采用（1）的方法依次处理每个小文件。

（4）多机+受限内存

        这种情况，为了合理利用多台机器的资源，可将数据分发到多台机器上，每台机器采用（3）中的策略解决本地的数据。可采用hash+socket方法进行数据分发。

        从实际应用的角度考虑，（1）（2）（3）（4）方案并不可行，因为在大规模数据处理环境下，作业效率并不是首要考虑的问题，算法的扩展性和容错性才是首要考虑的。算法应该具有良好的扩展性，以便数据量进一步加大（随着业务的发展，数据量加大是必然的）时，在不修改算法框架的前提下，可达到近似的线性比；算法应该具有容错性，即当前某个文件处理失败后，能自动将其交给另外一个线程继续处理，而不是从头开始处理。

        top K问题很适合采用MapReduce框架解决，用户只需编写一个Map函数和两个Reduce 函数，然后提交到Hadoop（采用Mapchain和Reducechain）上即可解决该问题。具体而言，就是首先根据数据值或者把数据hash(MD5)后的值按照范围划分到不同的机器上，最好可以让数据划分后一次读入内存，这样不同的机器负责处理不同的数值范围，实际上就是Map。得到结果后，各个机器只需拿出各自出现次数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，这实际上就是Reduce过程。对于Map函数，采用Hash算法，将Hash值相同的数据交给同一个Reduce task；对于第一个Reduce函数，采用HashMap统计出每个词出现的频率，对于第二个Reduce 函数，统计所有Reduce task，输出数据中的top K即可。

        直接将数据均分到不同的机器上进行处理是无法得到正确的结果的。因为一个数据可能被均分到不同的机器上，而另一个则可能完全聚集到一个机器上，同时还可能存在具有相同数目的数据。

以下是一些经常被提及的该类问题。

（1）有10000000个记录，这些查询串的重复度比较高，如果除去重复后，不超过3000000个。一个查询串的重复度越高，说明查询它的用户越多，也就是越热门。请统计最热门的10个查询串，要求使用的内存不能超过1GB。

（2）有10个文件，每个文件1GB，每个文件的每一行存放的都是用户的query，每个文件的query都可能重复。按照query的频度排序。

（3）有一个1GB大小的文件，里面的每一行是一个词，词的大小不超过16个字节，内存限制大小是1MB。返回频数最高的100个词。

（4）提取某日访问网站次数最多的那个IP。

（5）10亿个整数找出重复次数最多的100个整数。

（6）搜索的输入信息是一个字符串，统计300万条输入信息中最热门的前10条，每次输入的一个字符串为不超过255B，内存使用只有1GB。

（7）有1000万个身份证号以及他们对应的数据，身份证号可能重复，找出出现次数最多的身份证号。

重复问题

        在海量数据中查找出重复出现的元素或者去除重复出现的元素也是常考的问题。针对此类问题，一般可以通过位图法实现。例如，已知某个文件内包含一些电话号码，每个号码为8位数字，统计不同号码的个数。

        本题最好的解决方法是通过使用位图法来实现。8位整数可以表示的最大十进制数值为99999999。如果每个数字对应于位图中一个bit位，那么存储8位整数大约需要99MB。因为1B=8bit，所以99Mbit折合成内存为99/8=12.375MB的内存，即可以只用12.375MB的内存表示所有的8位数电话号码的内容。

20.进程和线程的区别

http://blog.csdn.net/luoweifu/article/details/46595285

什么是进程（Process）：普通的解释就是，进程是程序的一次执行，而什么是线程（Thread），线程可以理解为进程中的执行的一段程序片段。在一个多任务环境中下面的概念可以帮助我们理解两者间的差别：

进程间是独立的，这表现在内存空间，上下文环境；线程运行在进程空间内。 一般来讲（不使用特殊技术）进程是无法突破进程边界存取其他进程内的存储空间；而线程由于处于进程空间内，所以同一进程所产生的线程共享同一内存空间。同一进程中的两段代码不能够同时执行，除非引入线程。线程是属于进程的，当进程退出时该进程所产生的线程都会被强制退出并清除。线程占用的资源要少于进程所占用的资源。 进程和线程都可以有优先级。在线程系统中进程也是一个线程。可以将进程理解为一个程序的第一个线程。

 

线程是指进程内的一个执行单元,也是进程内的可调度实体.与进程的区别:
(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间;
(2)进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源
(3)线程是处理器调度的基本单位,但进程不是.
(4)二者均可并发执行.