C++自学篇 虚函数

最新推荐文章于 2024-06-11 22:59:16 发布
最新推荐文章于 2024-06-11 22:59:16 发布
阅读量65 收藏
点赞数
分类专栏： C++自学历程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42842270/article/details/132953617
版权

前言：

笔者以前只学过C语言，没有学过C++，在新项目中用到C++做开发，因此需要快速学习C++。
注：
1.编译环境：g++.exe (x86_64-posix-seh-rev3, Built by MinGW-W64 project) 11.2.0
2.virtual关键字主要用于基类申明虚函数，override关键字主要用于衍生类申明重写函数。在项目中，只要基类使用virtual关键字申明了虚函数，其衍生类如果想改变此成员函数的实现，则必定会出现override关键字申明重写函数。
3.本篇使用的BaseClass代表基类，使用的DerivedClass代表衍生类。

1.虚函数的继承与virtual的使用

下述程序用于研究基类及其衍生类是否使用virtual关键字，对编译/运行造成的影响。

#include <iostream>

class BaseClass
{
public:
    void run_1(void) {
        printf("%s: BaseClass\r\n", __func__);
    }

    virtual void run_2(void) {
        printf("%s: BaseClass\r\n", __func__);
    }

    void run_3(void) {
        printf("%s: BaseClass\r\n", __func__);
    }

    virtual void run_4(void) {
        printf("%s: BaseClass\r\n", __func__);
    }
};

class DerivedClass : public BaseClass
{
public:
    void run_1(void) {
        printf("%s: DerivedClass\r\n", __func__);
    } 

    void run_2(void) {
        printf("%s: DerivedClass\r\n", __func__);
    }

    virtual void run_3(void) {
        printf("%s: DerivedClass\r\n", __func__);
    }

    virtual void run_4(void) {
        printf("%s: DerivedClass\r\n", __func__);
    }
};

int main(int argc, char *argv[])
{
    // Example_1: 基类指针 创建基类
    printf("BaseClass Pointer, New BaseClass:\r\n");
    BaseClass *baseLivingExample_1 = new BaseClass();
    baseLivingExample_1->run_1();   // BaseClass
    baseLivingExample_1->run_2();   // BaseClass
    baseLivingExample_1->run_3();   // BaseClass
    baseLivingExample_1->run_4();   // BaseClass
    delete baseLivingExample_1;

    // Example_2: 基类指针 创建衍生类
    printf("BaseClass Pointer, New DerivedClass:\r\n");
    BaseClass *baseLivingExample_2 = new DerivedClass();
    baseLivingExample_2->run_1();   // BaseClass
    baseLivingExample_2->run_2();   // DerivedClass
    baseLivingExample_2->run_3();   // BaseClass
    baseLivingExample_2->run_4();   // DerivedClass
    delete baseLivingExample_2;

    // Example_3: 衍生类指针 创建基类（编译错误）
    // printf("DerivedClass Pointer, New BaseClass:\r\n");
    // DerivedClass *derivedLivingExample_3 = new BaseClass();
    // derivedLivingExample_3->run_1();
    // derivedLivingExample_3->run_2();
    // derivedLivingExample_3->run_3();
    // derivedLivingExample_3->run_4();
    // delete derivedLivingExample_3;

    // Example_4: 衍生类指针 创建衍生类
    printf("DerivedClass Pointer, New DerivedClass:\r\n");
    DerivedClass *derivedLivingExample_4 = new DerivedClass();
    derivedLivingExample_4->run_1();    // DerivedClass
    derivedLivingExample_4->run_2();    // DerivedClass
    derivedLivingExample_4->run_3();    // DerivedClass
    derivedLivingExample_4->run_4();    // DerivedClass
    delete derivedLivingExample_4;

    return 0;
}

总结：
1.基类指针可以接收基类实体，衍生类指针可以接收衍生类实体
2.基类指针可以接收衍生类实体，衍生类指针不可以基类实体
3.基类的成员函数没有加“virtual”前缀，如果基类和衍生类的成员函数命名一致，则衍生类实体默认使用基类的成员函数
4.基类的成员函数有加“virtual”前缀，如果基类和衍生类的成员函数命名一致，则衍生类实体默认使用衍生类的成员函数

