1.什么是多态

生活中的多态，是指的客观的事物在人脑中的主观体现。例如，在路上看到⼀只哈士奇，你可以看做是哈士奇，可以看做是狗，也可以看做是动物。主观意识上的类别，与客观存在的事物，存在 is a 的关系的时候，即形成了多态。
在程序中，⼀个类的引用指向另外⼀个类的对象，从而产生多种形态。当⼆者存在直接或者间接的继承关系时，父类引用指向⼦类的对象，即形成多态。
多态是面向对象三⼤特性之⼀，记住继承是多态的前提，如果类与类之间没有继承关系，也不会存在多态。

2.多态的分类

c++⽀持编译时多态(静态多态)和运行时多态(动态多态)，运算符重载和函数重载就是编译时多态，而派生类和虚函数实现运行时多态。
静态多态和动态多态的区别就是函数地址是早绑定(静态联编)还是晚绑定(动态联编)。如果函数的调用，在编译阶段就可以确定函数的调用地址，并产生代码，就是静态多态(编译时多态)，就是说地址是早绑定的。而如果函数的调用地址不能编译不能在编译期间确定，而需要在运行时才能决定，这这就属于晚绑定(动态多态,运行时多态)。

3.对象转型

对象转型是指将一个类的对象视为另一个类的对象的过程。在C++中，对象转型主要涉及到向上转型和向下转型两种操作。

3.1 向上转型：

向上转型是将派生类的对象引用或指针赋给基类的引用或指针的操作。这是一个安全的操作，因为派生类的对象可以视为基类的对象，但只能访问基类中的成员。向上转型的目的通常是实现多态性。

示例：
class Animal {
public:
    void speak() {
        cout << "Animal speaks." << endl;
    }
};

class Dog : public Animal {
public:
    void speak() {
        cout << "Dog barks." << endl;
    }
};

int main() {
    Dog myDog;
    Animal& myAnimal = myDog; // 向上转型
    myAnimal.speak(); // 输出 "Animal speaks."
    return 0;
}
在这个示例中，myDog 是一个 Dog 类的对象，但通过向上转型，我们可以将它视为一个 Animal 类的对象。

3.2 向下转型：

向下转型是将基类的对象引用或指针转换为派生类的对象引用或指针的操作。这是一个潜在的危险操作，因为编译器不能保证基类对象实际上是一个派生类对象。因此，在执行向下转型之前，通常需要进行类型检查，以确保安全。

示例：
class Animal {
public:
    virtual void speak() {
        cout << "Animal speaks." << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks." << endl;
    }
};

int main() {
    Animal myAnimal;
    Dog* myDog = dynamic_cast<Dog*>(&myAnimal); // 向下转型，需要使用 dynamic_cast 并进行类型检查
    if (myDog) {
        myDog->speak(); // 输出 "Dog barks."
    } else {
        cout << "Conversion failed." << endl;
    }
    return 0;
}
在这个示例中，我们使用 dynamic_cast 进行向下转型，并在转型之前进行了类型检查，以确保安全地调用 speak 函数。

4.虚函数

C++动态多态性是通过虚函数来实现的，虚函数允许⼦类（派⽣类）重新定义父类（基类）成员函数，而子类（派生类）重新定义父类（基类）虚函数的做法称为覆盖(override)，或者称为重写。对于特定的函数进行动态绑定，C++要求在基类中声明这个函数的时候使用virtual关键字，动态绑定也就对virtual函数起作用。

1.为创建⼀个需要动态绑定的虚成员函数，可以简单在这个函数声明前⾯加上virtual关键字，定义时候不需要.
2.如果⼀个函数在基类中被声明为virtual，那么在所有派生类中它都是virtual的.
3.在派生类中virtual函数的重定义称为重写(override).
4.virtual关键字只能修饰成员函数.
5.构造函数不能为虚函数

class Animal {
public:
	// 将需要动态绑定的函数定义为虚函数
	virtual void bark() {
		cout << "Animal Bark" << endl;
	}
};
class Dog : public Animal {
public:
	// 在⼦类中重写虚函数
	void bark() override {
		cout << "Dog Bark" << endl;
	}
};
int main() {
	// 将Dog对象转成⽗类的对象
	// 这⾥是向上转型
	Dog dog;
	Animal& animal = dog;
	// 向上转型后的对象调⽤⽗类中的函数
	dog.bark();
	animal.bark();
	return 0;
}