错题精解

牛客网基础题总结。

目录

内容

编程语言(C++)" class="reference-link">编程语言(C++)

Q 1 :

题目：
    以下代码：
    class ClassA{
    public:
        virtual ~ClassA(){};
        virtual void FunctionA(){};
    };
    class ClassB{
    public:
        virtual void FunctionB(){};
    };
    class ClassC:public ClassA, public ClassB{
        public:
    };
    ClassC Object;
    ClassA* pA = &Object;
    ClassB* pB = &Object;
    ClassC* pC = &Object;
    关于pA,pB,pC的取值,下面的描述中正确的是:
答案:
    pA和pB不相同
解答:
    考察多继承且有虚函数情况下C++存储对象模型。
    1. 多继承按继承顺序组织对象模型，有虚函数时低地址包含指向虚函数表的指针。
    2. 对象Object的存储模型：类A虚函数表指针(ptrA) | 类A数据 | 类B虚函数表指针(ptrB) | 类B数据 | 类C数据。
    3. 子类的虚函数被放到了第一个基类的虚函数表最后（ptrA指向的虚函数表结构：类A虚函数 | 类C虚函数）。
    4. 有虚函数的继承，对象地址为指向虚函数表的指针的地址，即pC = &Object = &ptrA。
    6. pC = pA = &ptrA = &Object，(pC = pA) < pB。

Q 2 :

题目：
    下列程序的输出结果：
    #include <iostream>
    using namespace std;
    class A{
    public:
        void print(){
            cout << "A:print()";
        }
    };
    class B:private A{
    public:
        void print(){
          cout << "B:print()";
        }
    };
    class C:public B{
    public:
       void print(){
            A::print();
        }
    };
    int main(){
        C b;
        b.print();
    }
答案:
    编译出错
解答:
    考察C++继承问题。
    1. 类B私有继承类A。
    2. 私有继承：类A的公有成员和保护成员都作为类B的私有成员，并且不能被类B的子类（如类C）所访问。

Q 3 :

题目：
    下面两个结构体：
    struct One{
        double d;
        char c;
        int i;
    }
    struct Two{
        char c;
        double d;
        int i;
    }
    在#pragma pack(4)和#pragma pack(8)的情况下，结构体的大小分别是：
答案:
    16，16
    16，24
解答:
    考察结构体对齐。
    1. 4字节对齐：Struct One[8 + (1 + 3(pading)) + 4], struct Two[(1 + 3(pading)) + 8 + 4]。
    2. 8字节对齐：Struct One[8 + (1 + 3(pading) + 4)], struct Two[(1 + 7(pading)) + 8 + (4 + 4(pading))]。
    3. 一句话总结：按序存储，装得下尽量装，装不下换一行。

Q 4 :

题目：
    下列代码的输出为：
    #include "iostream"
    #include "vector"
    using namespace std;
    int main(void)
    {
        vector<int>array;
        array.push_back(100);
        array.push_back(300);
        array.push_back(300);
        array.push_back(500);
        vector<int>::iterator itor;
        for(itor = array.begin(); itor != array.end(); itor++){
            if(*itor == 300){
                itor = array.erase(itor);
            }
        }
        for(itor = array.begin(); itor != array.end(); itor++){
            cout << *itor << " ";
        }
        return 0;
    }
答案:
    100
    300
    500
解答:
    考察STL中erase和迭代器问题。
    1. erase返回值是一个迭代器，指向删除元素下一个元素。
    2. 删除第一个300时返回指向下一个300的迭代器，在循环体又被再加了一次，跳过了第二个300。

Q 5 :

题目：
    下面程序的输出是什么？
    int main(void)
    {
        int a[5] = {1, 2, 3, 4, 5};
        int *ptr = (int *)(&a + 1);
        printf("%d,%d", *(a + 1), *(ptr - 1));
        return 0;
    }
答案:
    2
    5
解答:
    1. a表示数组首元素的地址，对a的所有操作均是以一个元素为单位的。
    2. &a表示整个数组的地址，对&a的所有操作均是以一个数组为单位的。
    3. ptr类型为int *，所有对ptr的所有操作均是以int大小为单位进行的。
    4. (int *)(&a + 1)表示指向a数组最后一个元素后一个字节的int类型指针，*(ptr - 1)表示向前移动一个int类型的数据的位置。
    5. 所有指针类型操作先看右侧是以什么为单位，之后再转换为左侧定义的单位。

