网络营销战略内容seo短视频入口

引言

多态是面向对象编程的三大特性之一（封装、继承、多态），也是C++中最强大且最复杂的特性之一。它允许我们以统一的方式处理不同类型的对象，极大地提高了代码的灵活性和可扩展性。

本文将全面探讨C++中多态的概念，定义，实现，包括纯虚函数和抽象类及其实现原理。

1. 多态的概念

多态，在面向对象编程中，是指同一个行为具有多个不同表现形式或形态的能力。简单来说，就是“一个接口，多种实现”。

多态分为两种：

1. 编译时多态（静态多态）：函数重载和函数模版。
2. 运行时多态（动态多态）：虚函数和继承。

本文重点讨论运行时多态。

运行时多态，具体点就是去完成某个行为（函数），可以传不同的对象就会完成不同的行为，就达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票（75折）；军人买票时是优先买票。

2. 多态的定义和实现

2.1 实现多态的条件

1. 多态是一个继承关系下的类对象，去调用同一函数产生了不同效果的行为。所以必须有继承的基类和派生类。
2. 必须是基类的指针或者引用调用虚函数。因为只有基类的指针或引用才能既指向基类对象又指向派生类对象。
3. 被调用的函数必须是虚函数，并且完成了虚函数重写或覆盖。只有完成了重写或者覆盖，基类和派生类之间才能有不同的函数，多态的不同形态效果才能达到。

2.2 虚函数

类成员函数前面加 virtual 修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加 virtual 修饰。

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

2.3 虚函数的重写/覆盖

虚函数的重写/覆盖：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称派生类的虚函数重写了基类的虚函数。

注意：在重写基类虚函数时，派生类的虚函数也可以不加 virtual 关键字。

// 基类
class Person
{
public:// 基类成员函数必须使用 virtual 修饰virtual void BuyTicket() { cout << "买票-全价" << endl; }// 不使用 virtual 修饰// void BuyTicket() { cout << "买票-全价" << endl; }
};// 派生类
class Student : public Person {
public:// 可以加 virtual 修饰virtual void BuyTicket() { cout << "买票-打折" << endl; }// 也可以不加// void BuyTicket() { cout << "买票-打折" << endl; }
};void Func(Person& ptr)
{// 这里可以看到虽然都是 Person指针 Ptr 在调用 BuyTicket// 但是跟ptr没关系，而是由 ptr 指向的对象决定的。ptr.BuyTicket();
}class Animal
{
public:// 基类的必须加virtualvirtual void talk() const{}
};class Dog : public Animal
{
public:// 派生类的成员函数可以不加virtualvoid talk() const{std::cout << "汪汪" << std::endl;}
};class Cat : public Animal
{
public:// 也可以加virtualvirtual void talk() const{std::cout << "(>^ω^<)喵" << std::endl;}
};//virtual void func()
//{}void letsHear(const Animal& animal)
{animal.talk();
}int main()
{// 多态的实现Cat cat;Dog dog;letsHear(cat);letsHear(dog);/*Person ps;Student st;Func(ps);Func(st);*/return 0;
}

2.4 虚函数重写的一些其他问题

• 协变：派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用。
• 析构函数的重写：基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor ，所以基类的析构函数加了 virtual 修饰，派生类的析构函数就构成重写。
• 下面的代码我们可以看到，如果 ~C() ，不加 virtual ，那么 delete p2 时只调用的 C 的析构函数，没有调用 D 的析构函数，就会导致内存泄漏问题，因为 ~D() 中在释放资源。

// 协变
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();
}// 析构函数的重写
class C
{
public:virtual ~C(){cout << "~C()" << endl;}
};class D : public C {
public:// 析构函数会自动改名为destructor~D(){cout << "~D()->delete:" << _p << endl;delete _p;}protected:int* _p = new int[10];
};// 只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。int main()
{// 基类指针Person ps;// 派生类指针Student st;// 类外的函数。基类的指针返回基类的数据，派生类返回派生类的数据Func(&ps);Func(&st);// 基类指针创建了C类和D类的空间C* p1 = new C;C* p2 = new D;// 由于析构函数的重写，所以这里能分别调用各自的析构函数delete p1;delete p2;return 0;
}

2.5 override 和 final 关键字

• 从上面可以看出，C++ 对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错、参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来 debug 会得不偿失，因此 C++11 提供了 override，可以帮助用户检测是否重写。
• 如果我们不想让派生类重写这个虚函数，那么可以用 final 去修饰。

// error C3668: “Benz::Drive”: 包含重写说明符“override”的⽅法没有重写任何基类⽅法
class Car {
public:virtual void Dirve(){}
};class Benz :public Car {
public:virtual void Drive() override { cout << "Benz-舒适" << endl;}
};int main()
{return 0;
}// error C3248: “Car::Drive”: 声明为“final”的函数⽆法被“Benz::Drive”重写
class Car
{
public:virtual void Drive() final {}
};class Benz :public Car
{
public:virtual void Drive() { cout << "Benz-舒适" << endl; }
};int main()
{return 0;
}

2.6 重载/重写/隐藏的对比

3. 纯虚函数和抽象类

• 在虚函数的后面写上 =0，则这个函数为纯虚函数，纯虚函数不需要定义(实现没啥意义，因为要被派生类重写，但是语法上可以实现)，只要声明即可。
• 包含纯虚函数的类叫抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写的话，就实例化不出对象。

// 抽象类
class Car
{
public:// 纯虚函数virtual void Drive() = 0;
};// 由于抽象类中是纯虚函数。所以一定会被派生列重写。
// 所以派生类不是抽象类。如果基类成员函数没有被重写，就可能导致派生类成为抽象类，从而无法被实例化
class Benz :public Car
{
public:virtual void Drive(){cout << "Benz-舒适" << endl;}
};class BMW :public Car
{
public:virtual void Drive(){cout << "BMW-操控" << endl;}
};int main()
{// 编译报错：error C2259: “Car”: ⽆法实例化抽象类Car car;Car* pBenz = new Benz;pBenz->Drive();Car* pBMW = new BMW;pBMW->Drive();return 0;
}

书接下回：C++ 多态：面向对象编程的核心概念（二）