C++之多态使用小结

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