ZERO 笔试

时间 2019-11-30

原文原文链接

1.大多考到了计算机网络 tcpip 和操做系统多线程的知识直接懵逼html

2. 考到了递归的全排列ios

#include<iostream>  
using namespace std;  
  
void swap(int &a,int &b)  
{  
      int temp ;  
      temp=a;  
      a=b;  
      b=temp;  
}  
void show(int a[],int n) //显示所有数组    
{  
                for(int i=0;i<n;i++ )  
           {  
               cout<<a[i]<<"  ";  
           }  
           cout<<endl;  
}  
void prim(int a[],int k, int n)  //n是这个a[]中有多少个元素 ，k是a[]须要全排列的的坐下标  
{   
     if(k==n-1)//不是只有一个元素 而是全排列到最后一个数字时   终止递归的条件  
     {  
           show(a,n);  
     }  
     else   
     {  
         for(int i=k;i<n;i++)  //从k开始时保证交换和递归次数     
         {  
                  swap(a[i],a[k]);   //第一次 本身和本身交换即本身是最前单一前缀   交换单一前缀和后缀中的每个元素 ，让每个元素均可以作前缀  
              prim(a,k+1,n);  
              swap(a[i],a[k]);  //回溯以后  仍然恢复交换之前的顺序  
         }  
     }  
}  
  
int main(int argc, char* argv[])  
{  
        int  a[3]={1,2,3};  
        prim(a,0,3);  
    system("PAUSE");  
    return 0;  
}

　　若是只有两个 [1,2]的话我是看懂了 c++

3.多态继承和封装算法

http://blog.csdn.net/ruyue_ruyue/article/details/8211809编程

C++封装继承多态总结数组

面向对象的三个基本特征网络

面向对象的三个基本特征是：封装、继承、多态。其中，封装能够隐藏实现细节，使得代码模块化；继承能够扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另外一个目的——接口重用！数据结构

封装多线程

什么是封装？tcp

封装能够隐藏实现细节，使得代码模块化；封装是把过程和数据包围起来，对数据的访问只能经过已定义的界面。面向对象计算始于这个基本概念，即现实世界能够被描绘成一系列彻底自治、封装的对象，这些对象经过一个受保护的接口访问其余对象。在面向对象编程上可理解为：把客观事物封装成抽象的类，而且类能够把本身的数据和方法只让可信的类或者对象操做，对不可信的进行信息隐藏。

继承

什么是继承？

继承是指这样一种能力：它可使用现有类的全部功能，并在无需从新编写原来的类的状况下对这些功能进行扩展。其继承的过程，就是从通常到特殊的过程。

经过继承建立的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。要实现继承，能够经过“继承”（Inheritance）和“组合”（Composition）来实现。在某些 OOP 语言中，一个子类能够继承多个基类。可是通常状况下，一个子类只能有一个基类，要实现多重继承，能够经过多级继承来实现。

继承的实现方式？

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

1. 实现继承是指使用基类的属性和方法而无需额外编码的能力；

2. 接口继承是指仅使用属性和方法的名称、可是子类必须提供实现的能力；

3. 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

多态

什么是多态？

多态性（polymorphisn）是容许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值以后，父对象就能够根据当前赋值给它的子对象的特性以不一样的方式运做。简单的说，就是一句话：容许将子类类型的指针赋值给父类类型的指针。

例子：（2012某**软件公司笔试题）

请按顺序写出下面代码的输出结果：

答案：call child func

call ~child

call ~base

多态的实现方式分析？

实现多态，有二种方式，覆盖，重载。覆盖：是指子类从新定义父类的虚函数的作法。重载：是指容许存在多个同名函数，而这些函数的参数表不一样（或许参数个数不一样，或许参数类型不一样，或许二者都不一样）。

分析：

“重载”是指在同一个类中相同的返回类型和方法名，可是参数的个数和类型能够不一样

“覆盖\重写”是在不一样的类中。

其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不一样的参数表，对同名函数的名称作修饰，而后这些同名函数就成了不一样的函数（至少对于编译器来讲是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器作过修饰后的函数名称多是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经肯定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），所以，重载和多态无关！真正和多态相关的是“覆盖”。当子类从新定义了父类的虚函数后，父类指针根据赋给它的不一样的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是没法肯定的（调用的子类的虚函数的地址没法给出）。所以，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，若是它不是晚邦定，它就不是多态。”

C++多态机制的实现：

该部分转自：http://blog.chinaunix.net/uid-7396260-id-2056657.html

一、c++实现多态的方法

面向对象有了一个重要的概念就是对象的实例，对象的实例表明一个具体的对象，故其确定有一个数据结构保存这实例的数据，这一数据包括对象成员变量，若是对象有虚函数方法或存在虚继承的话，则还有相应的虚函数或虚表指针，其余函数指针不包括。

虚函数在c++中的实现机制就是用虚表和虚指针，可是具体是怎样的呢？从more effecive c++其中一篇文章里面能够知道：是每一个类用了一个虚表，每一个类的对象用了一个虚指针。要讲虚函数机制，必须讲继承，由于只有继承才有虚函数的动态绑定功能，先讲下c++继承对象实例内存分配基础知识：

