现在整理出来,希望可以记住这个。
重载
函数的名称一样,但是参数不同,就是重载;
函数的名称知道了,但是编译的时候不知道调用哪个函数,重载决议;根据参数决定到底应该调用哪个函数;
区别就是:调用的参数不一样;
覆盖
对于非虚函数,子类和基类同名(不管参数),那么就是导致覆盖;
如果参数完全一样,那么会完全覆盖,只会留下子类的函数;如果参数不一样,那么父类的会保留到子类中;
// =========================================
// 覆盖
#include <iostream>
#include <string>
using namespace std;
class A {
public:
void print(string &str) {
cout << str << endl;
}
void fun(int a, int b) {
cout << "A:a+b=" << a + b << endl;
}
};
class B : public A {
public:
// B会完全继承A的print函数
// B的fun函数 覆盖了A的fun
void fun(int a, int b) {
cout << "B:a*b=" << a*b << endl;
}
};
int main() {
A a;
B b;
//a 调用A::fun
a.fun(1, 2);
// b 调用B::fun
b.fun(2, 3);
// a 指定调用A::fun
b.A::fun(3, 4);
a.print("1234444");
b.print("8888888");
return 0;
}
输出结果:
多态
通过虚函数实现多态;对于同名函数,基类的指针指向子类的时候,如果是虚函数,会调用子类的函数;
#include <iostream>
#include <string>
using namespace std;
// =====================================
// 多态
class A {
public:
void print(string str) {
cout << "调用了A::" << str << endl;
}
virtual void fun(int a, int b) {
cout << "A:a+b=" << a + b << endl;
}
};
class B : public A {
public:
void print(string str) {
cout << "调用了B::" << str << endl;
}
// B的fun函数 覆盖了A的fun
virtual void fun(int a, int b) {
cout << "B:a*b=" << a*b << endl;
}
};
int main() {
A a;
B b;
a.fun(1, 2);
b.fun(2, 3);
a.print("1234444");
b.print("8888888");
//虚函数调用
A* p = &a;
// 此处调用了A::print
p->print("p->print(str)");
// 此处调用了A::fun
p->fun(10, 12);
p = &b;
// 此处调用了A::print
p->print("p->print(str)");
// 此处调用了B::fun
p->fun(10, 12);
return 0;
}
输出结果: