虚函数

virtual修饰的成员函数就是虚函数，
1.虚函数对类的内存影响：增加一个指针类型大小（32位和64位）
2.无论有多少个虚函数，只增加一个指针类型

虚函数表：指向虚函数的指针(监视的窗口看)
我们自己也可以通过虚函数指针表去访问函数（一般做这样的说数据操作，不写数据类型）

include<iostream>
#include<string>using namespace std;class MM
{
public:virtual void print(){cout << "第一个虚函数" << endl;}virtual void printDate(){cout << "第二个虚函数" << endl;}private:int age;string name;
};
int main()
{cout << sizeof(MM) << endl;system("pause");return 0;
}

抽象类

拥有一个或一个以上的纯虚函数就被叫做抽象类
特点：
1.抽象类不能够创建对象
2.抽象类可以创建对对象指针

纯虚函数

纯虚函数也是一个虚函数，所以也需要virtual来修饰
特点：
1.纯函数没有函数体
所以函数 = 0；

#include<iostream>
#include<string>using namespace std;class MM
{
public:virtual void print() = 0; //纯虚函数private:int age;};
int main()
{//MM mm; //抽象类不能够构造对象MM* pmm = nullptr;return 0;
}

虚析构函数

在析构函数前面加一个virtual

1.当父类指针对子类对象进行初始化的时候，就要用虚析构函数
2.所有析构函数底层解析的话。函数名想相同

include<iostream>
#include<string>using namespace std;class MM
{
public:void print(){cout << "MM" << endl;}~MM(){cout << "MM析构" << endl;}
protected:string M_name;
};class son : public MM
{
public:void print(){cout << "son" << endl;}~son(){cout << "son析构" << endl;}
};int main()
{MM* p = new son; //父类指针，构造子类对象，先构造父类对象，在构造子类的对象delete p;system("pause");return 0;
}

只调用了父类的析构函数，没有调用子类的析构函数，存在内存的泄露。
所以用父类指针初始化子类的对象，必须使用虚虚构函数

#include<iostream>
#include<string>using namespace std;class MM
{
public:void print(){cout << "MM" << endl;}virtual ~MM(){cout << "MM析构" << endl;}
protected:string M_name;
};class son : public MM
{
public:void print(){cout << "son" << endl;}~son(){cout << "son析构" << endl;}
};int main()
{MM* p = new son; //父类指针，构造子类对象，先构造父类对象，在构造子类的对象delete p;system("pause");return 0;
}

多态

多态：在继承中，指针的同一行为的不同结果
多态的概念其实并不重要，重要的是，你需要知道，那个对象指针在特定情况调用那个成员。
实现多态的2个条件
1.必须是public继承
2.必须父类存在virtual类型的成员函数，并且子类中存在该函数的同名函数。
3.一定存在对象的引用

#include<iostream>
#include<string>using namespace std;class MM
{
public:void print(){cout << "MM" << endl;}virtual void printDate(){cout << "virtual printDate" << endl;}virtual ~MM(){cout << "MM析构" << endl;}
protected:string M_name;
};class son : public MM
{
public:void print(){cout << "son" << endl;}void printDate(){cout << "printDate" << endl;}~son(){cout << "son析构" << endl;}
};int main()
{//MM* p = new son; //父类指针，构造子类对象，先构造父类对象，在构造子类的对象//delete p;MM* p = new son;p->print();  // 没有virtual，看指针类型，这里调用的是父类的p->printDate();  //有virtual，看对象，这里调用的是son的p = new MM;  //调用MM 的   这就是多态p->print(); //引用的类型也存在多态MM mm;MM& girl = mm;mm.printDate();system("pause");return 0;
}

虚函数的几个问题

不管被继承几次，父类中有的虚函数，依然存在

#include<iostream>using namespace std;class A
{
public:virtual void print(){cout << "A" << endl;}
};class B : public A
{
public:
};class C : public B
{
public:void print(){cout << "C" << endl;}};int main()
{A* p = new C;p->print();system("pause");return 0;
}

子类实现父类虚函数的同名函数叫做：重写
final :静止重写（子类中不允许存在与之同名的虚函数）
override ：强制重写，起说明作用，表示子类当前是方法是重写父类(就是说明父类中一定存在一个同名的虚函数)，用于子类实现父类的同名虚函数

#include<iostream>using namespace std;class A
{
public:virtual void print() final   //final:静止重写,子类中不能够存在同名函数{}virtual void printDate(){}};class B : public A
{
public:void printDate() override // 强制重写，起说明作用，表示子类当前是方法是重写父类(就是说明父类中一定存在一个同名的虚函数){}
};
int main()
{system("pause");return 0;
}

纯虚函数和ADT

ADT：抽象数据类型
注意：抽象类本身不能够创建对象，但是抽象类的子类可以创建对象
抽象类，一般用于架构项目，构建好整个项目模块，具体的细致工作，交给子类去实现

采用ADT的方式设计项目，可以把这个模块构建出来，并且测试代码也可以提前完成。