【C++】多态及原理

文章目录

1.多态的概念

多态，顾名思义就是多种状态，具体点就是去完成某种行为，但是通过不同的对象去完成某种行为都会产生不同的状态，这就是多态

比如买票这个行为。当普通人买票时，是全价买票；学生买票时，是半价买票；军人买票时是优

先买票。

这就是不同的对象去做同一件事却会有不同的状态。

2.多态的定义及实现

2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。

Person对象买票全价，Student对象买票半价。

1.必须通过基类打的指针或者引用来调用虚函数

2.被调用的函数必须是虚函数，并且子类必须对父类的虚函数进行重写

虚函数就是被virtual修饰的成员函数

class Person {
public:
 virtual void BuyTicket() { cout << "买票-全价" << endl;}
};

2.2虚函数的重写

虚函数重写的要求：

1.返回值相同，协变的时候可以不同(只要满足继承关系)

2.函数名字相同

3.参数相同

class Person {
public:
 	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};
class Student : public Person {
public:
 	virtual void BuyTicket() { cout << "买票-半价" << endl; }
 	/*注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写(因为继
承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性),但是该种写法不是很规范，不建议这样使用
*/
 /*void BuyTicket() { cout << "买票-半价" << endl; }*/
};
void Func(Person& p)
{ 
	p.BuyTicket(); 
}
int main()
{
 Person ps;
 Student st;
 
 Func(ps);
 Func(st);
 return 0;
}

协变：

class A{};
class B : public A {};
class Person {
public:
 	virtual A* f() {return new A;}
};
class Student : public Person {
public:
 	virtual B* f() {return new B;}
};

2.3析构函数的重写

析构函数为什么需要重写，不重写会发生什么？

class Person
{
public:
	
	virtual void test(int a = 1)
	{
		cout <<"a=："<< a << endl;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}

};

class Student :public Person
{
public:

	virtual void test(int a = 2)override
	{
		cout << "a=：" << a << endl;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}

};

int main(void)
{
	Person* p = new Person;
	delete p;
	Person* p1 = new Student;
	delete p1;
	return 0;
}

我丢，析构函数怎么都只调用了父类呢？那我里面的Student咋办，这不就内存泄漏了嘛？

如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的

析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规

则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处

理成destructor。

这样就完成了析构函数的调用了。

2.4 C++11 override和 final

1.final修饰的虚函数，表示该虚函数不能够被继承

class Car
{
public:
 	virtual void Drive() final {}
};
class Benz :public Car
{
public:
 	virtual void Drive() {cout << "Benz-舒适" << endl;}
};

2.override用于检查子类中的虚函数是否完成了重写

class Car{
public:
 	virtual void Drive(){}
};
class Benz :public Car {
public:
 	virtual void Drive() override {cout << "Benz-舒适" << endl;}
};

2.5重载、重写(覆盖)、重定义(隐藏)的对比

3.抽象类

3.1定义

在虚函数后面加上=0就表示这是一个抽象类，抽象类不能够被实例化，如果继承了抽象类的子类没有重写抽象函数一样无法被实例化，抽象类相当于一个接口。

class Person
{
public:
	virtual void love()=0
	{}
};

class mudan
{
public:
	virtual void love()
	{
		cout << "牡丹爱友进" << endl;
	}
};

class youjin
{
public:
	virtual void love()
	{
		cout << "友进爱牡丹" << endl;
	}
};

int main(void)
{
	Person p1;//报错

	mudan mygirlfirend;
	mygirlfirend.love();
	return 0;
}

4.多态的原理

4.1虚函数表

// 这里常考一道笔试题：sizeof(Base)是多少？
class Base
{
public:
 	virtual void Func1()
 	{
 		cout << "Func1()" << endl;
 	}
private:
 	int _b = 1;
};

通过观察测试我们发现b对象是8bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会

放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表

function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数的地址要被放到虚函数表中，

虚函数表也简称虚表，。那么派生类中这个表放了些什么呢？我们接着往下分析

为了方便观察，对代码进行改造

class Base
{
public:
	virtual void Func1()
	{
		cout << "Base::Func1()" << endl;
	}
	virtual void Func2()
	{
		cout << "Base::Func2()" << endl;
	}
	void Func3()
	{
		cout << "Base::Func3()" << endl;
	}
private:
	int _b = 1;
};

class Derive : public Base
{
public:
	virtual void Func1()
	{
		cout << "Derive::Func1()" << endl;
	}
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

可以看到Func1的地址变了，但是Func2的地址没有改变，这是因为Func1函数被重写了(覆盖)了。

总结一下子类的虚表产生过程

1.先把父类的虚函数表拷贝一份到子类的虚函数表当中

2.如果子类重写了父类当中的某个虚函数，那么在子类的虚函数表中需要覆盖掉之前copy父类的虚函数

3.子类自己添加的虚函数按照其声明的次序依次增加到子类的虚表的最后面

虚函数存在哪里？

和普通的函数一样，存在代码段当中

虚表存在哪？

虚表也存在代码段

上面分析了这个半天了那么多态的原理到底是什么？还记得这里Func函数传Person调用的

Person::BuyTicket，传Student调用的是Student::BuyTicket

观察下图的红色箭头我们看到，p是指向mike对象时，p->BuyTicket在mike的虚表中找到虚函数是

Person::BuyTicket。

观察下图的蓝色箭头我们看到，p是指向johnson对象时，p->BuyTicket在johson的虚表中找到虚函数

是Student::BuyTicket。

这样就实现出了不同对象去完成同一行为时，展现出不同的形态

总结就是，它会在虚表当中找到对应的虚函数，从而实现了多态

虚表

class Person
{
public:
	virtual void test1()
	{}

