2018-9-15 科大讯飞C++面经

科大讯飞C++面经

---

一面

虚函数

https://blog.csdn.net/LC98123456/article/details/81143102
https://www.jianshu.com/p/f85bd1728bf0
虚函数是声明时前面加了virtual关键字的函数，作用是实现运行时动态绑定。一般有两种函数会声明为虚函数，一种是基类的析构函数，另一种是在派生类重写了基类的普通成员函数，而且使用了一个基类指针调用该成员函数，要想实现动态绑定派生类对象，则需要将基类的该成员函数声明为虚函数。看下面的两个例子吧。
虚析构函数，可以看我上面的链接，里面有详细解释。

#include 
using namespace std;

class Base
{
public:
    Base()
    {
        cout << "create Base " << endl;
    }
    virtual ~Base()
    {

        cout << "delete Base" << endl;
    }
};
class Inherit :public Base
{
public:
    Inherit()
    {
        cout << "create Inherit" << endl;
    }
    ~Inherit()
    {
        cout << "delete Inherit" << endl;

    }
};
int main()
{
    Base *p;
    p = new Inherit;
    delete p;
    return 0;
}

基类虚成员函数：

#include 
using namespace std;
class A {
public:
    A() {
        ver = 'A';
    }
    void print() const {
        cout << "The A version is: " << ver << endl;
    }
protected:
    char ver;
};


class D1 :public A {
public:
    D1(int number) {
        info = number;
        ver = '1';
    }
    void print() const {
        cout << "The D1 info: " << info << " version: " << ver << endl;
    }
private:
    int info;
};


class D2 :public A {
public:
    D2(int number) {
        info = number;
    }
    void print() const {
        cout << "The D2 info: " << info << " version: " << ver << endl;

    }
private:
    int info;
};

int main() {
    A a;
    D1 d1(4);
    D2 d2(100);

    A *p = &a;
    p->print();
    p = &d1;
    p->print();
    p = &d2;
    p->print();

    system("pause");
    return 0;
}

The A version is: A
The A version is: 1
The A version is: A

我们先看上述代码，派生类中重新定义了基类中的函数，我们在使用一个基类指针指向派生类的时候，本义想要调用派生类中的重定义函数，但是由于基类中此函数不是虚函数，因此指针会静态绑定此函数，结果就不是我们的本意。而如果我们将基类中的方法改成虚函数，如下：

#include 
using namespace std;
class A {
public:
    A() {
        ver = 'A';
    }
    virtual void print() const {
        cout << "The A version is: " << ver << endl;
    }
protected:
    char ver;
};


class D1 :public A {
public:
    D1(int number) {
        info = number;
        ver = '1';
    }
    void print() const {
        cout << "The D1 info: " << info << " version: " << ver << endl;
    }
private:
    int info;
};


class D2 :public A {
public:
    D2(int number) {
        info = number;
    }
    void print() const {
        cout << "The D2 info: " << info << " version: " << ver << endl;
    }
private:
    int info;
};

int main() {
    A a;
    D1 d1(4);
    D2 d2(100);

    A *p = &a;
    p->print();
    p = &d1;
    p->print();
    p = &d2;
    p->print();

    system("pause");
    return 0;
}

The A version is: A
The D1 info: 4 version: 1
The D2 info: 100 version: A

可以看到，将基类方法改成虚函数，那么就会动态绑定，在运行时才决定调用哪个函数。

补充：上面函数后面有个const修饰，表示该成员函数不能修改任何成员变量，除非成员变量用mutable修饰。const修饰的成员函数也不能调用非const修饰的成员函数，因为可能引起成员变量的改变。
mutalbe的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词。在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量(mutable只能由于修饰类的非静态数据成员)，将永远处于可变的状态，即使在一个const函数中。
详见 https://www.cnblogs.com/xkfz007/articles/2419540.html

纯虚函数

https://blog.csdn.net/qq_36221862/article/details/61413619
纯虚函数的声明：
virtual 函数类型 函数名 （参数表列） = 0；
一般用于抽象类中，抽象类不可用于实例化。

面向对象三大特性

封装，继承，多态

指针和引用的区别

引用是一个变量的别名，不能为空，必须在声明的时候初始化，而且之后不能修改为其他的变量的别名；
指针的值是一块内存的地址，可以为空，可以先声明后初始化，后面可以修改其指向的内存地址。

STL中vector和list

https://www.cnblogs.com/shijingjing07/p/5587719.html
vector是一片连续的内存空间，相当于数组。随机访问方便，插入和删除效率低。
list是不连续的内存空间，是双向链表。随机访问效率低，插入和删除方便。

统计一个班级成绩（整数）及对应的人数，按照从大到小的顺序输出

成绩是整数，可以用一个一定长度的数组统计每个分数的人数，然后逆序输出。

冒泡排序

常考题

---

二面

STL中vector和list

继续一面的问题，但是考了vector如果满了然后还要插入怎么解决。

指针和引用

手写代码

1. 字符串变成整型数字
   剑指offer原题

#include
#include
using namespace std;

int StrToInt(string str) {
    
    if (!str.size()) return 0;
    int s = 1;
    long long res = 0;
    if (str[0] == '-') 
        s = -1;
    
    for (int i = (str[0] == '-' || str[0] == '+') ? 1 : 0; i < str.size(); ++i) {
        if (!('0' <= str[i] && str[i] <= '9')) return 0;
        res = res * 10 + str[i] - '0';
    }
    return res * s;
}
int main() {
    string str;
    getline(cin, str);
    cout << StrToInt(str) << endl;
    return 0;
}

2. 取出字符串中连续重复的字符，只保留一个

#include
#include
using namespace std;
//输入一串字符串，将其中连续重复的字符保留其中一个，如aabbccbc，保留abcbc

string func(string arr) {

    char* p1 = &arr[0];
    char* p2 = &arr[1];
    while (*p2 != '\0') {
        if (*p2 == *p1) {
            *p2 = '\0';
            p2++;
        }
        else {
            p1++;
            *p1 = *p2;
            *p2 = '\0';
            p2++;
        }
    }
    return arr;
}

int main() {
    string str;
    cin >> str;
    cout << func(str);

    system("pause");
    return 0;
}