继承与多态（多态）-优快云博客

本文链接：https://blog.youkuaiyun.com/sswithyou/article/details/142213681

一多态的定义及实现

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了

Person。Person对象买票全价，Student对象买票半价。

那么在继承中要构成多态还有两个条件：

1. 必须通过基类的指针或者引用调用虚函数

2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

举个例子吧

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);
	return 0;
}

！：在重写基类虚函数时，派生类的虚函数在不加 virtual 关键字时，虽然也可以构成重写 ( 因

为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性 ), 但是该种写法不是很规范，不建议这样使用

虚函数重写的两个例外：

1. 协变(基类与派生类虚函数返回值类型不同)

class B :public A
{};
class Person {
public:
	virtual A* f() { return new A; }
};
class Student : public Person {
public:
	virtual B* f() { return new B; }
};

我们Person和Student返回的类型是一个子类一个父类，这样的叫做协变，这样也是符合虚函数重写的

2. 析构函数的重写(基类与派生类析构函数的名字不同)

class Person {
public:
 virtual ~Person() {cout << "~Person()" << endl;}
};
class Student : public Person {
public:
 virtual ~Student() { cout << "~Student()" << endl; }
};

我们在写代码的时候，看到的是不一样的类不同的析构函数，但是c++做了统一处理，编译后析构函数的名称统一处理成destructor，所以只是我们看到函数名字不一样，但实际上也没有改变这个规则，函数名字还是一样的。

二 重载、覆盖 ( 重写 ) 、隐藏 ( 重定义 ) 的对比

我们每个都举个例子

重写：

double add(double a,double b)
{
	return  a + b;
}
int add(int a, int b)
{
	while (b != 0) 
	{
		int tep = a ^ b;
		b = (a & b) << 1;
		a = tep;
	}
	return a;
}
int main()
{
	double a = 10.2,b=2.3;
	int x = 2, y = 3;
	cout << add(a, b) << endl;
	cout << add(x, y) << endl;
	return 0;
}

重定义：

class A
{
public:
	void Print()
	{
		cout << a << endl;
	}
	
private:
	int a=10;
};
class B:public A
{
public:
	int Print()
	{
		cout << b << endl;
		return 0;
	}
	string b="11111";
};
int main()
{
	A a;
	a.Print();
	B b;
	b.Print();
	return 0;
}

三 抽象类

1 概念

在虚函数的后面写上 =0 ，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口

类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生

类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

class Car
{
public:
	virtual void Drive() = 0;
};
class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};
void Test()
{
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
}
int main()
{
	Test();
	return 0;
}

我们可以看到虚函数是不能实例化出对象的，我们想要通过它调用对应对象的函数，我们需要用到指针的方式

四多态的原理

1.函数表