基类派生类多态虚函数？

拼搏现实的明天。 2023-09-26 22:55 27阅读 0赞

通常在层次关系的根部有一个基类，其他类则直接或间接的从基类继承而来，这些继承得到的类称为**派生类**。基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类定义各自特有的成员。

成员函数与继承派生类可以继承其基类的成员,  
然而有时候派生类必须对其重新定义。派生类需要对这些操作提供自己的新定义以覆盖从基类继承而来的旧定义。所以基类的成员函数反正都要被覆盖，从某种意义上来基类的成员函数可以用纯虚函数来代替。  
在C++语言中，基类必须将它的两种成员函数区分开来:  
一种是基类希望其派生类进行覆盖的函数  
另一种是基类希望派生类直接继承而不要改变的函数。  
对于前者，基类通常将其定义为虚函数(virual)。当我们使用指针或引用调用虚函数时，该调用将被动态绑定。  
根据引用或指针所绑定的对象类型不同，该调用可能执行基类的版本，也可能执行某个派生类的版木，基类通过在其成员函数的声明语句之前加上关键字virtual使得该函数执行动态绑定。  
任何构造函数之外的非静态函数都可以是虚函数。  
关键字virtual只能出现在类内部的声明语句之前而不能用于类外部的函数定义。  
如果基类把一个函数声明成虚函数，则该函数在派生类中也是虚函数。  
成员函数如果没被声明为虚函数,则其解析过程发生在编译时而非运行时。就会按照实际情况调用。  
派生类可以继承定义在基类中的成员，但是派生类的成员函数不一定有权访问从基类继承而来的成员。  
和其他使用基类的代码一样，派生类能访问公有成员，而不能访问私有成员。  
不过在某些时候基类中还有这样一种成员，基类希望它的派生类有权访问该成员，同时禁止其他用户访问。我们用受保护的(protected)访问运算符说明这样的成员。

派生类必须通过使用类派生列表(clss erivatin list）明确指出它是从哪个(哪些)基类继承而来的。  
类派生列表的形式是:首先是一个冒号，后面紧跟以逗号分隔的基类列表，其中每个基类前面可以有以下三种访问说明符中的一个\*\*:public、protected或者private\*\*  
派生类必须将其继承而来的成员函数中需要覆盖的那些重新声明。  
现在，我们只需知道访问说明符的作用是控制派生类从基类继承而来的成员是否对派生类的用户可见。  
如果一个派生是公有的，则基类的公有成员也是派生类接口的组成部分。此外，我们能将公有派生类型的对象绑定到基类的引用或指针上。  
大多数类都只继承自一个类，这种形式的继承被称作“单继承”。  
派生类中的虚函数派生类经常(但不总是)覆盖它继承的虚函数。如果派生类没有覆盖其基类中的某个虚函数,则该虚函数的行为类似于其他的普通成员，派生类会直接继承其在基类中的版本，派生类可以在它覆盖的函数前使用virtual关键字，但不是非得这么做（可有可无）。

**多态：**  
多态：静态多态，动态多态  
静态多态：函数重载，运算符重载，复用函数名  
动态多态：派生类和虚函数实现运行时多态  
区别：  
静态多态的函数地址 早绑定-》编译阶段确定函数地址  
动态多态的函数地址 晚绑定-》运行阶段确定函数地址  
动态多态满足关系：  
1.有继承关系  
2.子类重写父类的虚函数  
动态多态使用：父类的指针或引用 指向子类对象  
重写：函数返回值类型 函数名 参数列表 完全一致叫重写

如果子类中没有堆区数据，可以不用写虚析构和纯虚析构。

1.虚析构与纯虚析构共性：  
解决父类指针释放子类对象不干净问题  
都需要有具体的函数实现

2.区别：  
如果是纯虚析构，该类属于抽象类，无法实例化  
.虚析构语法：  
virtual ~类名()\{\}  
纯虚析构语法：  
virtual ~类名()=0;  
类名::~类名()\{\}

纯虚数  
子类的内容会覆盖父类，所以父类中函数没有意义了  
类中只要有一个纯虚函数就称为抽象类  
virtual void func() = 0;  
抽象类无法实例化对象（堆区，栈区）  
子类也必须要重写父类中的虚函数，否则子类也就是抽象类

具体代码示意如下所示

#include<iostream>
    using namespace std;
    
    class animal
    {
        
    public:
    	void speak()
    	{
        
    		cout << "dongwuzaishouhua" << endl;
    	}
    
    	 void speak()
    	{
        
    		cout << "dongwuzaishouhua" << endl;
    	}
    	
    class cat :public animal
    {
        
    public:
    	void speak()
    	{
        
    		cout << "xiaomaozaishuohua" << endl;
    	}
    };
    class dog :public animal
    {
        
    public:
    
    	virtual void speak()
    	{
        
    		cout << "xioagouzaishuoihua" << endl;
    	}
    	//注释之后对象模型：
    
    	class dog       size(1):
            +---
     0      | +--- (base class animal)
            | +---
            +---
    
    };
    
    void dospeak(animal& animal) //aniaml& aniaml= cat
    {
        
    	animal.speak();       //会打印出dongwuzaishouhua，因为aniaml& 
    }
    void test01()
    {
        
    	cat cat;
    	dospeak(cat);
    	dog dog;
    	dospeak(dog);
    }
    /*
    vfptr: 虚函数表指针
    v- virtual
    f- function
    ptr- pointor
    vftable：虚函数表
    v- virtual
    f- function
    table- table
    */
    
    /* 有函数对象时模型：
    class dog       size(4):
    		+---
     0      | +--- (base class animal)
     0      | | {vfptr}
    		| +---
    		+---
    
    dog::$vftable@:
    		| &dog_meta
    		|  0
     0      | &dog::speak  //覆盖 父类的指针或引用 指向子类对象发生多态
    
    */
    class base
    {
        
    public:
    	//纯虚数
    	// 子类的内容会覆盖父类，所以父类中函数没有意义了
    	//类中只要有一个纯虚函数就称为抽象类
    	virtual void func() = 0;
    	
    	/*
            抽象类无法实例化对象（堆区，栈区）
    		子类也必须要重写父类中的虚函数，否则子类也就是抽象类
    	*/
    	virtual ~base()
    	{
        
    		cout << "base的析构函数" << endl;
    	}
    
    };
    
    
    class son :public base
    {
        
    public:
    	virtual void func()
    	{
        
    		cout << "fff";
    	}
    	virtual ~son()
    	{
        
    		cout << "son的析构函数" << endl;
    	}
    
    };
    void test00()
    {
        
    	//son s;不允许使用抽象类类型 "son" 的对象
    	//base s;
    	//new base;
    	/*base* b = new son;
    	b->func();*/
    
    
    }
    int main()
    {
        
    
    	//test01();
    	test00();
    	system("pause");
    	return 0;
    }