当前位置：首页 > news >正文

（入门自用）--C++--抽象类--多态原理--虚表--1020

news 来源：原创 2024/5/19 6:23:56

析构函数重写的意义

class Person
{
public:
    virtual ~Person()
    {
        cout<<"~Person"<<endl;
    }	
};
class Student :public Person
{
    virtual ~Student()
    {
        cout<<"~Student"<<endl;
    }
};
int main()
{
    Person*ptr1=new Person;
    Person*ptr2=new Student;
    delete ptr1;
    delete ptr2;
    return 0;
}

子类析构函数重写父类析构函数，这里才能正确调用。指向谁调用谁的析构函数。

否则都是根据this指针去调用父类的析构函数而导致子类中的元素没有被析构。

重载、重写、隐藏

重载	两个函数在同一作用域
重载	函数名相同、参数不同。（参数个数、参数类型、类型顺序）
重写	两个函数分别在基类和派生类的作用域
	函数名/参数/返回值必须相同（协变除外）
	两个函数必须是虚函数
隐藏	两个函数必须分别在基类和派生类的作用域
	函数名相同
	不构成重写才是隐藏

抽象类

纯虚函数：在虚函数的后面写上 =0 。

class Car
{
public:
virtual void Drive() = 0;
};

Car就是一个抽象类。

包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象。

class Benz :public Car
{
};

子类继承后也不能实例化出对象。只有重写了纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。（接口是基类的，实现是派生类的）

class Car
{
public:
virtual void Drive() = 0;
};
class Benz :public Car
{
public:
 virtual void Drive()
 {
 cout << "Benz-舒适" << endl;
 }
}
void Test()
{
Car* pBenz = new Benz;
 pBenz->Drive();
}

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

多态的原理

虚表

虚函数表，本质是函数指针数组。

class Base
{
public:
 virtual void Func1()
 {
 cout << "Func1()" << endl;
 }
private:
 int _b = 1;
};
int main()
{
    Base b;
    int size=sizeof(b);
    return 0;
}

除了_b成员，还多一个__vfptr放在对象的前面。对象中的这个指针我们叫做虚函数表指针。

父类和子类中的虚表

#include<iostream>
using namespace std;
class Person
{
public:
	virtual void Buyticket()
	{
		cout << "买票--全价" << endl;
	}
    virtual void Func1()
    {
        cout<<"Person::Func1()"<<endl;
    }
private:
	int _age = 29;
};
class Student :public Person
{
public:
	virtual void Buyticket()
	{
		cout << "买票--半价" << endl;
	}
    virtual void Fun2()//新增虚函数 Func1并未重写
    {
        cout<<"Studen::Func2()"<<endl;
    }
private:
	int _num = 2089060001;
};
void fun1(Person& p)
{
	p.Buyticket();
}
void fun2(Person p)
{
	p.Buyticket();
}
int main()
{
	Person a;
	Student b;
	fun1(a);
	fun1(b);
	fun2(a);
	fun2(b);
	return  0;
}

父类中的虚表的元素指向的是 Person::Buyticket

子类继承下来的虚表中元素指向的是Studen::Buyticket

基类对象和派生类对象虚表是不一样的，这里我们发现Buyticket完成了重写，所以b的虚表中存的是重写的Studen::Buyticket，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。

注意：

只要是虚函数，就要放入虚表

派生类的虚表生成：

a.先将基类中的虚表内容拷贝一份到派生类虚表中

b.如果派生类重写了基类中某个虚函数，用派生类自己的虚函数覆盖虚表中基类的虚函数

c.派生类自己新增加的虚函数按其在派生类中的声明次序增加到派生类虚表的最后。

虚表存的是虚函数指针，不是虚函数。虚函数存放于公共代码段。

如何查看派生类中新增的虚函数

在上述代码中，Fun1()并未重写，且子类中新增了一个虚函数Func2()，但打开监视窗口却在虚表中找不到该虚函数对应的元素。

typedef void(*VFPTR)();//将返回类型为void的 无参的 函数指针重命名为VFPTR
void PrintVFTable(VFPTR table[])
{
    for(size_t i=0;table[i]!=nullptr;i++)
    {
        printf("vft[%d]:%p",i,table[i]);
        VFPTR pf=table[i];
        pf();//使用函数指针 调用函数
    }
}
int main()
{
    Person A;
    Student B;
    PrintVFTable((VFPTR*)*(int*)&A);
    PrintVFTable((VFPTR*)*(int*)&B);
    return 0;
}