深入C++成员函数及虚函数表
大家好!这次逗比老师要和大家分享的是C++中的成员函数,我们会深入解析C++处理对象成员时的方式,还有关于成员函数指针、虚函数表等问题的深入研究。
简单对象的内存布局
在介绍其他问题之前,咱们先来研究一下,一个C++对象在内存中的存储布局。首先,如果是POD类型的对象,那么布局方式和C中的结构体相同,按照定义的顺序排布所有成员,并且会在适宜的时候进行内存对齐。例如下面例程我们写了一个简单的用来打印一个对象内部结构(十六进制方式)的代码:
#include <iostream>
#include <iomanip>
class C1 {
public:
char m1;
// pad 7 Bytes
uint32_t m2[5];
};
template <typename T>
void ShowMemory(const T &ref, const std::string &name = "no name") {
std::cout << "=====begin=====" << std::endl;
auto base = reinterpret_cast<const uint8_t *>(&ref);
auto size = sizeof(typename std::remove_reference<T>::type);
std::cout << "name: " << name << std::endl;
std::cout << "size: " << size << " Byte(s)" << std::endl;
std::cout << " |";
for (int i = 0; i < 16; i++) {
std::cout << std::setw(2) << std::hex << i << "|";
}
std::cout << std::endl;
int i = 0;
for (const uint8_t *ptr = base; ptr < base + size; ptr++) {
if (i % 16 == 0) {
std::cout << " " << std::hex << i / 16 << "|";
}
i++;
std::cout << std::setw(2) << std::setfill('0') << std::hex << uint16_t{*ptr} << "|";
if (i % 16 == 0) {
std::cout << std::endl;
}
}
std::cout << std::endl << "======end======" << std::endl;
}
#define SHOW(obj) ShowMemory(obj, #obj)
int main(int argc, const char * argv[]) {
C1 c1;
c1.m1 = 44;
c1.m2[0] = 88;
SHOW(c1);
return 0;
}
示例的输出结果如下:
=====begin=====
name: c1
size: 24 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|2c|00|00|00|58|00|00|00|00|00|00|00|00|00|00|00|
0|00|00|00|00|00|00|00|00|
======end======
相信这一部分大家都很熟悉了,不再啰嗦。
接下来我们要研究的是,非POD类型中,C++到底都“偷偷”在对象中做了什么。首先我们先看一下简单继承的方式,假如有B继承自A,那么B中是如何布局的呢?请看例程:
// ShowMemory相关内容省略,参考之前的例程即可
class A {
public:
uint16_t m1, m2;
uint8_t m3;
};
class B : public A {
public:
uint16_t m4;
};
int main(int argc, const char * argv[]) {
B b;
b.m1 = 0x1234;
b.m2 = 0x4567;
b.m3 = 0xef;
b.m4 = 0x789a;
SHOW(b);
return 0;
}
输出如下:
=====begin=====
name: b
size: 8 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|34|12|67|45|ef|00|9a|78|
======end======
看得出,地址0x00和0x01是m1,0x02和0x03是m2,0x04是m3,然后0x05是一个字节的内存对齐。也就是说,0x00~0x05其实就是一个完整的A类型对象,也就是父类集成到的内容。然后0x06和0x07是m4,也就是后面排的是子类的扩展内容。
我们知道,数据类型仅仅是处理数据的方式,然而数据本身都只是相同的二进制数罢了,如果知道了一个对象的实际内存布局,那么我们其实也可以反过来直接构造一个对象。请看下面历程:
// 省略A和B的定义,请参考上面历程
int main(int argc, const char * argv[]) {
// 直接构造二进制数据
uint8_t data[] = {0x34, 0x12, 0x67, 0x45, 0xef, 0x00, 0x9a, 0x78};
// 用对象方式解析数据
B *ptr = reinterpret_cast<B *>(data);
// 尝试读取m2和m4
std::cout << std::hex << ptr->m2 << ", " << ptr->m4 << std::endl;
return 0;
}
输出结果如下:
4567, 789a
看起来,通过二进制数据来反向构造对象,到目前为止还是可行的。
请大家先消化上面的内容,我们再一起来往下看。
成员函数指针
我们了解到,C++其实本质还是C语言,只不过做了很多语法糖,使得语法更为高级,更加适合用高等思维去设计。但语法并不改变语义,C++的高级语法其实都可以等价翻译为C语言语法,例如函数重载,其本质是编译器在函数名前后加上了前后缀用以区分的。
那么成员函数也是一样的,虽然我们把它写在类当中,但本质上,它仍是函数,和普通函数一样,它的指令也会存入一块内存,我们也可以设法找到这片内存。
先来看一个静态成员函数的例子:
class C1 {
public:
static void test() {std::cout << "C1::test" << std::endl;}
};
int main(int argc, const char * argv[]) {
// 静态成员函数指针
void (*pf1)() = C1::test;
// 打印地址的值
std::cout << reinterpret_cast<void *>(pf1) << std::endl;
// 直接调用
pf1();
return 0;
}
执行结果:
0x100003074
C1::test
这里的0x100003074其实就是C1::test函数保存的跳转地址。所以这里我们看到,其实静态成员函数就是普通的函数而已,语义上来说,和写在外面的函数没什么区别,这里的类名其实与命名空间几乎无异了。只是语法上来说,它在C1内,那我们自然是要写和C1相关的内容。
但如果是非静态成员函数呢?请看例程:
class C1 {
public:
int m1;
void test(int a) {std::cout << "C1::test, a=" << a << ", m1=" << m1 << std::endl;}
};
int main(int argc, const char * argv[]) {
// 定义对象
C1 c1;
// 成员赋值
c1.m1 = 1234;
// 成员函数指针
void (C1::*pf1)(int) = &C1::test;
// pf1的长度
std::cout << sizeof(pf1) << std::endl;
// 调用
(c1.*pf1)(5);
return 0;
}
输出如下:
16
C1::test, a=5, m1=1234
非静态成员函数指针的用法大家应该不陌生,但似乎让我们很诧异的是这个16,照理讲,在64位环境下,指针的大小都是8字节,可pf1却很个性地来了个16,这是为什么?
先不急,我们还是把pf1的二进制内容先打印出来看看:
int main(int argc, const char * argv[]) {
C1 c1;
c1.m1 = 1234;
void (C1::*pf1)(int) = &C1::test;
SHOW(pf1);
return 0;
}
/* 输出结果:
=====begin=====
name: pf1
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|80|28|00|00|01|00|00|00|00|00|00|00|00|00|00|00|
======end======
*/
后面一长串都是0,而前面这部分看上去有点像是地址,不免让人猜测,是否前8字节才是真正的函数地址呢?我们来做个实验便好:
class C1 {
public:
int m1;
void test(int a) {std::cout << "C1::test, a=" << a << ", m1=" << m1 << std::endl;}
void test2() {std::cout << "C1::test2" << std::endl;}
};
int main(int argc, const char * argv[]) {
C1 c1;
c1.m1 = 1234;
void (C1::*pf1)(int) = &C1::test;
void (C1::*pf2)() = &C1::test2;
auto test_ppf = reinterpret_cast<void (**)()>(&pf2);
(*test_ppf)();
return 0;
}
/*输出结果:
C1::test2
*/
(这里怕有些读者看晕,我稍微多解释一下。由于void (C1::*)()这种类型是16字节长度的,并不是普通的指针,因此我们不能直接转换成void *或普通函数指针。而我们现在要做的是把pf2的前8个字节拿出来,再按照一个普通的函数指针去读取。因此,我们先取pf2的地址,然后把这个地址按照二级指针进行解指针,得到一个指针,而这个指针的值其实就是pf2的前8个字节。所以刚才那几行代码如果详细一点来写就是这样:
void (C1::*pf2)() = &C1::test2;
void *ppf2 = reinterpret_cast<void *>(&pf2); // ppf2是pf2的地址
// 但此时ppf2应该是个二级指针,解指针后应该得到一个8字节的数
uintptr_t pf_addr = *reinterpret_cast<uintptr_t *>(ppf2);
// pf_addr的值,应该就是我们想到的函数的地址的值了,还需要再转换成函数指针类型
void (*pf)() = reinterpret_cast<void (*)()>(pf_addr);
// 按照函数方式调用
pf();
转义之后相信大家应该更容易看得懂了。)
果然如此,前8个字节解出来的地址,还真的是个可调用的函数。但到目前为止我们都没有出现任何问题,是因为C1::test2是无参的,并且内部也与成员变量无关。如果把相同的操作用给C1::test的话就会core dump,有兴趣的读者可以自行尝试。
既然是非静态的成员函数,我们都只要正常操作都是用对象来调用的,这个对象会作为函数的一个隐藏参数(也就是this)来传入,所以,我们其实少传了一个this参数。例如C1::test的操作应该是这样的:
class C1 {
public:
int m1;
void test(int a) {std::cout << "C1::test, a=" << a << ", m1=" << m1 << std::endl;}
};
int main(int argc, const char * argv[]) {
C1 c1;
c1.m1 = 1234;
void (C1::*pf1)(int) = &C1::test;
// 对象作为第一个参数传进去,其他参数跟在后面,即可转换为普通函数
auto test_ppf = reinterpret_cast<void (**)(C1 *, int)>(&pf1);
(*test_ppf)(&c1, 5);
// 引用其实本质是指针的语法糖,所以也可以改写成引用类型
auto test_ppf2 = reinterpret_cast<void (**)(C1 &, int)>(&pf1);
(*test_ppf2)(c1, 5);
return 0;
}
/*调用结果:
C1::test, a=5, m1=1234
C1::test, a=5, m1=1234
*/
看来确实是这样了,pf1的前8个字节真的就是一个普通的函数,只不过有一个隐藏的this参数罢了。我们也就把obj->func(arg)的形式,成功改写成了func(obj ,arg)的形式。那后8个字节到底是干什么的呢?先别急,后面就知道了。在解释后8个字节的作用之前,我们不妨先换换脑子,看另一个问题。
成员变量的本质是内存偏移量和数据类型的记录
这个小标题可能会让读者有点摸不着头脑,不过没关系,很快你就会明白,我们先来看一段例程:
class C1 {
public:
int m1;
// 为了方便观察,这里我用十六进制打印m1
void test(int a) {std::cout << "C1::test, a=" << a << ", m1=" << std::hex << m1 << std::endl;}
};
int main(int argc, const char * argv[]) {
// 这是随意写的一段数据
uint8_t data[] = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc};
void (C1::*pf1)(int) = &C1::test;
// 注意这里,我将隐藏参数改为了void *
auto test_ppf = reinterpret_cast<void (**)(void *, int)>(&pf1);
auto f = *test_ppf;
f(data, 8);
return 0;
}
/*输出结果:
C1::test, a=8, m1=78563412
*/
这通操作相当大胆,f是C1::test所对应的实际函数,照理说,第一个参数是要传一个C1类型的对象的,但此时我传入了一个随意的二进制数据,程序竟然可以正常运行。并且我们观察运行结果,0x78563412正好是data的前4个字节。这也就是说,程序把data当做了C1类型来处理,取的m1,就是取这个对象(或数据)的前4个字节,并且当做整数来处理。
为了验证这个说法,我们不妨再多定义几个变量:
class C1 {
public:
int m1;
char m2;
short m3;
void test(int a) {std::cout << "C1::test, a=" << a << ", m1=" << std::hex << m1 << ", m2=" << m2 << ", m3=" << m3 << std::endl;}
};
int main(int argc, const char * argv[]) {
// 这是随意写的一段数据
uint8_t data[] = {0x12, 0x34, 0x56, 0x78, 0x3c, 0xbc, 0x11, 0xaa, 0xcc, 0x55};
void (C1::*pf1)(int) = &C1::test;
// 注意这里,我将隐藏参数改为了void *
auto test_ppf = reinterpret_cast<void (**)(void *, int)>(&pf1);
auto f = *test_ppf;
f(data, 8);
return 0;
}
/*输出结果:
C1::test, a=8, m1=78563412, m2=<, m3=aa11
*/
没问题,成员都是按照对首地址的偏移,以及定义的类型来解析的,比如这里m2,应当取的是0x3c所对应的ASCII码,自然是'<'。
那么此时我们在回头看一眼这一节的小标题,有没有恍然大悟呢?
虚函数表
我们再来看看,如果一个类(或父类)拥有虚函数,会变成什么样。请看下面例程:
// 省略SHOW相关代码,请参考前面例程
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << m1 << std::endl;}
};
int main(int argc, const char * argv[]) {
C1 c1;
SHOW(c1);
return 0;
}
/*输出结果:
=====begin=====
name: c1
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|38|40|00|00|01|00|00|00|34|12|00|00|00|00|00|00|
======end======
*/
看起来m1跑到了0x08的位置,那么0x00~0x07位置应当就是虚函数表指针了。将这个指针解开以后,就可以得到虚函数表,虚函数表其实就是一个指针数组,每一个元素指向一个函数。为了验证这个说法,我们不妨再做个实验,请看例程:
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << std::hex << m1 << std::endl;}
virtual void test2() {std::cout << "test2" << std::endl;}
};
int main(int argc, const char * argv[]) {
C1 c1;
// 由于虚函数表指针是最初始的成员,偏移量为0,所以和对象首地址相同
void *pvfl = static_cast<void *>(&c1);
// 解pvfl应当得到一个数组,但是由于无法确定数组大小(也就是虚函数个数),因此用数组元素指针偏移来完成
void **vfl = *static_cast<void ***>(pvfl); // vfl是虚函数表,也就是个数组,里面的元素都是指针,所以vf1是void **类型,而pvfl是这个数组的指针,所以pvf1是void ***类型(如果实在想不通,把最里面的一层void *定义为func_t,vfl就是func_t[]类型,然后pvfl就是func_t (*)[]类型,所以*pvfl就是func_t[],再把数组替换成指针,把func_t替换成void *得到前面代码)
// 尝试取出第一个元素
void *vf1 = vfl[0];
// 将这个元素转化为函数指针,然后调用
void (*f1)(C1 &) = reinterpret_cast<void (*)(C1 &)>(vf1);
f1(c1);
return 0;
}
/*调用结果:
1234
*/
我们成功通过虚函数表访问到了成员函数。验证一下,我们来尝试取出test2对应函数地址:
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << std::hex << m1 << std::endl;}
virtual void test2() {std::cout << "test2" << std::endl;}
};
int main(int argc, const char * argv[]) {
C1 c1;
void *pvfl = static_cast<void *>(&c1);
void **vfl = *static_cast<void ***>(pvfl);
void *vf2 = vfl[1];
void (*f2)(C1 &) = reinterpret_cast<void (*)(C1 &)>(vf2);
f2(c1);
return 0;
}
/*调用结果:
test2
*/
没有问题,看来虚函数表,就是普通函数指针的指针,正常按照指针大小偏移即可。
虚函数指针及其调用过程
刚才我们用通过手动来控制指针偏移,找到了对应的虚函数并调用。编译器也可按照同样的方式,在成员定义列表中找到虚函数的位置,数出它是第几个,然后去虚函数表中找。但倘若我把虚函数的函数指针单独拿出来,该怎么办呢?(因为此时没法通过变量名来判断这是第几个虚函数了。)玄机,就在函数指针当中。
请看下面例程:
// 省略SHOW相关实现,请参考前面例程
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << std::hex << m1 << std::endl;}
virtual void test2() {std::cout << "test2" << std::endl;}
};
int main(int argc, const char * argv[]) {
void (C1::*pf1)() = &C1::test;
SHOW(pf1);
return 0;
}
/*调用结果:
=====begin=====
name: pf1
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|01|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
*/
我们可以看到,虚函数的函数指针中保存得不再是实际的函数地址(因为实际的保存在虚函数表中),而是字节的偏移量,注意这里偏移量是1起始,因此实际在虚函数表中的偏移量比这个数值少1(主要是由于0用来表示空指针了)。
验证一下,我们取test2即可:
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << std::hex << m1 << std::endl;}
virtual void test2() {std::cout << "test2" << std::endl;}
virtual void test3() {}
};
int main(int argc, const char * argv[]) {
void (C1::*pf2)() = &C1::test;
SHOW(pf2);
return 0;
}
/*调用结果:
=====begin=====
name: pf2
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|09|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
*/
OK,如果有继承关系会怎样呢?
class C1 {
public:
int m1 = 0x1234;
virtual void test() {std::cout << std::hex << m1 << std::endl;}
virtual void test2() {std::cout << "test2" << std::endl;}
};
class C2 : public C1 {
public:
virtual void test3() {}
};
int main(int argc, const char * argv[]) {
// 这里一定不可以用auto,因为C2中没有override这个函数,所以auto会推导出void (C1::*)()而不是void (C2::*)()
void (C2::*pf1)() = &C2::test;
SHOW(pf1);
void (C2::*pf2)() = &C2::test2;
SHOW(pf2);
void (C2::*pf3)() = &C2::test3;
SHOW(pf3);
return 0;
}
/*执行结果:
=====begin=====
name: pf1
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|01|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
=====begin=====
name: pf2
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|09|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
=====begin=====
name: pf3
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|11|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
*/
也就是说,继承时,父类的虚函数表也会继承过来,新的虚函数会续写在父类的虚函数表之后。
多继承和那神秘的高8字节
单继承的,虚函数表顺延续写看起来理所应当,可多继承呢?
多继承时,C++会将第一个继承类作为主父类,而其他的父类虚函数表将单独继承,不再合并。也就是说,如果一个类有N个父类的话,就会有N个虚函数表。
为了验证,请看例程:
struct A {
uint8_t pad[4] {1, 2, 3, 4};
virtual void f1() {}
};
struct B {
uint8_t pad[8] {1, 2, 3, 4, 5, 6, 7, 8};
virtual void f2() {}
};
struct C : A, B {};
int main(int argc, const char * argv[]) {
C c;
SHOW(c);
return 0;
}
/*执行结果:
=====begin=====
name: c
size: 32 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|50|40|00|00|01|00|00|00|01|02|03|04|00|00|00|00|
1|68|40|00|00|01|00|00|00|01|02|03|04|05|06|07|08|
======end======
*/
可以看到,0x00~0x07是一个虚函数表指针,也是主的(C和A拼接后的),而0x10~0x17是另一个虚函数表(从B直接继承下来的),读者可以自行验证该说法。
接下来我们做一个操作,在三个类中的函数里分别打印出this,请看例程:
struct A {
uint8_t pad[4] {1, 2, 3, 4};
virtual void f1() {std::cout << "f1, this=" << this << std::endl;}
};
struct B {
uint8_t pad[8] {1, 2, 3, 4, 5, 6, 7, 8};
virtual void f2() {std::cout << "f2, this=" << this << std::endl;}
};
struct C : A, B {
int m = 5;
virtual void f3() {std::cout << "f3, this=" << this << std::endl;}
};
int main(int argc, const char * argv[]) {
C c;
c.f1();
c.f2();
c.f3();
SHOW(c);
return 0;
}
/*调用结果:
f1, this=0x16fdff448
f2, this=0x16fdff458
f3, this=0x16fdff448
=====begin=====
name: c
size: 32 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|50|40|00|00|01|00|00|00|01|02|03|04|00|00|00|00|
1|70|40|00|00|01|00|00|00|01|02|03|04|05|06|07|08|
2|05|00|00|00|00|00|00|00|
======end======
*/
this指针的不同,其实也证实了上面的说法,A和C中函数都是正常的this(实际对象的首地址),而B中的函数打印出的this却发生了偏移。其实,C++的多继承,从第二个父类开始,就会转换成类的组合来处理。相当于在C类中先放了一个B的对象,因此我们观察对象c的内存布局,首先0x00~0x0f是从A类继承来的内容,然后0x10~0x1f是一个完整的B,最后0x20~0x27是C中新增的成员。
由于C的虚函数直接续写在了从A继承来的虚函数表后面,因此,这两个类中的虚函数传入的this都是对象的首地址,而B类中的虚函数的this则要传入C类中B类继承来位置的首地址,可以看得出偏移量是0x10,正好上面验证f2的this比f1和f3的this向后偏移了0x10。
现在我们再来打印一下三个函数指针:
struct A {
uint8_t pad[4] {1, 2, 3, 4};
virtual void f1() {std::cout << "f1, this=" << this << std::endl;}
};
struct B {
uint8_t pad[8] {1, 2, 3, 4, 5, 6, 7, 8};
virtual void f2() {std::cout << "f2, this=" << this << std::endl;}
};
struct C : A, B {
int m = 5;
virtual void f3() {std::cout << "f3, this=" << this << std::endl;}
};
int main(int argc, const char * argv[]) {
void (C::*p1)() = &C::f1;
SHOW(p1);
void (C::*p2)() = &C::f2;
SHOW(p2);
void (C::*p3)() = &C::f3;
SHOW(p3);
return 0;
}
/*调用结果:
=====begin=====
name: p1
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|01|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
=====begin=====
name: p2
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|01|00|00|00|00|00|00|00|10|00|00|00|00|00|00|00|
======end======
=====begin=====
name: p3
size: 16 Byte(s)
| 0| 1| 2| 3| 4| 5| 6| 7| 8| 9| a| b| c| d| e| f|
0|09|00|00|00|00|00|00|00|00|00|00|00|00|00|00|00|
======end======
*/
终于,成员函数指针神秘的高8字节作用解开了,就是这个this的偏移量,这里的0x10表示要向后偏移16字节。这就是成员函数指针是2个指针长度的原因所在了,第8字节是函数指针,高8字节是this的偏移量。
总结,完整的虚函数指针的调用方式如下:
1.取低8字节,表示虚函数表的偏移量
2.取高8字节,表示this的偏移量
3.根据this偏移量找到虚函数表
4.根据虚函数表偏移量找到函数
5.将调用者向后偏移对应的位置,作为实际调用者,传入函数的第一个参数中
例如:(obj.*vf1)() 【obj是对象,vf1是一个虚函数指针】
1.取vf1低8字节,记为f1
2.取vf2高8字节,记为adj
3.将&obj向后偏移adj字节,这是虚函数表指针,记为vpfl
4.vpfl向后偏移f1 * 指针大小,这是实际的函数指针,记为rf
5.调用rf,第一个参数是&obj偏移adj字节,其他参数递补。
结语
C++确实很难,因为它用了很基础的C作为底层支撑,却提供了很多高级的语法和功能,但如果我们可以把握本质,揭开它神秘面纱以后,发现其实也不过如此。
关于C++成员函数指针的相关问题就讲解到这里,如果读者有疑问,欢迎留言!