C++多态

最新推荐文章于 2024-11-12 15:18:48 发布

Lei宝啊

最新推荐文章于 2024-11-12 15:18:48 发布

阅读量974

点赞数 21

分类专栏： C++ 文章标签： c++ 多态

本文链接：https://blog.csdn.net/m0_74824254/article/details/135899771

版权

C++ 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

个人主页：Lei宝啊

愿所有美好如期而遇

多态的概念

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

举个例子：我们平时买票，学生票，成人票，同样都是买票，但是价格不同，也就是买票动作相同，是不同的对象去买票，也就有不同的状态，也就是多态。

多态的定义及实现

多态就是不同继承关系的类对象，去调用同一函数，产生不同行为。

首先是多态的构成条件：

必须通过基类指针或者引用调用虚函数
被调用的函数必须是虚函数，并且派生类必须对基类中的虚函数进行重写

在函数前加上virtual就是虚函数。

虚函数重写：派生类虚函数与父类虚函数返回值，函数名，参数相同，实现方法不同。实际上就是使用基类虚函数的声明，在派生类重新实现。举个例子：

#include <iostream>
using namespace std;

class A
{
public:
	virtual void print(int a = 0)
	{
		cout << "A::print() = " << a << endl;
	}
};

class B : public A
{
public:
	virtual void print(int a = 1)
	{
		cout << "B::print() = " << a << endl;
	}
};

int main()
{
	//先无视内存泄露的问题
	A* a = new A;
	A* b = new B;

	a->print();
	b->print();

	return 0;
}

虚函数重写的两个例外：

协变
析构函数重写

协变：基类与派生类虚函数返回值不同，并且对返回值有要求，即基类返回基类的指针或引用，派生类返回派生类的指针或引用。举个例子：

析构函数重写：

首先我们直接delete释放new的A和B对象，看看析构结果：

#include <iostream>
using namespace std;

class A
{
public:
	virtual void print(int a = 0)
	{
		cout << "A::print() = " << a << endl;
	}

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

class B : public A
{
public:
	virtual void print(int a = 1)
	{
		cout << "B::print() = " << a << endl;
	}

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

int main()
{
	//先无视内存泄露的问题
	A* a = new A;
	A* b = new B;

	a->print();
	b->print();

	delete a;
	delete b;

	return 0;
}

因为a，b是A类型的指针，同时没有进行虚函数重写，所以这样delete调用的时类A的析构函数。

我们需要知道的是析构函数的函数名最终都会被编译器处理成叫做destrcucor，所以，子类继承父类的析构函数，天然构成隐藏，当我们想要实现析构函数的多态，只需要在析构函数前加上virtual就可以，举个例子：

重载，重写，隐藏·(多定义)的对比：

重载：两个函数在同一作用域，并且函数名和参数相同
重写：两个虚函数在不同作用域，并且一个是基类，一个是派生类；返回值(协变除外)，函数名，参数(参数类型需要不同，名字可以不同)相同。
隐藏：两个函数的函数名相同，分别在基类和派生类两个作用域；并且，两个同名函数不构成重写就是隐藏。

抽象类

在虚函数后加上 = 0就是纯虚函数，包含纯虚函数的类叫做抽象类，抽象类无法实例化对象。

派生类继承抽象类后也不能实例化对象，必须重写纯虚函数，派生类才能实例化对象。纯虚函数规范了派生类必须重写，并且纯虚函数更体现了接口继承。

我们举个例子：

#include <iostream>
using namespace std;

class Car
{
public:
	virtual void Drive() = 0;
};

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

class BabyHorse : public Car
{
public:
	virtual void Drive()
	{
		cout << "BabyHorse" << endl;
	}
};

int main()
{

	Benz car1;
	BabyHorse car2;

	car1.Drive();
	car2.Drive();

	return 0;
}

接口继承和实现继承：

普通函数的继承是一种实现继承，派生类继承了基类，可以直接使用函数，继承的是函数的实现。

虚函数的继承是一种接口继承，派生类继承的是基类的接口，目的是为了重写，达成多态，继承的是接口（但是如果没有重写，那就当成普通函数使用即可，但是就比较多余，所以如果不使用多态，就不要把函数定义成虚函数）

多态的原理

我们希望可以理解以下几个问题：

虚基表指针和虚表指针的区分
虚表和虚表的存放位置
虚函数地址

先举个例子：

#include <iostream>
using namespace std;

class A
{
public:
	A()
		:_a(6)
	{}

