金山问题

金山问题

词霸的研发工程师。词霸的笔试题目对编程要求比较高。

第一题是一段英文阅读题，主要内容是关于COM的，后面有三道判断题，题目也是英文的，我想应该是考察应聘者的专业英文水平。我英文不是太好，虽然基本每句话能大概了解意思，题目仍然做不出。我想应该在大学学习中学习一些课外的知识会比较好，不要求会用，只要能了解其大概，基本工作原理，特性什么的就行，这题应该就很容易答出来。

第二题～第四题是算法编程题，应该是考察应聘者的基本专业素质

第二题的内容是：输入自然数n，打印1～n的所有质数。写出算法思路、函数实现、如何优化时间复杂度。
个人感觉这道题是比较简单的。最为比较常见的算法，应该掌握。

第三题的内容是：高精度乘法，输入不大于256位的正整数，计算其结果，并显示计算过程（乘法竖式），写出算法思路、函数实现
比如11×11＝121，应显示为：
11
× 11
——————
11
11
——————
121
这道题跟我以前的数据结构实验的一道题类似，当时要求使用链表，我没有选这道题，所以见到这道题我不太会做，只写了一下算法思路。

第四题是：已存在一组数据，若数据个数小于两个则程序结束，若不是，则选择一个中间点，将数据分成两组，比中间点小的放在一组，其余的放在一组。并对并对两组数据排序。
这道题应该是测试评聘者的基本素质，对经典排序算法的掌握程度。我对这些算法却仅仅是了解，建议大家一点要练到熟练写出的程度，可以节省很多时间。

第五题是VC++改错题，由于前边时间耽误的太多，没时间做了。应该考察的是应聘者对C++语言的语法熟悉程度。

第六题是操作系统的题目，是关于死锁的。不知做得对不对，但感觉上不是很难。

第七题是汇编题，本题有两道题，后一题是选做题。
前一题好象是说子程序的调用又要有汇编语句的支持，不同的编译器、操作系统等都有不同的隐式约定，简述你了解的一种。我对汇编不熟，而且学校学的是16位汇编，且好像没叫过题目说的东西，所以此题放弃。
后一题是现有一段英文简述64位汇编，之后问64汇编按英文简述的那样有什么优势？

今天去笔试金山了，出的题不算难，很基本，但是答好也根本就不容易
c语言中我们常用的memcpy(),memset(),memmove()等这些函数的实现细节平时有几个人能去把他弄明白哩……
反正我是没弄清楚，呵呵，今天晚上就出了memmove()的实现

第一个题目关键是运用模块化 ， 我当时就是不知道 ，一看比较简单，就直接写了下去，结果后来发现重复写的太多，已经写满了卷上的空白，没办法改了，结果就郁闷了 ，就是按照规则打印一些东西，看上去在main里边就能搞定，谁知道........ 哎  不提了
第二个题目是一个编写函数题 ， 就是考的是数组和指针的互用
第三个题目是一个考C++构造函数和继承 比较简单，不说了
剩下三个汇编题目  都是WIN32汇编，只记得有一个是写了一个函数，然后问是哪种调用方式
stdcall  ，c，还是pasical  ，就是根据参数进栈次序和清栈方式来进行判断
忘说了 ，最前面还有一个选择题，是英文的， 考的是C++

 1.第一题英文阅读理解，好像是从msdn中，复制了一段关于COblist的，让你选择3个答案  
  2.编程题；有a,b,c,d四个整数，从这四个数中，取一个数，2个数，3个数，4个  
  数，不能重复，问多少中情况，每一种得到数的和有多少不同的，列出分布情况  
  3。考你虚函数和重载的，  
  4.   改错题，关于动态分配，赋值操作这方面的东西  
  5.   论述题，谈谈你怎么开始一个新程序，具体机不起来的  
  ：）   只要你c++基础知识扎实，这些题还是很简单

class   Value  
{  
public:  
    Value(int   nVal)     {m_nVal=nVal;printf("Call   Value::Value(int   nValue)n");}  
    ~Value()   {printf("Call   Value::~Value()n");}  
    Value&   operator=(int   nVal)  
    {  
       m_nVal=nVal;  
       printf("Call   Value::operator=n");  
       return   *this;  
    }  
    void   Dump()     {printf("Value::m_nVal=%dn",m_nVal);}  
protected:  
    int   m_nVal;  
};  
 
class   Base  
{  
public:   Base()   {Init();}  
        virtual   ~Base()   {Release();}  
        virtual   void   Init()       {printf("Call   Base::Init()n");}  
        virtual   void   Release()     {printf("Call   Base::Release()n");}  
        virtual   void   Dump()     {printf("Call   Base::Dump()n");}  
};  
 
class   Derive:public   Base  
{  
public:Derive()     {printf("Call   Derive::Derive()n");}  
       ~Derive()         {printf("Call   Derive::~Derive()n");}  
       virtual   void   Init()       {m_Val=2;printf("Call   Derive::Init()n");}  
       virtual   void   Release()     {printf("Call   Derive::Release()n");}  
       virtual   void   Dump()     {m_Val.Dump();}  
protected:  
    static   Value   m_Val;  
};  
 
Value   Derive::m_Val=0;  
 
void   DestroyObj(Base*   pOb)  
{  
    pOb->Dump();  
    delete   pOb;  
}  
 
