目录
二、多态：统一接口下的行为多样性
在面向对象编程中，多态性是一个核心概念，它允许我们以统一的方式处理不同类型的对象。C++作为一门支持多态性的语言，提供了多种机制来实现这一特性。本文将深入探讨C++中的多态性，包括其概念、实现方式、原理以及在实际编程中的应用。
1、多态的概念
多态性，字面意思是“多种形态”，在编程中指的是允许不同类的对象对同一消息做出响应的能力，但响应的方式却因对象的实际类型而异。例如，考虑一个简单的BuyTicket行为，不同身份的人（如普通人、学生、军人）可能在购票时函数有不同的操作，普通人出普通票，学生出学生票，军人优先购票等等~
2、多态的实现和构成条件
在C++中，多态主要通过虚函数来实现。虚函数是使用virtual关键字声明的成员函数，它可以在派生类中被重写（Override），以提供特定的实现。
要构成多态，需要满足以下两个条件：
- 必须通过基类的指针或引用来调用虚函数。
- 被调用的函数必须是虚函数（只在基类声明为虚函数也不会报错），且派生类必须对基类的虚函数进行重写。
示例代码：
class Person {
public:
virtual void BuyTicket() { std::cout << "买票-全价" << std::endl; }
};
class Student : public Person {
public:
virtual void BuyTicket() { std::cout << "买票-半价" << std::endl; }
};
void Func(Person& p) {
p.BuyTicket();
}
int main() {
Person ps;
Student st;
Func(ps); // 输出：买票-全价
Func(st); // 输出：买票-半价
return 0;
}
[注意]：实现多态时，基类对象的析构函数必须声明为虚函数，使得析构函数也能够多态动态执行。否则在基类对象中存放派生类对象的情景时无法正确析构（派生类部分没有被析构 造成内存泄露）！！！！！！！！！
#include<iostream>
using namespace std;
class base
{
public:
base()
{
cout << "base()" << endl;
}
~base()
{
cout << "~base()" << endl;
}
};
class Abase : public base
{
public:
Abase()
{
cout << "Abase()" << endl;
}
~Abase()
{
cout << "~Abase()" << endl;
}
};
int main()
{
base* pa = new Abase;
delete pa;
// 因为基类对象析构函数没有声明为虚函数
// 所以delete pa时只调用了base的析构函数(派生类部分没有被析构 造成内存泄露)
return 0;
}概念解析：
1、虚函数（Virtual Function）
虚函数是使用virtual关键字声明的成员函数，它允许在派生类中重写（Override）基类的实现。当通过基类指针或引用调用虚函数时，将根据对象的实际类型来确定调用哪个函数，这就是动态绑定或晚绑定。
2、虚函数重写
在派生类中，可以使用override关键字（C++11引入）明确指出要重写基类的虚函数。这要求派生类的函数与基类中的虚函数具有相同的签名（函数名、参数列表和返回类型）。
3、抽象类与接口继承
抽象类是包含至少一个纯虚函数（使用=0指定）的类，它不能被实例化。抽象类通常用作接口，强制派生类实现某些函数。
4、重载、覆盖(重写)、隐藏(重定义)的对比
重载（Overloading）
重载指的是具有相同名称但参数列表不同的函数。这是静态绑定或早绑定的一个例子，编译器根据函数调用时提供的参数来确定调用哪个函数。
class Example {
public:
void DoWork(int value) {
std::cout << "Doing work with int: " << value << std::endl;
}
void DoWork(double value) {
std::cout << "Doing work with double: " << value << std::endl;
}
};覆盖（Overriding）
覆盖是重写的一种特殊情况，它指的是派生类中的虚函数完全替换了基类中的虚函数。这是多态性的一个重要方面，允许派生类改变基类的行为。
class Base {
public:
virtual void Display() {
std::cout << "Base Display" << std::endl;
}
};
class Derived : public Base {
public:
void Display() { // 覆盖了基类的Display函数
std::cout << "Derived Display" << std::endl;
}
};隐藏（Hiding）
如果派生类的函数与基类中的函数名称相同，但不是虚函数，或者参数列表不完全相同，那么派生类的函数将隐藏基类的函数。这意味着通过派生类对象调用该函数时，将调用派生类的版本，而不是基类的版本。
class Base {
public:
void Hide(int value) {
std::cout << "Base Hide with int" << std::endl;
}
};
class Derived : public Base {
public:
void Hide(double value) { // 隐藏了基类的Hide函数
std::cout << "Derived Hide with double" << std::endl;
}
};
C++11中的final禁止重写和override重写检查
从上面的例子中发现，C++在处理函数重写时遵循严格的规则，但开发者在编码时的一些小失误，比如函数名的字母顺序错误，可能会导致无法实现预期的重载，这种类型的错误在编译时通常不会被发现。只有在程序执行时，由于得不到预期的行为，开发者才可能意识到问题并进行调试，这无疑增加了开发和维护的成本。为了解决这个问题，C++11标准引入了override和final两个关键字，以帮助开发者更准确地控制和检测函数的重写行为。同时提高代码的可读性和可维护性帮助编译器更严格地检查函数的重写行为。
override 关键字：检查重写
override 关键字用于明确指出派生类中的函数是对基类中虚函数的重写。如果基类中不存在匹配的虚函数，编译器将报错，这有助于避免因拼写错误或签名不匹配而导致的意外隐藏或不正确的重写。
使用 override 的好处：
- 强制编译器检查函数签名是否与基类中的虚函数匹配。
- 增加代码的可读性，让其他开发者快速理解函数的意图。
class Base {
public:
virtual void Show() {
std::cout << "Base Show" << std::endl;
}
};
class Derived : public Base {
public:
void Show() override { // 明确表示这是一个重写的函数
std::cout << "Derived Show" << std::endl;
}
};如果 Derived 类中的 Show 函数没有使用 override 关键字，并且其签名与基类中的 Show 函数不完全匹配，编译器将不会报错，但运行时将不会表现出预期的多态行为。
final 关键字：禁止重写
final 关键字用于修饰虚函数，表示该函数在派生类中不能被进一步重写。这可以用来限制类的继承层次，确保某个函数的实现在某个派生类中成为最终版本。
使用 final 的好处：
- 防止函数在更远的派生类中被重写，有助于控制类的继承结构。
- 明确表示某个函数的实现是最终版本，提高代码的可读性。
class Base {
public:
virtual void Display() final {
std::cout << "Base Display" << std::endl;
}
};
class Derived : public Base {
public:
// 下面的函数将导致编译错误，因为Base::Display()被声明为final
void Display() override {
std::cout << "Derived Display" << std::endl;
}
};在这个例子中，尝试在 Derived 类中重写 Base 类的 Display 函数将导致编译错误，因为 Display 被声明为 final。
5、纯虚函数和抽象类
在C++中，纯虚函数是在基类中声明的虚函数，它没有实现，并且要求任何派生类都必须提供该函数的实现。纯虚函数使用 virtual 关键字声明，并在函数声明的末尾加上 = 0。
纯虚函数的要点：
- 没有实现：纯虚函数在基类中不提供实现，因此后面不跟函数体（即使提供了函数体，这个函数体也会被忽略）。
- 必须重写：包含纯虚函数的类是抽象类，任何派生类都需要重写这些纯虚函数才能被实例化。
- 接口定义：纯虚函数用于定义一个接口或协议，派生类通过实现这些函数来遵守这个协议。
- 多态：纯虚函数支持多态性，允许通过基类指针或引用调用派生类中重写的版本。
class Shape {
public:
// 纯虚函数，定义了接口
virtual void draw() const = 0;
virtual ~Shape() {} // 虚析构函数，确保派生类的析构函数被调用
};
class Circle : public Shape {
public:
void draw() const override { // 重写基类的纯虚函数
std::cout << "Drawing a circle." << std::endl;
}
};
class Square : public Shape {
public:
void draw() const override {
std::cout << "Drawing a square." << std::endl;
}
};
int main() {
// Shape shape; // 错误：Shape是一个抽象类，不能被实例化
Shape* shape = new Circle(); // 正确：Circle实现了Shape接口
shape->draw(); // 调用Circle的draw函数
delete shape;
shape = new Square(); // 正确：Square也实现了Shape接口
shape->draw(); // 调用Square的draw函数
delete shape;
return 0;
}解释：这里的 draw 就是纯虚函数，它告诉编译器这个函数必须在派生类中被重写（Override），并且由于它的存在，Shape 类成为了一个抽象类，不能被直接实例化。Circle 和 Square 是 Shape 的派生类，它们都重写了 draw 函数，提供了具体的实现。这样，Shape 类指针 shape 就可以指向 Circle 或 Square 的实例，实现多态行为。
3、多态的原理
虚函数表
每个含有虚函数的类都有一个虚函数表（VTable），它是一个存储虚函数地址的数组。当通过基类指针或引用调用虚函数时，程序会在运行时查找对象的虚函数表，以确定调用哪个函数。
动态绑定与静态绑定
- 静态绑定（早绑定）：在编译期间确定函数调用，如函数重载。
- 动态绑定（晚绑定）：在运行期间确定函数调用，这是通过虚函数表实现的。
满足多态以后的函数调用，不是在编译时确定的，是运行起来以后到对象的中取找的。不满足多态的函数调用时编译时确认好的。
4、精选面试题
- 静态成员可以是虚函数吗？静态成员函数不能是虚函数。静态成员函数没有this指针，它们使用类名直接调用，而不是通过对象实例，因此无法访问虚函数表。
- 构造函数可以是虚函数吗？构造函数不能是虚函数。构造函数的目的是初始化对象，而虚函数表指针是在对象构造过程中的构造函数初始化列表阶段才被初始化。
- 析构函数可以是虚函数吗？析构函数可以并且通常被声明为虚函数。这是必要的，以确保在删除通过基类指针指向的派生类对象时，能够正确地调用派生类的析构函数。
- 对象访问普通函数快还是虚函数更快？对于普通对象，访问普通函数和虚函数的速度是一样的。但是，如果通过指针或引用调用函数，普通函数会更快，因为虚函数需要在运行时通过虚函数表来解析。
- 虚函数表是在什么阶段生成的，存在哪的？虚函数表是在编译阶段生成的，并且通常存储在代码段的常量区。
- 什么是抽象类？抽象类的作用？抽象类是包含至少一个纯虚函数的类，不能被实例化。抽象类通常用来定义接口或规范派生类的实现。它们体现了接口继承关系，并强制派生类实现某些函数。
扫一扫
1344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
