C++多态

2024-08-07 16:43:58 浏览数 (2)

多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。

以一个显示现实生活中的例子来理解多态：买高铁票的时候，分为成人票、学生票，军人买票时优先票，同样都是买票，但是不同身份买票的种类不一样，这个买票行为就称之为多态行为。

多态的定义及实现

构成多态的条件

不同的对象去做同一件事，展现出多种形态，结果不一样。

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

要实现C 多态，需满足以下两个条件：

  1. 父子类完成虚函数重写（函数名、参数、返回值相同），子类虚函数重写了虚函数
  2. 父类的指针或者引用去调用虚函数

从而满足指向谁调用谁的虚函数。

虚函数：即被virtual修饰的类成员函数称为虚函数

虚函数的重写

虚函数的重写(覆盖)：派生类中有一个跟基类完全相同的虚函数(即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同)，称子类的虚函数重写了基类的虚函数。 虚函数重写的两个例外：

  1. 协变(基类与派生类虚函数返回值类型不同) 派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
代码语言：javascript复制
class A {};
class B : public A {};

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

class Student : public Person {
public:
	virtual B* BuyTicket() 
	{ 
		cout << "买票-半价" << endl; 
		return nullptr;
	}
};
  1. 析构函数的重写(基类与派生类析构函数的名字不同) 如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
代码语言：javascript复制
class Person {
public:
	virtual ~Person() { cout << "~Person()" << endl; }
};
class Student : public Person {
public:
	virtual ~Student() { cout << "~Student()" << endl; }
};

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

指向父类调父类析构，指向子类调子类析构。

关于多态的代码分析

以下是一个非常坑的代码分析题：

代码语言：javascript复制
class A
{
public:
	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
	virtual void test() { func(); }
};

class B : public A
{
public:
	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	return 0;
}


//A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

父类和子类的func()函数构成重写，虚函数的重写，重写的是函数体的实现，函数的结构部分（函数名参数、返回值等）用的是父类。

创建了 B 类的对象指针 p，然后调用了 p->test()。由于 B 类继承自 A，因此 test() 函数调用的是基类 A 中的版本。

p->test() 调用基类 A 中的 test() 函数。 基类 A 的 test() 函数中调用 func()，而 func() 是虚函数，根据对象 p 的动态类型（即 B 类型），应该调用 B 类中的 func(int val = 0)。但是，在 C 中，默认参数的绑定是在编译时确定的，而不是运行时。因此，在编译阶段 A::func(int val = 1) 的默认参数值 1 将被使用，而不是 B::func(int val = 0) 的默认参数值 0。

运行结果：

多继承中指针偏移问题？下面说法正确的是( C)

代码语言：javascript复制
class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main() {
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;
	return 0;
}
代码语言：javascript复制
A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

运行结果：

C 11 override 和 final

C 对函数重写的要求比较严格，但是有些情况下由于疏忽，可能会导致函数名字母次序写反而无法构成重载，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此：C 11提供了override和final两个关键字，可以帮助用户检测是否重写。

  1. final：修饰虚函数，表示该虚函数不能再被重写
  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

override加到子类的重写虚函数，检查是否完成重写

如果没有完成重写，添加了override就会检查出是否重写：

但是如果没有添加override，就不会检查出是否重写：

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

多态的原理

虚函数表

sizeof(Base)是多少？

代码语言：javascript复制
class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
private:
	int _b = 1;
	char _ch = 'x';
};

int main()
{
	cout << sizeof(Base) << endl;
	Base b;
	return 0;
}

运行结果：

这里存在了一个函数虚函数表指针（只有虚函数有这个）

代码语言：javascript复制
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;

	return 0;
}

对象模型：

理解多态如何实现

满足多态条件，这里调用生成的指令，就会去指向对象的虚表中找对应的虚函数进行调用，指向谁调用谁的虚函数。

同类型的对象共用一个虚表，不同类型的对象有各自的虚表：

单继承和多继承关系的虚函数表

单继承中的虚函数表

在监视窗口下发现，Base是正常的，但是Derive不正常：func3和func4不在。这里是编译器的监视窗口故意隐藏了这两个函数，也可以认为是他的一个小bug。

但是通过内存，我们会发现可以看到func1和func2后面还有两个地址，疑似func3和func4。

多继承中的虚函数表

分析一下下面的代码中为什么Derive对象的大小位20？

Base1和Base2中都各有一个变量和虚拟函数表，因此各自大小位8，Derive本身大小位4，因此加一起一共20个字节。

在Derive中，有两个虚函数表，里面分别是func1和func2。但是通过监视窗口看不到func3的信息：

打印出虚表地址，并且可以查看到func3的地址：

因此func3放在Base1中

