静态多态、动态多态

静态多态:程序在编译阶段就可以确定调用哪个函数。这种情况叫做静态多态。比如重载,编译器根据传递给函数的参数和函数名决定具体要使用哪一个函数。
动态多态:在运行期间才可以确定最终调用的函数。需要通过虚函数+封装+继承实现。

虚函数

  • 虚函数都必须有定义
  • 虚函数一般用在继承中。多个子类继承同一基类,若在某种行为上不同的派生类有着自己的实现方式。这种情况我们就会用到多态。采用在基类中将此函数定义成虚函数,派生类中定义这个函数的不同实现。当我们使用基类的引用或指针调用一个虚成员函数时会执行动态绑定。因为直到运行的时候才能知道到底调用了哪个版本的虚函数,判断依据是根据引用或指针所绑定的对象的真实类型。
  • 若子类中重写了父类的方法,但是父类中此方法并没有设置为虚函数。那么通过指向子类的指针或引用调用此方法的时候,调用的是父类的方法。
  • 基类中某个函数一旦被声明为虚函数,则在所有派生类中它都是虚函数,不需要在派生类中再一次通过virtual关键字指出该函数的性质。
  • 当且仅当通过指针或引用调用虚函数时,才会在运行时解析该调用。

哪些函数类型不可以被定义成虚函数?

  • 内联函数
  • 构造函数
  • 静态成员函数:static成员函数是属于类的。不属于任何对象。
  • 友元函数:不支持继承,没有实现为虚函数的必要
  • 赋值运算符:赋值运算符要求形参类型与本身类型相同,基类中赋值操作符形参为基类类型,即使声明成虚函数,也不能作为子类的赋值操作符

内联函数为什么不能被定义成虚函数?
内联函数是为了在代码中直接展开,减少函数调用花费的代价。
inline 函数是在编译时确定的,而 virtual 属性是在运行时确定的,因此这个两个属性是不可能同时定义的。
即使虚函数被声明为内联函数,编译器遇到这种情况根本不会把这样的函数内联展开,而是当作普通函数来处理。

构造函数为什么不能被定义成虚函数?
如下:
1:继承情况下,构造函数的执行顺序时:A() B(),先执行父类的构造函数,在执行子类的构造函数

2:如果A的构造函数是虚函数,B类也定义了构造函数(即也为虚函数),则只会执行子类的构造函数。即只会执行B类的构造函数,不会再执行A类的构造函数,这样的话父类A就不能构造了

这样的话1和2就发生了矛盾。并且 virtual 函数是在不同类型的对象产生不同的动作,现在对象还没产生,是不存在通过virtual实现不同动作的想法的。

class A
{
A() {}
}; class B : public A
{
B() : A() {}
}; int main()
{
B b;
B * pb = &b;
}

虚函数的访问方式

  • 对象名: 通过对象名访问虚函数的时候,此时采用的是静态联编。调用哪个类的函数取决于定义对象名的类型。对象类型是基类时,就调用基类的函数;对象类型是子类时,就调用子类的函数。
  • 指针: 通过指针访问虚函数的时候,编译器根据指针所指对象的类型来决定要调用哪个函数(动态联编),而与指针本身的类型无关
  • 引用: 与指针访问虚函数类似。不同之处在于,引用一经声明后,引用变量本身无论如何改变,其调用的函数就不会在改变,始终指向其开始定义时的函数。引用在一定程度上提高了代码的安全性,可以将引用理解为一种“受限制的指针”。

析构函数中的虚函数

如 B:A,A是基类,B是子类
构造子类对象时,先运行基类构造函数初始化基类部分,再执行子类的构造函数初始化子类部分。在执行基类构造函数时,派生部分还是未初始化的。实际上,此时对象还不是一个派生类对象。即先 A 后 B
撤销子类对象时,首先撤销子类部分,然后按照与构造顺序的逆序撤销它的基类部分。即先B 后 A

下面看一个例子:

#include <iostream>
using namespace std; class Father
{
public:
Father()
{
cout << "Father Constructor" << endl;
}
void calcMethod()
{
cout << "Father calcMethod()" << endl;
}
virtual void virtualMethod()
{
cout << "Father virtualMethod()" << endl;
}
virtual void virtualCommon()
{
cout << "Father virtualCommon()" << endl;
}
~Father()
{
cout << "Father disConstruct" << endl;
}
}; class Son:public Father
{
public:
Son()
{
cout << "Son Constructor" << endl;
}
void calcMethod()
{
cout << "Son calcMethod()" << endl;
}
void virtualMethod()
{
cout << "Son virtualMethod()" << endl;
}
~Son()
{
cout << "Son disConstruct" << endl;
}
}; int main()
{
Father *f = new Son(); //先执行father构造函数,在执行son构造函数
f->calcMethod(); //Father calcMethod()。父,子--->父。如果父类中的方法有自己的实现,则会去调用父类的方法。 见上述第3条。
f->virtualMethod(); //Son virtualMethod()。父虚,子虚--->子。若把父类中的方法定义成虚函数,子类中有自己的实现,则会去调用指向的子类中对应的方法。 见上述第2条。
f->virtualCommon(); //Father virtualCommon()。父虚,子无--->父。若把父类中的方法定义成虚函数,子类中有没有覆盖这个虚函数,则会直接调用父类的虚函数。 delete f;
return 0;
}

控制台打印:

Father Constructor
Son Constructor
Father calcMethod()
Son virtualMethod()
Father disConstruct

可以发现调用 delete 的时候只执行了父类的析构函数,没有执行子类的析构函数。因为父类的析构函数不是虚函数,这不是造成了内存泄漏?怎么解决这个问题呢?

虚析构函数

delete后面跟父类指针,则只会执行父类的析构函数。
delete后面跟子类指针,那么即会执行子类的析构函数,也会执行父类的析构函数。

可以通过在基类中把析构函数定义成虚函数来解决这个问题。因为若不定义成虚函数,通过指向子类的指针或引用调用delete的时候会默认执行父类的析构函数(可参考上述虚函数介绍的第3条),而不会去执行子类的析构函数。

#include <iostream>
using namespace std; class Father
{
public:
Father()
{
cout << "Father Constructor" << endl;
}
virtual ~Father()
{
cout << "Father Destruct" << endl;
}
}; class Son:public Father
{
public:
Son()
{
cout << "Son Constructor" << endl;
}
~Son()
{
cout << "Son Destruct" << endl;
} }; int main()
{
Father *f = new Son();
delete f; cout << "--------------" << endl; Son *s = new Son();
delete s; return 0;
}

控制台打印:

Father Constructor
Son Constructor
Son Destruct
Father Destruct
--------------
Father Constructor
Son Constructor
Son Destruct
Father Destruct

虚函数表指针 vptr

class Base
{
public:
virtual void f()
{
cout << "Base::f" << endl;
} virtual void g()
{
cout << "Base::g" << endl;
} virtual void h()
{
cout << "Base::h" << endl;
}
}; int main()
{
// 函数指针
typedef void (*Func) (void); Base b; cout << sizeof(b) << endl; // B 函数只有一个虚函数表指针,即 4
cout << "虚函数表地址:" << (int*)(&b) << endl;
cout << "虚函数表-第一个函数地址:" << (int *)*(int *)(&b) << endl; Func pFunc = NULL;
pFunc = (Func)*((int*)*(int*)(&b)); // 通过 Func * 把 int*强制转换成函数指针
pFunc(); return 0;
}

多继承下的虚函数表

class A
{
public:
virtual void a() { cout << "a() in A" << endl; }
virtual void b() { cout << "b() in A" << endl; }
virtual void c() { cout << "c() in A" << endl; }
virtual void d() { cout << "d() in A" << endl; }
}; class B : public A
{
public:
virtual void a() { cout << "a() in B" << endl; }
virtual void b() { cout << "b() in B" << endl; }
}; class C : public A
{
public:
virtual void a() { cout << "a() in C" << endl; }
virtual void b() { cout << "b() in C" << endl; }
}; class D : public B, public C
{
public:
virtual void a() { cout << "a() in D" << endl; }
virtual void d() { cout << "d() in D" << endl; }
};

每个类的虚函数表结构如下:

B :public A 重写了 a() b()

C :public A 重写了 a() b()

D :public B , public C 重写了 a() d()

可见,多继承时,有几个基类就有几个vptr。D类中的函数 a与d 覆盖了B类中的同名函数

虚基类表指针 bptr

菱形继承即如下图继承方式:B、C 虚拟继承A,D普通继承B,C

B : virtual public A
C : virtual public A
D : public B, public C

虚拟继承情况下,基类不管在继承串链中被派生多少次,永远只会存在一个实体

在虚拟继承基类的子类中,子类会增加某种形式的指针,指向虚基类子对象或指向相关表格(表格中存放的不是虚基类子对象的地址,就是其偏移量),此指针被称为 bptr