从more effecive c++其中一篇文章里面能够知道：是每一个类用了一个虚表，每一个类的对象用了一个虚指针。具体的用法以下：
class A
{public:
    virtual void f();
    virtual void g();
private:
    int a
};

class B : public A
{
public:
    void g();
private:
    int b;
};
//A，B的实现省略
由于A有virtual void f（），和g（），因此编译器为A类准备了一个虚表vtableA，内容以下：

A::f 的地址

A::g 的地址

B由于继承了A，因此编译器也为B准备了一个虚表vtableB，内容以下：

A::f 的地址

B::g 的地址

注意：由于B::ｇ是重写了的，因此B的虚表的g放的是B::g的入口地址，可是f是从上面的A继承下来的，因此f的地址是A::f的入口地址。而后某处有语句 B bB;的时候，编译器分配空间时，除了A的int a，B的成员int b；之外，还分配了一个虚指针vptr，指向B的虚表vtableB，bB的布局以下：

vptr ：指向B的虚表vtableB

int a：继承A的成员

int b： B成员

当以下语句的时候：
A *pa = &bB;
pa的结构就是A的布局（就是说用pa只能访问的到bB对象的前两项，访问不到第三项int b）
那么pa->g()中，编译器知道的是，g是一个声明为virtual的成员函数，并且其入口地址放在表格（不管是vtalbeA表仍是vtalbeB表）的第2项，那么编译器编译这条语句的时候就如是转换：call *(pa->vptr)[1]（C语言的数组索引从0开始哈~）。
这一项放的是B：：g()的入口地址，则就实现了多态。（注意bB的vptr指向的是B的虚表vtableB）
另外要注意的是，如上的实现并非惟一的，C++标准只要求用这种机制实现多态，至于虚指针vptr到底放在一个对象布局的哪里，标准没有要求，每一个编译器本身决定。我以上的结果是根据g++ 4.3.4通过反汇编分析出来的。
二、两种多态实现机制及其优缺点

除了c++的这种多态的实现机制以外，还有另一种实现机制，也是查表，不过是按名称查表，是smalltalk等语言的实现机制。这两种方法的优缺点以下：
（1）、按照绝对位置查表，这种方法因为编译阶段已经作好了索引和表项(如上面的call *(pa->vptr[1]） )，因此运行速度比较快;缺点是：当A的virtual成员比较多（好比1000个），而B重写的成员比较少（好比2个），这种时候，B的vtableＢ的剩下的998个表项都是放Ａ中的virtual成员函数的指针，若是这个派生体系比较大的时候，就浪费了不少的空间。
好比：GUI库，以MFC库为例，MFC有不少类，都是一个继承体系；并且不少时候每一个类只是一、2个成员函数须要在派生类重写，若是用Ｃ＋＋的虚函数机制，每一个类有一个虚表，每一个表里面有大量的重复，就会形成空间利用率不高。因而ＭＦＣ的消息映射机制不用虚函数，而用第二种方法来实现多态，那就是：
（２）、按照函数名称查表，这种方案能够避免如上的问题；可是因为要比较名称，有时候要遍历全部的继承结构，时间效率性能不是很高。（关于MFC的消息映射的实现，看下一篇文章）
３、总结：
若是继承体系的基类的virtual成员很少，并且在派生类要重写的部分占了其中的大多数时候，用C++的虚函数机制是比较好的；可是若是继承体系的基类的virtual成员不少，或者是继承体系比较庞大的时候，并且派生类中须要重写的部分比较少，那就用名称查找表，这样效率会高一些，不少的GUI库都是这样的，好比MFC，QT
PS 其实，自从计算机出现以后，时间和空间就成了永恒的主题，由于二者在98%的状况下都没法协调，此长彼消；这个就是计算机科学中的根本瓶颈之所在。软件科学和算法的发展，就看能不能突破这对时空权衡了。呵呵
何止计算机科学如此，整个宇宙又未尝不是如此呢？最基本的宇宙之谜，仍是时间和空间~

16进制转字符串数组基本思路是这样子的，也考到了

#include<iostream>
using namespace std;

int strOne(char * dest, char *src){
int x,y;
dest[0] = '0';
dest[1] = 'x';
x = (int)src[0] / 16;
y = (int)src[0] % 16;
dest[2] = (x>=10)?('A'+x-10):('0'+ x);
dest[3] = (y>=10)?('X'+y-10):('0'+ y);
}
int main(int argc, char* argv[])
{
char ss[2]={0x11,0x22};
char pp[100] = {0};
strOne(pp,ss);
cout<<pp<<endl;
system("PAUSE");
return 0;
}

在平常工做中经常要进行字符串的复制工做，而strcpy是你们经常使用的字符串复制函数，如今要详细地说明这个函数可能带来的错误，并给个人使用心得。

首先，看看MSDN怎么说：

strcpy

原型：char *strcpy(char *dest,char *src);

用法：#include <string.h>

功能：把src所指由NULL结束的字符串复制到dest所指的数组中。

说明：src和dest所指内存区域不能够重叠且dest必须有足够的空间来容纳src的字符串。

返回指向dest的指针。

strcpy只是复制字符串，但不限制复制的数量。很容易形成缓冲溢出，也就是说，不过dest有没有足够的空间来容纳src的字符串，它都会把src指向的字符串所有复制到从dest开始的内存，举例说明：

容易形成的后果。