C++_多态详解

news2024/11/16 0:42:03

多态的概念

概念：需要去完成某个行为时，当不同的对象去完成会产生出不同的状态。通俗点说就是不同类型的对象去做同一个行为，产生的结果不同。

多态的定义及实现

虚函数

定义：即被virtual修饰的类成员函数称为虚函数

虚函数的重写(覆盖)

派生类中有一个跟基类 完全相同 的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。

重写可以简单地理解为：用基类的函数声明，加上派生类的函数体组合而成的函数

虚函数重写的例外

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

派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

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

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

// 析构函数的多态
class Person {
public:
	virtual ~Person() 
	//  ~Person() 相当于 destructor()
	{
		cout << "~Person()" << endl; 
	}
};
class Student : public Person {
public:
	virtual ~Student() // virtual 可加可不加
	//  ~Student() 也相当于 destructor()
	{ 
		cout << "~Student()" << endl; 
	}
};
int main(){
	Person* p1 = new Person;

	// 这里p1会先调用析构 也就是p1->destructor()
	// 然后在调用operator delete(p1)
	delete p1;

	Person* p2 = new Student;

	// p2与p1类似，但是p2会先调用派生类的析构，再调用基类的析构
	delete p2;

	return 0;
}

多态的构成条件

必须通过基类的指针或者引用调用虚函数
被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写

class Person {
public:
	virtual void BuyTicket() { 
		cout << "买票-全价" << endl; 
	}
};
class Student : public Person {
public:
	virtual void BuyTicket() {     //虚函数的重写
		cout << "买票-半价" << endl; 
	}
};
//void func(Person& p){  // 父类的引用调用虚函数
//	p.BuyTicket();
//}
void func(Person* p){    // 父类的指针调用虚函数
	p->BuyTicket();
}

多态的原理

虚函数表

在接触虚函数表之前，我们先来做一道题：

// 在32位平台下sizeof(be)是多少？
class Base
{
public:
	virtual void Func1(){ // 虚函数
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
};

int main()
{
	Base be;
	cout << sizeof(be) << endl;
	return 0;
}

很多同学一看到sizeof(be)，心里就想到：简单！不就是计算Base的大小吗？大小为4。其实不然，仔细分析我们会发现，在Base里面除了_b成员，还有一个虚函数Func1。请看下图be对象的监视窗口

从上图可知，除了_b成员，还多一个_vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。所以上题的答案一目了然，32位下的结果为8。

一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，虚函数表也简称虚表。虚表是在编译期间生成的

多态的原理

我们先来看下面的代码

class Base
{
public:
    virtual void Func1(){                // 虚函数Func1
        cout << "Base::Func1()" << endl;
    }
    virtual void Func2(){                // 虚函数Func2
        cout << "Base::Func2()" << endl;
    }
    void Func3(){                        // 非虚函数Func3
        cout << "Base::Func3()" << endl;
    }
};
class Derive : public Base
{
public:
    virtual void Func1(){                // 对基类虚函数Func1的重写
        cout << "Derive::Func1()" << endl;
    }
};

void Func(Base* pb)
{
    pb->Func1();
    pb->Func3();
}
int main(){
    Base b;
    Derive d;

    Func(&b);
    Func(&d);
    // 结果为：Base::Func1()
    //        Base::Func3()
    //        Derive::Func1()
    //        Base::Func3()
    return 0;
}

通过上面的代码我们可以发现：

派生类对象d中也有一个虚表指针，d对象由两部分构成，一部分是父类继承下来的成员，虚表指针也就是存在在这部分，另一部分是自己的成员。
基类b对象和派生类d对象虚表是不一样的，这里我们发现Func1完成了重写，所以d的虚表中存的是重写的Derive::Func1，所以虚函数的重写也叫作覆盖，覆盖就是指虚表中虚函数的覆盖。重写是语法的叫法，覆盖是原理层的叫法。
另外Func2继承下来后是虚函数，所以放进了虚表，Func3也继承下来了，但是不是虚函数，所以不会放进虚表。
虚函数表本质是一个存虚函数指针的函数指针数组，一般情况这个数组最后面放了一个nullptr。