C++：多态

最新推荐文章于 2024-09-20 20:43:57 发布
最新推荐文章于 2024-09-20 20:43:57 发布
阅读量484 收藏
点赞数
分类专栏： C++ 基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/you_fathe/article/details/128272729
版权

文章目录

1 、概念

多态：同一指令，针对不同对象，产生不同行为。

多态的类型

  • 静态多态（静态联编）：编译时多态。形式：函数重载、运算符重载、模板。

  • 动态多态（动态联编）：运行时多态。形式：虚函数。

多态与虚函数不是等价的，动态多态的体现必须要有虚函数，调用虚函数并不一定体现多态。

2、虚函数

2.1、虚函数的定义

虚函数：在成员函数前加 virtual 关键字，在末尾可添加 override 关键字。

派生类重写基类的虚函数

  • 函数同名
  • 返回值类型相同
  • 参数列表相同：参数类型、参数个数、参数顺序

不能设置为虚函数的函数

  • 普通函数：非成员函数
  • 静态成员函数：编译时绑定。虚函数的调用需要对象，需要 this 指针，而静态函数没有 this 指针，可以不使用对象调用，使用类名+作用域限定符调用
  • 内联成员函数：没有必要，内联函数本身是为了减少函数调用的代价，而虚函数需要创建虚函数表，失去内联的意义。
  • 非成员函数的友元函数
  • 构造函数：
    • 从继承观点来看，构造函数不能被继承，而虚函数可以被派生类重写。
    • 从存储角度，如果构造函数是虚函数，则需用通过虚表来调用，但是对象还没有实例化，没有内存空间，无法通过虚函数指针找到虚表。
    • 从语义角度，构造函数就是为了初始化数据成员，然而虚函数是为了在完全不了解细节情况下也能正确处理对象，虚函数要对不同类型的对象产生不同的动作。如果构造函数是虚函数，那么对象都没有产生，无法完成想要的操作。

2.2、虚函数的实现机制

2.2.1、实现原理
  • 虚函数指针 vfptr：指向虚表
  • 虚函数表（虚表）：虚函数的入口地址。注意：多基继承时，只有第一个虚表存放虚函数入口地址，其他虚表存放跳转指令，指向第一个虚表。

在这里插入图片描述

当基类定义虚函数的时候，就会在基类对象的存储布局的前面多一个虚函数指针，指向自己的虚函数表，存放虚函数的入口地址。当派生类继承该基类的时候，把基类的虚函数吸收过来，派生类虚函数指针指向自己的虚函数表，若派生类重写该虚函数，则派生类虚函数表中对应的虚函数的入口地址被覆盖 override。

2.2.2、多态被激活的条件
  • 基类定义虚函数
  • 派生类重定义虚函数
  • 创建派生类对象
  • 基类的指针（引用）指向（绑定）到派生类对象
  • 使用基类指针（引用）调用虚函数
2.2.3、测试虚表

测试虚表的存在，一级指针指向派生类对象（虚表的首地址），二级指针指向虚表中的虚函数，打印虚表。

#include <iostream>
using std::cout;
using std::endl;
 
class Base {
public:
	Base(long base)
	: _base(base)
	{	cout << "Base(long)" << endl;	}

	virtual void func1() {	cout << "Base::func1()" << endl;	}
	virtual void func2() {	cout << "Base::func2()" << endl;	}
	virtual void func3() {	cout << "Base::func3()" << endl;	}
private:
	long _base;		
};

class Derived
: public Base
{
public:
	Derived(long base, long derived)
	: Base(base)
	, _derived(derived)
	{	cout << "Derived(long,long)" << endl;	}

	virtual void func1() {
		cout << "Derived::func1() _derived:" << _derived << endl;
	}
	virtual void func2() {	
        cout << "Derived::func2()" << endl;	
    }
private:
	long _derived;
};

// 通过二级指针验证虚函数表的存在，
void test() {
	Derived d(10, 100);
    cout << "----- 打印虚函数表中的虚函数地址 -----" << endl;
	// 一级指针，指向派生类对象的首地址，即虚函数表的地址
    long *pvtable = (long*)&d;
    for(int idx = 0; idx < 3; ++idx) { 
        // 打印虚函数的地址
        cout << pvtable[idx] << endl; 
    } 
    
    cout << "----- 调用虚函数表中的虚函数，不传 this 指针 -----" << endl;
    // 二级指针，指向派生类对象地址的地址，即虚函数的地址
    long **pVtable = (long **)&d; 
    typedef void(* Function)(); 
    for(int idx = 0; idx < 3; ++idx) { 
        // 回调虚函数，没有传this指针
        Function f = (Function)pVtable[0][idx]; 
        f(); 
    } 
    
	cout << "----- 调用虚函数表中的虚函数，传入 this 指针-----" << endl;
	typedef void (*Function2)(Derived*);
	for(int idx = 0; idx < 3; ++idx) { 
        // 回调虚函数，传入this指针
        Function2 f2 = (Function2)pVtable[0][idx];
        f2(&d);
	} 	
} 

