虚函数的声明与定义

虚函数存在于C++的类、结构体等中，不能存在于全局函数中，只能作为成员函数存在。

代码演示

基类Person

Person.h

#pragma once
//定义一个Person类
class Person
{
public:
	virtual void speak();//声明一个虚成员函数(简称虚函数)
	virtual void eat();//声明一个虚成员函数(简称虚函数)
	void walk();//声明一个普通成员函数
};

Person.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

#pragma once
#include "Person.h"
//定义一个类Man并继承Person类
class Man :public Person
{
	//这个函数是重写了基类中的虚函数，此时这个函数也是虚函数，前面的virtual可以省略。
	void speak() override;//override 关键字只能用于虚函数,明确表明要重写基类的虚函数
	//virtual void speak() override;//等价于上面
};

Man.cpp

#include "Man.h"
#include <iostream>

void Man::speak()
{
	std::cout << "Man::speak" << std::endl;
}

派生类Woman

Woman.h

#pragma once
#include "Person.h"
//定义一个类Woman并继承Person类
class Woman :public Person
{
	void speak() override;
};

Woman.cpp

#include "Woman.h"
#include <iostream>
void Woman::speak()
{
	std::cout << "Woman::speak" << std::endl;
}

含有虚函数的类，在编译期间会生成一张虚函数表及虚表指针。虚函数表其实是一个指针数组，里面的元素是虚函数地址。而续表指针指向虚函数表的首地址。也可以这么认为编译器给含有虚函数的类，自动增加了一个 const void* pvtr 的指针成员变量。和一个静态的 static const void* vtable[]的指针数组;也就是说同一个类的虚函数表是共享的，同一个类下不同对象的虚表指针指向的同一个虚函数表。

测试代码

#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 到底指向的实际对象是哪个类的，从而实现了动态绑定，即多态性。

静态绑定

所有的类中的非虚成员函数都是静态绑定的。即在编译期间就确定了实际调用哪个函数。普通成员函数的实际调用者，是根据代码里的调用者的类型来判断的，即在编译期就能确定，无法体现多态性。

注意:即使派生类没有重写基类中的虚函数，也没有自己特有的虚函数。那么派生类就会继承父类中的虚函数，即派生类也拥有虚函数表及虚表指针，只是自己的虚函数表中的虚函数都是父类的虚函数，除非自己重写过，虚函数表中的基类虚函数地址会被替换为自己重写后的。

访问私有虚函数

我们把上方的代码修改一下：

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;
	}
};

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函数。通过常规的手段是访问不到的。

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 //指针指向虚函数表中第二个元素
注意：这种方式能够获取私有虚函数的地址，不能获取私有普通成员函数的地址。这也是虚函数的特殊实现原理优势的。
而且这种方式最后获取的虚函数指针，不用再使用对象.* 或对象.->的动态方式来访问。直接 虚函数指针名(参数)；来调用函数。

总结一下通过成员函数指针调用函数的方式

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函数

关于函数地址的相关博客类中成员函数及普通函数地址获取方式