virtual的限制1

虚析构函数

静态动态（早绑定）与动态多态（晚绑定）

多态定义

纯虚函数

静态多态（早绑定）：在运行前，编译阶段就已确定要调用哪个函数，很早就把函数编译进去。 动态多态（晚绑定）：不同对象，下达相同指令，产生不同动作。前提：以封装与继承为基础。至少要两个类，父类与子类，用三个类时，动态多态表现地会更明显。

 实现多态的成员函数：用virtual修饰函数，使之成为虚函数。

多态是建立在封装和继承的基础上的，至少有2个类；

用父类的指针指向子类的对象，用父类的指针调用时调用的函数都是父类的计算面积函数

 使用virtual关键字修饰成员函数，使其成为虚函数，在想要实现多态的成员函数前加上关键字，在子类的定义中也加上关键字，不必须，会自动加上，但还是要写

虚函数表

 ——多态的核心 

——C++中实现多态的关键所在

多态就是不同对象对于同一条命令有不同的操作

使用RTTI时需要加上#include<typeinfo>头文件

将多个类共有的特性抽象封装成一个纯虚函数，可以借由全局函数灵活控制调用的是父类子类中的共有函数。

如【飞行能力类】是【飞机类】和【战斗机类】所共有的，既可以由【战斗机类】多重继承【飞机类】->【飞行能力类】，也可以【战斗机】多继承【飞机类】+【飞行能力类】。

如果不把【飞行能力类】抽象成一个独立的类，那么【鸟类】将无法继承【飞行能力类】，得在函数体内重新定义一个【飞行能力类】。

如果还有【苍蝇类】等诸多具有相同能力的类，那么类的声明与定义将变得繁琐和冗杂，不利于程序的编写和阅读。

可以视为对人类世界抽象概念的具体化。比如【战斗】【飞行】【表演】【学习】【繁衍】等等。

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义动物类：Animal
 * 虚函数：eat()
 * 纯虚函数：move()
 * 数据成员：m_strName
 */
class Animal
{
public:
    // 默认构造函数
    Animal(){};
    // 含参构造函数
	Animal(string name){m_strName = name; cout << "Animal" << endl;}
    // 虚析构函数
	virtual ~Animal(){cout << "~Animal" << endl;}
    // 虚成员函数
	virtual void eat(){cout << "Animal--" << m_strName << "-- eat" << endl;}
    // 纯虚函数
	virtual void move() = 0；
public:
    // 数据成员
	string m_strName;
};

/**
 * 定义狗类：Dog
 * 公有继承动物类
 * 虚成员函数：eat()、move()
 */
class Dog : public Animal
public:
    // 默认构造函数
    Dog(){};
    // 含参构造函数
	Dog(string name){m_strName = name; cout << "Dog" << endl;}
    // 虚析构函数
	virtual ~Dog(){cout << "~Dog" << endl;}
    // 虚成员函数eat()
	virtual  void eat(){cout << "Dog--" << m_strName << " -- eat" << endl;}
    // 虚成员函数move()
	virtual void move(){cout << "Dog--" << m_strName << " -- move" << endl;}
public:
    // 数据成员
	string m_strName;
};

int main(void)
{
    // 通过动物类实例化狗类
    Animal *p=new Dog("狗类");
    // 调用成员函数
	p->eat();
    p->move();
    // 释放内存
	delete p;
	p=NULL;
    
	return 0;
}

跟答案 一样为什么运行不了？

注意函数的完整性

 C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型别的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。

 这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。

 比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议

 数下，有virtual修饰=覆盖，无virtual=隐藏