美文网首页2018年秋招面经汇总
2018-9-15 科大讯飞C++面经

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

作者: 囊萤映雪的萤 | 来源:发表于2018-11-05 17:23 被阅读0次

    科大讯飞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;
    }
    

    相关文章

      网友评论

        本文标题:2018-9-15 科大讯飞C++面经

        本文链接:https://www.haomeiwen.com/subject/vvmdxqtx.html