当前位置：首页 > news >正文

记录一些面试遇到的问题

news 来源：原创 2025/5/18 13:19:37

重载和重写的区别

重载是overload，覆盖是override
在这里插入图片描述
重载属于编译时多态，覆盖属于运行时多态

运行时多态和编译时多态

运行时多态指的是在运行的时候才知道要调用哪一个函数，编译时多态是指在编译的时候就知道调用哪一个函数。

运行时多态

可以使得父类指针调用子类函数，当然子类指针也可以调用父类函数

#include <iostream>

class Base {
public:
    virtual void show() { std::cout << "Base class" << std::endl; }
};

class Derived : public Base {
public:
    void show() override { std::cout << "Derived class" << std::endl; }
};

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;
    ptr->show();  // 调用 Derived::show()，发生运行时多态
}

by the way，如果代码不慎写为了这样，编译器也不会报错，而是友善提示：
函数 ‘show’ 从类 ‘Base’ 中隐藏了一个非虚拟函数

#include <iostream>

class Base {
public:
    void show() { std::cout << "Base class" << std::endl; }
};

class Derived : public Base {
public:
    void show() { std::cout << "Derived class" << std::endl; }
};

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;
    ptr->show();  // 调用 Derived::show()，发生运行时多态
}

因为在C++ 规定，如果子类定义了与基类同名的函数，则基类中的所有同名函数都会被隐藏（即使参数列表不同）。
那如果有一个需求，首先满足Derived类继承了Base，同时有自己的show函数（参数列表和Base不一样，因此单纯的override是不行的），可以在Derived类里添加一句using Base::show;即可。

class Base {
public:
    virtual void show() { std::cout << "Base class" << std::endl; }
};

class Derived : public Base {
public:
    using Base::show;
    void show(int a)  { std::cout << "Derived class" <<a<< std::endl; }
};

int main() {
    Derived* ptr; //注意这里变为了Derived*
    Derived obj;
    ptr = &obj;
    ptr->show();
    ptr->show(1);
}

如果有对多态学术不精，只记得在虚函数的加持下可以使得父类指针访问子类函数，而将上述代码写为了

    Base* ptr; 
    Derived obj;
    ptr = &obj;
    ptr->show();
    ptr->show(1);

代码是不会通过检查的，因为父类指针可以调用子类的函数，但前提是 这个函数必须在父类中声明为 virtual，这样才能实现运行时多态（动态绑定）。
虽然我们在父类里有show()这个函数，但show(int) 不是 Base 类的虚函数，所以 Base* 看不到 Derived 里的 show(int)，导致编译错误。

编译时多态

特点：

同一作用域内，多个函数同名但参数列表不同（参数个数或类型不同）。
在编译时根据函数调用的参数选择具体的函数（编译器做“名字修饰（Name Mangling）”处理）。
不会引发运行时开销，函数的匹配完全在编译阶段完成。

继承

公有继承

class Base {
public:
    int a;
protected:
    int b;
    
private:
    int c;
};

class Derived : public Base {
    void print(){
        cout<<b;
    }
};

int main() {
    Derived* ptr;
    Derived obj;
    ptr = &obj;
    cout << ptr->a;
}

基类的 public 变成 public，protected 变成 protected，private 仍然是 private。

保护继承

在这里插入图片描述基类的 public 和 protected 变成 protected，private 不可访问。

私有继承

private（私有继承）：基类的 public 和 protected 变成 private，private 不可访问。

多继承下的菱形继承

sizeof

虚函数的size

在这里插入图片描述
输出的结果为：

这是因为虚函数引入了虚表，因此需要额外存储一个虚表指针，64位系统下size = 8B。
如果再加上一个int，则为16（需要做到对齐，因此还补了4B）

多继承的情况下：
输出结果为16，因为继承了A和B，因为有两个虚指针
在这里插入图片描述

普通函数的size

普通函数size = 1

struct的size

struct也要遵循内存对齐，对齐原则是结构体或类的整体大小必须是其最大对齐数的整数倍（最大成员的对齐值）
因此比如

在这里插入图片描述

因为char[]里有一个’\0’，因此size是6

指针与引用

先来个很经典的题

void GetMemory1(char* p){
    p = (char*)malloc(100);
}
void Test1(void){
    char* str =NULL;
    GetMemory1(str);
    strcpy(str,"hello");
    printf(str);
}

int main() {
    Test1();
}

这样会导致程序直接崩溃，原因是GetMemory1传入的函数是指针。注意，这里进行的是值传递，也就是说，我们传入的是str的复制值，因此在GetMemory1里修改p对外面的str没有一点用处。
那么如何修改呢？只需要将GetMemory的参数改为指针的引用 or 指针的指针即可
指针的引用版：

void GetMemory1(char* p){
    p = (char*)malloc(100);
}
void Test1(void){
    char* str =NULL;
    GetMemory1(str);
    strcpy(str,"hello");
    printf(str);
}

int main() {
    Test1();
}

指针的指针版：

void GetMemory1(char** p){
    *p = (char*)malloc(100);
}
void Test1(void){
    char* str =NULL;
    GetMemory1(&str);
    strcpy(str,"hello");
    printf(str);
}

再来个题目

char* GetMemory2(){
    char p[] = "hello";
    return p;
}
void Test2(){
    char* str = NULL;
    str = GetMemory2();
    printf(str);
}

这会导致系统崩溃，因为
char p[] = “hello”; 是一个局部数组，存储在栈上。
当 GetMemory2() 结束后，p 变量的生命周期结束，它所在的栈内存可能被覆盖或释放。
str = GetMemory2(); 让 str 指向了这块无效的内存。
printf(str); 试图访问这块无效的内存，导致未定义行为（Undefined Behavior），可能程序崩溃。
但如果我们修改为，此时内存被分配到堆上，就不会报错了。注意还需要对应的free