c++多态

//动态多态，静态多态
//这里我们希望传入那个对象就调用哪个对象的函数
//函数地址在编译阶段就能确定，叫静态联编
//函数地址在运行阶段才能确定，叫动态编边
//动态满足条件：1继承关系2子类重写父类中虚函数
//多态使用：父类指针或引用指向子类对象
//重写：完全一致
//class animal {
//    public:
//        virtual    void speak() { //写上virtual就是虚函数，编译器在编译时就不能确定函数调用，不加的话，会直接确定，即说动物在说话
//            cout << "动物在说话" << endl;
//        }
//};
//
//class cat: public animal {
//    public:
//        void speak() {
//            cout << "cat在说话" << endl;
//        }
//};
//
//class dog: public animal {
//    public:
//        void speak() {
//            cout << "dog在说话" << endl;
//        }
//};
//
//void dospeak(animal &animal) {
//    animal.speak();
//}
//
//int main () {
//    cat cat;
//    dospeak(cat);//隐含animal &animal=cat
//    dog dog;
//    dospeak(dog);
//}

//案例，多态写计算器
//class AbstractCalculator {
//    public:
//        virtual int getresult() {
//            return 0;
//        }
//        int m_num1;
//        int m_num2;
//};
//
加法计算器
//class addclaculator: public AbstractCalculator {
//    public:
//        int getresult() {
//            return m_num1 + m_num2;
//        }
//};
//
//class subclaculator: public AbstractCalculator {
//    public:
//        int getresult() {
//            return m_num1 - m_num2;
//        }
//};
//
//class mulclaculator: public AbstractCalculator {
//    public:
//        int getresult() {
//            return m_num1 * m_num2;
//        }
//};
//
使用条件：父类指针指向子类对象
//int main () {
//    //加法
//    AbstractCalculator *abc = new addclaculator; //new创建堆区，手动开辟手动释放
//    abc->m_num1 = 10;
//    abc->m_num2 = 10;
//    cout << abc->m_num1 << "+" << abc->m_num2 << "=" << abc->getresult() << endl;
//    delete abc;
//    //减法
//    abc = new subclaculator;
//    abc->m_num1 = 10;
//    abc->m_num2 = 10;
//    cout << abc->m_num1 << "-" << abc->m_num2 << "=" << abc->getresult() << endl;
//    delete abc;
//    //乘法
//    abc = new subclaculator;
//    abc->m_num1 = 10;
//    abc->m_num2 = 10;
//    cout << abc->m_num1 << "*" << abc->m_num2 << "=" << abc->getresult() << endl;
//    delete abc;
//
//}

//纯虚函数,为多态而生
//class Base {
//    public:
//        //纯虚函数,只要有一个纯虚函数叫做抽象类
//        //抽象类特点1无法实例化对象,比如
//        //Base b;   new Base;
//        //2,抽象类子类必须重写父类中纯虚函数，否则也是纯虚函数，会报错
//        virtual void func() = 0; //加virtual
//};
//
//class son: public Base {
//    public:
//        virtual void func() {
//            cout << "func()函数调用" << endl;
//        };
//};
//
//int main() {
    son s;
//    Base *base = new son;
    Base *base=NULL;    base=new son;上面一行代码的等价
//    delete base;
//    base->func();
//}

//案例2，制作饮品（子类分到咖啡于茶叶）
//class drink {
//    public:
//        virtual void boilwater() = 0;
//        virtual void incup() = 0;
//        virtual void putsome() = 0;
//        void makedrink() {
//            boilwater();
//            incup();
//            putsome();
//            //    makedrink();加上这一行就循环往复
//        }
//
//};
//
//class coffee: public drink {
//    public:
//        virtual void boilwater() {
//            cout << "煮农夫山泉" << endl;
//        }
//        virtual void incup() {
//            cout << "倒入杯子" << endl;
//
//        }
//        virtual void putsome() {
//            cout << "加奶，糖" << endl;
//        }
        virtual void makedrink() {
            void boilwater();
            void incup();
            void putsome();
            void makedrink();

        }
//};
//
//class tea: public drink {
//    public:
//        virtual void boilwater() {
//            cout << "煮泉水" << endl;
//        }
//        virtual void incup() {
//            cout << "倒入茶杯" << endl;
//
//        }
//        virtual void putsome() {
//            cout << "加柠檬" << endl;
//        }
        virtual void makedrink() {
            void boilwater();
            void incup();
            void putsome();
            void makedrink();

        }
//};
//
//void dowork(drink *abs) {
//    abs->makedrink();//接口
//    delete abs;
//}
//
//int main() {
//    dowork(new coffee);
//
//    dowork(new tea);
//    return 0;
//
//}

//虚析构，解决释放父类指针子类对象不干净问题
//如果子类没有堆区开辟的数据，可以不写虚析构
//纯虚析构也属于抽象类，无法实例化对象
class Animal {
    public:
        Animal() {
            cout << "animal构造函数调用" << endl;

        }
//        virtual    ~Animal() {//加virtual，成虚析构，解决释放父类指针子类对象不干净问题
//            cout << "animal析构函数调用" << endl;
//
//        }
        virtual~Animal() = 0; //纯虚析构，需要声明也需要实现
        virtual void speak() = 0;//纯虚函数
};

Animal::~Animal() {
    cout << "Animal纯虚析构函数调用" << endl;

}

class cat: public Animal {
    public:
        cat(string name) {
            cout << "cat构造函数调用" << endl;

            m_name = new string(name);
        }
        virtual void speak() {
            cout << *m_name << "小猫在说话" << endl;
        }
        ~cat() {//加virtual，成虚析构，解决释放父类指针子类对象不干净问题
            if (m_name != NULL) {
                cout << "cat析构函数调用" << endl;
                delete m_name;
            }

        }
        string *m_name;
};

int main () {
    Animal *animal = new cat("tom");
    animal->speak();
    delete animal;
}