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

科大讯飞C++面经


一面

虚函数

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

#include <iostream>
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 <iostream>
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 <iostream>
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<iostream>
#include<string>
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;
}
  1. 取出字符串中连续重复的字符,只保留一个
#include<iostream>
#include<string>
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;
}

推荐阅读更多精彩内容