C++之多态使用小结

点云实验室lab

已于 2024-07-14 16:03:25 修改

阅读量882

点赞数 11

分类专栏： C++ 文章标签： c++ 多态继承面向对象

于 2024-07-13 18:27:45 首次发布

本文链接：https://blog.csdn.net/qq_32867925/article/details/140402987

版权

C++ 专栏收录该内容

40 篇文章 2 订阅

订阅专栏

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关键字，在具体实现虚函数方法时不需要添加。

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。那么，在Student构造函数中，使用如下命令，其中Student类的构造函数首先调用基类Person的构造函数来初始化name、age、gender。然后使用初始化列表来分别初始化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 案例一：

下面介绍对这句话的理解：基类的指针引用或者调用调用虚函数。

其可以这样理解：

如果指针指向基类地址，那么将调用基类的虚函数
如果指针指向派生类地址，那么将调用派生类中重写的虚函数
如果基类中的函数被声明为虚函数，而派生类没有重写这个虚函数，那么当通过指向派生类对象的指针调用这个虚函数时，将调用基类中定义的版本

#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