C++之多态使用小结

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 案例一:

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

其可以这样理解:

  1. 如果指针指向基类地址,那么将调用基类的虚函数
  2. 如果指针指向派生类地址,那么将调用派生类中重写的虚函数
  3. 如果基类中的函数被声明为虚函数,而派生类没有重写这个虚函数,那么当通过指向派生类对象的指针调用这个虚函数时,将调用基类中定义的版本
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

参考博客:

【1】【C++】多态(举例+详解,超级详细)_c++多态-CSDN博客

相关推荐
UestcXiye1 小时前
《TCP/IP网络编程》学习笔记 | Chapter 3:地址族与数据序列
c++·计算机网络·ip·tcp
霁月风2 小时前
设计模式——适配器模式
c++·适配器模式
jrrz08283 小时前
LeetCode 热题100(七)【链表】(1)
数据结构·c++·算法·leetcode·链表
咖啡里的茶i3 小时前
Vehicle友元Date多态Sedan和Truck
c++
海绵波波1073 小时前
Webserver(4.9)本地套接字的通信
c++
@小博的博客3 小时前
C++初阶学习第十弹——深入讲解vector的迭代器失效
数据结构·c++·学习
爱吃喵的鲤鱼4 小时前
linux进程的状态之环境变量
linux·运维·服务器·开发语言·c++
7年老菜鸡5 小时前
策略模式(C++)三分钟读懂
c++·qt·策略模式
Ni-Guvara5 小时前
函数对象笔记
c++·算法
似霰5 小时前
安卓智能指针sp、wp、RefBase浅析
android·c++·binder