IT公司笔试面试题系列（转载）
说明：前些日子准备各大IT公司的笔试面试，在网上找了好多资料，有的自己看过，有的没看过，弃之可惜，所以决定在闲暇之余，将这些资料整理到我的blog上，希望能对看到它的人有帮助。还有一件事情是不得不提的，只有公司掌握题库，对面试者本身就是不公平的，而且题目用过之后需要保密，好像没有相关法律约束吧，所以如果我的blog里如果出现了某公司的笔试面试题，纯属巧合！特此声明。
多态类中的虚函数表是Compile-Time，还是Run-Time时建立的?
答案：各个虚拟函数这时被组织成了一个虚拟函数的入口地址的数组.而对象的隐藏成员--虚拟函数表指针是在运行期--也就是构造函数被调用时进行初始化的,这是实现多态的关键.
一个父类写了一个virtual
函数，如果子类覆盖它的函数不加virtual
,也能实现多态?
在子类的空间里，有没有父类的这个函数，或者父类的私有变量? (华为笔试题）
关键字，在派生类实现的时候覆盖该函数时，virtue关键字可加可不加，不影响多态的实现。子类的空间里有父类的所有变量(static除外)。
3.完成字符串拷贝可以使用
sprintf、strcpy
函数，请问这些函数有什么区别，你喜欢使用哪个，为什么？
答案：这些函数的区别在于实现功能以及操作对象不同。
1.strcpy 函数操作的对象是字符串，完成从源字符串到目的字符串的拷贝功能。
2.snprintf
函数操作的对象不限于字符串：虽然目的对象是字符串，但是源对象可以是字符串、也可以是任意基本类型的数据。这个函数主要用来实现（字符串或基本数据类型）向字符串的转换功能。如果源对象是字符串，并且指定
格式符，也可实现字符串拷贝功能。
函数顾名思义就是内存拷贝，实现将一个内存块的内容复制到另一个内存块这一功能。内存块由其首地址以及长度确定。程序中出现的实体对象，不论是什么类型，其最终表现就是在内存中占据一席之地（一个内存区间或块）。因此，memcpy
的操作对象不局限于某一类数据类型，或者说可适用于任意数据类型，只要能给出对象的起始地址和内存长度信息、并且对象具有可操作性即可。鉴于
函数等长拷贝的特点以及数据类型代表的物理意义，memcpy
函数通常限于同种类型数据或对象之间的拷贝，其中当然也包括字符串拷贝以及基本数据类型的拷贝。
对于字符串拷贝来说，用上述三个函数都可以实现，但是其实现的效率和使用的方便程度不同：
无疑是最合适的选择：效率高且调用方便。
2.snprintf
要额外指定格式符并且进行格式转化，麻烦且效率不高。
虽然高效，但是需要额外提供拷贝的内存长度这一参数，易错且使用不便；并且如果长度指定过大的话（最优长度是源字符串长度
+ 1），还会带来性能的下降。其实
strcpy 函数一般是在内部调用
函数或者用汇编直接实现的，以达到高效的目的。因此，使用 memcpy 和 strcpy 拷贝字符串在性能上应该没有什么大的差别。
4.请编写一个 C 函数，该函数给出一个字节中被置 1
的位的个数，并请给出该题的至少一个不同解法。第一种
unsigned&int&TestAsOne0(char&log)&&&
&&&&int&i;&&&
&&&&unsigned&int&num=0,
&&&&for(i=0;&i&8;&i++)&&&
&&&&&&&&&val
=&log&&&&i;&&&&
&&&&&&&&&val&&=&0x01;&&&&
&&&&&&&&&&&&
if(val)&&&
&&&&&&&&&&&&&&&&num++;&&&
&&&&return
unsigned&int&TestAsOne1(char&log)&&
&&&&int&i;&&&
&&&&unsigned&int&num
&&&&for(i=0;&i&8;&i++)&&&
&&&&&&&&&val&=&(~log)
&&&&&&&&&val&&=&0x00;&&&&&&&&&&
&&&&&&&&&if(!val)&&&
&&&&&&&&&&&&&&num++;&&&
&&&&return&&&
}&还有一种方法是X&X-1，微软的《编程之美》里有，这里不再赘述。
5.请编写一个 C
函数，该函数将给定的一个字符串转换成整数。int Invert(char *str)
int num=0;
while(*str!='\0')
int digital=*str-48;
num=num*10+
str=str+1;&
<font COLOR="#.请编写一个 C
函数，该函数将给定的一个整数转换成字符串。void&IntToCharChange(int&num,
char*&pval)&&
&&&&&char&strval[100];&&&
&&&&&int&i,&j;&&&
&&&&&int&val0&=&0;&&&
&&&&&int&val1
&&&&&val0&=&&&&&&&&&&&&
&&&&&for(i=0;&i&100;&i++)&&&
&&&&&&&&&val1&=&val0&%&10;&&
&&&&&&&&&val0&=
val0&/&10;&&
strval[i]&=&val1&+&48;&
//数字—字符&
&&&&&&&&&if(val0&&
&&&&&&&&&&&&
&&&&&&&&&&&&
strval[i]&=&val0&+&48;&&
&&&&&&&&&&&&
&&&&&&&&&}&&&
&&&&&for(j=0;&j&=i;&j++)&&&&
&&&&&&&&&pval[j]&=&strval[i-j];&&&
&&&&&pval[j]&=
7.请编写一个 C
函数，该函数在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的。int&ChildString(char*p)&&&&
Char *q=p;
int&stringlen=0,
i=0,j=1,len=0,maxlen=1;&&
while(*q!=’\0’)&&&&&&&&&
//不能用strlen,求得长度stringlen
Stringlen++;
while( i& Stringlen
if(*(p+i)==*(p+j)&&j&
Stringlen)&&
&&&&&&&&&&&&&&
len++;&&&&&&&&&&&&&&&&&&&
//统计子串长度
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&
&&&&&&&&&}&&
&&&&&&&&&&&&&&
if(len&maxlen)&&&&&&&&&&
//统计最大子串长度
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&
maxlen=len+1;&&
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&}&
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&
1.假设现有一个单向的链表，但是只知道只有一个指向该节点的指针p，并且假设这个节点不是尾节点，试编程实现删除此节点
参考：将下一个节点的内容复制到本节点上，然后删除下一个节点。
2.字符指针、浮点数指针、以及函数指针这三种类型的变量哪个占用的内存最大？为什么？答案：指针变量也占用内存单元，而且所有指针变量占用内存单元的数量都是相同的。就是说，不管是指向何种对象的指针变量，它们占用内存的字节数都是一样的，并且要足够把程序中所能用到的最大地址表示出来（通常是一个机器字长）。
3.类ClassB从ClassA派生，那么ClassA *a = new ClassB(…);
试问该表达是否合法？为什
么？答案：派生类的指针指向基类的对象是错误的，不能通过编译的；基类的指针可以指向派生类的对象，调用派生类的函数。
4.如果ClassA中定义并实现虚函数int
func(void)，ClassB中也实现该函数，那么上述变量
a-&func()将调用哪个类里面的函数？如果int
func(void)不是虚函数，情况又如何？为什么？答案：第一问调用的是B的。第二问调用A的。
虚函数的一个典型应用，虚函数只能借助于指针或者引用来达到多态的效果
如果没有定义成虚函数：------
void print(){ cout&&”This is
class B:public A{
void print(){ cout&&”This is
//为了在以后便于区分，我这段main()代码叫做main1
p1-&print();
p2-&print();
结果是两个This is A
如果定义成虚函数：---------
virtual void print(){ cout&&”This is
//现在成了虚函数了
class B:public A{
void print(){ cout&&”This is
//这里不需要在前面加上关键字virtual，只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数
再运行main输出的结果就是This is A和This is B。
5.char **p,
a[16][8];&
问：p=a是否会导致程序在以后出现问题？为什么？参考:
这个不会导致出现问题，但是要注意p的使用，如a[1][2] 等价的为 *(*(p+1)+2)而不是*(p+11),
会的，这样会出现编译错误& 正确的是：char a[5][5]; char
(*p)[5]; p=a;
6.应用程序在运行时的内存包括代码区和数据区，其中数据区又包括哪些部分？参考：对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。
7.用&&,&&,|,&实现一个WORD(2个字节)的高低位交换
int main()
unsigned&short&a
unsigned&short&b&
unsigned short c,
8)&0xff00;&&
d&=&b&|&c;
printf("\n%x",b);
printf("\n%x",c);
printf("\n%x",d);
return& 0;
结果是& CDAB&
2俩个字节是16位& 前八位为高位&
后八位为低位& 然后结合
8.编写一个函数，函数接收一个字符串,是由十六进制数组成的一组字符串,函数的功能是把接到的这组字符串转换成十进制数字.并将十进制数字返回.
BOOL&HexToDec(&LPCTSTR&shex,
&&&&int&i,
&&&&int&len&=&lstrlen(&shex&);&&&
&&&&if(&len
&&&&&&&&&return&FALSE;&&&
&&&&mid&=&0;&idec&=&0;&&&
&&&&for(&i=0;i&i++&)&&&
&&&&&&&&if(&shex[i]&='0'&&shex[i]&='9'&)&&&
&&&&&&&&&&&&&mid&=
shex[i]-'0';&&&
&&&&&&&&else&if(&shex[i]&='a'&&shex[i]&='f'
&&&&&&&&&&&&&mid&=&shex[i]
&&&&&&&&else&if(&shex[i]&='A'&&shex[i]&='F'&)&&&
&&&&&&&&&&&&&mid&=&shex[i]
&&&&&&&&else&&&
&&&&&&&&&&&&&return
mid&&&=&((len-i-1)&&2);&&
// 移位表示变为2的n次方倍
&&&&&&&&idec
&&&&&return&TRUE;&&&
9.写一算法检测单向链表中是否存在环(whether there is a
loop in a link list), 要求算法复杂度(Algorithm's complexity是O(n))
并只使用常数空间(space is O(c)).
注意，你只知道一个指向单向链表头的指针。链表的长度是不定的，而且环出现的地方也是不定的，环有可能在头，有可能在中间。而且要求是检测,
不能破坏环的结构.（MOTO）
答：用两个指针来遍历这个单向链表，第一个指针p1，每次走一步；第二个指针p2，每次走两步；当p2指针追上p1的时候，就表明链表当中有环路了。
int testLinkRing(Link *head)
& Link *t1=head,*t2=
& while( t1-&next
&& t2-&next)
(NULL == (t2 = t2-&next-&next))
&&&&&&&&&&return
0;&& //无环
(t1 == t2)
&&&&&&&&&&return
&& return 0;
如果要定位环路在链表当中的开始点
发现p2和p1重合，确定了单向链表有环路了。接下来，让p2回到链表的头部，重新走，P1也继续走，每次步长都走1，那么当p1和p2再次相遇的时候，就是环路的入口了。
10.用最有效率的方法算出2乘以8等於几？移位
11.#include
“filename.h”和#include
&filename.h&的区别?对于＃include
&filename.h&编译器从标准库开始搜索filename.h；对于＃include
“filename.h”编译器从用户工作路径开始搜索filename.h。
<font COLOR="#.头文件的作用是什么?一、通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
二、头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。
13.C++函数中值的传递方式有哪几种?C++函数的三种传递方式为：值传递、指针传递和引用传递。
14.内存的分配方式的分配方式有几种?答：一、从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。
二、在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
三、从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
15.C++里面是不是所有的动作都是main()引起的？如果不是，请举例.比如全局变量的初始化，就不是由main函数引起的
class&A{};&&&
&&&&&&&A&a;&&
//a的构造函数限执行&&&
&&&&&&&int&main()
1.三个float:a,b,c。 问值
(a+b)+c==(b+a)+c&&
(a+b)+c==(a+c)+b两者都不行。在比较float或double时，不能简单地比较。由于计算误差，相等的概率很低。应判断两数之差是否落在区间（-e,e)内。这个e应比浮点数的精度大一个数量级。
<font COLOR="#.请讲一讲析构函数和虚函数的用法和作用？析构函数是特殊的类成员函数，它没有返回类型，没有参数，不能随意调用，也没有重载，只有在类对象的生命期结束的时候，由系统自动调用。有适放内存空间的做用。
虚函数是C++多态的一种表现, 使用虚函数，我们可以灵活的进行动态绑定，当然是以一定的开销为代价。
<font COLOR="#.全局变量和局部变量有什么区别？实怎么实现的？操作系统和编译器是怎么知道的？生命周期不同：全局变量随主程序创建和创建，随主程序销毁而销毁。
&&&&&&&&&&&&&
局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在；内存中分配在全局数据区。
使用方式不同：通过声明后全局变量程序的各个部分都可以用到。&&&
&&&&&&&&&&&&&&局部变量只能在局部使用；分配在栈区。
操作系统和编译器通过内存分配的位置来知道的，全局变量分配在全局数据段并且在程序开始运行的时候被加载。局部变量则分配在堆栈里面。
<font COLOR="#.多态。overload 和
override的区别。overload是重载，重载是一种参数多态机制，即代码通过参数的类型或个数不同而实现的多态机制。是一种静态的绑定机制（在编译时已经知道具体执行的是哪个代码段）。&&
&override是覆盖。覆盖是一种动态绑定的多态机制。即在父类和子类中同名元素（如成员函数）有不同的实现代码。执行的是哪个代码是根据运行时实际情况而定的。
重载Overload特点
public bool withdraw(double amt, string name)
public double withdraw(double amt)
1、方法名必须相同2、参数列表必须不相同3、返回值类型可以不相同
注意：override存在于继继承的关系类中。
覆写Override特点(三相同)：
public override bool withdraw(...)
1、方法名相同2、参数列表相同3、返回值类型相同
注意：存在于同一类中，但是只有虚方法和抽象方法才能被覆写.
<font COLOR="#.解释堆和栈的区别。在传统的C中堆和栈实际是一块物理内存，堆主要用来动态分配内存，从堆栈内存的低端向上分配；而栈主要用来传递函数参数、返回值和局部参数内存分配，是从堆栈内存的高端向下分配，俗称压栈和出栈;堆是动态分配,比如用new,malloc分配,需要手工释放,不然会导致memory&leak,栈是静态分配,比如函数调用是需要分配堆栈,但堆栈能自动释放.
<font COLOR="#.论述含参数的宏与函数的优缺点。宏是编译期的，函数是运行期的；宏不是实体，而函数是一个可寻址的实体；宏只是编译期替换，在程序里每遇到S(a,b)，就用a*b代替，a和b两个实体并没有由宏实际产生，而函数S会在栈中定义两个对象a和b。宏没有生存期、作用域之类的概念，而函数就有。
<font COLOR="#.非C++内建型别 A 和
B，在哪几种情况下B能隐式转化为A？
a. class B : public A { ……} // B公有继承自A，可以是间接继承的
b. class B { operator A( ); } // B实现了隐式转化为A的转化
c. class A { A( const B& ); } //
A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数
d. A& operator= ( const A& ); //
赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个
<font COLOR="#.C++中的空类，默认产生哪些类成员函数？
class Empty
Empty();&&&&&&&&&&&&&&&&&&&&&&&&&
// 缺省构造函数
Empty( const Empty&
);&&&&&&&&&&&
// 拷贝构造函数
~Empty();&&&&&&&&&&&&&&&&&&&&&&&&
// 析构函数
Empty& operator=( const Empty& );
// 赋值运算符
operator&();&&&&&&&&&&&&&&
// 取址运算符
const Empty* operator&()
&& // 取址运算符
<font COLOR="#.头文件的作用是什么?答：一、通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
二、头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。
10.内存的分配方式的分配方式有几种?答：一、从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量。
二、在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
三、从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。
1.请你分别画出OSI的七层网络结构图和TCP/IP的五层结构图。7
应用层&&&&&&&&
表示层&&&&&&&&
会话层&&&&&&&&
传输层&&&&&&&&
2 数据链路层
网络层&&&&&&&&
数据链路层&&&&
2.请你详细地解释一下IP协议的定义，在哪个层上面？主要有什么作用？TCP与UDP呢？IP协议(Internet
Protocol)又称互联网协议，是支持网间互连的数据报协议，它与TCP协议（传输控制协议）一起构成了TCP/IP协议族的核心。
<font COLOR="#.请问交换机和路由器各自的实现原理是什么？分别在哪个层次上面实现的？交换机（二层交换）的工作原理和网桥一样，它的各个端口都具有桥接功能，每个端口可以连接一个LAN或一台高性能网站或服务器，交换机按每一个包中的MAC地址相对简单地决策信息转发。//路由器转发IP分组时，只根据IP分组目的IP地址的网络号部分，选择合适的端口，把IP分组送出去。同主机一样，路由器也要判定端口所接的是否是目的子网，如果是，就直接把分组通过端口送到网络上，否则，也要选择下一个路由器来传送分组。
交换机一般用于ＬＡＮ－ＷＡＮ的连接，交换机归于网桥，是数据链路层的设备，有些交换机也可实现第三层的交换。路由器用于ＷＡＮ－ＷＡＮ之间的连接，可以解决异性网络之间转发分组，作用于网络层。
<font COLOR="#.8086是多少位的系统？在数据总线上是怎么实现的？ ＊8086是16微处理器，内部及对外有16位数据通路，只有8位。&&&
8086寻址空间1MB,为64KB。8086有一个初级流水线结构，内部操作与对外操作具有并行性，8085无。
8086是个里程碑。
8086的机器字长是16位，8086使用40个引脚的16个做地址/数据复用引腿来传输数据，一次读写过程由一个基本总线周期完成，它由4个时钟(CLK)周期组成，按时间顺序定义为T1、T2、T3、T4。在T1期间8086发出访问目的地的地址信号和地址锁存选通信号ALE；T2期间发出读写命令信号RD、WR及其它相关信号；T3期间完成数据的访问；T4结束该总线周期。可见，地址与数据信号不会同时出现在一个时钟(CLK)周期，二者可以分时复用同一组引线。
5.局部变量能否和全局变量重名？答：能，局部会屏蔽全局。要用全局变量，需要使用"::"局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。
<font COLOR="#.如何引用一个已经定义过的全局变量？答：extern
可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。
<font COLOR="#.全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？答：可以，在不同的C文件中以static形式来声明同名全局变量。可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错。
<font COLOR="#.用两个栈实现一个队列的功能？要求给出算法和思路！设2个栈为A,B,
一开始均为空.
将新元素push入栈A;
(1)判断栈B是否为空；
(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；
(3)将栈B的栈顶元素pop出。
<font COLOR="#.voip都用了那些协议?VOIP ，即指在 IP 网络上使用 IP
协议以数据包的方式传输语音。存在一些 VOIP 协议栈，如 H.323、SIP、MEGACO 和 MGCP。
<font COLOR="#.TCP/IP通信建立的过程怎样，端口有什么作用？三次握手
A-&B SYN：我的初始序号是X，ACK是0，设置SYN位，未设置ACK位。
B-&A ACK：你的序号是X+1，我的初始序号是Y，设置SYN位和ACK位。
A-&B ACK：你的序号是Y+1，我的序号是X+1，设置ACK位，未设置SYN位；
端口确定是哪个应用程序使用该协议。
<font COLOR="#.1号信令和7号信令有什么区别，我国某前广泛使用的是那一种？1号信令利用TS16传送时，每个TS16负责传送两个话路的线路信令，TS16和话路有着固定的一一对应关系。而7号信令利用TS16来传送时，只是将组成信令单元的若干个8位位组，依次插入TS16，TS16并不知道传送的内容，即信令和话路没有固定关系，只不过利用TS16作为传送信令的载体，时传送信令消息的数据链路，因此，选用哪个时隙做数据链路均可。
--- 这也是随路信令和公共信道信令的一个本质区别。我国目前广泛使用的是7号信令。
<font COLOR="#.编写一个 C
函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。char
* search(char *cpSource, char ch)
char *cpTemp=NULL, *cpDest=NULL;
int iTemp, iCount=0;
while(*cpSource)
if(*cpSource == ch)
&&&&&&&&&&&&
iTemp = 0;
&&&&&&&&&&&&
cpTemp = cpS
&&&&&&&&&&&&
while(*cpSource == ch)&
&&&&&&&&&&&&&&&&&
++iTemp, ++cpS
&&&&&&&&&&&&
if(iTemp & iCount)
&&&&&&&&&&&&&&&&&
iCount = iTemp, cpDest = cpT
&&&&&&&&&&&&
if(!*cpSource)&
&&&&&&&&&&&&&&&&&&
return cpD
<font COLOR="#.什么是中断？中断发生时CPU做什么工作？所谓中断是指系统发生某一事件后，CPU暂停正在执行的程序转去执行处理该事件的程序过程，处理中断事件的程序称为中断处理程序，产生中断信号的那个部件称为中断源。硬件的中断机构与处理这些中断的程序统称为中断系统。
当中断发生时，硬件机构自动地进入响应中断过程，由操作系统的中断处理程序对中断事件进行处理，具体过程如下:
①&保存现场
系统开辟现场区，并将现场区组织成"栈"结构，当中断响应时，(1)硬件结构自动将PS和PC寄存器的内容压人栈中作为现场信息保存起来。(2)根据发生的中断，硬件从指定的中断向量单元中取出PS和PC内容，分别装人PS和PC寄存器，同时正确填人路寄存器的"当前状态"和"先前状态"字段。
②&分析原因，转中断处理程序
不同原因产生的中断事件要进行不同的处理，根据中断的路寄存器内容得出发生该种中断的具体原因。转人相对应的申断处理程序运行。
③&恢复现场
在多级中断系统中，考虑退回当前中断时，必须依据原先被中断的程序，完成不同的工作，中断处理结柬后，软件必须退出中断。如果此次是高级中断，并且被中断的程序是一个低级中断处理程序，则此次中断应返回到该低级中断处理程序。如果原来被中断的是用户程序，则退出中断前应先考虑进行一次调度选择，以挑选出更适合在当前情况下运行的新程序。
14.CPU在上电后，进入操作系统的main()之前必须做什么工作？整个系统对开发环境以及各种变量的初始化,包括了变量空间的分配,cpu内部寄存器的初始化,总线的初始化等等,总之,只有等系统初始化完成以后,我们的c语言的main才能被识别和执行下来。
<font COLOR="#.makefile文件的作用是什么？Makefile
的作用是根据配置的情况，构造出需要编译的源文件列表，然后分别编译，并把目标代码链接到一起，最终形成 Linux
内核二进制文件。&
<font COLOR="#.UNIX显示文件夹中，文件名的命令是什么？能使文件内容显示在屏幕的命令是什么？ls。cat，more
<font COLOR="#。手机用户在从一个基站漫游到另一个基站的过程中，都会发生什么?原基站与手机用户之间的链路将由新基站与手机用户之间的链路取代的过程。
a[2][2][3]={{{1,6,3},{5,4,15}},{{3,5,33},{23,12,7}} };
for(int i=0;i&12;i++)
printf("%d ",_______);
在空格处填上合适的语句，顺序打印出a中的数字答案：a[i/6][(i/3)%2][i%3]；这道题目是多维数组的输出问题，这里要考虑的是每维数字的取值顺序问题：第一维，前六次循环都取0，后六次取1，于是i/6可以满足要求；第二维，前3次为0，再3次为1，再3次为0，再3次为1，用量化的思想，i/3把12个数字分为4组每组3个，量化为0、1、2、3，为要得到0、1、0、1我们这里就需要对（0、1、2、3）％2＝（0、1、0、1），于是(i/3)%2；最后一维我们需要的是（0、1、2；0、1、2；0、1、2；0、1、2；）我们就i%3。
2.char **p,
a[16][8];&
问：p=a是否会导致程序在以后出现问题？为什么？答案：这个不会导致出现问题，但是要注意p的使用，如a[1][2]
等价的为 *(*(p+1)+2)而不是*(p+11)
3．一个单链表，不知道长度，写一个函数快速找到中间节点的位置.普通的方法就是先遍历得到链表的长度，然后再通过长度遍历得到链表的中间节点。更好的办法是：
1）& 使用两个指针进行遍历，快指针每次步进2，慢指针每次步进1；
2）& 当快指针到达链表尾部的时候，慢指针指向的就是链表的中点。
（这个算法的思想和经典问题“判定链表中是否存在环”的思想是一致的）
函数代码如下：
node* find_mid_element(node* head)
if (NULL == head) return NULL;
if (head-&_next == NULL)
if (head-&_next-&_next == NULL)
node* mid=
node* p = mid-&_
while ((NULL != p) && (NULL !=
p-&_next))
&&&&&&&&&&&&&
mid = mid-&_
&&&&&&&&&&&&&
p = p-&_next-&_
下面来道微软的吧
4. Implement
a string class in C++ with basic functionality like comparison,
concatenation, input and output. Please also provide some test
cases and using scenarios (sample code of using this class).
Please do not use MFC, STL and other libraries in your
implementation.我的实现方案如下,这道题真地对c++的主要特性都进行了较好地考察.
#ifndef STRING_H
#define STRING_H
#include &iostream&
class String{
&& public:
String(int n,char c);
String(const char* source);
String(const String& s);
//String& operator=(char* s);
String& operator=(const String&
~String();
char& operator[](int i){return a[i];}
const char& operator[](int i) const {return
a[i];}//对常量的索引.
String& operator+=(const String&
int length();
operator&&(istream&
is, String&
s);//搞清为什么将&&设置为友元函数的原因.
&& //friend bool
operator& (const String& left,const
String& right);
&& friend bool
operator& (const String& left, const
String& right);//下面三个运算符都没必要设成友元函数,这里是为了简单.
&& friend bool
operator== (const String& left, const
String& right);
&& friend bool
operator!= (const String& left, const
String& right);
&& private:
String.cpp:
#include "String.h"
#include &cstring&
#include &cstdlib&
String::String(){
a = new char[1];
a[0] = '\0';
String::String(int n,char c){
&a = new char[n + 1];
&memset(a,c,n);
&a[n] = '\0';
String::String(const char* source){
&if(source == NULL){
& a = new char[1];
& a[0] = '\0';
& size = 0;
size = strlen(source);
& a = new char[size + 1];
& strcpy(a,source);
String::String(const String& s){
&size = strlen(s.a);//可以访问私有变量.
&a = new char[size + 1];
&//if(a == NULL)
&strcpy(a,s.a);
String& String::operator=(const
String& s){
&if(this == &s)
& return *
& delete[]
size = strlen(s.a);
& a = new char[size + 1];
& strcpy(a,s.a);
& return *
String::~String(){
String& String::operator+=(const
String& s){
& int j = strlen(a);
& int size = j + strlen(s.a);
& char* tmp = new char[size+1];
& strcpy(tmp,a);
& strcpy(tmp+j,s.a);
int String::length(){
&return strlen(a);
#include &iostream&
#include "String.h"
bool operator==(const String& left, const
String& right)
&int a = strcmp(left.a,right.a);
if(a == 0)
bool operator!=(const String& left, const
String& right)
&return& !(left ==
operator&&(ostream&
os,String& s){
&int length = s.length();
&for(int i = 0;i &
s.a[i];这么不行,私有变量.
String operator+(const
String& a,const String& b){
bool operator&(const String&
left,const String& right){
&int j = 0;
&while((left[j] != '\0')
&& (right[j] != '\0')){
& if(left[j] &
&& if(left[j] ==
right[j]){
&if((left[j] == '\0')
&& (right[j] != '\0'))
bool operator&(const String& left,
const String& right)
{&& int a =
strcmp(left.a,right.a);
operator&&(istream&
is, String& s){
&delete[] s.a;
&s.a = new char[20];
&int m = 20;
&int i = 0;
&while (is.get(c)
&& isspace(c));
& do {s.a[i] =
if(i == m - 1 ){
s.a[i] = '\0';
char* b = new char[m];
strcpy(b,s.a);
&&&&&&&&&&&&&&&&
m = m * 2;
s.a = new char[m];
strcpy(s.a,b);
& while (is.get(c)
&& !isspace(c));
//如果读到空白,将其放回.
is.unget();
&s.a[i] = '\0';
int main(){
&String a = "abcd";
&String b = "www";
&//String c(6,b);这么写不对.
String c(6,'l');
&String e =//abcd
f;//需要输入...
&g = a +//abcdwww
&if(a & b)
& cout && "a
& cout && "a
&if(e == a)
& cout && "e
& cout && "e
&cout && a
&cout && b
&cout && d
&cout && e
&cout && f
&cout && g
&cout && g[0]
&return 0;
再来点智力题吧
1.巴拿赫病故于日。他的出生年份恰好是他在世时某年年龄的平方，问：他是哪年出生的？答案：设他在世时某年年龄为x，则x的平方&1945，且x为自然数。其出生年份x的平方xx（x1），他在世年龄;x（x1）。1945的平方根&#，则x应为44或略小于此的数。而x44时，x（x1）&#&#，算得其在世年龄为;;53；又x43时，x（x1）&#&#，得其在世年龄为;;139；若x再取小，其在世年龄越大，显然不妥。故x44，即他出生于1892年，终年53岁。
2.有50家人家，每家一条狗。有一天警察通知，50条狗当中有病狗，行为和正常狗不一样。每人只能通过观察别人家的狗来判断自己家的狗是否生病，而不能看自己家的狗，如果判断出自己家的狗病了，就必须当天一枪打死自己家的狗。结果，第一天没有枪声，第二天没有枪声，第三天开始一阵枪响，问：一共死了几条狗？
死了3条（第几天枪响就有几条）。
简单分析：从有一条不正常的狗开始，显然第一天将会听到一声枪响。这里的要点是你只需站在那条不正常狗的主人的角度考虑。
有两条的话思路继续，只考虑有两条不正常狗的人，其余人无需考虑。通过第一天他们了解了对方的信息。第二天杀死自己的狗。换句话说每个人需要一天的时间证明自己的狗是正常的。有三条的话，同样只考虑那三个人，其中每一个人需要两天的时间证明自己的狗是正常的狗。
3.一个经理有三个女儿，三个女儿的年龄加起来等于13，三个女儿的年龄乘起来等于经理自己的年龄。有一个下属已知道经理的年龄，但仍不能确定经理的三个女儿的年龄，这时经理说只有一个女儿的头发是黑的，然后这个下属就知道了经理的三个女儿的年龄。请问三个女儿的年龄分别是多少？为什么？
答案：分别是2，2，9。& ???
简单分析：
1 1 11 11 伪穷举，呵呵
1 2 10 20
1 3 9 27
1 4 8 32
1 5 7 35
1 6 6 36
36在所有的可能性中，只有这两个相同，如果经理的年龄为其他，则他下属就可以确定三个人分别为几岁了,所以只有两种可能：1，6，6或者2，2，9。如果是1，6，6的话，那么两个同样大的6岁的孩子应该都是黑头发,
所以只有2，2，9比较合理，大的那个是黑头发，另外两个是黄毛丫头
2 3 8 40
2 4 7 56
2 5 6 60
3 3 7 42
3 4 6 72
3 5 5 75
4 4 5 80
4.如果六千，六百，六表示成6606，那么十一千，十一百，十一表示成什么？+11=12111
5.grass后面加一个词，agent前面加一个单词，组成两个新词，这个词是什么？land&&&
land-agent 地产管理人
6.农场不知道有多少鸡，现有一批饲料，如果卖掉75只鸡饲料够20天用，买进100只鸡饲料够用15天，问原来有多少只鸡？
(x-75)*20=(x+100)*15&&
7.6个桶，装着两种液体，一种液体的价格是另外一种的double，桶容量为8，13，15，17，19，31，有一个美国人，各用了14美元买两种液体，剩下一个桶。问剩下哪个？
X(价格)*V1(体积)=14&&
2X*V2=14&&&
由题意可知所买的一种液体体积是另一种的两倍，固8+13+15+17+19+31=103之和再减去其中一个数所得的数（记为X）要求是3的倍数,
103-8=95;&
103-13=90;&
103-15=88;&
103-17=86;&
103-19=84;&&
所以得出13，19，31合题意，但液体是不能混合的，所以X除3（记为Y）必需是其中两容器之和。
(8,15,17,19,31)
没有合适组合&&
72/3=24& （8，13，15，17，19）没有合适组合
(8，13，15，17，31)&&&
-13,15组合
补充点堆和栈的理论知识
1.申请方式
由系统自动分配。 例如，声明在函数中一个局部变量 系统自动在栈中为b开辟空间
需要程序员自己申请，并指明大小，在c中malloc函数
如p1 = (char *)malloc(10);
在C++中用new运算符
如p2 = (char *)malloc(10);
但是注意p1、p2本身是在栈中的。
2.申请后系统的响应栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
3.申请大小的限制栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址
和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
4.申请效率的比较：栈由系统自动分配，速度较快。但程序员是无法控制的。
堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。
5.堆和栈中的存储内容栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
6.存取效率的比较char s1[] =
"aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
void main()
char a = 1;
char c[] = "";
char *p ="";
对应的汇编代码
10: a = c[1];
A 4D F1 mov cl,byte ptr [ebp-0Fh]
4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
B 55 EC mov edx,dword ptr [ebp-14h]
A 42 01 mov al,byte ptr [edx+1]
45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。&
7.堆和栈的区别及内存泄露
堆和栈是两个不同的概念。在学微机原理时没有感觉到，因为书上只提到了堆栈；数据结构上也提到过栈。但是，始终不明白什么是堆，什么是栈。后来无意翻看了C++，才知道（只是知道，不是明白，更称不上懂）它们的区别。
简单的来讲堆（heap）上分配的内存，系统不释放，而且是动态分配的。栈（stack）上分配的内存系统会自动释放，它是静态分配的。
由malloc或new分配的内存都是从heap上分配的内存，从heap上分配的内存必须有程序员自己释放，用free来释放，否则这块内存会一直被占用而得不到释放，就出现了“内存泄露（Memory
Leak）”。这样会造成系统的可分配内存的越来越少，导致系统崩溃。
C/C++是“跨国语言”，在任何平台上都可以使用。所以，Memory
Leak在每个系统上都会出现。避免方法就是在写完malloc后，紧跟着就在下一行写free。然后在两行代码中间加其他的代码。哈哈，梁肇新的成对编码，这样会很好的解决。
1.Windows程序的入口是哪里？写出Windows消息机制的流程。Windows程序的入口是WinMain函数.消息机制：系统将会维护一个或多个消息队列，所有产生的消息都会被放入或是插入队列中。系统会在队列中取出每一条消息，根据消息的接收句柄而将该消息发送给拥有该窗口的程序的消息循环。每一个运行的程序都有自己的消息循环，在循环中得到属于自己的消息并根据接收窗口的句柄调用相应的窗口过程。而在没有消息时消息循环就将控制权交给系统。
2.如何定义和实现一个类的成员函数为回调函数？所谓的回调函数，就是预先在系统的对函数进行注册，让系统知道这个函数的存在，以后，当某个事件发生时，再调用这个函数对事件进行响应。
定义一个类的成员函数时在该函数前加CALLBACK即将其定义为回调函数，函数的实现和普通成员函数没有区别。
3.C++里面是不是所有的动作都是main()引起的？如果不是，请举例。
不是，比如中断引起的中断处理不是直接由main()引起的，而是由外部事件引起的。
在运行c++程序时，通常从main()函数开始执行。因此如果没有main(),程序将不完整，编译器将指出未定义main()函数。
例外情况：如，在windows编程中，可以编写一个动态连接库（dll)模块，这是其他windows程序可以使用的代码。由于DLL模块不是独立的程序，因此不需要main().用于专用环境的程序--如机器人中的控制器芯片--可能不需要main().但常规的独立程序都需要main().
比如全局变量的初始化，就不是由main函数引起的.但是这个初始化动作并不能为编译器的断点所截断。
4.C++里面如何声明const void
f(void)函数为C程序中的库函数？在该函数前添加extern
“C”声明。
5.下列哪两个是等同的
A const int* a = &b;
B const* int a = &b;
C const int* const a = &b;
D int const* const a =
&b;各式表示的意思分别为：
A const int* a = &b; //*a是const,但指针a可变
B const* int a = &b; //a是const，但*a可变
C const int* const a = &b;
//a和*a都是const,常量和指针的值都不能改变
D int const* const a = &b;
//a和*a都是const,常量和指针的值都不能改变
因此C，D两者是相同的。
总结个技巧：如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。
6．内联函数在编译时是否做参数类型检查？做类型检查，因为内联函数就是在程序编译时，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体来代替。
void g(base & b){
void main(){
g(s);
}7.写出判断ABCD四个表达式的是否正确, 若正确, 写出经过表达式中
(A)a += (a++); (B) a += (++a) ;(C) (a++) +=(D) (++a) +=
a = ?答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) +=
改后答案依次为9,10,10,11
8.某32位系统下,
C++程序，请计算sizeof 的值
char str[] = “”
int n = 10;
sizeof (str ) = ？（1）
sizeof ( p ) = ？（2）
sizeof ( n ) = ？（3）
void Foo ( char str[100]){
sizeof( str ) = ？（4）
void *p = malloc( 100 );
sizeof ( p ) = ？（5）
答：（1）17 （2）4 （3） 4 （4）4 （5）4
回答下面的问题
(1).头文件中的 ifndef/define/endif
干什么用？预处理
答：防止头文件被重复引用
(2). #include 和 #include “filename.h” 有什么区别？
答：前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。
(3).在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？
答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern
"C"修饰的变量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调用C 函数。C++提供了一个C
连接交换指定符号extern“C”来解决这个问题。
(4). switch()中不允许的数据类型是?
回答下面的问题
(1).Void GetMemory(char **p, int
*p = (char *)malloc(num);
void Test(void){
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
请问运行Test 函数会有什么样的结果？
答：输出“hello”
(2). void Test(void){
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL){
strcpy(str, “world”);
printf(str);
请问运行Test 函数会有什么样的结果？
答：输出“world”
(3). char *GetMemory(void){
char p[] = "hello world";
void Test(void){
char *str = NULL;
str = GetMemory();
printf(str);
请问运行Test 函数会有什么样的结果？
答：无效的指针，输出不确定。
微软亚洲技术中心的面试题
1．进程和线程的差别。
线程是指进程内的一个执行单元,也是进程内的可调度实体.
与进程的区别:
(1)调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位
(2)并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可并发执行
(3)拥有资源：进程是拥有资源的独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源.
(4)系统开销：在创建或撤消进程时，由于系统都要为之分配和回收资源，导致系统的开销明显大于创建或撤消线程时的开销。
2．Heap与stack的差别
Heap是堆，stack是栈。
Stack的空间由操作系统自动分配/释放，Heap上的空间手动分配/释放。
Stack空间有限，Heap是很大的自由存储区
C中的malloc函数分配的内存空间即在堆上,C++中对应的是new操作符。
程序在编译期对变量和函数分配内存都在栈上进行,且程序运行过程中函数调用时参数的传递也在栈上进行
3．Windows下的内存是如何管理的？
4．介绍.Net和.Net的安全性。
5．客户端如何访问.Net组件实现Web Service？
6．C/C++编译器中虚表是如何完成的？
7．谈谈COM的线程模型。然后讨论进程内/外组件的差别。
8．谈谈IA32下的分页机制
小页(4K)两级分页模式，大页(4M)一级
9．给两个变量，如何找出一个带环单链表中是什么地方出现环的？
一个递增一，一个递增二，他们指向同一个接点时就是环出现的地方
10．在IA32中一共有多少种办法从用户态跳到内核态？
通过调用门，从ring3到ring0，中断从ring3到ring0，进入vm86等等
11．如果只想让程序有一个实例运行，不能运行两个。像winamp一样，只能开一个窗口，怎样实现？
用内存映射或全局原子（互斥变量）、查找窗口句柄..
FindWindow，互斥，写标志到文件或注册表,共享内存。
12．如何截取键盘的响应，让所有的‘a’变成‘b’？
键盘钩子SetWindowsHookEx
13．Apartment在COM中有什么用？为什么要引入？
14．存储过程是什么？有什么用？有什么优点？
存储过程（Stored Procedure）是一组为了完成特定功能的SQL
语句集，经编译后存储在数据库。中用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。
存储过程用于实现频繁使用的查询、业务规则、被其他过程使用的公共例行程序
存储过程在创建时即在服务器上进行编译，所以执行起来比单个 SQL 语句快
15．Template有什么特点？什么时候用？
16．谈谈Windows DNA结构的特点和优点。
17.网络编程中设计并发服务器，使用多进程与多线程 ，请问有什么区别？
1，进程：子进程是父进程的复制品。子进程获得父进程数据空间、堆和栈的复制品。
2，线程：相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
区别：两者都可以提高程序的并发度，提高程序运行效率和响应时间。线程和进程在使用上各有优缺点：线程执行开销小，但不利于资源管理和保护；而进程正相反。同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。
MSRA Interview Written Exam（December
2003，Time：2.5 Hours）
1写出下列算法的时间复杂度。
(1)冒泡排序；
(2)选择排序；
(3)插入排序；
(4)快速排序；
(5)堆排序；
(6)归并排序；
2写出下列程序在X86上的运行结果。
struct mybitfields
unsigned short a : 4;
unsigned short b : 5;
unsigned short c : 7;
void main(void)&
i=*((short *)&test);
printf("%d\n",i);
3写出下列程序的运行结果。
unsigned int i=3;
cout&&i * -1;
4写出下列程序所有可能的运行结果。
//Start F1,F2 in parallel
F1(); F2();
printf("a=%d\n",a);
5考察了一个CharPrev()函数的作用。
6对 16 Bits colors的处理，要求：
（1）Byte转换为RGB时，保留高5、6bits；
（2）RGB转换为Byte时，第2、3位置零。
7一个链表的操作，注意代码的健壮和安全性。要求：
（1）增加一个元素；
（2）获得头元素；
（3）弹出头元素（获得值并删除）。
8一个给定的数值由左边开始升位到右边第N位，如 0010&&1 ==
请用C或者C++或者其他X86上能运行的程序实现。
附加题（只有在完成以上题目后，才获准回答）
1。In C++, what does "explicit" mean? what does "protected"
c++中的explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，在某些情况下，我们要求类的使用者必须显示调用类的构造函数时就需要使用explicit,反之默认类型转换可能会造成无法预期的问题。
protected控制的是一个函数对一个类的成员（包括成员变量及成员方法）的访问权限。protected成员只有该类的成员函数及其派生类的成员函数可以访问
==================&
1.在C++中有没有纯虚构造函数？
构造函数不能是虚的。只能有虚的析构函数
2.在c++的一个类中声明一个static成员变量有没有用？
在C++类的成员变量被声明为static（称为静态成员变量），意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，也就是说不管创建多少对象，static修饰的变量只占有一块内存。其修改值为该类的其它所有实例所见；而类的静态成员函数也只能访问静态成员（变量或函数）。
static是加了访问控制的全局变量，不被继承。&3.解释一下多播（组播）和广播的含义？
组播:主机之间“一对一组”的通讯模式，也就是加入了同一个组的主机可以接受到此组内的所有数据，网络中的交换机和路由器只向有需求者复制并转发其所需数据。主机可以向路由器请求加入或退出某个组，网络中的路由器和交换机有选择的复制并传输数据，即只将组内数据传输给那些加入组的主机。
广播:主机之间“一对所有”的通讯模式，网络对其中每一台主机发出的信号都进行无条件复制并转发，所有主机都可以接收到所有信息（不管你是否需要）.
4.MFC中CString是类型安全类么？
答：不是，其它数据类型转换到CString可以使用CString的成员函数Format来转换
5.C++中为什么用模板类。
答：(1)可用来创建动态增长和减小的数据结构
（2）它是类型无关的，因此具有很高的可复用性。
（3）它在编译时而不是运行时检查数据类型，保证了类型安全
（4）它是平台无关的，可移植性
（5）可用于基本数据类型
6.CSingleLock是干什么的。
答：同步多个线程对一个数据类的同时访问7.NEWTEXTMETRIC
答：物理字体结构，用来设置字体的高宽大小8.程序什么时候应该使用线程，什么时候单线程效率高。
答：1．耗时的操作使用线程，提高应用程序响应
2．并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。
3．多CPU系统中，使用线程提高CPU利用率
4．改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
其他情况都使用单线程。
9.Linux有内核级线程么。
答：线程通常被定义为一个进程中代码的不同执行路线。从实现方式上划分，线程有两种类型：“用户级线程”和“内核级线程”。用户线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。这种线程甚至在象
DOS 这样的操作系统中也可实现，但线程的调度需要用户程序完成，这有些类似 Windows 3.x
的协作式多任务。另外一种则需要内核的参与，由内核完成线程的调度。其依赖于操作系统核心，由内核的内部需求进行创建和撤销，这两种模型各有其好处和缺点。用户线程不需要额外的内核开支，并且用户态线程的实现方式可以被定制或修改以适应特殊应用的要求，但是当一个线程因
而处于等待状态时，整个进程就会被调度程序切换为等待状态，其他线程得不到运行的机会；而内核线程则没有各个限制，有利于发挥多处理器的并发优势，但却占用了更多的系统开支。
Windows NT和OS/2支持内核线程。Linux 支持内核级的多线程
10.C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中？
答：栈: 存放局部变量，函数调用参数,函数返回值，函数返回地址。由系统管理
堆: 程序运行时动态申请，new 和 malloc申请的内存就在堆上
11.使用线程是如何防止出现大的波峰。
答：意思是如何防止同时产生大量的线程，方法是使用线程池，线程池具有可以同时提高调度效率和限制资源使用的好处，线程池中的线程达到最大数时，其他线程就会排队等候。
12.函数模板与类模板有什么区别？
答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显式地指定。
13.一般数据库若出现日志满了，会出现什么情况，是否还能使用？
答：只能执行查询等读操作，不能执行更改，备份等写操作，原因是任何写操作都要记录日志。也就是说基本上处于不能使用的状态。
14.&SQL Server是否支持行级锁，有什么好处？
答：支持，设立封锁机制主要是为了对并发操作进行控制，对干扰进行封锁，保证数据的一致性和准确性，行级封锁确保在用户取得被更新的行到该行进行更新这段时间内不被其它用户所修改。因而行级锁即可保证数据的一致性又能提高数据操作的并发性。
15.&关于内存对齐的问题以及sizeof()的输出
答：编译器自动对齐的原因：为了提高程序的性能，数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。
16.&int i=10, j=10, k=3; k*=i+j;
k最后的值是？
答：60，此题考察优先级，实际写成：
k*=(i+j);，赋值运算符优先级最低17.对数据库的一张表进行操作,同时要对另一张表进行操作,如何实现?
答：将操作多个表的操作放入到事务中进行处理18.TCP/IP
建立连接的过程?(3-way shake)
答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
19.ICMP是什么协议,处于哪一层?
答：Internet控制报文协议，处于网络层（IP层）
20.触发器怎么工作的?
答：触发器主要是通过事件进行触发而被执行的，当对某一表进行诸如UPDATE、
INSERT、 DELETE 这些操作时，数据库就会自动执行触发器所定义的SQL 语句，从而确保对数据的处理必须符合由这些SQL
语句所定义的规则。
21.winsock建立连接的主要实现步骤?
答：服务器端：socket()建立套接字，绑定（bind）并监听（listen），用accept（）等待客户端连接。
客户端：socket()建立套接字，连接（connect）服务器，连接上后使用send()和recv（），在套接字上写读数据，直至数据交换完毕，closesocket()关闭套接字。
服务器端：accept（）发现有客户端连接，建立一个新的套接字，自身重新开始等待连接。该新产生的套接字使用send()和recv（）写读数据，直至数据交换完毕，closesocket()关闭套接字。
22.动态连接库的两种方式?
答：调用一个DLL中的函数有两种方法：
1．载入时动态链接（load-time dynamic
linking），模块非常明确调用某个导出函数，使得他们就像本地函数一样。这需要链接时链接那些函数所在DLL的导入库，导入库向系统提供了载入DLL时所需的信息及DLL函数定位。
2．运行时动态链接（run-time dynamic
linking），运行时可以通过LoadLibrary或LoadLibraryEx函数载入DLL。DLL载入后，模块可以通过调用GetProcAddress获取DLL函数的出口地址，然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了
23.IP组播有那些好处?
答：Internet上产生的许多新的应用，特别是高带宽的多媒体应用，带来了带宽的急剧消耗和网络拥挤问题。组播是一种允许一个或多个发送者（组播源）发送单一的数据包到多个接收者（一次的，同时的）的网络技术。组播可以大大的节省网络带宽，因为无论有多少个目标地址，在整个网络的任何一条链路上只传送单一的数据包。所以说组播技术的核心就是针对如何节约网络资源的前提下保证服务质量。
使用基于公共语言运行库的语言编译器开发的代码称为托管代码；托管代码具有许多优点，例如：跨语言集成、跨语言异常处理、增强的安全性、版本控制和部署支持、简化的组件交互模型、调试和分析服务等。
每个类型成员都有一个唯一的签名。方法签名由方法名称和一个参数列表（方法的参数的顺序和类型）组成。只要签名不同，就可以在一种类型内定义具有相同名称的多种方法。当定义两种或多种具有相同名称的方法时，就称作重载。
1.一个类有基类、内部有一个其他类的成员对象，构造函数的执行顺序是怎样的。
答：先执行基类的（如果基类当中有虚基类，要先执行虚基类的，其他基类则按照声明派生类时的顺序依次执行），再执行成员对象的，最后执行自己的。
中，聚合(aggregation)和组合(composition)有什么区别
答案：聚合关系更强，类似于pages 和book
的关系；组合关系要弱，类似于books和bookshelf 的关系。3.C#和C++除了语法上的差别以外，有什么不同的地方？
答案：（C#我只是了解，不是很精通）
(1) c#有垃圾自动回收机制，程序员不用担心对象的回收。(2)c#严禁使用指针，只能处理对象。如果希望使用指针，则仅可在unsafe
程序块中能使用指针。(3)c#只能单继承。(4)必须通过类名访问静态成员。不能像C++中那样，通过对象访问静态成员。(5)在子类中覆盖父类的虚函数时必须用关键字override,覆盖父类的方法要用关键字new
4.ADO.net 和ADO
的区别？答案：实际上除了“能够让应用程序处理存储于DBMS
中的数据“这一基本相似点外，两者没有太多共同之处。但是ADO 使用OLE DB 接口并基于微软的COM 技术，而ADO.NET
拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET
接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML
5.&New delete
与malloc free 的区别
答案：用malloc 函数不能初始化对象，new 会调用对象的构造函数。Delete
会调用对象的destructor，而free 不会调用对象的destructor.
6.#define DOUBLE(x)
i = 5*DOUBLE(10)； i 是多少？正确的声明是什么？
答案：i 为60。正确的声明是#define DOUBLE(x) (x+x)
7.有哪几种情况只能用intialization list
而不能用assignment?
答案：当类中含有const、reference
成员变量；基类的构造函数都需要参数；类中含有其他类的成员对象，而该类的构造函数都需要参数。8.C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换。C#是类型安全的。
函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main
函数之前执行。10.比较一下C++中static_cast 和 dynamic_cast
的区别。dynamic_casts在帮助你浏览继承层次上是有限制的。它不能被用于缺乏虚函数的类型上，它被用于安全地沿着类的继承关系向下进行类型转换。如你想在没有继承关系的类型中进行转换，你可能想到static_cast
11.在8086 汇编下，逻辑地址和物理地址是怎样转换的？
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
12．类成员函数的重载、覆盖和隐藏区别答案：
成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）13．如何判断一段程序是由C
编译程序还是由C++编译程序编译的？
#ifdef __cplusplus
cout&&"c++";
cout&&"c";
14.数组a[N]，存放了1至N-1个数，其中某个数重复一次。写一个函数，找出被重复的数字.时间复杂度必须为o（N）函数原型：int
do_dup(int a[],int N)答案：方法1：如果数就是1－N-1,那么求出a[N]的和，然后减去1－N-1就行了。(确定数字1-N)
S = N * (N-1) / 2;
int s = 0;
for(i=0;i&N;++i)
s += a[i];
int res = s - S;
方法2．a[]中的某元素a[i]看做是pi[]数组的下标，元素a[i]存储到对应数组下标pi[a[i]]的地址中
#include&stdio.h&
#define N 10
void main()
&int a[N]={1,2,3,4,5,6,7,7,8,9};
&int pi[N]={0};
&int key=0;
&for(int i=0;i&N;i++)
if(pi[a[i]]==0)
pi[a[i]]=a[i];
{ key=a[i];
&printf("多余的数字是%d\n",key);
15.一语句实现x是否为2的若干次幂的判断
int i = 512;& cout
&& boolalpha
&& ((i & (i - 1)) ?
false : true) &&
<font COLOR="#.什么是预编译？何时需要预编译？１、总是使用不经常改动的大型代码体。
２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。
1.请问以下代码有什么问题：
int main()
strcpy(str,"hello");
printf(str);
&& return 0;
}没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
2.char* s="AAA";
printf("%s",s);
printf("%s",s);
有什么错？"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
cosnt char* s="AAA";然后又因为是常量，所以对是s[0]的赋值操作是不合法的。
3.关键字volatile有什么含意？并举出三个不同的例子？
提示编译器对象的值可能在编译器未监测到的情况下改变。
int (*s[10])(int) 表示的是什么
int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。
4.交换两个变量的值，不使用第三个变量。
有两种解法, 一种用算术算法, 一种用^(异或)
a = a^b;// 只能对int,char..
a;5.c和c++中的struct有什么不同？c和c++中struct的主要区别是c中的struct不可以含有成员函数，而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private.
6.要对绝对地址0x100000赋值，我们可以用
(unsigned int*)0x100000 = 1234;
那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？*((void
(*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即:
(void (*)())0x100000
然后再调用它:
*((void (*)())0x100000)();
用typedef可以看得更直观些:
typedef void(*)() voidFuncP
*((voidFuncPtr)0x100000)();
7.已知一个数组table，用一个宏定义，求出数据的元素个数#define
#define NTBL (sizeof(table)/sizeof(table[0]))
8.线程与进程的区别和联系? 线程是否具有相同的堆栈?
dll是否有独立的堆栈?进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。
每个线程有自己的堆栈。
DLL中有没有独立的堆栈，这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是EXE中的线程所调用，那么这个时候是不是说这个DLL没有自己独立的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有独立的堆栈？
以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃。
9.位域：有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1
两种状态，用一位二进位即可。为了节省存储空间，并使处理简便，Ｃ语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。这样就可以把几个不同的对象用一个字节的二进制位域来表示。一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为：
struct 位域结构名
{ 位域列表 };
其中位域列表的形式为： 类型说明符 位域名：位域长度
位域变量的说明与结构变量说明的方式相同。 可采用先定义后说明，同时定义说明或者直接说明这三种方式。例如：
说明data为bs变量，共占两个字节。其中位域a占8位，位域b占2位，位域c占6位。对于位域的定义尚有以下几点说明：
一个位域必须存储在同一个字节中，不能跨两个字节。如一个字节所剩空间不够存放另一位域时，应从下一单元起存放该位域。也可以有意使某位域从下一单元开始。例如：
unsigned a:4
unsigned :0
unsigned b:4
unsigned c:4
在这个位域定义中，a占第一字节的4位，后4位填0表示不使用，b从第二字节开始，占用4位，c占用4位。
2. 由于位域不允许跨两个字节，因此位域的长度不能大于一个字节的长度，也就是说不能超过8位二进位。
位域可以无位域名，这时它只用来作填充或调整位置。无名的位域是不能使用的。例如：
从以上分析可以看出，位域在本质上就是一种结构类型， 不过其成员是按二进位分配的。
1.求1000！的未尾有几个0
（用素数相乘的方法来做，如72=2*2*2*3*3）
求出1-&1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3,
能被625整除的数的个数n4.
1000!末尾的零的个数=n1+n2+n3+n4;
#include&stdio.h&
#define NUM 1000
int find5(int num)
int ret=0;
while(num%5==0)
int main()
int result=0;
for(i=5;i&=NUM;i+=5)
result+=find5(i);
printf(" the total zero number is %d\n",result);
2.打印螺旋矩阵，输入N, 打印 N*N 矩阵
比如 N = 3，打印：
N = 4，打印：
12 13 14 5
11 16 15 6
1 #define N 15
int s[N][N];
void main()
int k = 0, i = 0, j = 0;
int a = 1;
for( ; k & (N+1)/2; k++ )
while( j & N-k ) s[i][j++] = a++; i++; j--;
while( i & N-k ) s[i++][j] = a++; i--; j--;
while( j & k-1 ) s[i][j--] = a++; i--; j++;
while( i & k ) s[i--][j] = a++; i++; j++;
for( i = 0; i & N; i++ )
for( j = 0; j & N; j++ )
cout && s[i][j]
2 define MAX_N 100
int matrix[MAX_N][MAX_N];
void SetMatrix(int x, int y, int start, int n) {
if (n &= 0) //递归结束条件
if (n == 1) { //矩阵大小为1时
matrix[x][y] =
for (i = i & x + n-1; i++) //矩阵上部
matrix[y][i] = start++;
for (j = j & y + n-1;
j++) //右部
matrix[j][x+n-1] = start++;
for (i = x+n-1; i & i--)
matrix[y+n-1][i] = start++;
for (j = y+n-1; j & j--)
matrix[j][x] = start++;
SetMatrix(x+1, y+1, start, n-2);
void main() {
scanf("%d", &n);
SetMatrix(0, 0, 1, n);
//打印螺旋矩阵
for(i = 0; i & i++) {
for (j = 0; j & j++)
printf("M", matrix[i][j]);
printf("\n");
3.以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] )
sizeof( str ) = ?
void *p = malloc( 100 );
sizeof ( p ) = ?解答：
sizeof( str ) = 4
sizeof ( p ) = 4
Func ( char str[100]
)函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下：
（1）数组名指代一种数据结构，这种数据结构就是数组；
例如：char str[10];
cout && sizeof(str)
输出结果为10，str指代数据结构char[10]。
（2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10];&
str++; //编译出错，提示str不是左值
（3）数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p )
4.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？least = MIN(*p++,
#define MIN(A,B) ((A) &= (B) ? (A)
MIN(*p++, b)会产生宏的副作用
剖析： 这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。程序员对宏定义的使用要非常小心，特别要注意两个问题：（1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) &= (B) ? (A) :
#define MIN(A,B) (A &= B ? A : B )
都应判0分；（2）防止宏的副作用。宏定义#define
MIN(A,B) ((A) &= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：
((*p++) &= (b) ? (*p++) :
(*p++))这个表达式会产生副作用，指针p会作三次++自增操作。除此之外，另一个应该判0分的解答是：
#define MIN(A,B) ((A) &= (B) ? (A)
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。
5.为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#ifdef __cplusplus
解答：头文件中的编译宏
#ifndef __INCvxWorksh
#define __INCvxWorksh
#endif的作用是防止被重复引用。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern
"C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。
