文章目录
虚函数的声明与定义
虚函数存在于C++的类、结构体等中，不能存在于全局函数中，只能作为成员函数存在。
代码演示
基类Person
Person.h
cpp
#pragma once
//定义一个Person类
class Person
{
public:
virtual void speak();//声明一个虚成员函数(简称虚函数)
virtual void eat();//声明一个虚成员函数(简称虚函数)
void walk();//声明一个普通成员函数
};Person.cpp
cpp
#include "Person.h"
#include <iostream>
void Person::speak()//虚函数的定义，前面不能加vitrual，否则编译不过
{
std::cout << "Person::speak" << std::endl;
}
void Person::eat()//虚函数的定义，前面不能加vitrual，否则编译不过
{
std::cout << "Person::eat" << std::endl;
}
void Person::walk()//普通函数的定义
{
std::cout << "Person::walk" << std::endl;
}派生类Man
Man .h
cpp
#pragma once
#include "Person.h"
//定义一个类Man并继承Person类
class Man :public Person
{
//这个函数是重写了基类中的虚函数，此时这个函数也是虚函数，前面的virtual可以省略。
void speak() override;//override 关键字只能用于虚函数,明确表明要重写基类的虚函数
//virtual void speak() override;//等价于上面
};Man.cpp
cpp
#include "Man.h"
#include <iostream>
void Man::speak()
{
std::cout << "Man::speak" << std::endl;
}派生类Woman
Woman.h
cpp
#pragma once
#include "Person.h"
//定义一个类Woman并继承Person类
class Woman :public Person
{
void speak() override;
};Woman.cpp
cpp
#include "Woman.h"
#include <iostream>
void Woman::speak()
{
std::cout << "Woman::speak" << std::endl;
}
含有虚函数的类，在编译期间会生成一张虚函数表及虚表指针。虚函数表其实是一个指针数组，里面的元素是虚函数地址。而续表指针指向虚函数表的首地址。也可以这么认为编译器给含有虚函数的类，自动增加了一个 const void* pvtr 的指针成员变量。和一个静态的 static const void* vtable[]的指针数组;也就是说同一个类的虚函数表是共享的，同一个类下不同对象的虚表指针指向的同一个虚函数表。
测试代码
cpp
#include "Person.h"
#include "Man.h"
#include "Woman.h"
//test函数的声明
void test(Person* person);
void test(Person& person);
int main(int argc, char* argv[])
{
Person person;
test(&person);//传地址
//test(person);
Man man;
test(&man);//传地址
//test(man);
Woman woman1;
test(&woman1);//传地址
Woman woman2;
test(&woman2);//传地址
return 0;
}
//test函数的实现，体现了多态
void test(Person* person)//指针传递
{
person->speak();
//person->eat();
//person->walk();
}
void test(Person& p)//引用传递
{
p.speak();
p.eat();
p.walk();
}打印结果：
动态绑定
虚函数的好处就是体现了C++中多态。即当基类类型的指针或引用 指向子类的对象时，在调用虚函数时，实际调用的虚函数是子类对象中的虚函数。
就像上面的test(Person* person)函数，编译器在编译期间不确定函数内实际调用哪个类中的speak函数，需要在实际代码执行时，才能确定，指针 person 到底指向的实际对象是哪个类的，从而实现了动态绑定，即多态性。
静态绑定
所有的类中的非虚成员函数都是静态绑定的。即在编译期间就确定了实际调用哪个函数。普通成员函数的实际调用者，是根据代码里的调用者的类型来判断的，即在编译期就能确定，无法体现多态性。
注意:即使派生类没有重写基类中的虚函数，也没有自己特有的虚函数。那么派生类就会继承父类中的虚函数，即派生类也拥有虚函数表及虚表指针，只是自己的虚函数表中的虚函数都是父类的虚函数，除非自己重写过，虚函数表中的基类虚函数地址会被替换为自己重写后的。
访问私有虚函数
我们把上方的代码修改一下：
cpp
class Person
{
private:
virtual void speak(){
cout << "Person::speak" << endl;
}
public:
virtual void eat(){
cout << "Person::eat" << endl;
}
}
class Woman : public Person
{
public:
void eat(){
cout << "Woman::eat" << endl;
}
};
cpp
int main(int argc, char *argv[])
{
Person person;
//person.speak();//编译报错，无法访问私有属性成员
Woman woman;
//woman.speak();//编译报错，同上
//void (Person:: *fun1)(void) = &Person::speak;//编译报错，右值报错，无法通过&Person::speak获取函数地址。还是因为私有属性问题
return 0;
}我们想要在类的定义外部访问speak函数。通过常规的手段是访问不到的。
cpp
int main(int argc, char *argv[])
{
typedef void (*Fun)(void);//给函数指针类型取别名
Woman woman;
Fun pfun1 = (Fun)*((int*)*(int*)&woman);
Fun2 pfun2 = (Fun)*((int*)*(int*)&woman + 1);//此时pfun2 将不再是一个被类作用域限制的成员函数的指针了，而相当于一个全局函数的指针。
pfun1();//输出结果：Person::speak
pfun2();//输出结果：Woman::eat
return 0;
}分析一下：上面的pfun1 和 pfun2 函数指针，在执行时的输出结果。首先要明白一点，含有虚函数的类，在编译时，创建的虚表指针变量会优化为类中第一个成员属性，那么创建对象时，虚表指针所占的内存地址和对象的地址是相同的。类似于 数组首元素的地址和数组名的关系。
上方的图中的：有两处的地址为何可以转为(int )即int型指针，因为地址值就是整型的。虚表指针vptr的值是地址，虚函数表元素也是地址。
又因为指针的类型和指针所指向的地址存储的内容类型是关联的。另一处是转为（Fun）即函数指针。也是一个道理，函数指针指向的地址（即函数地址）存储的是真实的函数。
(int )(int )&woman //指针指向虚函数表中第一个元素
(int*)(int )&woman + 1 //指针指向虚函数表中第二个元素
注意：这种方式能够获取私有虚函数的地址，不能获取私有普通成员函数的地址。这也是虚函数的特殊实现原理优势的。
而且这种方式最后获取的虚函数指针，不用再使用对象.* 或对象.->的动态方式来访问。直接 虚函数指针名(参数)；来调用函数。
总结一下通过成员函数指针调用函数的方式
cpp
void (Woman:: *fun1)(void) = &Woman ::speak;//访问公共属性的成员普通函数或成员虚函数
Woman woman;
(woman.*fun1)();//调用speak函数
Woman & woman1 = &woman;
(woman.->fun1)();//调用speak函数
typedef void (*Fun)(void);
Fun fun = (Fun)*((int*)*(int*)&woman);//访问公共成员虚函数或者私有成员函数
fun();//调用speak函数关于函数地址的相关博客类中成员函数及普通函数地址获取方式