void   main()  
{  
    Derive   *pOb=new   Derive;  
    DestroyObj(pOb);  
}
写出输出结果
Call   Value::Value(int   nValue)//static
Call   Base::Init()
Call   Derive::Derive()
Value::m_nVal=0
Call   Derive::~Derive()
Call   Base::Release()
Call   Value::~Value()//static
 
设计一函数，求整数区间[a,b]和[c,d]的交集
二题:  
 /////////////////////////////////////////  
 #define     BOOL   int  
 #define     TRUE   1  
 #define     FALSE   0  
   
 BOOL   jiba(int   *p1,   int   *p2,   int**pt)  
 {  
 if   ((p1   ==   NULL)   ||   (p2   ==   NULL)   ||  
          (p1[0]   >   p1[1])   ||   (p2[0]   >   p2[1]))  
 {  
 printf("输入有误n");  
 return   FALSE;  
 }  
   
 if   (p2[0]   <=   p1[0])  
 {  
 if   (p2[1]   <   p1[0])  
 return   FALSE;  
 else  
 {  
 *pt   =   new   int[2];  
 (*pt)[0]   =   p1[0];  
 (*pt)[1]   =   (p2[1]<=p1[1]   ?   p2[1]:p1[1]);  
 return   TRUE;  
 }  
 }  
 else  
 {  
 if   (p2[0]   >   p1[1])  
 return   FALSE;  
 else  
 {  
 *pt   =   new   int[2];  
 (*pt)[0]   =   (p1[0]   >=   p2[0]   ?   p1[0]:p2[0]);  
 (*pt)[1]   =   p1[1];  
 return   TRUE;  
 }  
 }  
 return   TRUE;  
 }  
   
 //test!  
 int   rt[2]   ={1,5};  
 int   rt1[2]={3,9};  
 int   main()  
 {  
 int   *p   =   NULL;  
 BOOL   b   =   jiba(rt,rt1,&p);  
 if   (b)  
 {  
 printf("[%d,%d]与[%d,%d]的交集为[%d,%d]n",rt[0],rt[1],rt1[0],rt1[1],   p[0],p[1]);  
 delete   p;  
 }  
 else  
 {  
 printf("[%d,%d]与[%d,%d]的交集为空n",rt[0],rt[1],rt1[0],rt1[1]);  
 }  
 getchar();  
 return   0;  
 }

第一道:

两个数 int a, int b,不用中间变量交换两个值的C++代码.

第二道,分析程序输出.代码如下:

#include

class B {
public:
           int i, j;

 B(int x = 999) :j(x), i(j)
 {
               cout << "B::B() invokedn" << endl;
 }

 ~B()
 {
                cout << "B::~B() invokedn" << endl;
 }
};

class D : public B {
public:
 D()
 {
               cout << "D::D() invokedn" < }
 ~D()
 {
                cout << "D::~D() invokedn" << endl;
 }

};

void main()
{
 D d;
 cout << "d.i" << d.i << endl;
 cout << "d.j=" << d.j << endl;
}

结果：
B::B() invoked

D::D() invoked

d.i-858993460
d.j=999
D::~D() invoked

B::~B() invoked

_cdecl    
   
  按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于“C”函数或者变量，修饰名是在函数名前加下划线。对于“C++”函数，有所不同。    
   
  如函数void   test(void)的修饰名是_test；对于不属于一个类的“C++”全局函数，修饰名是?test@@ZAXXZ。    
   
  这是缺省调用约定。由于是调用者负责把参数弹出栈，所以可以给函数定义个数不定的参数，如printf函数。    
   
   
  _stdcall    
   
  按从右至左的顺序压参数入栈，由被调用者把参数弹出栈。对于“C”函数或者变量，修饰名以下划线为前缀，然后是函数名，然后是符号“@”及参数的字节数，如函数int   func(int   a,   double   b)的修饰名是_func@12。对于“C++”函数，则有所不同。    
   
  所有的Win32   API函数都遵循该约定。   

  _pascal 

   按从左至右的顺序压参数入栈 ...其它的与_stdcall相同;
   
   
  _fastcall    
   
  头两个DWORD类型或者占更少字节的参数被放入ECX和EDX寄存器，其他剩下的参数按从右到左的顺序压入栈。 由被调用者把参数弹出栈，对于“C”函数或者变量，修饰名以“@”为前缀，然后是函数名，接着是符号“@”及参数的字节数，如函数int   func(int   a,   double   b)的修饰名是@func@12。对于“C++”函数，有所不同。    
   
  未来的编译器可能使用不同的寄存器来存放参数。    
   
   
  thiscall    
   
  仅仅应用于“C++”成员函数。this指针存放于CX寄存器，参数从右到左压栈。thiscall不是关键词，因此不能被程序员指定。    
   
   
  naked   call    
   
  采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。naked   call不产生这样的代码。    
   
  naked   call不是类型修饰符，故必须和_declspec共同使用，如下：    
   
  __declspec(   naked   )   int   func(   formal_parameters   )    
   
  {    
   
  //   Function   body    
   
  }    
   
       
  

 便于更好理解, 看下面例子（函数调用的过程以汇编代码表示）：     
   
  void   cdecl       fun1(int   x,int   y);  
  void   stdcall     fun2(int   x,int   y);  
  void   pascal     fun3(int   x,int   y);