2017江汉大学紫龙互娱招生面试题

基础能力

一。英语翻译，给出了两段unity官网的新手指引的英文（翻译难度大致如下） 。例如 ：

Use the Unity Editor to create 2D and 3D games, apps and experiences. (Download the Editor atunity3d.com.)

The Unity User Manual helps you learn how to use the Unity Editor and its associated services. You can read it from start to finish, or use it as a reference.

译文：使用unity编辑器创建2D,3D游戏，应用与 体验。（在unity3d.com下载编辑器）

Unity 用户手册可以帮助你学会如何使用unity编辑器及其相关服务。你可以从头到尾阅读，也可以使用它作为参考

This section of the documentation contains details of the scripting API that Unity provides. To use this information, you should be familiar with the basic theory and practice of scripting in Unity which is explained in theScripting section of our manual.

译文：本节文档包含了unity提供的脚本API的详细细节。为了 使用这个信息，你应该熟悉unity脚本编程的基本理论与实践，这在我们手册的脚本部分有解释。

英文段落中除了有少数单词比较陌生外，翻译基本没有什么难度。

二。基础数学题。

某一飞船由静止沿着某一方向做变加速直线 运动，其加速度为10m/3次方s*t,问飞船10s能飞行多远距离？

解：该题 考察的是数学知识与物理场景的结合，主要考察重积分的计算。

算法与数据结构

三。面向对象基础编程

1.下列变量所占内存空间大小分别是多少字节 ？

    char *s=str[7];
    int *p;
    char   c[6];
    int m;
    void *q 

    答： 
    sizeof(s)=4 ;
    sizeof(p)=4;
    sizeof(c)=6;
    sizeof(m)=4;
    sizeof(q)=4;
    归纳：指针变量的大小实际 是有 cpu的寻址位数决定，不等同于cpu字长，寻址位数取决于当前 cpu运行的模式 及其本身特性，通常为4个字节 

2.c++中static关键字的作用有哪些？

1.修饰全局变量时，用于限制该全局变量的使用范围。仅能在本文件内使用该变量。

2.修饰局部变量时，用于修改该变量的存储控件类型。普通局部变量存储在栈区，当函数执行结束后，就会被清空。静态局部变量存储在静态区，当函数执行结束后，不会被清空。下次再次执行函数时，能保持上一回的值。

3.修饰成员变量或者函数时，用于修改该函数的使用方法。静态成员变量和静态成员函数不属于某一个对象，而是属于整个对象。可以使用类名::成员/方法 的方式进行使用。

3.Overload与override的区别 ？

Overload(重载)：在C++程序中，可以将语义、功能相似的几个函数用同一个名字表示，但参数或返回值不同（包括类型、顺序不同），即函数重载。
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。

Override(覆盖)：是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。

Overwrite(重写)：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

4.如何防止内存泄漏 ？

1.用完的内存及时回收 
2.空指针指向NULL
3.尽量安全的内存访问函数
4.优化代码减少递归层次
5.数组下标访问提高警惕

5.C++中继承方式的区别？

    public 共有继承：在派生类中，基类的公有成员和保护成员被继承后分别作为派生类的共有成员与保护成员，这样使得派生类的成员函数可以直接访问他们，而派生类成员函数无法直接访问基类的私有成员。在类的外部，派生类对象可以访问继承下来的公有成员.

    protected  保护继承：在派生类中，基类的公有成员和保护成员作为派生类的保护成员，派生类的成员函数可以直接访问他们，而派生类成员函数无法直接访问基类的私有成员。在类外部，派生类的对象无法访问基类的所有成员。

    private 私有继承:在派生类中，基类的公有成员和保护成员作为派生类的私有成员，派生类的成员函数可以直接访问他们，而派生类成员函数无法直接访问基类的私有成员。在类外部，派生类的对象无法访问基类的所有成员。

6.在STL容器中，vector与list有什么区别？

在STL中vector与list均为顺序容器，即线性结构。

vector：向量，按需收缩数组，物理上采用顺序存储，在对其尾部插入删除元素，以及访问元素的时间复杂度是恒定的。

list：双向链表，每个结点均含有两个指针域，物理上采用链式存储结构，在对其插入删除元素时间复杂度是恒定的，而访问中间元素则是线性的。

