【C++】面向对象---多态(万字详解)(C++是面向对象的吗)

java8

帖子摘要： 欢迎来到小林的博客 ???????博客主页??小林爱敲代码 ???????文章专栏??小林的C之路 ???????欢迎关注点赞收藏??留言  ??????今天给大家讲解多态多态是面向对象的一个重要内......
' U, H& a: _2 A7 _+ h$ B% a# R
大家好，欢迎来到Java吧（www.java8.com），交流、学习Java技术、获取Java资源无任何套路，今天说一说：“【C++】面向对象---多态(万字详解)”


        
3 d# i* h  g0 F" |8 z( `               
8 z; G% L. ^2 I* O. }                    
                        
1 @9 A' U3 Q2 M- r1 q! K3 R9 g                    
: E% B  b6 y) ~( D                    
??? ??? 欢迎来到小林的博客
???????博客主页??小林爱敲代码
???????文章专栏??小林的C++之路
???????欢迎关注点赞收藏??留言

; L" h$ I; Q8 z  B; l8 U) o/ t: x+ t

43e0037f1b8645ee81bdc9012e8f63bd.png (304.08 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
43e0037f1b8645ee81bdc9012e8f63bd.png

: }5 f* @: G! S??????今天给大家讲解多态多态是面向对象的一个重要内容。也非常的抽象所以今天尽我所能为大家分享自己对C++中多态的一些理解。

9 \8 }( B9 Q2 Z! c
8 j( g6 Z$ K' K9 A
; E* E' w$ ?/ n: c8 v4 n, x( A( ~[color=]?? ??????每日一句: 世界上只有想不通的人没有走不通的路。
& h0 u  {8 S! E4 p

大纲:
" ?) w/ D- v$ v9 e
. M- W! C3 y1 h5 Z4 K: I

b8136d3adb044d9583ec10f0601f1d38.png (80.68 KB, 下载次数: 0, 售价: 1 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
b8136d3adb044d9583ec10f0601f1d38.png

( v" O* ]& D) g- }

6 L( y7 t5 j! p1 |' X) k 目录
- l  \3 _" G5 r9 h

1. 多态的概念

2. 多态的定义及实现

2.2 多态的构成条件

2.3 虚函数

2.4 虚函数的重写

2.5 协变

2.6析构函数的重写

2.7 重载重写(覆盖)重定义(隐藏)之间的区别
: G+ P, s6 s2 P; j0 L. m1 `  

3. override 和 final(c++11)

4.抽象类

5.多态的原理

6.单继承和多继承的虚函数表

6.2 打印虚函数表

6.3 单继承的虚函数表

6.4 多继承的虚函数表
  

7.多态面试问答题

总结

' O- a1 g9 k8 ?" I: `" B. ?# M1. 多态的概念
, q, {& N( ?# {0 Z. l& O
????多态的意思就是多种形态简而言之就是 :
[color=]不同的事物做同一种行为产生了不同的结果。
# E" P7 O& c$ [; G; O 打个比方学生和普通人买票学生优惠7折而普通人没有优惠。这类现象就符合多态不同的事物(普通人学生)做同一种行为(买票)产生了不同的结果(学生七折普通人全款)。

8c8f97ef01844e49a59392d857642ca5.png (247.58 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
8c8f97ef01844e49a59392d857642ca5.png

2 [  i3 v* ?5 U0 l 而普通人和学生之间还有另外一种关系那就是继承关系。因为学生也是人所以构成多态的前提是不同的事物之间构成继承关系。
; C% A  d# m7 ~/ j& e/ l( i$ S
! H! X: P' A$ y: w+ X8 q
, c+ e7 r, Y0 p6 G$ S" ~+ j
8 Z. O- L. p; V% K8 T2. 多态的定义及实现
2.2 多态的构成条件
????想要知道多态如何定义那么我们必须知道多态的定义条件。构成多态的两个条件:
0 c) I- ?. H2 K6 B0 q  N: |

1.必须通过基类的指针或引用调用虚函数。
6 i( |8 S( E6 `  w( L' W" @ 2.被调用的函数必须是虚函数且派生类必须对基类的虚函数进行重写。



/ c8 ?; k( u7 t6 m: ]: e2.3 虚函数
" k% ^  v/ t+ G/ h. E& m! ~' A
虚函数:被virtual 修饰的函数即为虚函数。

class Person
{
4 M, i: S! H! i1 ~7 o& _) Q3 S
public:
        virtual void BuyTicket()//被virtual修饰是虚函数
& ?# V. B* t# D% z/ T
        {
$ L! v2 }4 ~0 T% Q) y8 v6 n# e
                
        }
};
复制代码

! }$ L& k3 f( D% W0 J& Y2.4 虚函数的重写
8 H" }" A" ?7 [( x虚函数的重写: 派生类必须有一个和基类一样(三同)的虚函数才能构成重写。构成重写的条件:
6 w# ~8 v' t) y+ R( k 1.派生类被重写的函数也得是虚函数(虽然不是也可以因为会直接继承父类的虚函数)。
) H2 j- o1 l4 T& }5 S* ~ 2.派生类被重写的函数和基类的虚函数一样 (函数名返回值参数都相同协变除外)。

6 O3 z, k0 y  r5 Q4 L/ }  F( m7 _下面是一个虚函数构成重写的案例:

& j9 e) f+ x% c0 P3 d

class Person
; J) |* K/ G; R/ J- X( E2 I8 l
{
6 Y, P2 G3 F& @+ D$ {- K
public:
        virtual void BuyTicket()
        {
' T+ A* S0 `/ {! ]
                cout 
8 @( x+ u) m  t2 Z: I" ?
public:
) V7 V8 F4 `9 m- W
        virtual void BuyTicket()
. d4 ?$ L- i( y3 U8 K6 t
        {
                cout  
以上代码构成以下关系:
* f+ [" [4 n; b' b, A" @
 基类 : Person
 派生类 : Student
5 P7 n) j( D0 j& k1 u
 基类的BuyTicket函数被virtual修饰所以是虚函数。
 派生类有一个和基类虚函数一模一样的虚函数。
 所以派生类BuyTicket构成重写(覆盖)。
) ]. Y8 J( y# i$ V! M
 
[size=5]2.5 协变[/size] 
5 q, q  m8 G% h! f: P) |/ R8 \
上面说过被重写的函数必须与其基类对应的虚函数保持三同(返回值函数名参数)而协变是个例外协变支持返回值是父子类的指针或引用。
 
# G1 a! x+ d" S3 a3 ]. U9 c6 i
代码案例如下:
) K. K/ K  Y0 H2 {- B
 
! ^' o9 l6 j: [4 a) f
[code]class A{};
6 w$ W. R. G4 D  l- ^
class B:public A
6 L4 Q( Z& |* A; M
{};
) Z% D) W) V4 J+ T
class Person
5 }* B! y: ?0 I: ]' H' E
{
! ^( J. t8 U- G
public:
3 i( F. K( F+ @5 e
        virtual A* BuyTicket()
: ~: u4 G% ~2 T- X( Y2 \
        {
                new A();
* T' U! b3 i9 u# p7 A! T
        }
" s; I! q2 Y/ `
};
class Student : public Person
{
2 f3 r8 O" ~$ `+ u- X" r
public:
8 h3 }6 v0 H  y
        virtual B* BuyTicket()
        {
                new B();
        }
};
复制代码

返回值是父子类的指针或引用(也就是协变)一样会重写。

! s$ _) x. C+ r, i1 I% R2.6析构函数的重写
当我们在通过父类指针接收一个子类对象时并期望释放掉这个对象。那么我们必须要让子类重写析构函数。也就是让析构函数变成虚函数析构函数变成虚函数之后。子类会自动重写析构这是因为在编译时析构函数的函数名会被统一处理为destructor。所以析构函数的函数名看起来不同但实际上却是相同的。
' Q  o2 ]2 Y9 M6 r# Q
& t0 d; ~' U0 G; @& A! K5 H6 K下面是一个重写析构函数的例子:
, y" U; B. X! u6 {! j 不重写析构函数的代码:
& n! c  ^5 R3 `, u% z6 m- M0 ?

class Person
{
public:
        virtual void BuyTicket()
        {
                cout 
( M* c! z9 k  \2 G1 i
                cout 
public:
0 ^  H' b0 V1 W/ a
        virtual void BuyTicket()
" m) r% P8 d6 |6 q
        {
0 Y( I% p- D( |8 G% {$ o2 t3 b/ W3 S. S
                cout 
) s0 x+ w) ?6 m2 z* h; k% f( N! R9 u. w
                cout 
        delete p;
6 Z4 p' I' E: U
}
$ H- H) O& @! a2 ~7 k) q3 l
int main()
- I( K8 c7 R6 }7 q
{
        Person* p = new Person();
        Student* s = new Student();
7 z6 b1 y* K1 o" a4 U) ?3 b7 Y
        a(s);        
/ Y- n/ J" z! i9 T: C
        return 0;
$ ]  ?( _# }0 d0 Q, ^
}
复制代码

我们这个代码是没有没有重写析构函数的因为析构函数不是虚函数我们看看结果。

/ i2 K! s1 f+ ^; G4 @8 N/ L

10e50e295349471fbe4c1cfbc0f36554.png (94.56 KB, 下载次数: 0, 售价: 3 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
10e50e295349471fbe4c1cfbc0f36554.png

4 |1 E; p7 a1 L% f; }) _
我们会发现问题很严因为我传过去的是一个Student也就是基类对象。但是我们用父类指针接收那么 指针pp的使用范围 就是Person的范围。所以无法调用子类的析构函数只能调用自己的析构函数。也就是说释放不彻底因为传过去的对象是s对象的指针而delete它时它却只调用了父类的析构函数没有调用自己本身的析构函数如果此时s对象有动态开辟的空间那么就造成了内存泄露这是很严重的。这是因为指针是Person类型的所以只能访问Person的那一部分。想要解决这个问题我们就需要重写析构函数。以至于传子类对象指针父类指针接收也能调到子类的析构函数。

. x( g0 P9 k, d2 B* } 正确的写法:
5 k2 l& Y3 c8 J
1 a' i: l. ~; d: t' N

class Person
  C/ d( [3 [$ h4 E' D/ o- E
{
9 G, D6 U: @$ s
public:
# u% ^0 m! b. x- Y- a5 S
        virtual void BuyTicket()
        {
                cout 
                cout 
# h- G; A5 x/ a. n/ x; k2 T2 r
public:
5 b( B" B/ P, k# @2 Z5 D
        virtual void BuyTicket()
        {
                cout 
                cout 
        delete pp;
}
int main()
, i! ~! X+ [6 d5 w0 w/ t/ {! a, U
{
        Person* p = new Person();
8 [7 a) r$ I( B/ o  _
        Student* s = new Student();
' x1 }9 `0 |3 V- o, Z5 H
        a(s);        
        return 0;
}
5 {- ]7 m4 c& p2 ~/ v" R
复制代码

: j1 }4 U: x" u7 e) x5 s这时候我们可以看到Student的析构函数也被调用了这就意味着s对象被真正析构。所以析构函数还是很有必要被重写的。

% `2 _3 {8 B+ S7 \

50f86aac21c34a72bb0f285b8555b287.png (97.36 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
50f86aac21c34a72bb0f285b8555b287.png

5 Z+ w) {( b! j$ i1 [( [/ I
: k5 o; C; g1 u2.7 重载重写(覆盖)重定义(隐藏)之间的区别
# S$ ~) T* l. Q) C0 g- x一张图概括

% i7 ?- {/ J% E+ M, e0 ~3 S

35424cca7035480395dbc0c66d66bc60.png (69.78 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
35424cca7035480395dbc0c66d66bc60.png

6 i, f2 R0 F  K1 k& l2 K
3. override 和 final(c++11)
9 x% C6 v' p% b2 ~8 o; \override 和 final 在c++11才被引用2个关键字的作用也很简单。
final修饰虚函数表示虚函数不能被重写。
override检查派生类是否重写了虚函数如果没重写会报错。

final的使用
/ M) B) S7 K/ X9 j- X) a7 J: y
( P% W4 Z& K( x2 O& X' e# H

9de7f0ccb457468fa3f8652340296c08.png (72.32 KB, 下载次数: 0, 售价: 2 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
9de7f0ccb457468fa3f8652340296c08.png

' S# x0 g4 S! ]  K4 {, Noverride的使用
. h& D2 \3 S% X$ R9 O4 n" y
& a: h3 B6 r. z# b  m( g; a

7a9f69d69f39481f93080977f0a61737.png (61.28 KB, 下载次数: 0, 售价: 3 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
7a9f69d69f39481f93080977f0a61737.png

: y  s6 R! b& S  M7 \
4.抽象类

在虚函数的后面加上一个 = 0这个函数就是纯虚这就代表这是一个抽象类也叫接口类抽象类不能被实例化派生类继承后也不能实例化出对象。除非重写其基类的纯虚函数。
# j0 K: |$ _! _' e

2 i1 V$ z! |  z4 X- G, D& o代码样例:

9 d7 b9 }4 X) p1 D

class Person
{
public:
        virtual void Eat() = 0
        {
        }
- q$ w/ X: i4 v* D1 U3 z- d- \) z
};
% L, _" E8 Y2 }1 Z8 r& @! q
class Student : public Person
{
public:
};
int main()
& H8 w. ~8 E2 j1 b6 O
{
  ?; a  [( L2 S" {% Y
        Person p;
        Student s;
: e# K2 h: O) f* F! L+ U
        return 0;
}
/ b# x3 Q* Z. e, E! q& w: l) Q
复制代码

57ad9c90d20e4d1a9468703c110ff24d.png (78.45 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
57ad9c90d20e4d1a9468703c110ff24d.png

- L6 U' B' y5 e; p: \ 如果想使用我们必须重写纯虚函数。

  h- X0 V7 D! ]

f1b9644615f34b698a2c4cc85c8bcda6.png (80.87 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
f1b9644615f34b698a2c4cc85c8bcda6.png

但是p依然不能实例化想要p对象我们可以通过指针或者引用的方式。
# N" ?  g1 E6 W& K2 k

class Person
) X; n1 e8 a, `) V. ~0 h
{
public:
3 p2 i( e4 C( ~$ ?6 z0 x* Q$ t
        virtual void Eat() = 0
; p5 n0 Z& F  _) @& U8 ^
        {
        }
2 b1 N# z- ]# m: Z: O, I9 ?& [
};
' M1 @" e8 y7 I3 D3 @6 r
class Student : public Person
. @/ W9 l+ M5 v  k- t9 s
{
public:
. J+ V' h  B, Y6 l9 [
        virtual void Eat()
( @6 `5 J1 n; Z2 C6 [
        {
' ~8 r$ c) ^' Y
                cout 
% |" T, P+ W: z
        Student s;
        Person& p = s;
7 t7 F+ [) f1 T1 P2 @8 P/ K
        p.Eat();
/ ?2 {- d7 r2 J9 n! D
        return 0;
}
复制代码

这种方法已经构成了多态因为s通过了基类的指针调用其纯虚函数。


5.多态的原理
那么多态是怎么实现的呢我们先来监视一下非多态时子类对象和父类对象。
+ Z2 c/ B. O3 |1 V$ r. o! o

class Person
{
public:
         void BuyTicket()
7 Q) P' a7 K  F# Q, }" P
        {
: j- P/ \5 B7 r, i' \% a
                 cout 
' ^0 a4 N* K9 S; L3 o* e2 J* o
public:
         void BuyTicket()
        {
                cout 
3 z3 P- L6 U: T  s3 M
        Student s;
2 }  E9 }: O& z4 u
        Person p;
        return 0;
0 ]0 o0 C9 N& w8 Y$ g
}
- ]" u7 F8 F9 ^
复制代码

这是父类对象

+ H, ~( }9 [+ C5 R: I. H9 M6 ]

1c053c886a3a43eb88b233efa3641e20.png (35.94 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
1c053c886a3a43eb88b233efa3641e20.png

& U; w1 I  a( q9 Z' k8 O) I
7 j! Q# o2 j- R4 v 这是子类对象
5 l! P3 I5 @2 I" A

ed1057c5ae7545089ddec1c16cc735b7.png (22.59 KB, 下载次数: 0, 售价: 3 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
ed1057c5ae7545089ddec1c16cc735b7.png

接下来我们看看实现多态时的样子。
) i) O! W' F5 n  m) c  |5 K
# z3 ~& q1 k, E' N2 }3 I: l2 E& F* E

class Person
{
public:
        virtual void BuyTicket()
  H  I- P; }& A3 b/ N
        {
                 cout 
; T- N  }1 e: N- S
public:
/ R- P5 P+ r1 A" S7 c: i7 \
        virtual void BuyTicket()
        {
) f& r0 q# y& e$ ~3 G: e
                cout 
        Student s;
        Person p;
        return 0;
& R8 Z& `( m% R% C3 r
}
复制代码

8 Y+ y) j" L8 t! ?8 T父类对象:
- D( `) x" {4 _

4bd1cbaccd304e49b79144e5d5eb787c.png (22.18 KB, 下载次数: 0, 售价: 2 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
4bd1cbaccd304e49b79144e5d5eb787c.png

2 @" N, K. K* x, X- G5 K3 i3 _ 子类对象:
& G, L4 N4 F2 D4 s9 B* d- \

7d5fce80e81d492dbd1d1adcc21abe88.png (25.64 KB, 下载次数: 0, 售价: 2 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
7d5fce80e81d492dbd1d1adcc21abe88.png

# w- `& b/ f5 h- W 我们可以很清楚的发现构成多态后对象里面会多一个__vfptr的参数。而这个参数是虚函数表指针(简称虚表指针)它指向一个数组数组的每个元素是一个函数指针。而这个数组叫做虚函数表。而虚函数表里面存的就是虚函数的地址。当子类进行重写的时候就会去虚函数表里面把存储的父类虚函数的地址覆盖成自己的虚函数地址。所以进行切片时虚函数表里的虚函数地址还是自己的。调用虚函数时去自己的虚函数表里面找到对应的虚函数。

所以多态的实现原理简单来说就是以下几个步骤

[ol]

看父类有没有虚函数如果有虚函数则会在父类生成一个虚函数表。

7 H0 h3 z4 B; I# a) w9 n/ v& E

138ed1c1b0d84209aaf36a9397021e61.png (22.35 KB, 下载次数: 0, 售价: 2 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
138ed1c1b0d84209aaf36a9397021e61.png

' l" J! K4 S5 s# t

子类继承父类时会把父类的虚函数表也继承下来。

a2bea881074848c08e0a97c1e4f1fba6.png (34.33 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
a2bea881074848c08e0a97c1e4f1fba6.png

随后子类查找有没有符合重写条件的函数(三同且是虚函数)符合重写条件则到继承的虚函数表里覆盖掉父类的虚函数表。
9 D# E, l2 V+ i [/ol]
# M( t% D! P7 K" D! I

c5e64822c78249c3bb34833bd885dd9a.png (37.04 KB, 下载次数: 0, 售价: 4 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
c5e64822c78249c3bb34833bd885dd9a.png

此时如果构成多态就会进Student的虚函数表里面找对应的虚函数调用因为父类虚函数的地址被替换了。
4 A, {5 }3 w4 I: \
! Z* g- O) f4 Q+ N" J
# S  }3 u2 }3 c# P 6.单继承和多继承的虚函数表
7 \$ v( |0 ^) _$ q 6.2 打印虚函数表
以下这段代码可以直接打印虚函数表其原理取对象的地址随后强制转换成一个指针。因为指针在32平台是4字节在64平台是8字节。所以把对象强制转换成指针类型访问的第一个元素就是一个指针的大小。因为虚表指针就是在对象的最前面4个或8个字节。然后强制转换成函数指针。

class Person
{
public:
        virtual void fun1()
        {
) d0 m( \9 j" z! h4 t
                cout 
                cout 
) a# B; Y- V& \0 T5 k2 I
public:
% D9 v  [9 y, ^
        virtual void fun1()
        {
                cout 
                cout 
4 u/ q1 Y, y) l# ]- _
                cout 
. n5 r6 o, R( R6 j) |: ^! o
                cout 
, e( X& h- }* G
        p.fun1();
. @6 I. V* O5 k- v9 J. Q/ `8 \
}
typedef void(*VFPTR) ();
void PrintVTable(VFPTR vTable[])
$ x# q0 y( x7 c4 W, l" Z
{
! s+ \, Q! g5 s+ m
        
, d& ^+ W( N9 Q1 \$ ?
        cout " 
. q! l4 i% }% M5 L& a
                printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
                VFPTR f = vTable[i];
( r7 R. Y# X: U. A/ ?
                f();
5 Z& f3 D( M, g  i& g
        }
        cout 
        Person p;
9 P" h! R* i- b- a+ K
        Student s;
  |5 r3 s  B# L8 S" n
        VFPTR * vTableb = (VFPTR*)(*(void**)&p);
        PrintVTable(vTableb);
1 L8 u# \5 b7 ?* O) j0 r
        VFPTR* vTabled = (VFPTR*)(*(void**)&s);
        PrintVTable(vTabled);
        return 0;
}
+ o. k  }- M8 T- v8 g3 x* Q& v
复制代码

我们看看打印结果

041367ea241b44578486fcc8d91a0739.png (210.2 KB, 下载次数: 0, 售价: 6 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
041367ea241b44578486fcc8d91a0739.png

: p3 {- u9 ]) X9 e- o% A 这样我们就可以看到虚函数表的打印结果了。

6.3 单继承的虚函数表
上面说过的情况就是单继承时的情况子类继承父类时会继承它的虚表。随后在虚表里面覆盖重写的函数。那么如果此时子类自己的函数也是虚函数那么也会添加至虚函数表中。

6 g  Z/ [( f; |) e两个类的关系如下所示
6 U8 o" h9 `7 s/ g7 Q. |0 R! T3 h

class Person
& H: q7 _' y5 h% A, [. [
{
public:
        virtual void fun1()
4 m; ~. M) C+ m! f; t7 y$ A" s
        {
$ f- M1 V  `+ d
                cout 
                cout 
public:
5 E0 N5 d- F' m' z* D) X
        virtual void fun1()
. O$ H+ ]* U, ^  A! s7 B  w
        {
" h; Z0 d: t/ B# a
                cout 
                cout 
                cout 
                cout  
: b) i3 E' P& d( Q9 V
我们可以发现子类的fun1和fun2与父类构成多态。可是fun3和fun4并没有构成多态但是它们依然会被添加进子类的虚函数表。
 







533d9fd595e645aeb9ea5ffed31d5949.png

(190.22 KB, 下载次数: 0, 售价: 1 金钱)



2023-1-19 14:32 上传
点击文件名下载附件
533d9fd595e645aeb9ea5ffed31d5949.png



 所以虚函数表也会添加自身的虚函数。
) o* J4 P4 l, I+ W. E
 
: X' \4 N3 C! u9 E- l  ^  ^
[size=5] 6.4 多继承的虚函数表[/size] 
9 A5 p+ y9 V# X/ e0 W' }4 P; L
那么如果是多继承呢
 
以下代码实现了多继承me继承了Base1和Base2。因此Base1的虚函数表在m的前4/8个字节的位置。但是Base2的虚函数表可不在后面。所以要想知道Base2的虚函数表位置。我们需要m的地址在原有的基础上加一个Base1大小这样就到达了Base2对象的首地址再取前4/8个字节就是Base2的虚函数表。
 
[code]class Base1
. q% g+ A( N& T# f% v
{
. X$ H* |" Q6 }. h
public:
/ G" ]6 M% x9 W$ E1 ~9 I
        virtual void fun1()
" D, J1 t. Z  y. l# ^$ E: N
        {
                cout 
: e% W6 y8 v: R, X7 c! w: {. ~
                cout 
- H8 E9 v& t5 p, T9 h& k3 A
public:
        virtual void fun3()
        {
0 E- Z5 w/ b6 f  i& t6 {% }8 K
                cout 
                cout 
7 Y$ Q7 ~+ |1 S; ^
        virtual void fun1()
! n% [1 u* H4 k( U6 j7 Z
        {
                cout 
                cout 
3 D$ S/ {+ |1 }4 |! Q8 t' ?
                cout 
                cout 
# m) J; j9 U1 u# s$ r# D; k
        
        cout " 
8 K1 |5 ~" `, L* h8 \( S
                printf(" 第%d个虚函数地址 :0X%x,->", i+1, vTable[i]);
                VFPTR f = vTable[i];
* V. Z3 `* r6 N
                f();
$ e; M( h1 u8 i
        }
+ }8 d* V3 a* ~6 I4 `
        cout 
! O, v* J7 I4 g2 b. s. J
        me m;
        VFPTR * vTableb = (VFPTR*)(*(void**)&m);
        PrintVTable(vTableb);
, Z- V$ y4 [: p
        VFPTR* vTabled = (VFPTR*)(*(void**)((char*)&m+sizeof(Base1)));
# Y( q1 v1 ^' Q6 k- L* m) V3 n- n
        PrintVTable(vTabled);
! A4 K! O5 T( m4 K9 `1 C
        return 0;
! n* h# M; V' I0 i+ d9 t/ M" \, z
}
复制代码

2 u* {0 Q8 Z4 a4 {; H# R9 G8 D我们看看代码结果:
. @) l+ B* l1 M+ k( C7 \9 x- X" g

557b6a5eee174334885e44e00540537c.png (147.76 KB, 下载次数: 0, 售价: 1 金钱)

2023-1-19 14:32 上传

点击文件名下载附件
557b6a5eee174334885e44e00540537c.png

我们可以看到当有一个类继承了多个类时那么会产生多张虚函数表。而自己的虚函数(非重写) 将会被默认放在第一张函数表中。

: ^: u. q! ?4 T* [: w, t) S 7.多态面试问答题
[ol]

什么是多态
. {5 h2 ]; w5 _  i* B& C 2答不同的事物做同一行为产生不同的结果。
4 l: v" E; g4 a: J0 A' p

什么是重载、重写(覆盖)、重定义(隐藏)
答重载要在同一作用域下且函数名相同但参数的顺序个数类型不同。
重写是当基类和派生类有一模一样的虚函数时子类虚函数表中的父类虚函数地址会被覆盖。
3 h) i# A# C* i" ^/ j# [ 重定义从父类继承下来且没有重写的就是重定义重定义函数名参数相同。

多态的实现原理
答父类的所有虚函数都会存在虚函数表中而虚函数表存储在常量区。当子类继承了父类时也会继承父类的虚函数表如果此时子类又符合重写要求的函数。则会去自己的虚函数表中替换掉父类的虚函数地址换成自己的虚函数地址。

inline函数可以是虚函数吗
答可以不过编译器就忽略inline属性这个函数就不再是
inline因为虚函数要放到虚表中去。
6 d$ V9 `5 m  r! _* H( S

静态成员可以是虚函数吗
答不能因为静态成员函数没有this指针使用类型::成员函数的调用方式无法访问虚函数表所以静态成员函数无法放进虚函数表。
. X# `& ^# z1 A

构造函数可以是虚函数吗
7 x/ h0 U) a! x1 ? 答不能因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
8 O9 k% R; i# ?: z

析构函数可以是虚函数吗什么场景下析构函数是虚函数
可以并且最好把基类的析构函数定义成虚函数否则当子类和父类构成多态时。delete释放对象可能会导致内存泄漏具体上面有讲解。

对象访问普通函数快还是虚函数更快
9 P3 w8 [2 B0 ?8 z# P; ?0 S/ \ 答构成多态普通函数快。不构成多态一样快。
+ I, A0 ~7 u6 v* u# a* v5 T

虚函数表是在什么阶段生成的存在哪的
答虚函数表是在编译阶段就生成的一般情况下存在代码段(常量区)的。
) c! `, b' p8 h, [+ R4 V% P

什么是抽象类抽象类的作用
0 d& C4 y1 k; j0 ]9 ]/ w+ k, x; h 答抽象类强制重写了虚函数另外抽象类体现出了接口继承关系。
[/ol]
总结
/ j1 v( I5 u2 y8 M; k2 A3 N如果有写的有什么不好的地方希望大家指证出来我会不断的改正自己的错误。如果感觉写的还可以可以点赞三连一波哦~后续会持续为大家更新C/C++数据结构Linux相关的知识
) a3 J9 p+ ~. [# W: k/ n
1 {: {6 w8 J. R/ W7 K6 V; \ 你们的支持是我最大的动力希望在往后的日子里我们大家一起进步
               
               
               
本文来源csdn，由Java吧转载发布，观点不代表Java吧的立场，转载请标明来源出处：https://www.java8.com