多态前序（虚函数）

//多态
#include<iostream>
#include<string>
using namespace std;
//继承
#if 0
class Animal
{
public:
    Animal(string name);
    void say();
protected:
    string m_name;
};
Animal::Animal(string name):m_name(name){}
void Animal::say()
{
    cout << m_name << ":$%#*&^%$" << endl;
}
//派生类
class Dog:public Animal
{
public:
    Dog(string name);
    void say();
};
Dog::Dog(string name):Animal(name){}
void Dog::say()
{
    cout << m_name << ":狗叫" << endl;
}
int main()
{
    Animal* p = new Animal("动物");
    p->say();//$%#*&^%$        
    delete p;
    p = new Dog("狗");//因为Dog中有个animal对象
    p->say();//$%#*&^%$             基类指向继承类 访问范围会缩小还是在基类   调用看指针类型 p的类型为Animal
    delete p;
    p = NULL;
    //编译器通过指针调用函数是根据指针类型调用
    /*
    直观上认为，指针指向派生类对象，就应该使用派生类成员，符合人类思维
    但是，本例结构说明，基类指针p指向派生类Dog的对象时候，调用的是Dog的成员变量，但是没有使用他的成员函数
    狗直接发出动物叫声
    */
    return 0;
}//基类指针指向子类对象 皆然性 缩小访问范围是安全的  继承
#endif
#if 0
class Animal
{
public:
    Animal(string name);
    //成员函数前加关键字virtual,该函数称为虚函数
    virtual void say();//返回类型、函数名、参数表完全一样 基类声明成虚函数 子类相同函数原形的函数也会变成虚函数
    void eat()
    {
        cout << m_name << "$%^&*(" << endl;
    }
protected:
    string m_name;
};
Animal::Animal(string name) :m_name(name) {}
void Animal::say()
{
    cout << m_name << ":$%#*&^%$" << endl;
}
//派生类
class Dog :public Animal
{
public:
    Dog(string name);
    //子类成员函数和基类的虚函数都具有相同的函数原型 ，该成员函数也就是虚函数，无论其是否带有virtual关键字，都对基类虚函数构成覆盖(重写)
    void say();//受到基类虚函数影响 变成虚函数
    void eat()
    {
        cout << m_name << "eat骨头" << endl;
    }
};
class Cat :public Animal
{
public:
    Cat(string name);
    //子类成员函数和基类的虚函数都具有相同的函数原型 ，该成员函数也就是虚函数，无论其是否带有virtual关键字，都对基类虚函数构成覆盖(重写)
    void say();//受到基类虚函数影响 变成虚函数
    void eat()
    {
        cout << m_name << "eat 鱼" << endl;
    }
};
Dog::Dog(string name) :Animal(name) {}
void Dog::say()
{
    cout << m_name << ":狗叫" << endl;
}
Cat::Cat(string name) :Animal(name) {}
void Cat::say()
{
    cout << m_name << ":猫叫" << endl;
}
int main()
{
    Animal* p = new Animal("动物");
    p->say();//$%#*&^%$        
    p->eat();
    delete p;
    p = new Dog("狗");//因为Dog中有个animal对象
    p->say();//$%#*&^%$             基类指向继承类 访问范围会缩小还是在基类   调用看指针类型 p的类型为Animal
    p->eat();
    delete p;
    p = NULL;
    p = new Cat("猫");
    p->say();
    p->eat();
    delete p;
    p = NULL;
    /*
    将基类中的say()声明成虚函数

    使用虚函数，基类指针（基类引用）会调用根据实际指向类型来分别调用不同的函数
    这种现象就是多态
    基类引用不像指针一样灵活，指针可以改指向，引用只能引用固定对象，在多态性方面缺乏表现性
    */
    //基类指针（基类引用）会调用根据指针类型来调用
    //基类指针（基类引用）调用虚函数是根据实际指向类型调用
    return 0;
}
#endif //虚函数解决上面的问题  
#if 1
//单态 一个函数对应一个功能
int add(int x, int y)
{
    return x + y;
}
int mul(int x, int y)
{
    return x * y;
}
int divi(int x, int y)
{
    return x / y;
}
int sub(int x, int y)
{
    return x - y;
}
//多态 一个函数实现加减乘除功能
int calc(int x, int y, int(*fun)(int, int))
{
    return fun(x, y);
}
int main()
{
    cout << calc(1, 2, add)<<endl;
    cout << calc(6, 2, sub) << endl;
}
#endif //多态函数