1、多态定义
1.1 多态概念
C++多态性(Polymorphism)是面向对象编程(OOP)的一个重要特性之一,它允许我们使用统一的接口来处理不同类型的对象。多态性使得程序更加灵活、可扩展并且易于维护。
通俗来说,就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会 产生出不同的状态。
1.2 多态的构成条件
多态是在不同继承关系的类对象,去调用同一函数,产生了不同的行为。对于同一行为买票(BuyTicket)比如,由于Student继承了Person。Person对象买票全价,Student对象买票半价。
在继承中要构成多态还有两个条件:
- 必须通过基类的指针或者引用调用虚函数。
- 被调用的函数必须是虚函数,且派生类必须对基类的虚函数进行重写。
- 允许通过基类类型的指针或引用来调用派生类中重写(override)的虚函数,其他派生类中有,基类中没有的函数,无法使用。
在C++中,当派生类重写基类中的虚函数时,不需要再次使用 virtual
关键字。虚函数的声明仅需要在基类中出现一次。派生类中的函数如果具有与基类虚函数相同的签名(即相同的函数名、参数列表和返回类型),它将自动被视为对基类虚函数的重写。
如下,Student在继承Person时,对BuyTicket()进行重写,不要添加virtual关键字。
2、多态的使用
2.1 虚函数
构成多态的条件中提到了虚函数,所谓的虚函数,就是被virtual修饰的类成员函数。具体如下,函数BuyTicket()即为虚函数。其中只要在申明时添加virtual关键字,在具体实现虚函数方法时不需要添加。
cpp
class Person {
public:
virtual void BuyTicket();
};
void Person::BuyTicket()
{
cout << "买票-全价" << endl;
}
2.2 虚函数的重写
虚函数的重写(覆盖):派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同),称子类的虚函数重写了基类的虚函数。我们看如下例子派生类Student对虚函数BuyTicket() 进行了重写。
cpp
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。那么,在Student构造函数中,使用如下命令,其中Student类的构造函数首先调用基类Person的构造函数来初始化name、age、gender。然后使用初始化列表来分别初始化id 和 score。
cpp
Student::Student(string name, int age, string gender, string id, int score) : People(name, age, gender), id(id), score(score)
{}
cpp
#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 案例一:
下面介绍对这句话的理解:基类的指针引用或者调用调用虚函数。
其可以这样理解:
- 如果指针指向基类地址,那么将调用基类的虚函数
- 如果指针指向派生类地址,那么将调用派生类中重写的虚函数
- 如果基类中的函数被声明为虚函数,而派生类没有重写这个虚函数,那么当通过指向派生类对象的指针调用这个虚函数时,将调用基类中定义的版本
cpp
#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 案例二:
cpp
#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 案例三:
cpp
#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
参考博客: