【C++】——多态（上）

【C++】——多态（上）

• 1 多态的概念
• 2 多态的定义及实现
• • 2.1 多态的构成条件
  • • 2.1.1 实现多态的必要条件
    • 2.1.2 虚函数
    • 2.1.3 感受多态
    • 2.1.4 判断是否满足多态
    • 2.1.5 多态场景的一道选择题
    • 2.1.6 虚函数重写的一些其他问题
    • • 2.1.6.1 协变
      • 2.1.6.2 析构函数的重写
      • 2.1.7 override 和 final 关键字
      • 2.1.8 重载/重写/隐藏的对比重载
      • 3 纯虚函数和抽象类

        1 多态的概念

          多态的概念：通俗来说，多态就是多种形态。多态分为静态多态（编译时的多态）和动态多态（运行时多态）。本章我们重点介绍运行时多态。

          编译时多态（静态多态） 主要就是我们前面学习的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态。之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时一般归为静态，运行时归为动态

          

        比如：

        int i;
        double d;
        cout public:    
            virtual void BuyTicket() 
            { 
            cout 
        public:    
            virtual void BuyTicket() 
            { 
            cout 
            // 这⾥可以看到虽然都是Person指针Ptr在调用BuyTicket
            // 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
             ptr-BuyTicket();
        }
        int main()
        {
            Person ps;
            Student st;
            Func(&ps);
            Func(&st);
            return 0;
        }
        
        public:
        	virtual void talk() const
        	{}
        };
        class Dog : public Animal
        {
        public:
        	virtual void talk() const
        	{
        		std::cout 
        public:
        	virtual void talk() const
        	{
        		std::cout 
        	animal.talk();
        }
        int main()
        {
        	Cat cat;
        	Dog dog;
        	letsHear(cat);
        	letsHear(dog);
        	return 0;
        }
        
        public:
        	void BuyTicket() { cout 
        public:
        	virtual void BuyTicket() { cout 
        public:
            virtual void BuyTicket() { cout 
        public:
            virtual void BuyTicket() { cout 
            ptr-BuyTicket()
        }
        
        public:
        	virtual void talk() const
        	{}
        };
        class Dog : public Animal
        {
        public:
        	virtual void talk() const
        	{
        		std::cout 
        public:
        	virtual void talk() const
        	{
        		std::cout 
        	Cat* pcat = new Cat;
        	Dog* pdog = new Dog;
        	pcat-talk();
        	pdog-talk();
        	return 0;
        }
        
        public:
        	virtual void BuyTicket() { cout 
        public:
        	virtual void BuyTicket() { cout 
        	ptr-BuyTicket();
        }
        
        public:
            virtual void BuyTicket() { cout 
        public:
            void BuyTicket() { cout 
        	// 这⾥可以看到虽然都是Person指针Ptr在调⽤BuyTicket
        	// 但是跟ptr没关系，⽽是由ptr指向的对象决定的。
        	ptr-BuyTicket();
        }
        
        public:
        	virtual void func(int val = 1) { std::cout  func(); }
        };
        class B : public A
        {
        public:
        	void func(int val = 0) { std::cout 
        	B* p = new B;
        	p-test();
        	return 0;
        }
        
        	B* p = new B;
        	p-func();
        	return 0;
        }
        };
        class B : public A {};
        class Person {
        public:
        	virtual A* BuyTicket()
        	{
        		cout 
        public:
        	virtual B* BuyTicket()
        	{
        		cout 
        	ptr-BuyTicket();
        }
        int main()
        {
        	Person ps;
        	Student st;
        	Func(&ps);
        	Func(&st);
        	return 0;
        }
        
        public :
        	virtual ~A()
        	{
        		cout 
        public:
        	~B()
        	{
        		cout 
        	A* p1 = new A;
        	A* p2 = new B;
        	delete p1;
        	delete p2;
        	return 0
        }
        
        public :
        	 ~A()
        	{
        		cout 
        public:
        	~B()
        	{
        		cout 
        	A* p1 = new A;
        	A* p2 = new B;
        	delete p1;
        	delete p2;
        	return 0;
        }
        
        public:
        	virtual void Dirve() 
        	{}
        };
        class Benz :public Car {
        public:
        	virtual void Drive() override{ cout 
        	return 0;
        }
        
        public:
        	virtual void Dirve() final
        	{}
        };
        class Benz :public Car {
        public:
        	virtual void Dirve() { cout 
        	return 0;
        }
        
        public:
        	virtual void talk() const = 0;
        };
        class Cat : public Animal
        {
        public:
        	virtual void talk() const
        	{
        		std::cout 
        public:
        	virtual void talk() const
        	{
        		std::cout 
        	Animal* pCat = new Cat;
        	Animal* pDog = new Dog;
        	pCat-talk();
        	pDog-talk();
        	
        	return 0;
        }
        
        	Animal animal;
        	return 0;
        }
        
        public :
        	virtual void Drive() = 0;
        };
        class Benz :public Car
        {
        };
        
        public :
        	virtual void Drive() = 0;
        };
        class Benz :public Car
        {
        public :
        	virtual void Drive()
        	{
        		cout 
        public :
        	virtual void Drive()
        	{
        		cout