	virtual void print(int a = 0)
	{
		cout << "A::print() = " << a << endl;
	}

	virtual ~A()
	{
		cout << "~A" << endl;
	}

protected:
	int _a;
};

class B : public A
{
public:
	B()
		:_b(9)
	{}

	virtual void print(int a = 1)
	{
		cout << "B::print() = " << a << endl;
	}

	virtual ~B()
	{
		cout << "~B" << endl;
	}

private:
	int _b;
};

int main()
{

	A a;
	B b;

	return 0;
}

通过上面两张图，我们先解释虚表，虚表里面存放着虚函数地址，并且虚表是在编译时就已经产生的，虚表指针在构造函数初始化列表进行初始化，虚函数经过编译后应该是一串指令，而第一个指令的地址就是虚函数的地址，我们可以从反汇编里看到，在Vs上，编译器对虚函数地址做了封装，jmp指令的地址做了虚函数的地址，jmp指令就是跳到虚函数编译后的第一条指令。

上图，vfptr就是虚表指针，指向虚表，虚表中存放着虚函数地址。

如何区分虚表指针和虚基表指针？我们首先要明白虚基表指针是干什么的，他解决了菱形继承的数据冗余和二义性问题，也就是菱形虚拟继承时才会有虚基表指针，这个指针指向的位置存放着偏移量；而虚表指针指向虚表，虚表中存放着虚函数地址，只有当类中有自己的虚函数时，才会生成虚表，什么是自己的虚函数，也就是说，不是通过重写父类虚函数存在的。

那么虚函数存放在哪里呢？在Vs上，我们可以进行一个测试：

int main()
{

	Benz* p = new Benz();
	Benz** pp = &p;
	const char* cp = "haha";

	printf("  栈区地址：%p\n", pp);
	printf("  堆区地址：%p\n", p);
	printf("常量区地址：%p\n", cp);

    //p是Benz对象的地址，同时也是虚表指针的地址
    //我们想要拿到虚表指针，就需要进行强制类型转换后解引用
    //指针类型决定着一次可以读取多少个字节内容
	printf("  虚表地址：%p\n", (*(int*)p));
	return 0;
}

我们可以清楚的看到虚表是存在常量区的，这样做是为了什么呢？在创建相同类型的对象时，他们的虚表和虚表指针是相同的！我们来验证一下：

最终我们得出结论，在Vs上，虚表是存在常量区上的。

我们这里额外验证一下虚函数地址是存储在虚表中的：

#include <iostream>
using namespace std;

class A
{
public:
	virtual void func1(){}
	virtual void func2(){}
	virtual void func3(){}
private:
	int _a = 0;
};

typedef void(*vfptr)();

void func(vfptr* ptr)
{
	for (int i = 0; i < 3; i++)
	{
		cout << ptr[i] << endl;
	}
}

int main()
{

	A a;
	// (*(int*)&a)是虚表指针，相当于vfptr p[]中的p
	func((vfptr*)(*(int*)&a));

	return 0;
}

单继承和多继承中的虚函数表

这里我们需要理清楚几个模型：

单继承
多继承
菱形继承及其虚拟继承

单继承：

class A
{
public:
	A()
		:_a(1)
	{}

	virtual void print()
	{
		cout << "A" << endl;
	}

private:
	int _a;
};

class B ： public A
{
public:
	B()
		:_b(2)
	{}

	virtual void print()
	{
		cout << "B" << endl;
	}

private:
	int _b;
};

int main()
{
	A a;
	B b;

	return 0;
}

多继承：

class A
{
public:
	A()
		:_a(1)
	{}

	virtual void print()
	{
		cout << "A" << endl;
	}

private:
	int _a;
};

class B
{
public:
	B()
		:_b(2)
	{}

	virtual void print()
	{
		cout << "B" << endl;
	}

private:
	int _b;
};

class C : public A, public B
{
public:
	C()
		:_c(3)
	{}

	virtual void print()
	{
		cout << "C" << endl;
	}

private:
	int _c;
};

int main()
{
	A a;
	B b;
	C c;

	return 0;
}