2.虚函数的继承与override的使用

下述程序用于研究衍生类是否使用override关键字，对编译/运行造成的影响。

#include <iostream>

class BaseClass
{
public:
    virtual void run_1(void);
    virtual void run_2(void);
    void run_3(void);
    void run_4(void);
};

class DerivedClass : public BaseClass
{
public:
    void run_1(void) override;
    virtual void run_2(void) override;
    // void run_3(void) override;           // 编译报错
    // virtual void run_4(void) override;   // 编译报错
    // void run_5(void) override;           // 编译报错
    // virtual void run_6(void) override;   // 编译报错
};

void BaseClass::run_1(void)
{
    printf("%s: BaseClass\r\n", __func__);
}

void BaseClass::run_2(void)
{
    printf("%s: BaseClass\r\n", __func__);
}

void DerivedClass::run_1(void)
{
    printf("%s: DerivedClass\r\n", __func__);
}

void DerivedClass::run_2(void)
{
    printf("%s: DerivedClass\r\n", __func__);
}

int main(int argc, char *argv[])
{
    // Example_1: 基类指针 创建基类
    printf("BaseClass Pointer, New BaseClass:\r\n");
    BaseClass *baseLivingExample_1 = new BaseClass();
    baseLivingExample_1->run_1();   // BaseClass
    baseLivingExample_1->run_2();   // BaseClass
    delete baseLivingExample_1;

    // Example_2: 基类指针 创建衍生类
    printf("BaseClass Pointer, New DerivedClass:\r\n");
    BaseClass *baseLivingExample_2 = new DerivedClass();
    baseLivingExample_2->run_1();   // DerivedClass
    baseLivingExample_2->run_2();   // DerivedClass
    delete baseLivingExample_2;

    // Example_3: 衍生类指针 创建基类（编译错误）
    // printf("DerivedClass Pointer, New BaseClass:\r\n");
    // DerivedClass *derivedLivingExample_3 = new BaseClass();
    // derivedLivingExample_3->run_1();
    // derivedLivingExample_3->run_2();
    // delete derivedLivingExample_3;

    // Example_4: 衍生类指针 创建衍生类
    printf("DerivedClass Pointer, New DerivedClass:\r\n");
    DerivedClass *derivedLivingExample_4 = new DerivedClass();
    derivedLivingExample_4->run_1();    // DerivedClass
    derivedLivingExample_4->run_2();    // DerivedClass
    delete derivedLivingExample_4;

    return 0;
}

总结：
1.基类指针可以接收基类实体，衍生类指针可以接收衍生类实体
2.基类指针可以接收衍生类实体，衍生类指针不可以基类实体
3.衍生类使用“override”，对应的基类相同命名成员函数必须带有“virtual”的前缀
4.衍生类使用“override”，其基类必须有相同命名成员函数

3.使用基类指针接收的衍生类实体

下述程序用于研究基类指针接收的衍生类实体调用各个类的成员函数，对编译/运行造成的影响。

#include <iostream>

class BaseClass
{
public:
    virtual void run();
    virtual void show(void) {
        printf("%s: BaseClass\r\n", __func__);
    }
};

class DerivedClass_1 : public BaseClass
{
public:
    void run(void);
    void show(void) override;
    void show_1(void) {
        printf("%s: DerivedClass_1\r\n", __func__);
    }
};

class DerivedClass_2 : public BaseClass
{
public:
    void run(void) override;
    void show(void) override;
    void show_2(void) {
        printf("%s: DerivedClass_2\r\n", __func__);
    }
};

class DerivedClass_3 : public BaseClass
{
public:
    virtual void run(void);
    void show(void) override;
    void show_3(void) {
        printf("%s: DerivedClass_3\r\n", __func__);
    }
};

class DerivedClass_4 : public BaseClass
{
public:
    virtual void run(void) override;
    void show(void) override;
    void show_4(void) {
        printf("%s: DerivedClass_4\r\n", __func__);
    }
};