int main(void) {
	test();
	return 0;
}

2.3、虚函数的访问

  • 指针访问：基类的指针指向派生类对象，动态联编，体现多态
  • 引用访问：基类的引用绑定派生类对象，动态联编，体现多态
  • 成员函数访问： this 指针调用虚函数，表现动态多态
  • 对象访问：对象调用虚函数，静态联编，不体现多态
  • 构造函数或析构函数：静态联编，只会调用自己的虚函数

测试在构造函数或析构函数中，调用虚函数

#include <iostream>

using std::cout;
using std::endl;

class Grandpa {
public:
    Grandpa() {
        cout << "Grandpa()" << endl;
    }

    virtual void func1() {
        cout << "Grandpa::func1()" << endl;
    }

    virtual void func2() {
        cout << "Grandpa::func2()" << endl;
    }

    ~Grandpa() {
        cout << "~Grandpa()" << endl;
    }
};

class Father: public Grandpa {
public:
    Father() {
        cout << "Father()" << endl;
        func1(); // 构造函数调用虚函数
    }

    virtual void func1() {
        cout << "Father::func1()" << endl;
    }

    virtual void func2() {
        cout << "Father::func2()" << endl;
    }

    ~Father() {
        cout << "~Father()" << endl;
        func2(); // 析构函数调用虚函数
    }
};

class Son: public Father {
public:
    Son() {
        cout << "Son()" << endl;
    }

    virtual void func1() {
        cout << "Son::func1()" << endl;
    }

    virtual void func2() {
        cout << "Son::func2()" << endl;
    }

    ~Son() {
        cout << "~Son()" << endl;
    }
};

int main() {
    Son son; // 栈对象，自动销毁
    return 0;
}

测试结果：构造函数或析构函数中调用虚函数，表现的是静态联编，只会调用自己的虚函数

/* 
构造过程：grandfather -> father -> son 
析构过程：~son-> ~father -> ~grandfather
*/
Grandpa()
Father()
Father::func1() // son还未创建，此时只能调用father的func1
Son() 
~Son()
~Father() 
Father::func2() // son已经销毁，此时只能调用father的func2
~Grandpa()

2.4 、纯虚函数

纯虚函数：只有声明，没有实现，作为函数接口存在。

virtual 返回类型 函数名(参数列表) = 0;
2.4.1、抽象类

抽象类作为函数接口存在，不能创建对象，但可以创建抽象类的指针和引用

抽象类的形式

  • 纯虚函数：声明了纯虚函数的类，就是抽象类。若派生类没有对所有的纯虚函数进行重定义，则该派生类也会成为抽象类。
  • protected 修饰构造函数的类。可以派生新类，但不能创建对象。
// 基类定义为抽象类，不能创建基类对象
class Base { 
protected:
    Base(long base): _base(base) {} 
protected: 
    long _base; 
};

class Derived : public Base {
public: 
    Derived(long base, long derived) 
    : Base(base) // 可以调用基类的构造函数，创建派生类
    , _derived(derived) {}
private: 
    long _derived; 
}
2.4.2、开闭原则

面向对象的设计原则：开闭原则

特点：对扩展开放，对修改关闭

测试

#include <math.h>
#include <iostream>
using std::cout;
using std::endl;

// 抽象类：纯虚函数作为函数接口
class Figure {
public:
    virtual void display() const = 0;
    virtual double area() const = 0;
};

// 通过引用访问虚函数，表现动态多态
void func(const Figure &fig) {
    fig.display();
    cout << "'s area is : " << fig.area() << endl;
}

class Rectangle: public Figure {
public:
    Rectangle(double length = 0, double width = 0)
    : _length(length)
    , _width(width)
    { cout << "Rectangle(double = 0, double = 0)" << endl;}

    void display() const override {
        cout << "Rectangle ";
    }

    double area() const override {
        return _length * _width;
    }

    ~Rectangle() {
        cout << "~Rectangle()" << endl;
    }

private:
    double _length;
    double _width;
};

class Circle: public Figure {
public:
    Circle(double radius = 0)
    : _radius(radius) 
    { cout << "Circle(double = 0)" << endl; }

    void display() const override {
        cout << "Circle ";
    }

    double area() const override {
        return _radius * _radius * 3.14159;
    }

    ~Circle() {
        cout << "~Circle()" << endl;
    }
private:
    double _radius;
};

