安阳网络公司佛山网站建设优化制作公司
重载和重写的区别
重载是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
char* p = (char*)malloc(100);