c++那些事儿4.0 多态

 多态: 向不同对象发送一个消息，不同的对象接收会产生不同的行为。
   a.静态多态性。
     函数重载，最经典就是构造函数重载。
     运算符重载，最典型的是“<<”。
   b.动态多态性。
     不在编译时确定那个函数，而是在程序运行时动态确定所针对的对象。
     通过虚函数实现，即在函数前加上virtual。 // 感觉这样更明显,java覆盖加上override，也是很方便的。
     如果不采用虚函数，是同名覆盖原则。
 虚函数：
     c. 在基类用virtual声明为虚函数，在类外定义时，不必加上virtual。
     d. 定义一个指向基类的指针变量，并使她指向同一族需要调用该函数的对象。
     e. 通过指针调用此虚函数，此时调用的就是指针变量指向对象的同名函数。
     f. 虚析构函数。 //c++没有 gc机制，所以回收空间，防止内存溢出也很重要的。
     g. 纯虚函数。 //提供接口的作用。
         // 形式  virtual 函数类型  函数名(参数列表)=0;
抽象类：
     h.不能生产对象。
     i. 凡是包含纯虚函数类都是抽象类。

#include<iostream>
#include<string>
using namespace std;

class Person {
public:
    virtual  void display() = 0;
};

class Student:public Person {
 protected:
     string name;
     int age;
public:
    Student() {  //设置无参构造，便于子类的构造函数初始化。
        cout << "Student默认的无参构造" << endl;
    }
    Student(string name, int age);  //构造函数重载，静态多态性
    virtual void display();
    virtual ~Student() {
        cout << "student destructor" << endl;
    }

};

 Student::Student(string name, int age) {
     this->name = name;
     this->age = age;
}
 void Student::display() {
     cout << "student=" << "[" << name << "," << age <<"]"<< endl;
 }

 class Graduate :public Student {
 private:
     string gradu_School;
 public:
     Graduate(string name, int age, string nastu, int agestu, string  gradu_School);
     Graduate(string name, int age,string  gradu_School);
     void display();
     Graduate() {

     }
     ~Graduate() {
         cout << "Graduate destructor" << endl;
     }
    
 };

 Graduate::Graduate(string name, int age, string nastu, int agestu, string  gradu_School) :Student(nastu, age)
 {
     this->name = name;
     this->age = age;
     this->gradu_School = gradu_School;
 }
 Graduate:: Graduate(string name, int age, string  gradu_School) {
     this->name = name;
     this->age = age;
     this->gradu_School = gradu_School;
 }
 void Graduate::display() {
     cout << "Graduate=" << "[" << name << "," << age<<"," << gradu_School << "]" << endl;
 }

int main() {
    
    Student stu("张三", 222);
    Student *st;
    st = &stu;
    st->display();
    cout << "----------------------------------" << endl;
    Graduate gra("李四", 333,"王五",444, "家里蹲大学"),*g;
    g = &gra;
            //Graduate的display对 Student进行了覆盖。
    g->display();  //调用了Graduate的display。
    g->Student::display(); //拿域作用符指定，但是这不方便。
    cout << "----------- 多态-----------------------" << endl;
    /*
        多态，需要借助虚函数 。
       // java中把子类对象赋值给基类对象，向上转型，不用强制转换。
      // java中 函数会override，实现了多态，要调用父类方法采用 super。
      //c++有指针，实现这个必须通过指针和虚函数。把子类的地址赋值给基类的地址,实现动态多态。
    */

    st->display(); //这是调用student的方法。
    st = g;  //指向Graduate，就可以调用Graduate的函数了。
    st->display(); 
    cout << "----------- 不用指针，采用向上转型,好像不行啊！-----------------------" << endl;
    stu = gra;
    stu.display();
 

    cout << "------------------------析构函数" << endl;
    Student *s = new Graduate;  //new开辟动态空间。
    delete s;

    system("pause");
    return 0;
}

结果.PNG

如果不采用虚析构函数，情况

没有虚析构函数.PNG

采用了虚析构函数

采用虚析构函数.PNG

  窗外下起了雨，心情大好，我喜欢雨.

c++从入门到放弃，有从放弃到入门