class Triangle
: public Figure
{
public:
    Triangle(double a = 0, double b = 0, double c = 0)
    : _a(a)
    , _b(b)
    , _c(c)
    { cout << "Triangle(double = 0, double = 0, double = 0)" << endl; }

    void display() const override {
        cout << "Triangle " ;
    }

    double area() const override {
        double tmp = (_a + _b + _c)/2;
        return sqrt(tmp * (tmp - _a) * (tmp - _b) * (tmp - _c));
    }

    ~Triangle() {
        cout << "~Triangle()" << endl;
    }

private:
    double _a;
    double _b;
    double _c;
};

int main(int argc, char **argv) {
    Rectangle rectangle(10, 12);
    Circle circle(10);
    Triangle triangle(3, 4, 5);

    cout << endl;
    func(rectangle);
    func(circle);
    func(triangle);
    
    return 0;
}

2.5、虚析构函数

多态的问题：如果一个基类的指针指向派生类的对象，当 delete 该指针释放派生类对象，系统只会执行基类的析构函数，不会执行派生类的析构函数，发生内存泄漏。

为了防止内存泄漏，只要基类中定义了虚函数，必须将基类的析构函数设置为虚函数，派生类的析构函数自动成为为虚函数。

基类和派生类的函数名虽然看起来不同，不符合重写规则，但实际上每个类只有一个析构函数，编译器将析构函数名统一解释为 destructor，实现重写。

例：父类是虚析构函数，子类重写了父类的析构函数，当 delete base 指针时 pbase->~destructor即重写后的子类析构函数，子类析构后，调用父类的析构函数。

#include <string.h>
#include <iostream>

using std::cout;
using std::endl;

class Base {
public:
    Base(const char *pbase)
    : _pbase(new char[strlen(pbase) + 1]())
    {
        cout << "Base(const char *)" << endl;
        strcpy(_pbase, pbase);
    }
    // 将基类的析构函数声明为虚函数：~destructor
    virtual ~Base() {
        cout << "~Base()" << endl;
        if(_pbase) {
            delete [] _pbase;
            _pbase = nullptr;
        }
    }
private:
    char *_pbase;
};

class Derived: public Base {
public:
    Derived(const char *pbase, const char *pderived)
    : Base(pbase)
    , _pderived(new char[strlen(pderived) + 1]())
    {
        cout << "Derived(const char *, const char *)" << endl;
        strcpy(_pderived, pderived);
    }
	// 重写发生在派生类的析构函数: ~destructor
	// 基类的析构函数虚化 -> 派生类的析构函数虚化 -> 名字相同发生重写
    ~Derived() {
        cout << "~Derived()" << endl;
        if(_pderived) {
            delete [] _pderived;
            _pderived = nullptr;
        }
    }
private:
    char *_pderived;
};
int main() {
    Base *pbase = new Derived("hello", "world");
    
    // 执行析构函数 pbase->~destructor()
    // 先执行派生类对象的析构函数，再执行基类(Base*)的析构函数
    delete pbase;
        
    return 0;
}

2.6、重载 覆盖 隐藏

  • 重载：同一个作用域，函数名相同，参数列表不同。

  • 覆盖 | 重定义 | 重写：基类与派生类中的虚函数，函数名相同，参数列表相同。

  • 隐藏：基类与派生类，函数名相同，派生类屏蔽了基类的同名数据成员。使用基类的作用域才能访问到其同名函数。