菱形继承时的对象布局:

// 菱形继承
class A {}; class B : virtual public A {};
class C : virtual public A {}; class D : public B, public C {}; int main()
{
cout << "sizeof(A) : " << sizeof(A) << endl; // 1 空类,编译器会为空类安插一个字节
cout << "sizeof(B) : " << sizeof(B) << endl; // 4 bptr指针
cout << "sizeof(C) : " << sizeof(C) << endl; // 4 bptr指针
cout << "sizeof(D) : " << sizeof(D) << endl; // 8 一个虚基类子对象只会在继承类中存在一份实体,即A占用1B(现在编译器做了优化,可以为0),0 + 4 + 4 = 8
}

纯虚函数

纯虚函数相当于定义了一个接口,不同的子类必须定义自己的实现。

#include <iostream>
using namespace std; //抽象类
class Father
{
public:
virtual void calcMem() = 0; //=0表示这是个纯虚函数。纯虚函数不需要定义,没有方法体。
virtual void anotherMethod() = 0; //纯虚函数,也可以定义。
}; void Father::anotherMethod()
{
cout << "Father anotherMethod" << endl;
} class Son:public Father
{
public:
virtual void calcMem() //这里的virtual也可以不显示声明。
{
cout << "son calcMem" << endl;
} void anotherMethod()
{
cout << "Son anotherMethod" << endl;
}
}; int main()
{
Son *s = new Son();
s->calcMem(); //son calcMem
s->anotherMethod(); //Son anotherMethod Father *f = new Son();
f->calcMem(); //son calcMem
f->anotherMethod(); //Son anotherMethod
f->Father::anotherMethod(); //Father anotherMethod。也可以显示的调用父类的方法 return 0;
}

控制台打印:

son calcMem
Son anotherMethod
son calcMem
Son anotherMethod
Father anotherMethod

抽象类

抽象类不能声明对象,只是作为基类的派生类服务
抽象类不能定义对象,但是可以作为指针或者引用类型使用

1:含有纯虚函数的类成为抽象类。
      除非派生类中完全实现基类中所有的纯虚函数,否则,派生类也是抽象类,不能实例化对象。

2:只定义了protected型构造函数的类也是抽象类。因为无论是在外部还是派生类中都不能创建该对象。但是可以由其派生出新的类。

这种能派生出新类,但是不能创建自己对象的类时另一种形式的抽象类。

抽象类为什么不能实例化?
因为抽象类中的纯虚函数没有具体的实现,所以没办法实例化。

虚函数和纯虚函数的比较

(1)如果基类中定义了虚函数AF,派生类中对于这个虚函数可以覆盖也可以不覆盖。
派生类中如果覆盖了这个虚函数AZ,则通过指向子类的指针或引用调用的就是派生类中AZ
如果派生类中没有对这个AF进行覆盖,那么通过指向子类的指针或引用调用的就是基类中AF

(2)如果基类中定义了纯虚函数AAF,相当于是个接口。那么在派生类中就必须覆盖基类的这个纯虚函数。

转自:https://blog.csdn.net/qq_36748278/article/details/80433777

内联函数为什么不能被定义成虚函数?
内联函数是为了在代码中直接展开,减少函数调用花费的代价。
inline 函数是在编译时确定的,而 virtual 属性是在运行时确定的,因此这个两个属性是不可能同时定义的。