Q 6* :

题目：
    32位机上根据下面的代码，问哪些说法是正确的？
    signed char a = 0xe0;
    unsigned int b = a;
    unsigned char c = a;
答案:
    b的十六进制表示是：0xffffffe0
解答:
    考察有符号数和无符号数之间的转换。
    1. a : 1110 0000。
    2. 扩展问题：
        长 -> 短：低位对齐，按位复制。
        短 -> 长：符号位扩展。
    3. 精度提升：
        两个变量运算，表示范围小的变量精度达的变量提升（signed -> unsigned）。

Q 7 :

题目：
    下列代码的输出为：
    int* pint = 0;
    pint += 6;
    cout << pint << endl;
答案:
    24
解答:
    考察指针运算。
    1. 变量pint为指向int类型的指针，这里“+1”表示地址加4（pint值加4）。
    2. 变量pint初值为0，pint + 6后pint的值变为24。

Q 8 :

题目：
    如果两段内存重叠，用memcpy函数可能会导致行为未定义。而memmove函数能够避免这种问题，下面是一种实现方式，请补充代码。
    #include <iostream>
    using namespace std;
    void* memmove(void* str1, const void* str2, size_t n)
    {
        char* pStr1 = (char*) str1;
        const char* pStr2 = (const char*)str2;
        if( ){
            for(size_t i = 0;i != n; ++i){
                *(pStr1++) = *(pStr2++);
            }
        }
        else{
            pStr1 += n - 1;
            pStr2 += n - 1;
            for(size_t i = 0; i != n; ++i){
                *(pStr1--) = *(pStr2--);
            }
        }
        return ( );
    }
答案:
    pStr1 < pStr2
    str1
解答:
    1. 逐字符自动不存在内存覆盖问题。

Q 9 :

题目：
    设x、y、t均为int型变量，则执行语句：t = 3; x = y = 2; t = x++ || ++y; 后，变量t和y的值分别为：
答案:
    t = 1
    y = 2
解答:
    考察逻辑短路和运算符优先级。
    1*. =的优先级最低，t = (x++ || ++y) = 1。
    2. x++和++y为或关系，因为x++的值非0，所以++y不执行，y不变。

Q 10 :

题目：
    指出下面程序哪里可能有问题？
    class CBuffer
    {
        char * m_pBuffer;
        int m_size;
    public:
        CBuffer(){
            m_pBuffer = NULL;
        }
        ~CBuffer(){
            Free();
        }
        void Allocte(int size) (1) {
            m_size = size;
            m_pBuffer = new char[size];
        }
    private:
        void Free(){
            if(m_pBuffer! = NULL) (2){
                delete[] m_pBuffer;
                m_pBuffer = NULL;
            }
        }
    public:
        void SaveString(const char* pText) const (3){
            strcpy(m_pBuffer, pText); (4)
        }
        char* GetBuffer() const{
            return m_pBuffer;
        }
    };
    void main (int argc, char* argv[])
    {
        CBuffer buffer1;
        buffer1.SaveString("Microsoft");
        printf(buffer1.GetBuffer());
    }
答案:
    1
    3
    4
解答:
    考察动态分配空间等周边细节处理。
    1. 分配内存时, 未检测m_pBuffer是否为空, 容易造成内存泄露。
    2. 常成员函数不应该对数据成员做出修改, 虽然可以修改指针数据成员指向的数据, 但原则上不应该这么做。
    3*. 字符串拷贝时, 未检测是否有足够空间, 可能造成程序崩溃。

Q 11 :

