22.多态（上）

解决数据冗余和二义性用的virtual和这里的virtual没有关系，一语两用。

cpp 复制代码

class Person
{
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

class Student : public Person {
public:
	virtual void BuyTicket() { cout << "买票-打折" << endl; }
};
int main()
{
}

你有个虚函数我有个虚函数，这两个还满足三同

感受一下条件，必须是基类的指针和引用，按照继承的角度有个切片和切割，赋值兼容规则，指针或者引用，可以传基类过去或者子类派生类，指向谁调用谁，多态就是多种形态

父类的指针，如果没提多态的概念，我们认为调用的都是父类的buyticket，由调用类型决定的，跟你指向的对象没关系，现在跟类型没关系，指向谁调用谁。

如果把父类的虚函数去掉那就不满足条件2，没有完成虚函数的重写或者覆盖，此时虚函数的重写没完成

满足多态指向谁调用谁，不满足多态，就是跟以前一样，看ptr类型，ptr是父类的就调用父类的

引用也行，如果是基类对象呢，此时也不满足多态，调用的也是父类

子类就不能穿父类。只能穿子类。

cpp 复制代码

class Animal
{
public:
	virtual void talk() const
	{}
};

class Dog : public Animal
{
public:
	virtual void talk() const
	{
		std::cout << "汪汪" << std::endl;
	}
};

class Cat : public Animal
{
public:
	virtual void talk() const
	{
		std::cout << "(>^ω^<)喵" << std::endl;
	}
};
void letsHear(const Animal& animal)
{
	animal.talk();
}
int main()
{


	Cat cat;
	Dog dog;
	letsHear(cat);
	letsHear(dog);

	return 0;
}

多态在不同子类之间不同对象传一个函数，可以实现多态，animal是父类，穿子类可以实现切片，

只有基类的指针才可以穿不同子类，动物鸭子老虎，2.虚函数重写

B当中的virtual 重写了A中的virtual，B中val改成x也构成，缺省值也不重要。

继承是指搜索规则搜索text现在B里面搜。搜到text隐藏A，搜不到去A搜，继承并不会真的弄下来。所以不管A调用B调用都是A*，所以这里P给A*，父类指针基类指针去调用，如果是B*就不满足，2.虚函数重写，，满足构成多态，这里和A*没有关系了，和指向对象有关，调用B的

然而选B，

重写是重写实现，为什么不加virtual都可以，满足多态以后用父类声明部分加派生类实现，组成重写，重写的本质是重写虚函数。所以可以不加virtual，

这种情况不满足多态，

p不是基类指针是子类指针，不构成多态，

多态才复杂组合，普通没这么多弯弯绕绕。

cpp 复制代码

class A {};
class B : public A {};
//

//协变
class Person {
public:
	virtual A* BuyTicket()
	{
		cout << "买票-全价" << endl;
		return nullptr;
	}
};

class Student : public Person {
public:
	virtual B* BuyTicket()
	{
		cout << "买票-打折" << endl;
		return nullptr;
	}
};

void Func(Person* ptr)
{
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;

	Func(&ps);
	Func(&st);

	return 0;
}

返回值不同构成协变，满足多态，必须是父类和子类指针和引用这就编译报错

这样也行，只要是父子类就行

cpp 复制代码

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

class B : public A {
public:
	// 构成重写
	~B()
	{
		cout << "~B()->delete:" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};

int main()
{
	A* p1 = new A;
	A* p2 = new B;

	// p1->destructor() + operator delete 
	delete p1;
	delete p2;

	return 0;
}