7.hashtable的实现 原理是什么？

    散列表（Hash table，也叫哈希表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
    给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

四。编程题

1.给定数组A={6，3，4，10，7，2}，对于数组中给定的元素A[P]与 A[Q],P<Q,记A[Q]-A[P]的值为 diff，求A[Q]与A[P]差的最大值，即diff-MAX。（本题中 diff-MAX=A[3]-A[1]=7）

#include<iostream>
using namespace std;
int main()
{
    int A[]={6,3,4,10,7,2};//初始数组
    int  diff=A[1]-A[0]; //初始最大差
    for(int i=0;i<5;i++) //顺序取出一个元素
    {
        for(int j=i+1;j<6;j++)//与后面所有元素比较
        {
            int tmp=A[j]-A[i];
            if(tmp>diff) //如果大于diff则更新最大值
                diff=tmp;   
        }
    }
    cout<<diff; //输出结果 
} 

此题比较简单，主要就是考察简单的迭代求最值

2.编程实现strcpy函数，函数原型为 char* strcpy(char* strDest, const char* strSrc)

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

注意：判断字符串是否结束，我们通常是判断*p==’\0’来确定的，这不同于线性表判断节点是否为空p==NULL，同时母的字符指针要以 ‘\0’结尾，此函数不安全可能会发生越界。

3.编写算法实现二叉树节点统计，已知数据结构
typedef struct Node{
struct Node* left;
struct Node* rifht;
}Node,*Root;

//任选一种遍历方式即可。这里我采用先序遍历
int n=0;//n 用于计数
int GetCounts(Root root)  
{   
    if(root!=NULL)//如果不为空
    {
        n++; //计数+1
        GetCounts(root->left);//遍历左子树
        GetCounts(root->right);//遍历右子树  
    }
}

4.实现String类成员函数
class String
{
public:
String(const char *str = NULL); //通用构造函数
String(const String &str); //拷贝构造函数
~String(); //析构函数
private:
char* m_data;
}

 String::String(const char *str)//通用构造函数
{
    if (!str)
    {
        m_data = new char[1];
        *m_data = '\0';
    }
    else
    {
        m_data = new char[strlen(str)+1];
        strcpy(m_data, str);
    }
}
String::String(const String &str)//拷贝构造函数
{
    m_data = new char[strlen(str)+1];
    strcpy(m_data, str);
}
String::~String()//析构函数
{
    delete []m_data;
    m_data=NULL;
}

5.八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。请编写程序解决八皇后问题。

//八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。
//该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。
//请编写程序解决八皇后问题。

#include<iostream>
#include<cmath>
using namespace std;
int x[8]={0}; //八个皇后的位置数组
int s=0;      //记录解法
int num=8;    //皇后数量
int  count=0;
int  count1=0; 
int  count2=0;
//检测能否放置，t代表第t+1个皇后  
bool CanPlace(int t)
{
    count1++;
    for(int i=0;i<=t-1;i++)
    {   count2++;
        //如果出现列相同或者在一条对角线上（行默认不同） 
        if(x[i]==x[t]||(abs(x[i]-x[t])==abs(i-t)))
            return false;
    }
    //可以放置 
    return true;
}
//放置第t+1个皇后,t从0开始
void BackTrack(int t)
{
    count++;
    //成功放置8个皇后 
    if(t>=num)
    {
        s++;
        for(int i=0;i<num;i++)
        {
            cout<<x[i]<<" ";
        }
        cout<<endl;
    }
    else
    {
        //由第一列到第8列 
        for(int i=1;i<=num;i++)
        {
            x[t]=i;
            if(CanPlace(t))
                BackTrack(t+1);
        }
    }
}

int main()
{
    BackTrack(0);
    cout<<"共有"<<s<<"种放法"<<endl; 
    cout<<"共执行"<<count-1<<"次递归"<<endl; 
    cout<<"共调用了"<<count1<<"次检测方法"<<endl; 
    cout<<"共进行了"<<count2<<"次比较"<<endl; 
}

总结：此套试题难度一般，但针对性很强，着重考察了学生的编程思维能力与相关数学基础知识，需要好好复习面向对象编程想。