重载覆盖多态和虚函数

现在整理出来，希望可以记住这个。

重载

函数的名称一样，但是参数不同，就是重载；
函数的名称知道了，但是编译的时候不知道调用哪个函数，重载决议；根据参数决定到底应该调用哪个函数；
区别就是：调用的参数不一样；

覆盖

对于非虚函数，子类和基类同名（不管参数），那么就是导致覆盖；
如果参数完全一样，那么会完全覆盖，只会留下子类的函数；如果参数不一样，那么父类的会保留到子类中；

// =========================================
// 覆盖

#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;

    }

输出结果：