	virtual void test2()
	{}
};

int main(void)
{
	Person p1;
	Person p2;

	return 0;
}

可以看到，如果是同一个类实例化出来的对象，虚表都是同一个

单继承的虚表

class Base{
public:
	virtual void func1() { cout << "Base::func1" << endl; }
	virtual void func2() { cout << "Base::func2" << endl; }
private:
	int a;
};
class Derive :public Base {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
private:
	int b;
};

int main(void)
{
	Base b;
	Derive d;

	return 0;
}

可以发现，在d当中无法看见自己的虚表，既然它不显示，那么就可以尝试去打印它的值。

虚函数表其实是一个函数指针数组，那么我们只需要对这个函数指针数组进行遍历就知道里面有多少元素了。

typedef void(*VFPTR)();对VFPTR进行重命名，VFPTR代表void(*)()，这是一个函数指针，void是函数类型，因为*被括号括起来了，优先级更高，所以这是一个指针，加上一个函数，就是一个函数指针，这个指针用于存储函数的地址。

先观察这个对象的结构，第一部分就是虚函数表，因为是64位平台，因此前四个字节存的就是虚函数表的地址。

那么要怎么才能够取到前四个字节的内容呢？

第一个想到的就是指针，然后通过强制类型转换指针来修改一次性访问的权限大小，比如一个指针强制类型转换成char*那么一次性就是访问一个字节的内容，如果强制类型转换成int*那么就是一次性访问四个字节的内容

(VFPTR*)(*(int*)(&d));
这里就是先取到地址，然后强制类型转换成int*，然后解引用*，因为前四个字节的地址当中存的内容才是虚函数表的地址，但，现在还是int*类型，所以要转换成VFPTR*类型才能够将参数传递过去。

typedef void(*VFPTR)();

class Base{
public:
	virtual void func1() { 
		cout << "Base::func1" << endl;
	}

	virtual void func2() { 
		cout << "Base::func2" << endl;
	}
private:
	int a;
};

class Derive :public Base {
public:
	virtual void func1() { 
		cout << "Derive::func1" << endl;
	}

	virtual void func3() { 
		cout << "Derive::func3" << endl; 
	}

	virtual void func4() { 
		cout << "Derive::func4" << endl;
	}
private:
	int b;
};


void Print(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}

int main(void)
{
	Base b;
	Derive d;
	Print((VFPTR*)(*(int*)(&b)));
	Print((VFPTR*)(*(int*)(&d)));
	
	return 0;
}

可以看到func3、func4都是在虚函数表当中的，func2地址没有改变是因为子类的虚函数表建立的时候是先拷贝一份父类的虚函数表，由于func2没有被重写(覆盖)，所以地址没有改变，但是func1进行重写了，所以改变了，func3、func4紧跟在后面，编译器没有显示，但实际上是有的。

多继承的虚表

typedef void(*VFPTR)();

class Base1 {
public:
	virtual void func1() { cout << "Base1::func1" << endl; }
	virtual void func2() { cout << "Base1::func2" << endl; }
private:
	int b1;
};

class Base2 {
public:
	virtual void func1() { cout << "Base2::func1" << endl; }
	virtual void func2() { cout << "Base2::func2" << endl; }
private:
	int b2;
};

class Derive : public Base1, public Base2 {
public:
	virtual void func1() { cout << "Derive::func1" << endl; }
	virtual void func3() { cout << "Derive::func3" << endl; }
	virtual void func4() { cout << "Derive::func4" << endl; }
	virtual void func5() { cout << "Derive::func5" << endl; }
	virtual void func6() { cout << "Derive::func6" << endl; }
private:
	int d1;
};


void Print(VFPTR vTable[])
{
	cout << " 虚表地址>" << vTable << endl;
	for (int i = 0; vTable[i] != nullptr; ++i)
	{
		printf(" 第%d个虚函数地址 :0X%x,->", i, vTable[i]);
		VFPTR f = vTable[i];
		f();
	}
	cout << endl;
}

int main(void)
{
	Derive d;
	Print((VFPTR*)(*(int*)(&d)));
	Print((VFPTR*)(*(int*)((char*)(&d) + sizeof(Base1))));
	
	return 0;
}

这是上述多继承的对象的内存模型，如何访问Base2的内存呢？只需要在取到Base1内存的啥时候加上Base1的大小就能跨过Base1从而访问到Base2了。当然也可以通过切片来实现。

可以看到多继承子类的未重写的虚函数放在第一个继承父类部分的虚函数表中

问答题

1.inline函数可以是虚函数吗？

inline函数不可以是虚函数，因为inline函数没有地址，就无法把地址存放在虚函数表当中

2.静态成员可以是虚函数吗？

不能，因为静态成员函数没有this指针，就无法访问到虚函数表

3.析构函数可以是虚函数吗？

可以，如上文。

4.对象访问普通函数快还是虚函数更快？

首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。

构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始
化的。是什么意思

在C++中，每个包含虚函数的类都有一个虚函数表（vtable），虚函数表是一个指针数组，它存储了类中虚函数的地址。每个对象都有一个指向其所属类的虚函数表的指针，这个指针被称为虚函数表指针（vptr）。

在创建对象时，会先分配内存空间，然后调用对象的构造函数来初始化对象。由于每个对象都有一个虚函数表指针，因此在构造函数初始化列表阶段，会初始化这个指针，指向类的虚函数表。这样，在对象创建完成后，对象就可以正确地调用自己的虚函数了。

因此，如果构造函数是虚函数，那么在构造函数初始化列表阶段，虚函数表指针还没有被初始化，这时调用虚函数会导致不可预期的结果，可能会访问到错误的虚函数表或者调用到错误的函数。因此，C++不允许构造函数是虚函数。

总结：在初始化列表阶段，虚函数指针还没有存在，所以不能。