1、多态定义
1.1 多态概念
C++多态性（Polymorphism）是面向对象编程(OOP)的一个重要特性之一，它允许我们使用统一的接口来处理不同类型的对象。多态性使得程序更加灵活、可扩展并且易于维护。
通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
1.2 多态的构成条件
多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。对于同一行为买票（BuyTicket）比如，由于Student继承了Person。Person对象买票全价，Student对象买票半价。
在继承中要构成多态还有两个条件：
- 必须通过基类的指针或者引用调用虚函数。
- 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2、多态的使用
2.1 虚函数
构成多态的条件中提到了虚函数，所谓的虚函数，就是被virtual修饰的类成员函数。具体如下，函数BuyTicket(）即为虚函数。其中只要在申明时添加virtual关键字，在具体实现虚函数方法时不需要添加。
class Person {
public:
virtual void BuyTicket();
};
void Person::BuyTicket()
{
cout << "买票-全价" << endl;
}2.2 虚函数的重写
虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。我们看如下例子派生类Student对虚函数BuyTicket() 进行了重写。
class Person {
public:
virtual void BuyTicket();
};
void Person::BuyTicket()
{
cout << "买票-全价" << endl;
}
class Student : public Person {
public:
void BuyTicket();
};
void Student::BuyTicket()
{
cout << "买票-半价" << endl;
}3、多态练习
3.1 派生构造函数使用
派生函数在使用基类中成员变量的同时，再添加成员变量，这种情况用法可参考如下案例。基类Person中包括成员变量：name、age、gender。派生类Student又添加成员变量：id、score。那么，在构造函数中，使用如下命令，其中name、age、gender为继承People，id、score为赋值。
Student::Student(string name, int age, string gender, string id, int score) : People(name, age, gender), id(id), score(score)
{}#include <iostream>
#include<string>
using namespace std;
class People
{
public:
People();
People(string name, int age, string gender);
~People();
void PrintInfo();
public:
string name;//姓名
int age;//年龄
string gender;//性别
};
People::People(string name, int age, string gender)
{
this->name = name;
this->age = age;
this->gender = gender;
}
void People::PrintInfo()
{
cout << "name :" << this->name << endl;
cout << "age :" << this->age << endl;
cout << "gender :" << this->gender << endl;
}
People::People()
{
}
People::~People()
{
}
class Student :public People
{
public:
Student();
Student(string name, int age, string gender, string id, int score);
~Student();
void PrintInfo();
public:
string id;
int score;
};
Student::Student(string name, int age, string gender, string id, int score) : People(name, age, gender), id(id), score(score)
{}
void Student::PrintInfo()
{
cout << "name :" << this->name << endl;
cout << "age :" << this->age << endl;
cout << "gender :" << this->gender << endl;
cout << "id :" << this->id << endl;
cout << "score :" << this->score << endl;
}
Student::Student()
{
}
Student::~Student()
{
}3.2 案例一：
下面介绍对这句话的理解：基类的指针引用或者调用调用虚函数。
其可以这样理解：
（1）如果指针指向基类地址，那么只能访问基类的虚函数
（2）如果指针指向派生类地址，那么只能访问派生类中与基类对应的函数
#include <iostream>
#include<string>
using namespace std;
class Person
{
public:
virtual void BuyTicket()
{
cout << "买票-全价" << endl;
}
};
class Student : public Person
{
public:
virtual void BuyTicket()
{
cout << "买票-半价" << endl;
}
};
void Func(Person& p)
{
p.BuyTicket();
}
int main()
{
Person ps;
Student st;
Func(ps);
Func(st);
system("pause");
return 0;
}上述代码构成了多态吗？首先是虚函数BuyTicket()，其次完成了重写。结果如下，原因是ps对应的是基类指针，因此只能访问基类的BuyTicket()函数；而st对应的是派生类指针，因此访问派生类的BuyTicket()函数。
3.3 案例二：
#include <iostream>
#include<string>
using namespace std;
class A
{
public:
virtual void func(int val)
{
cout << "A->" << val << std::endl;
}
};
class B : public A
{
public:
virtual void func(int val)
{
cout << "B->" << val << std::endl;
}
};
int main()
{
A* p = new B;
p->func(1);
system("pause");
return 0;
}上述的代码调用构成多态吗？首先是虚函数func()，其次完成了重写上述代码中，p指针是指向派生类B地址，因此，只能访问B对应的func()函数，是B->1
3.4 案例三：
#include <iostream>
#include<string>
using namespace std;
class A
{
public:
virtual void func(int val = 1)
{
std::cout << "A->" << val << std::endl;
}
virtual void test()
{
func();
}
};
class B : public A
{
public:
void func(int val = 0)
{
cout << "B->" << val << std::endl;
}
};
int main(int argc, char* argv[])
{
B*p = new B;
p->test();
system("pause");
return 0;
}在 B 类的 func 函数中，有一个默认参数值为 0，这意味着当 test 函数被调用时，它会使用这个默认值。然而，test 函数中有一个显式的调用 func()，这意味着它会调用 B 类中的 func 实现，并传递参数 1
参考博客：