c++ 虚函数多态、纯虚函数、虚函数表指针、虚基类表指针详解的更多相关文章

  1. C++ 虚基类表指针字节对齐

    下面博客转载自别人的,我也是被这个问题坑了快两天了,关于各种虚基类,虚继承,虚函数以及数据成员等引发的一系列内存对齐的问题再次详细描述 先看下面这片代码.在这里我使用了一个空类K,不要被这个东西所迷惑 ...

  2. C++ 虚继承实现原理(虚基类表指针与虚基类表)

    虚继承和虚函数是完全无相关的两个概念. 虚继承是解决C++多重继承问题的一种手段,从不同途径继承来的同一基类,会在子类中存在多份拷贝.这将存在两个问题:其一,浪费存储空间:第二,存在二义性问题,通常可 ...

  3. 【c++内存分布系列】虚基类表

    虚基类表相对于虚函数表要稍微难理解些,故单独提出来. 虚函数表是在对象生成时插入一个虚函数指针,指向虚函数表,这个表中所列就是虚函数. 虚基类表原理与虚函数表类似,不过虚基类表的内容有所不同.表的第一 ...

  4. C++ 中的虚函数表及虚函数执行原理

    为了实现虚函数,C++ 使用了虚函数表来达到延迟绑定的目的.虚函数表在动态/延迟绑定行为中用于查询调用的函数. 尽管要描述清楚虚函数表的机制会多费点口舌,但其实其本身还是比较简单的. 首先,每个包含虚 ...

  5. C++对象的内存布局以及虚函数表和虚基表

    C++对象的内存布局以及虚函数表和虚基表 本文为整理文章, 参考: http://blog.csdn.net/haoel/article/details/3081328 http://blog.csd ...

  6. C++虚函数表与虚析构函数

    1.静态联编和动态联编联编:将源代码中的函数调用解释为要执行函数代码. 静态联编:编译时能确定唯一函数.在C中,每个函数名都能确定唯一的函数代码.在C++中,因为有函数重载,编译器须根据函数名,参数才 ...

  7. YTU 2636: B3 指向基类的指针访问派生类的成员函数

    2636: B3 指向基类的指针访问派生类的成员函数 时间限制: 1 Sec  内存限制: 128 MB 提交: 433  解决: 141 题目描述 领导类(Leader)和工程师类(Engineer ...

  8. 分区函数Partition By的与row_number()的用法以及与排序rank()的用法详解(获取分组(分区)中前几条记录)

    partition by关键字是分析性函数的一部分,它和聚合函数不同的地方在于它能返回一个分组中的多条记录,而聚合函数一般只有一条反映统计值的记录,partition by用于给结果集分组,如果没有指 ...

  9. 18.Java 封装详解/多态详解/类对象转型详解

    封装概述 简述 封装是面向对象的三大特征之一. 封装优点 提高代码的安全性. 提高代码的复用性. "高内聚":封装细节,便于修改内部代码,提高可维护性. "低耦合&quo ...

随机推荐

  1. Qt:QWebEngineView

    0.说明 QWebEngineView提供一个用于展示和编辑网页内容的Widget,QWebEngineView本质是一个Widget. 一个Web View通过load( QUrl )方法加载一个U ...

  2. 文件上传漏洞之MIME类型过滤

    上传的时候修改Content-Type为image/jpeg等程序指定的类型即可. 修改为: 使用蚁剑连接测试

  3. 云计算与云存储:使用云服务器搭建一个情侣纪念Web服务器

    做完了实验一,做完感觉这门还是蛮好玩的,而且第一实验就很有趣,搭建了一个可以在公网访问的纪念网站给女朋友秀了一下.写好实验报告后简单搬运,应该能给感兴趣的朋友带来帮助. 创建阿里云主机 进入阿里云官方 ...

  4. C++雾中风景18:C++20, 从concept开始

    转眼间,C++20的标准已经发布快两年了.不少C++的开源项目也已经将标准升级到最新的C++20了,笔者也开启了新标准的学习历程了.所以借这系列的博文,记录下笔者学习新标准的一些心得与吐槽~~ 作为C ...

  5. NLP论文解读:无需模板且高效的语言微调模型(下)

    原创作者 | 苏菲 论文题目: Prompt-free and Efficient Language Model Fine-Tuning 论文作者: Rabeeh Karimi Mahabadi 论文 ...

  6. Docker 部署xxl-job 报错:xxl-rpc remoting error(connect timed out), for url : xxxxxx

    使用Docker 部署的xxl-job,当调度中心和执行器部署在不同的容器内,此时xxl-job调用执行器的服务就会报: address:http://172.0.0.1:8841/ code:500 ...

  7. 总结一下Java基础知识

    重中之重-----------基础 底层结构决定上层建筑,所以,基础很重要. 自信心 在开始说基础之前先说明一下自信心的重要性,没有自信心学什么东西都学不好. 核心自信***** 核心自信从三个方面来 ...

  8. java笔记:00 数据类型

  9. LGP6156题解

    真·简单题 题目大意 给定 \(n\) 和 \(k\),求出这个柿子的值: \[\sum_{i=1}^n\sum_{j=1}^n(i+j)^k\mu^2(\gcd(i,j)gcd(i,j) \] 按照 ...

  10. web自动化之selenium(六)利用坐标点定位

    这是通过第三发库实现对元素的定位,因为在无法定位元素的时候,只能通过外部来定位,此时就可以使用pyautogui模块,操作鼠标,模拟人进行操作 # 使用注意事项,不要过于的依赖它 1.使用时需要在通过 ...