菱形继承、菱形虚拟继承

实际中我们不建议设计出菱形继承及菱形虚拟继承，一方面太复杂容易出问题，另一方面这样的模型，访问基类成员有一定得性能损耗。所以菱形继承、菱形虚拟继承我们的虚表我们就不看了，一般我们也不需要研究清楚，因为实际中很少用。 简单来看一下菱形继承：

代码语言：javascript复制
class A
{
public:
	virtual void func1()
	{}
public:
	int _a;
};

class B : virtual public A
{
public:
	virtual void func1()
	{}

	virtual void func2()
	{}
public:
	int _b;
};

class C : virtual public A
{
public:
	virtual void func1()
	{}

	virtual void func3()
	{}
public:
	int _c;
};

class D : public B, public C
{
public:
	virtual void func1()
	{

	}
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

虚函数表的打印

通过打印对象的虚表，来看看后面两个是不是func3和func4的地址

实现虚函数表打印的封装： 我们知道虚函数表本质是一个函数指针数组，存的都是void（*）（）类型的函数指针，为了书方便，我们重新定义名称：typedef void(*VFPTR)();。VFPTR 是一个函数指针类型的别名，它指向一个返回 void 类型且不接受任何参数的函数。

void PrintVFT(VFPTR* vft): 这个函数接受一个名为 vft 的参数，它是一个指向 VFPTR 函数指针数组的指针。

代码语言：javascript复制
void PrintVFT(VFPTR* vft)
{
	for (size_t i = 0; i < 4; i  )
	{
		printf("%pn", vft[i]);
	}
}

如何将这个虚函数指针传入上述函数中打印地址？ 取出d对象的头4bytes，就是虚表的指针：VFPTR* ptr = (VFPTR*)(*(int*)&d);

  1. 先取b的地址，强转成一个int*的指针
  2. 再解引用取值，就取到了b对象头4bytes的值，这个值就是指向虚表的指针
  3. 再强转成VFPTR*，因为虚表就是一个存VFPTR类型(虚函数指针类型)的数组

通过打印地址可以看到，通过内存查看的地址和打印出来的一致，所以，后面两个就是func3和func4的地址。

可以在打印虚表的时候顺便通过这个函数指针去调用一下这个函数：

代码语言：javascript复制
//打印虚函数表
typedef void(*VFPTR)();
void PrintVFT(VFPTR* vft)
{
	for (size_t i = 0; i < 4; i  )
	{
		printf("%p->n", vft[i]);
		VFPTR pf = vft[i];
		(*pf)();
	}

}

printf("%p->n", vft[i]); 打印函数指针 vft[i] 的地址。%p 格式用于以十六进制格式打印指针的地址。 VFPTR pf = vft[i]; 将 vft[i] 的函数指针存储在 pf 变量中。 (*pf)(); 调用 pf 指向的函数。这里假设 vft[i] 存储了一个有效的函数地址，(*pf)() 语法用于调用函数指针所指向的函数。

抽象类

概念

在虚函数的后面写上=0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。派生类继承后也不能实例化出对象，只有重写纯虚函数，派生类才能实例化出对象。纯虚函数规范了派生类必须重写，另外纯虚函数更体现出了接口继承。

抽象类强制派生类完成重写，间接强制虚函数重写：

前面提到过override，override是写在派生类中，已经重写了虚函数，帮助检查是否重写，检查是否有问题。

代码语言：javascript复制
class Car
{
public:
	virtual void Drive() = 0;
};

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

class BMW :public Car
{
public:
	virtual void Drive()
	{
		cout << "BMW-操控" << endl;
	}
};

int main()
{
	//Car c;
	Benz b1;
	BMW b2;

	Car* ptr = &b1;
	ptr->Drive();

	ptr = &b2;
	ptr->Drive();

	return 0;
}

运行结果：

接口继承和实现继承

普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实现。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。

关于多态的一些思考

虚函数存放位置

虚函数跟普通函数一样都是存放在代码段，不是存在虚表中，虚表中存的仅仅是虚函数的地址。

虚表存在区域

代码段

代码语言：javascript复制
class Person {
public:
	virtual void BuyTicket() { cout << "买票-全价" << endl; }
};

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

void Func(Person& p)
{
	p.BuyTicket();
}


int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%pn", &i);
	printf("静态区:%pn", &j);
	printf("堆:%pn", p1);
	printf("常量区:%pn", p2);

	Person p;
	Student s;
	Person* p3 = &p;
	Student* p4 = &s;

	printf("Person虚表地址:%pn", *(int*)p3);
	printf("Student虚表地址:%pn", *(int*)p4);

	return 0;
}
继承 指针 c++ 对象 函数

0 人点赞