题目：
    某32位系统下, C++程序，请计算sizeof 的值：
    char str[] = "http://www.xxxxx.com";
    char *p = str;
    int n = 10;
    sizeof(str) = (1);
    sizeof(p) = (2;
    sizeof(n) = (3);
    void Foo(char str[100]){
        sizeof(str) = (4);
    }
    void *p = malloc(100);
    sizeof(p) = (5);
答案:
    21
    4
    4
    4
    4
解答:
    考察sizeof返回值。
    1. 具体类型，返回该类型所占的空间大小。
    2. 对象，返回对象的实际占用空间大小。
    3. 数组，返回编译时分配的数组空间大小（数组名 ≠ 指针）。作为参数时数组退化为指针。
    4. 指针，返回存储该指针所用的空间大小。
    5. 函数，返回函数的返回类型所占的空间大小。函数的返回类型不能是void。
    6. 上题中(2)(4)(5)均为指针。

Q 12* :

题目：
    在C++中，
    const int i = 0;
    int *j = (int *) &i;
    *j = 1;
    printf("%d, %d", i, *j);
    输出是多少？
答案:
    0
    1
解答:
    考察C++常量折叠。
    1. const变量放在编译器的符号表中，计算时编译器直接从表中取值，省去了访问内存的时间，从而达到了优化。
    2. 结论，const变量通过取地址方式可以修改该地址存储的数据值，但不能修改常量的值。

Q 13 :

题目：
    下列代码的输出为：
    class parent{
    public:
        virtual void output();
    };
    void parent::output(){
        printf("parent!");
    }
    class son : public parent{
    public:
        virtual void output();
    };
    void son::output(){
        printf("son!");
    }
    son s;
    memset(&s, 0, sizeof(s));
    parent& p = s;
    p.output();
答案:
    没有输出结果，程序运行出错。
解答:
    考察memset和虚函数指针。
    1. 虚函数表地址被清空。

Q 14 :

题目：
    有哪几种情况只能用intialization list而不能用assignment？
答案*:
    当类中含有const成员变量；基类无默认构造函数时，有参的构造函数都需要初始化表；当类中含有reference成员变量。
解答:
    1. 见答案。

Q 15 :

题目：
    对以下数据结构中data的处理方式描述正确的是：
    struct Node{
        int size;
        char data[0];
    };
答案:
    编译器会认为这就是一个长度为0的数组,而且会支持对于数组data的越界访问。
解答:
    考察柔性数组。
    1*. 柔性数组，作为占位符放在结构体末尾，使得结构体的大小动态可变，在声明结构体变量的时候可根据需要动态分配内存。
    2. 长度为0的数组并不占用空间，因为数组名本身不占空间，它只是一个偏移量， 数组名这个符号本身代表了一个不可修改的地址常量。
    3. 常用于网络通信中构造不定长数据包，不会浪费空间浪费网络流量。

Q 16 :

题目：
    给定3个int类型的正整数x，y，z，对如下4组表达式判断正确的选项：
    int a1 = x + y - z; int a2 = x - z + y;
    int b1 = x * y / z; int b2 = x / z * y;
    int c1 = x << y >> z; int c2 = x >> z << y ;
    int d1 = x & y | z; int d2 = x | z & y;
答案:
    a1一定等于a2
解答:
    考察对变量运算原理的了解。
    1. 加减操作虽然可能出现溢出，但相同操作数的不同顺序只是中间结果不同，最终结果相同。
    2. int类型做除法可能会造成截断，比如3/2 = 1。
    3. 移位运算可能会丢弃超出的位数。有符号数二进制数1111 1111，先左移2位再右移三位为1111 1111，反之1111 1100。

Q 17 :

题目：
    若有以下定义和语句：
    char s1[] = "12345", *s2 = "1234";
    printf("%d\n", strlen(strcpy(s1, s2)));
    则输出结果是：
答案:
    4
解答:
    考察strcpy和strlen。
    1. 首先strlen得到的是'\0'之前的字符长度。
    2. strcpy将s2指向的字符串'1234\0'全部拷贝到s1指向位置并覆盖其'12345'部分。

Q 18 :

题目：
    以下函数用法正确的个数是：
    void test1(){
        unsigned char array[MAX_CHAR + 1], i;
        for(i = 0;i <= MAX_CHAR; i++){
            array[i] = i;
        }
    }
    char *test2(){
        char p[] = "hello world";
        return p;
    }
    char *p = test2();
    void test3(){
        char str[10];
        str++;
        *str = '0';
    }
答案:
    0
解答:
    考察数组名和指针区别。
    1. i的范围有可能超过unsigned char范围。
    2. 这里char p[] = "hello world"是数组，该数组是临时变量，函数结束后不能继续使用。
    3. 如果为char *p = "hello world"，这里p是指针并指向常量区字串，虽然p会被销毁，但字符串仍然在，就不会出问题。
    4. 这里str是数组名，数组名是常量，不可以自增，正确的操作是char *p = str; p++; *p = '0'。

Q 19 :

题目：
    假设在一个32位little endian的机器上运行下面的程序，结果是多少？
    #include <stdio.h>
    int main(){
        long long a = 1, b = 2, c = 3;
        printf("%d %d %d\n", a, b, c);
        return 0;
    }
答案:
    1
    0
    2
解答:
    考察小端法及printf输出控制符。
    1. long long占8字节。
    2. 小端表示，低字节在低位，最低4字节为1，接下来四字节为高位部分的0，再接下来4字节为第二个数低位的2。
    3. printf的控制符相当于分配好待打印容器大小，这里"%d %d %d"就分配了12字节，分别装入三个8字节元素，只装入一半。

Q 20 :

题目：
    请选择下列程序的运行结果:
    #include<iostream>
    using namespace std;
    class B0{
    public:
        virtual void display(){
            cout << "B0::display0" << endl;
        }
    };
    class B1:public B0{
    public:
        void display(){
            cout << "B1::display0" << endl;
        }
    };
    class D1: public B1{
    public:
        void display(){
            cout << "D1::display0" << endl;
        }
    };
    void fun(B0 ptr){
        ptr.display();
    }
    int main(){
        B0 b0;
        B1 b1;
        D1 d1;
        fun(b0);
        fun(b1);
        fun(d1);
    }
答案:
    B0::display0
    B0::display0
    B0::display0
解答:
    1. 这里传递的是对象本身而非指针，对象被直接转为基类对象，调用基类的函数。
    2. 如果要实现虚函数动态绑定需要将B0 ptr改为B0* ptr，ptr->display()。
    3. 对象的形参传递需要先使用拷贝构造函数（默认）生成B0类型的临时变量，只拷贝基类部分数据（只有指向基类虚函数表的虚函数指针）。

Q 21 :

题目：
    i的初始值为0，i++在两个线程里面分别执行100次，能得到最大值是()，最小值是()。
答案:
    200
    2
解答:
    考察多线程操作同一未上锁变量。
    1. 每次都准确加1，结果为最大，200。
    2. 结果为2时步骤：
        a取内存0到寄存器，b取内存0到寄存器；
        a执行99次并写入内存，内存值为99；
        b执行1次并写入内存，内存值被覆盖为1；
        a取内存1到寄存器，b取内存1到寄存器；
        b执行99次并写入内存，内存值为100；
        a执行1次，写入内存，覆盖之前的100，值为2。
    3. 每次计算过程必须是先从内存取数然后计算，之后再重新写入内存。但对各个线程而言，取数和计算中间可以被另一个线程打断。

Q 22 :

题目：
    char fun(char x, char y){
        if(x)
            return(y);
    }
    int main(){
        int a = '0', b = '1', c = '2';
        printf("%c\n", fun(fun(a, b), fun(b, c)));
    }
答案:
    2
解答:
    1. 均为字符，非布尔值的0，所以每次返回后者。

Q 23 :

题目：
    当一个类A中没有声明任何成员变量与成员函数,这时sizeof(A)的值是多少？
答案:
    1
解答:
    1. 一个空类对象的大小是1byte。这是被编译器安插进去的一个字节，这样就使得这个空类的两个实例得以在内存中配置独一无二的地址。

Q 24 :

题目：
    有以下程序：
    #include<stdio.h>
    #include<stdlib.h>
    void fun(int *pl, int *p2, int *s){
        s = (int*)calloc(1, sizeof(int));
        *s = *pl + *p2;
        free(s);
    }
    int main(){
        int a[2] = {1, 2}, b[2] = {40, 50}, *q = a;
        fun(a, b, q);
        printf("%d\n", *q);
    }
答案:
    1
解答:
    考察形参不改变变量值问题。
    1. p是指针变量，但是是值传递，其值(指向数组a首元素的地址)并没有改变。
    2. 通过解引用*p才是数组a的地址，才能改变数组a的值。

Q 25* :

题目：
    在32位操作系统gcc编译器环境下，下面程序的运行结果为：
    #include <iostream>
    using namespace std;
    class A{
    public:
        int b;
        char c;
        virtual void print(){
            cout << "this is father’s fuction! " << endl;
        }
    };
    class B: A{
    public:
        virtual void print(){
            cout << "this is children’s fuction! " << endl;
        }
    };
    int main(int argc, char * argv[]){
        cout << sizeof(A) << " " << sizeof(B) << endl;
        return 0;
    }
答案:
    12
    12
解答:
    考察结构体对齐及虚继承和虚函数继承的区别。
    1. A的大小包括本身的虚函数指针及定义的变量。
    2. B的大小包括本身的虚函数指针和继承自A的变量b和c。
    3. 如果是虚继承，则B的大小会增加4字节，增加的内容为指向虚继承的指针。

Q 26 :

题目：
    有如下语句序列：
    char str[10]；
    cin >> str；
    当从键盘输入"I love this game"时，str中的字符串是:
答案:
    I
解答:
    1*. cin遇空格，结束输入。

Q 27 :

题目：
    阅读下面代码，程序会打印出来的值是：
    #include <stdio.h>
    void f(char** p){
        *p += 2;
    }
    int main(){
        char *a[] = {"123", "abc", "456"}, **p;
        p = a;
        f(p);
        printf("%s\r\n", *p);
    }
答案:
    3
解答:
    1. p的类型为char **，(*P)的类型为char *。
    2. p原本指向字符串"123"。
    3. *p是char *类型的，*p + 2表示指向第一个字符串第三个字符。
    4. p是char **类型的，p + 2表示只想第三个字符串，*(p + 2) = "456"。
    5. p的值是*p的地址，虽然p是形参本身值未变，但*p的值在调用函数中被改变。

Q 28 :

题目：
    下列对函数double add(int a, int b)进行重载，正确的是：
答案:
    int add(int a, int b, int c)
    int add(double a, double b)
    double add(double a, double b)
解答:
    考察重载概念。
    1. 在使用重载时只能通过相同的方法名，不同的参数形式实现。
    2. 不同参数形式包括：
        参数类型不同（至少有一个）
        参数个数不同
        *如果同时在类中，对于函数名相同的const函数和非const函数能够构成重载
    3. 编译器区分重载函数是通过“返回类型 + 函数名 + 参数列表”重新改写函数名还区分重载函数的，但返回值类型在C++中并不作为重载标记。

Q 29 :

题目：
    在linux gcc下，关于以下代码，正确的是：
    std::string& test_str(){
        std::string str = "test";
        return str;
    }
    int main(){
        std::string& str_ref = test_str();
        std::cout << str_ref << std::endl;
        return 0;
    }
答案:
    编译警告
    返回局部变量的引用,运行时出现未知错误
    把代码里的&都去掉之后,程序可以正常运行
解答:
    考察调用函数返回值和变量生命周期问题。
    1. 返回值为局部变量时可以正确运行。
    2. 返回值为指针时，看指针指向的变量实体定义的位置，如果是定义在栈上的变量则会出错，指向静态区则不会有问题。
    3. 引用返回的是局部变量本身，而不是复制一份再返回，所以结果难以预料。
    4. 如果去掉&，string类会调用复制构造函数，形同局部变量返回，可以正常运行。

Q 30 :

题目：
    下面有关继承、多态、组合的描述，说法错误的是：
答案:
    继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展
    覆盖是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同
解答:
    考察继承、多态概念。
    1. 父类只有非private的部分才能被子类继承访问。
    2. 重载（overload）：函数名相同 、函数参数不同、 必须位于同一个域（类）中。
    3. 覆盖（override）：函数名相同 、函数参数相同、 分别位于派生类和基类中（虚函数）。

Q 31 :

题目：
    分析一下这段程序的输出：
    #include<iostream>
    using namespace std;
    class B{
    public:
        B(){
            cout << "default constructor" << " ";
        }
        ~B(){
            cout << "destructed" << " ";
        }
        B(int i):data(i){
            cout << "constructed by parameter" << data << " ";
        }
    private:
        int data;
    };
    B Play(B b){
        return b;
    }
    int main(int argc, char *argv[]){
        B temp = Play(5);
        return 0;
    }
答案:
    constructed by parameter5
    destructed
    destructed
解答:
    考察赋值运算顺序以及拷贝构造函数。
    1. B temp = Play(5)从右向左执行。
    2. 先将"5"转为形式参数B的类型，之后调用B(int i)打印"constructed by parameter"。
    3. B temp调用B的默认浅拷贝构造函数，完成赋值，由于拷贝构造函数没有输出，所以没有打印东西。
    4. Play()生命周期结束后，b析构打印"destructed"。
    5. main()生命周期结束后，temp析构打印"destructed"。

Q 32 :

题目：
    int i=10, j=10, k=3;
    k*=i+j;
    k最后的值是？
答案:
    60
解答:
    考察运算符优先级。
    1. +优先级高于*=，等价于k = k * (i +j)。

Q 33 :

题目：
    #include命令的功能是：
答案:
    在命令处插入一个文本文件
解答:
    1. "#include"在命令处插入，插入文本过程为预处理过程。

Q 34 :

题目：
    有一个类A，其数据成员如下：
    class A {
    private:
        int a;
    public:
        const int b;
        float* &c;
        static const char* d;
        static double* e;
    };
    则构造函数中，成员变量一定要通过初始化列表来初始化的是：
答案:
    b
    c
解答:
    考察构造函数初始化列表的使用。
    1. 构造函数中，成员变量一定要通过初始化列表来初始化的有以下几种情况：
        const常量成员：因为常量只能在初始化，不能赋值，所以必须放在初始化列表中。
        引用类型：引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表中。
        没有默认构造函数的类类型：因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数。

Q 35 :

题目：
    在一个64位的操作系统中定义如下结构体：
    struct st_task{
        uint16_t id;
        uint32_t value;
        uint64_t timestamp;
    };
    同时定义fool函数如下：
    void fool(){
        st_task task = {};
        uint64_t a = 0x00010001;
        memcpy(&task, &a, sizeof(uint64_t));
        printf("%11u, %11u, %11u", task.id, task.value, task.timestamp);
    }
    上述fool()程序的执行结果为：
答案:
    1
    0
    0
解答:
    考察结构体对齐。
    1. 假设低地址在低位，最低16 bits被赋给低16位的id变量。
    2. 接下来16 bits的0x0001部分被赋值给了pading部分，没有被使用。
    3. value和timestamp均未被赋值。

Q 36 :

题目：
    在32位系统中：
    char arr[] = {4, 3, 9, 9, 2, 0, 1, 5};
    char *str = arr;
    sizeof(arr) = (1);
    sizeof(str) = (2);
    strlen(str) = (3);
答案:
    8；4；5
解答:
    考察指针和数组名使用sizeof时区别及转义字符。
    1. 数字0对应'\0'。
    2. strlen求字符串长到'\0'前。

Q 37 :

题目：
    下面代码输出什么：
    #include<stdio.h>
    int main( ){
        unsigned int a = 6;
        int b = -20;
        (a + b > 6) ? printf(">6") : printf("<=6");
        return 0;
    }
答案:
    >6
解答:
    考察强制类型转换。
    1. 必须先明确：int与unsigned相加，int -> unsigned int。
    2. int b = -20，首位位"1"，用无符号型表示是非常大的正整数。

Q 38 :

题目：
    对于下面的C语言声明描述正确的一项是:
    char (*p)[16]
答案:
    p是指向长度为16的字符数组的指针
解答:
    考察运算符优先级。
    1. p先和那个运算符结合就是什么。
    2. char *p[16]：p是一个包含16个元素的Char型指针数组，[]优于*，p[]先结合，是数组。
    3. char (*p)[16]：p是一个指针，指向一个包含16个元素的char数组，由于()出现，先和*结合，是指针。

Q 39 :

题目：
    下面程序输出结果是什么：
    #include<iostream>
    using namespace std;
    class A{
    public:
        A(char *s){
            cout << s << endl;
        }
        ~A(){}
    };
    class B:virtual public A{
    public:
        B(char *s1, char*s2):A(s1){
            cout << s2 << endl;
        }
    };
    class C:virtual public A{
    public:
        C(char *s1, char*s2):A(s1){
            cout << s2 << endl;
        }
    };
    class D:public B, public C{
    public:
        D(char *s1, char *s2, char *s3, char *s4):B(s1, s2), C(s1, s3), A(s1){
            cout << s4 << endl;
        }
    };
    int main() {
        D *p = new D("class A", "class B", "class C", "class D");
        delete p;
        return 0;
    }
答案:
    class A
    class B
    class C
    class D
解答:
    考察虚继承的继承顺序。
    1. class B, class C为虚继承。
    2. 虚继承（class 派生类:virtual 继承方式 基类名）：从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝。
    3. 继承顺序：
        执行基类构造函数，多个基类的构造函数按照被继承的顺序构造。
        执行成员对象的构造函数，多个成员对象的构造函数按照声明的顺序构造。
        执行派生类自己的构造函数。
    4. 要执行D构造函数必须先执行参数列表，欲构造B, C必须先构造A，其B, C虚继承A，所以只要执行一次构造函数。

Q 40 :

题目：
    如下程序段：
    char a[] = "xyz", b[] = {'x', 'y', 'z'};
    if(strlen(a) > strlen(b))
        printf("a > b\n");
    else
        printf("a <= b\n");
    则程序输出：
答案:
    a<=b
解答:
    考察对strlen实现的理解。
    1. strlen函数判断字符串长仅仅是通过字符串末的'\0'（字符0）来确定。
    2. 数组b为标识具体'\0'位置，所以使用strlen结果至少大于等于3。

Q 41 :

题目：
    执行以下语句，输出结果为：
    char *p1 = "hello";
    char *p2 = "world";
    char *p3 = "a piece of cake";
    char *str[] = {p1, p2, p3};
    printf("%c", *(str[0] + 1));
答案:
    e
解答:
    考察指针、指针函数及其操作。
    1. str是指针数组，每个元素都是指针。str[0]代表的是char *类型指针p1。
    2. p1是char *类型，只想字符串"hello"，所以这里“+1”代表以字符为单位，结果为'e'。

Q 42 :

题目：
    以下表达式那些会被编译器禁止：
    int a = 248, b = 4;
    int const c = 21;
    const int *d = &a;
    int *const e = &b;
    int const * const f = &a;
答案:
    *c = 32
    *d = 43
    e = &a
    f = 0x321f
解答:
    考察指针常量、常量指针。
    1. 区分是指针的值不会变还是指针指向的变量值不会变。
    2. 方法：
        如果 const 位于 * 的左侧，则 const 就是用来修饰指针所指向的变量，即指针指向为常量。
        如果 const 位于 * 的右侧， const 就是修饰指针本身，即指针本身是常量。
    3. 方法使用：
        int const c -> 变量c的值不可改变。
        const int *d -> const在*左（离指针远），修饰指向的变量 -> 指针d指向的变量不可变。
        int *const e-> const在*右（例指针近），修饰指针 -> 指针e的值不可变。
        int const * const f -> 有左有右 -> 值和指针均不可变。

Q 43 :

题目：
    以下描述正确的是：
答案:
    虚函数不能是内联函数
    父类的析构函数是非虚的，但是子类的析构函数是虚的，delete子类对象指针会调用父类的析构函数
解答:
    1. 虚函数不能是内联函数（编译时展开，必须有实体），不能是静态函数（属于自身类，不属于对象，而虚函数要求有实体），不能是构造函数（尚未建立虚函数表）。
    2. delete子类对象是一定会调用父类的析构函数的先调用子类的析构函数然后调用父类的析构函数。

Q 44 :

题目：
    class Base{
    public:
        Base(){
            Init();
        }
        virtual void Init(){
            printf("Base Init\n");
        }
        void func(){
            printf("Base func\n");
        }
    };
    class Derived: public Base{
    public:
        virtual void Init(){
            printf("Derived Init\n");
        }
        void func(){
            printf("Derived func\n");
        }
    };
    int main(){
        Derived d;
        ((Base *)&d)->func();
        return 0;
    }
答案：
    Base Init
    Base func
解答：
    考察虚函数。
    1. 类Derived继承自Base，先调用基类构造函数Base()，再调用基类的init()，输出Base Init。
        构造子类对象，基类中不会调用子类的虚函数：
            基类构造函数 -> 子类构造函数
            子类还没有构造，还没有初始化，属于未初始化对象
            基类不会去调用子类虚函数（哪怕子类中确实声明为虚函数）
    2. 虽然 ((Base *)&d)->func()是虚函数调用的样子，但func()跟本没有被定义为虚函数，基类指针访问基类的func()。

Q 45 :

题目：
    采用多路复用I/O监听3个套接字的数据时，如果套接字描述符分别是：5,17,19,则：
    select(int maxfd, struct fd_set* rdset, NULL, NULL)
    中的maxfd应取为：
答案:
    20
解答:
     1. maxfd是三个套接字描述符中最大数字加上1。

Q 46 :

题目：
    下面的说法那个正确：
    #define NUMA 10000000
    #define NUMB 1000
    int a[NUMA], b[NUMB];
    void pa(){
        int i, j;
        for(i = 0; i < NUMB; ++i)
            for(j = 0; j < NUMA; ++j)
                ++a[j];
    }
    void pb(){
        int i, j;
        for(i = 0; i < NUMA; ++i)
            for(j = 0; j < NUMB; ++j)
                ++b[j];
    }
答案:
    pb比pa快
解答:
    1. 二维数组操作时，因为缓存的原因，外层放小循环，内层放大循环效率高。
    2. 个人觉得这题是因为在给大数组赋值时会发生缺页，而小数组赋值不会，所以pb比较快。

Q 47 :

题目：
    看以下代码：
    class A{
    public:
        ~A();
    };
    A::~A(){
        printf("delete A");
    }
    class B : public A{
    public:
        ~B();
    };
    B::~B(){
        printf("delete B");
    }
    请问执行以下代码的输出是：
    A *pa = new B();
    delete pa;
答案:
    delete A
解答:
    考察虚析构函数。
    1. 若B *pb = new B()，则本题会同时输出delete A和delete B。
    2. 但如果delete的是一个指向派生类的基类指针，则需要虚构造函数。
    3. 这里基类没有定义虚析构函数，属未定义行为。

Q 48 :

题目：
    下面程序输出结果为？
    #include<iostream.h>
    #define SUB(X,Y) (X)*Y
    int main(){
        int a = 3, b = 4;
        cout << SUB（a++, ++b);
        return 0;
    }