摸鱼呀
关注
专栏目录
C++:基于多态的职工管理系统
04-22
在本项目"C++:基于多态的职工管理系统"中，主要涉及了C++编程语言以及面向对象编程的一些关键概念和技巧。系统设计的核心是利用多态性来实现不同类型的员工管理，例如，可能存在经理、工程师等多种职位的员工，每种...
C++代码：面积计算
qq_52061884的博客
12-02 1078
包括圆形、矩形、三角形。
c语言中用double写圆的面积,用java写一个函数area,接收一个double类型的参数（表示圆的半径r）,用于计算圆的面积...
weixin_36290220的博客
05-19 1746
题目：用java写一个函数area,接收一个double类型的参数(表示圆的半径r),用于计算圆的面积然后调用该函数计算半径为3的圆的面积解答：引入包类我还没有学,不好意思.希望对你有助.class Cicle//定义圆类.{double area(double r)//定义方法计算圆的面积.{return 3.14*r*r;}}class Test5{public static void mai...
（1）定义接口A，里面包含值为3.14的常量PI和抽象方法double area()。 （2）定义接口B，里面包含抽象方法void setColor(String c)。
Xue_fabulous的博客
02-03 6991
代码 /*第一题： （1）定义接口A，里面包含值为3.14的常量PI和抽象方法double area()。 （2）定义接口B，里面包含抽象方法void setColor(String c)。 （3）定义接口C，该接口继承了接口A和B，里面包含抽象方法void volume()。 （4）定义圆柱体类Cylinder实现接口C，该类中包含三个成员变量：底圆半径radius、 圆柱体的高height、颜色color。
C语言:多态（多继承实现）
04-23
在C++中，多态（Polymorphism）是面向对象编程的一个重要概念，它允许我们使用一个接口来表示多种不同的类型。然而，C语言本身并不直接支持多态性，特别是多继承这一特性，这是C++引入的概念。但在C语言中，我们可以...
C语言:多态（单继承实现）
04-23
在C++中，多态（Polymorphism）是面向对象编程的一个核心概念，它允许我们使用一个接口来代表多种不同的类。尽管C语言本身并不直接支持面向对象编程和多态，但通过一些技巧，我们可以模拟出类似的效果。在这个...
实验报告五：多态的源码文件
11-10
在C++等语言中，虚函数是实现多态的关键，它们在基类中被声明为虚函数，使得子类可以重写这些函数，从而在运行时根据对象的实际类型调用相应的实现。例如，基类可能有一个`print()`虚函数，而多个子类可以各自实现...
CF C. Nikita and LCM
qq_74190237的博客
09-13 344
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
配置VS Code以进行C/C++编程：深入探讨与实操指南
GZM888888的博客
09-19 630
打开VS Code，点击左侧边栏中的Extensions图标（或按下快捷键），搜索“C/C++”，找到由Microsoft提供的官方扩展，点击Install按钮进行安装。在这个示例中，我们定义了一个名为“（gdb） Launch”的配置，它将使用GDB调试器来调试当前打开的文件。为了让VS Code知道如何构建你的项目，你需要创建一个名为的文件。在这个示例中，我们定义了一个名为“build”的任务，它将使用命令来编译当前打开的文件。如果你计划调试你的C/C++程序，你还需要创建一个名为的文件。
C++_map_set详解
2302_77644537的博客
09-16 1038
set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。在内部，set中的元素总是按照其内部比较对象(类型比较)所指示的特定严格的排序准则（默认是小于）进行排序。set在底层是用二叉搜索树(红黑树)实现的。map是关联容器，它按照特定的次序(按照key来比较)存储由键值key和值value组合而成的元素。
TMS Scripter Crack TMS Scripter is a Delphi C++ Builder
q2315702359的博客
09-19 925
　　The integrated development environment or the IDE allows the users in process of creating script jobs during the runtime with the help of multiple cross-language scripts such as de Pascal and the Basics.　　It has support for the cross-utilization of the s
【C++】STL----stack和queue常见用法
GGDxianv的博客
09-20 941
在 C++ 中，stack 是一种标准模板库（STL）提供的容器适配器，它遵循“后进先出”（LIFO, Last In First Out）的原则。这意味着最后插入的元素最先被访问。stack 是通过底层容器（如 vector 或 deque）实现的。在C++中，queue 是一个非常有用的容器适配器，它提供了一种先进先出（FIFO, First In First Out）的数据结构。
CCF201903_1
m0_67663419的博客
09-14 254
【代码】CCF201903_1。
C++笔记---模板进阶
2302_80372340的博客
09-13 964
【优点】1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生2. 增强了代码的灵活性【缺陷】1. 模板会导致代码膨胀问题，也会导致编译时间变长2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误。
C++速通LeetCode中等第7题-和为K的子数组（巧用前缀和）
lyx的博客
09-19 200
子数组和问题可用前缀和解决，前缀和就是头元素到当前序号子数组元素的和
C语言：刷题日志(1)
zm3rttqs9f的博客
09-07 1580
阶乘计算升级版 然后是几点 求整数段和 爬动的蠕虫 龟兔赛跑
(c++)线程的创建、互斥锁的使用、线程数组
最新发布
weixin_53112343的博客
09-20 89
但是线程可能在cpu分配的一个时间片中做不完10万次+1的操作，这时候cpu会被其他线程抢占，由于num1++不是一个原子操作（操作过程中可能会发生中断），导致++其实没有做完，所以num1的最终结果会小于100万。2.创建10个线程，每个线程都做10万次全局变量num2++操作，与前者不同的是，这次对num2++操作加入互斥锁，也就是让num2++成为一个“原子操作”（操作过程不会被中断），所以结果符合预期为100万。
C++实验：多态与抽象类应用
实验第一部分主要展示了多态的基础应用。在C++中，多态性允许不同类型的对象对同一消息作出不同的响应。这里通过定义一个基类Point，包含x和y坐标属性，并声明了一个纯虚函数`virtual double getArea() = 0;`。纯虚...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值