void BaseClass::run(void)
{
    printf("%s: BaseClass\r\n", __func__);
}

void DerivedClass_1::run(void)
{
    printf("%s: DerivedClass_1\r\n", __func__);
}

void DerivedClass_1::show(void)
{
    show_1();
}

void DerivedClass_2::run(void)
{
    printf("%s: DerivedClass_2\r\n", __func__);
}

void DerivedClass_2::show(void)
{
    show_2();
}

void DerivedClass_3::run(void)
{
    printf("%s: DerivedClass_3\r\n", __func__);
}

void DerivedClass_3::show(void)
{
    show_3();
}

void DerivedClass_4::run(void)
{
    printf("%s: DerivedClass_4\r\n", __func__);
}

void DerivedClass_4::show(void)
{
    show_4();
}

int main(int argc, char *argv[])
{
    BaseClass *baseLivingExample[] = {
        new BaseClass,
        new DerivedClass_1,
        new DerivedClass_2,
        new DerivedClass_3,
        new DerivedClass_4,
    };

    for (int i = 0; i < sizeof(baseLivingExample) / sizeof(baseLivingExample[0]); i++) {
        baseLivingExample[i]->run();
    }

    baseLivingExample[0]->show();
    // baseLivingExample[1]->show_1(); // 编译报错
    // baseLivingExample[2]->show_2(); // 编译报错
    // baseLivingExample[3]->show_3(); // 编译报错
    // baseLivingExample[4]->show_4(); // 编译报错
    baseLivingExample[1]->show();
    baseLivingExample[2]->show();
    baseLivingExample[3]->show();
    baseLivingExample[4]->show();

    for (int i = 0; i < sizeof(baseLivingExample) / sizeof(baseLivingExample[0]); i++) {
        delete baseLivingExample[i];
    }

    return 0;

总结：
1.基类指针可以接收基类实体，基类指针可以接收衍生类实体
2.基类指针接收的衍生类实体，不允许访问衍生类特有的成员函数
3.基类想要访问衍生类特有的成员函数，需要用虚函数，在衍生类中实现虚函数去调用对应的成员函数
4.在实际项目中，可以用基类的指针数组统一管理各个衍生类的实体

凌X绦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 7万+
C/C++学习路线总结与分享
C++自学路线
vernon055的博客
06-29 2890
一、C++基础（3个月） 1、面向对象的三大特性：封装、继承、多态 封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是：代码重用。而多态则是为了实现另一个目的——接口重用。 2、类的访问权限：private、protected、public 3、类的构造函数、析构函数、赋值函数、拷贝函数 4、移动构造函数与拷贝构造函数对比 C++11新出的，可以不用管。 5、深拷贝与浅拷贝的区别  ...
【C++】自学终极笔记
热门推荐
朝花夕拾
11-28 1万+
"C++学习笔记"是一份深入探索C++编程语言的博客，涵盖了从基础概念到高级技术的丰富内容。通过简洁而清晰的教程，读者将学到C++语法、面向对象编程、模板、异常处理等核心概念。此外，博客还提供实用的编程示例和常见问题的解决方案，帮助读者更好地理解和运用C++。无论是初学者还是有经验的开发者，这份学习笔记都是一个有价值的资源，助力构建稳健、高效的C++应用程序。
C++自学笔记
yuandenixin的博客
10-22 234
C++自学笔记（18 继承）18 继承继承（面向对象的三大特性之一）继承方式继承中的对象类型赋值运算符重载关系运算符重载函数调用的运算符重载 18 继承 本次记录继承，还请各位大佬批评指正！ 继承（面向对象的三大特性之一） 继承的好处： 减少重复代码。 语法： class 子类（也称为派生类） ： 继承方式 父类（也称为派生类）。 1、普通实现网页页面 #include<iostream> #include <stdlib.h> #include<string> us
C++自学精简实践教程 目录(必读)
C++ 爱好者 make_it_simple888
08-24 4639
1.1 创作背景在辅导欧美留学生本科C++课程的时候，发现手上没有一个超级迷你的C++教程。《C++ Primer》太大，国内教材基本上还停留在C with Class层面，不得要领，国外教材不同学校差异也比较大，侧重点也不同。所以急需一个超级小的，内容是必须掌握的知识点集合。顺便提一下，欧美名校的所有C++教程没有一个是C with Class 的。全都是标准C++，和C++ Primer 的内容完全一致。国内目前我带的学生当中复旦大学大一C++是没问题的，其他大部分学校依然堪忧。
c++ - 含有虚函数类的sizeof_sizeof虚函数
2401_83817653的博客
05-13 560
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年嵌入式&物联网开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上嵌入式&物联网开发知识点，真正体系化！
c++自学日记 day11
m0_74214396的博客
06-01 743
多态满足条件。
c++自学日记 day10
m0_74214396的博客
05-28 721
今日学习：继承1、继承的语法：class Son :public Father (Son是子类（派生类），father是父类（基类））继承的好处：可以减少重复的代码A 类称为子类 或 派生类B 类称为父类 或 基类一类是从基类继承过来的，一类是自己增加的成员。从基类继承过过来的表现其共性，而新增的成员体现了其个性。
C++57个入门知识点_32 初识多态及虚函数-核心（加virtual的函数称为虚函数；某一个函数在父子类有不同实现，运行时对象自行决定调用哪一类实现；没virtual调父类同名函数，否则调子类函数）
分享学习成长历程，Winter is coming！
10-30 370
1.什么是多态： 某一个函数在父类子类有不同的实现，运行时对象自行决定调用哪一个类下实现 （1）常规下我们要实现，一个房间多国人，不同国家的人说不同的话 #include <iostream> //面向对象：多态 class CPerson { public: CPerson() { } void speak() { printf("说人话\r\n"); } }; class CChinese :public CPerson { public: CChinese()
c++纯虚函数的用法及详解
12-04
在c++学习的过程中，尤其是自学，遇到这样那样的函数，尤其是虚函数这一块，并且虚函数的类型还多，让人真是头痛，这个是我在学习过程中搜索的一点资料，希望对大家能够有所帮助。
C++轻松入门
08-07
第2篇主要介绍C++面向对象的程序设计，包括类和对象、继承和派生、多态性和虚函数等内容。第3篇主要介绍数据结构中链表的C++实现和C++中模板的应用。, 《C++轻松入门》附有配套光盘，光盘中提供了《C++轻松入门》中...
Thinking in C++
04-01
内容涉及对象的演化、数据抽象、隐藏实现、初始化与清除、函数重载与缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚函数、模板和包容器...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1010
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 146
BCSP-X 11题 C++代码详解
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 753
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 324
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
STL——Stacks容器
qq_74811378的博客
06-11 292
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。size() 函数返当前堆栈中的元素数目。如当前堆栈为空，empty() 函数 返回。值压栈，使其成为栈顶的第一个元素。pop() 函数移除堆栈中最顶层元素。push() 函数将。
【C++】 基础复习 ｜ 数据类型，输入，输出流 scanf printf
最新发布
专注于人工智能的算法与应用
06-11 827
是 C 语言中两个非常重要的标准输入输出函数，它们分别用于从标准输入（通常是键盘）读取数据和向标准输出（通常是屏幕）打印数据。在这种情况下如果想控制输出，即满足一定格式输出，比如保留几位小数什么的，就要用manipulator了。需要变量的地址 ，即前面需要加一个&。函数用于从标准输入读取数据，并根据格式字符串解析这些数据。存储内存地址的变量。用户定义的复合数据类型，用于将不同类型的数据组合在一起。称做流式输入输出，
c++导出类虚函数 eclipse
05-23
如果您想导出一个C++类的虚函数，使其可以在其他语言（如Java）中调用，可以使用C++的导出功能。这需要使用一些C++编译器特定的指令，例如Microsoft Visual C++的`__declspec(dllexport)`。 以下是在Eclipse中导出...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值