答案：
    15
解答：
    考察宏定义命令和自加运算。
    1. SUB(3++, ++4) = (3++) * ++4 = 3 * 5 =15
    2. 3++是否有括号并不影响，后置自增变量值在本条语句结束前（分号之前）均不改变。
    3. 前置自增值在本条语句内立即改变且自增优先级高于*。

Q 49 :

题目：
    以下代码输出结果为：
    int main(){
        int a[2][5] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
        int *ptr = (int *)(&a + 1);
        printf("%d\n", *(ptr - 3));
    }
答案：
    8
解答：
    考察指针运算。
    1. 首先需要明确a为二维数组，其类型是int **。
    2. 此时对a进行加1操作，操作的单位的每个一维数组。
    3. &a的单位可以理解为int ***，对其操作单位是整个二维数组。
    4. ptr = (int *)(&a + 1)指向的是二维数组后一个单元。
    5. 进行输出操作时，&a + 1被强制转换为int *类型，按四字节读取。
    6. ptr - 3从数组末尾回退3个int大小，指向数字8。

Q 50 :

题目：
    在一台主流配置的PC机上，调用f(35)所需的时间大概是：
    int f(int x){
        int s = 0;
        while(x-- > 0)
            s += f(x);
        return max(s, 1);
    }
答案：
    几分钟
解答：
    考察递归时间复杂度。
    1.   O(f(n)) = O(f(n - 1)) + O(f(n - 2)) + ... + O(f(0))
       = 2*O(f(n - 2)) + 2*(O(f(n - 3)) + ... + 2*O(f(0))
       = 2^35*O(f(0))