c++多态

A19771979

已于 2023-09-06 15:54:53 修改

阅读量44

点赞数

分类专栏： C++ 文章标签： c++

于 2023-09-06 15:50:51 首次发布

本文链接：https://blog.csdn.net/a19771979/article/details/132717137

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

C++的多态特性是一种编程语言的能力，它允许我们使用相同的接口（通常是基类）来定义不同的行为。多态在面向对象编程中非常有用，它允许我们以更抽象的方式思考问题，并将具体实现推迟到运行时。

在C++中，多态主要通过虚函数（virtual functions）实现。虚函数是基类中声明的函数，其派生类可以重写（override）这个函数，从而实现不同的行为。当通过基类的指针或引用调用这个函数时，实际调用的函数是派生类中的函数，而不是基类中的函数。这个过程被称为动态绑定（dynamic binding）。

以下是一个简单的例子来说明C++的多态特性：

#include

class Shape {

public:

virtual void draw() const {

std::cout

}

};

class Circle : public Shape {

public:

void draw() const override {

std::cout

}

};

int main() {

Shape* shape = new Circle;

shape->draw(); // 输出 "Drawing Circle"

delete shape;

return 0;

}

在这个例子中，我们有一个基类Shape和它的派生类Circle。Shape中有一个虚函数draw，而Circle重写了这个函数。在main函数中，我们创建了一个指向Circle对象的Shape指针，并调用它的draw函数。由于draw是虚函数，所以实际调用的是Circle中的draw函数，输出"Drawing Circle"。

除了虚函数，C++还提供了纯虚函数（pure virtual functions），这是一种特殊的虚函数，它必须在派生类中被实现。如果一个类中有一个或多个纯虚函数，那么这个类就是抽象类，不能被实例化。

多态的实现

在面向对象编程语言中，子类继承了父类的所有属性和方法。当一个子类需要重写父类中的某个方法时，它可以在自己的类中实现该方法，同时保留方法名和参数列表。当一个对象调用该方法时，会根据对象的实际类型来决定调用哪个实现。

在代码执行时，确定执行哪个多态的接口是通过动态绑定（Dynamic Binding）实现的。动态绑定是指在运行时根据对象的实际类型来决定调用哪个方法或运算符。

在面向对象编程语言中，动态绑定是通过虚函数表（Virtual Function Table）来实现的。每个有虚函数的类都有一个虚函数表，它是一个函数指针数组，其中每个元素都指向该类的一个虚函数。当调用虚函数时，会先根据对象的指针找到对应的虚函数表，然后根据虚函数表中的索引来找到要调用的函数。

在运行时，虚函数表中的函数指针会被动态地替换为实际对象的函数指针，这就是动态绑定的过程。通过这种方式，程序可以在运行时根据对象的实际类型来决定调用哪个函数，从而实现多态。

需要注意的是，多态只有在有虚函数的情况下才会发生。如果一个类没有虚函数，那么它的所有方法都是静态绑定的，不会发生多态。

动态绑定过程

动态绑定（Dynamic Binding）是指在运行时根据对象的实际类型来决定调用哪个方法或运算符的过程。下面以一个例子来说明动态绑定过程：

假设有一个基类 Shape 和两个派生类 Circle 和 Square，它们都有一个名为 area() 的方法。我们可以通过一个指向 Shape 类型的指针来调用 area() 方法，但是在运行时，根据对象的实际类型来决定调用哪个类的 area() 方法。

#include

class Shape {

public:

virtual double area() const {

std::cout

return 0.0;

}

};

class Circle : public Shape {

public:

double area() const override {

std::cout

return radius * radius * 3.14;

}

private:

double radius;

};

class Square : public Shape {

public:

double area() const override {

std::cout

return side * side;

}

private:

double side;

};

int main() {

Shape* shape;

Circle circle(10.0);

Square square(5.0);

shape = &circle;

shape->area(); // 输出 "Calculating area of Circle"

shape = □

shape->area(); // 输出 "Calculating area of Square"

return 0;

}

在上面的例子中，我们定义了一个指向 Shape 类型的指针 shape，它可以指向 Circle 或 Square 类型的对象。我们通过这个指针调用 area() 方法，但是由于动态绑定的机制，程序会在运行时根据对象的实际类型来决定调用哪个类的 area() 方法。当 shape 指向 Circle 类型的对象时，调用的是 Circle 的 area() 方法；当 shape 指向 Square 类型的对象时，调用的是 Square 的 area() 方法。这就是动态绑定的过程。

动态绑定实现

动态绑定是通过虚函数表（Virtual Function Table）实现的。每个有虚函数的类都有一个虚函数表，它是一个函数指针数组，其中每个元素都指向该类的一个虚函数。

在运行时，根据对象的实际类型，程序会根据虚函数表中的索引来找到要调用的函数。具体实现过程如下：

当调用一个虚函数时，程序首先根据对象的指针找到对应的虚函数表（vtable）。
然后根据虚函数表中的索引（通常是一个整数）来找到要调用的函数。
接着根据索引找到对应的函数指针，并执行该函数。

通过这种方式，程序可以在运行时根据对象的实际类型来动态地绑定要调用的函数。

动态绑定索引确定

虚函数表中的索引是由编译器在编译时根据基类虚函数声明和派生类中重写的虚函数声明的顺序生成的。每个重写的虚函数都会在虚函数表中获得一个新的索引，以便在运行时能够正确地找到要调用的函数。

具体来说，编译器首先会根据基类的虚函数声明创建一个虚函数表，并按照声明的顺序为每个虚函数分配索引。然后，当派生类重写基类的虚函数时，编译器会在派生类中创建一个新的虚函数表，并将基类中的虚函数声明和派生类中重写的虚函数声明都插入到这个新的虚函数表中。新的虚函数表中的索引会根据声明的顺序重新排列，以反映重写后的虚函数顺序。

在运行时，当通过指向基类对象的指针调用虚函数时，程序会根据对象的指针找到对应的虚函数表，并根据索引找到要调用的函数。由于每个重写的虚函数都会在虚函数表中获得一个新的索引，因此程序可以根据对象的实际类型找到正确的函数实现。