/*
多态分为静态多态和动态多态
    1静态多态：编译时多态，包括函数重载，模板(函数模板和类模板)
    2静态多态：运行时多态，使用指针/引用调用对应类型的虚函数

bark()：常规类内虚函数
bark1()：在类外实现全局重载，使用静态绑定
bark2()：在类外实现全局重载，传入对象地址利用指针实现动态绑定

抽象类：
对于父类的Animal，大部分时候都不是为了让它实现某些操作，而是提供一个通用方法让子类继承重写
比如bark()，因此可以写成纯虚函数的方式，将Animal变为抽象类

注意：抽象类不可以实例化对象，但是可以定义指针/引用变量
    Animal a;           不可以
    Animal* b;          可以
    Animal& c = cat;    可以，但是引用要记得初始化
*/
class Animal  // 拥有纯虚函数就是抽象类，不可实例化
{
protected:
    string _name;
public:
    Animal(string name) :_name(name) {}
    virtual void bark() = 0;  // 在父类中不需要实现bark()，所以直接写成纯虚函数交给子类重写
};

class Cat :public Animal
{
public:
    Cat(string name) :Animal(name) {}
    void bark() { cout << _name << "：喵喵" << endl; }
};
class Dog :public Animal
{
public:
    Dog(string name) :Animal(name) {}
    void bark() { cout << _name << "：汪汪" << endl; }
};
class Pig :public Animal
{
public:
    Pig(string name) :Animal(name) {}
    void bark() { cout << _name << "：哼哼" << endl; }
};

// bark1()
void bark(Cat& cat) { cat.bark(); }  // 类外重载虚函数，并使用指针/引用调用对应类型的函数，也会发生动态绑定
void bark(Dog& dog) { dog.bark(); }  // 但是不符合开-闭原则(对修改关闭，对扩展开放)
void bark(Pig& pig) { pig.bark(); }

// bark2()
void bark(Animal* p) { p->bark(); }  // 类外重载虚函数，被调用时使用父类指针指向子类对象，发生动态绑定

int main()
{
    Cat cat("cat");
    Dog dog("dog");
    Pig pig("pig");

    cout << "======调用类外bark1()======" << endl;
    bark(cat);  // 调用的bark1()
    bark(dog);  // 此时不会调用类内的bark()，因为没有使用指针/引用调用，所以调用的外部bark()
    bark(pig);

    cout << "\n======调用类外bark2()======" << endl;
    bark(&cat);  // 调用的bark2()，实现Animal* p = &cat发生动态绑定
    bark(&dog);  // 注意此时依旧不会调用类内的bark()，因为该处没有发生动态绑定，而是在传参时
    bark(&pig);

    cout << "\n======调用类内bark()=======" << endl;
    //Animal p = new Animal("");  // 抽象类不可实例化
    Animal* p = &cat;           // 但是可以通过指针的方式指向子类对象
    p->bark();  // 正常调用类内bark()

    return 0;
}

需要注意的例子

class Car
{
protected:
    string _name;
    int _oil;  // 油量
    virtual int getMilesPerOil() = 0;  // 油耗函数
public:
    Car(string name, int oil) :_name(name), _oil(oil) {}
    string getName()const { return _name; }

    int getMiles()  // 油量还能行驶多少距离，普通函数但里面有虚函数
    {
        return _oil * getMilesPerOil();  // 因为有虚函数，发生动态绑定
        // 成员变量有个隐藏的this指针，所以是this->getMilesPerOil()
    }
};

class Audi :public Car
{
public:
    Audi(string name, int oil) :Car(name, oil) {}
    int getMilesPerOil() { return 20; }
};
class Bnze :public Car
{
public:
    Bnze(string name, int oil) :Car(name, oil) {}
    int getMilesPerOil() { return 19; }
};
class BMW :public Car
{
public:
    BMW(string name, int oil) :Car(name, oil) {}
    int getMilesPerOil() { return 18; }
};

void getInfo(Car& car)  // 给外界提供一个同一接口获取Car的信息
{
    cout << car.getName() << " 可用公里数：";
    cout << car.getMiles() << endl;
    // 此时调用的是Car父类的普通函数，静态绑定
}

int main()
{
    Audi a("奥迪", 10);
    Bnze b("奔驰", 10);
    BMW c("宝马", 10);

    getInfo(a);  // 10*20
    getInfo(b);  // 10*19
    getInfo(c);  // 10*18
    /*
    实现流程：
        1在全局函数getInfo中传入Car& tmp = a;静态绑定
        2调用父类普通函数getMiles()
        3getMiles()中含有虚函数this->getMilesPerOil()，发生动态绑定
            调用对应子类的oil和name和虚函数
    */
    return 0;
}