投稿
  1. 首页
  2. C

【C++篇】多态

code • 2022-5-12 • C • 阅读 13

【C++篇】多态,第1张

准备

博主:大大怪先森(记得关注哦!）
编程环境：vs2013
所示代码：码源

提示：写完文章后，目录可以自动生成

文章目录
  • 准备
  • 前言
  • 一、多态的概念
  • 二、多态的定义和实现
    • 2.1多态的构成条件
    • 2.2虚函数
    • 2.3函数的重写
      • 2.3.1协变和析构（两个例外）
    • 2.5C++11当中的final和override
    • 2.6重写（覆盖），重载，重定义（隐藏）的区别
  • 三、抽象类
  • 四、多态的原理
    • 4.1虚函数表
    • 4.2多态的原理
      • 4.2.1单继承的虚函数表
      • 4.2.2打印虚函数表
      • 4.2.3多继承的虚函数表
  • 五、 菱形继承和菱形虚拟继承
  • 结语

前言

本文将讲解c++多态的相关知识！！！

提示：以下是本篇文章正文内容

一、多态的概念

多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
打个比喻：
就好像是你和一个VIP成员取取银行取钱的时候，VIP用户可以去VIP通道取钱而你只能去普通通道取钱，看人办事！！！！

二、多态的定义和实现 2.1多态的构成条件

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为
那么在继承中要构成多态还有两个条件：

  1. 必须通过基类的指针或者引用调用虚函数
  2. 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写
2.2虚函数 
虚函数：即被virtual修饰的类成员函数称为函数

class Person
{
public:
	virtual void BuyTicket()//虚函数
	{
		cout << "票价 - 全价" << endl;
		return;
	}
};
2.3函数的重写

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

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "票价 - 全价" << endl;
		return;
	}
};
class Student : public Person
{
public:
	//子类中满足三同（函数名，参数，返回值）虚函数，叫做重写（覆盖）
	//virtual void BuyTicket()
	void BuyTicket()
	{
		cout << "票价 - 半价" << endl;
	}
};
//构成多态，跟p的类型没有关系，传的那个类型对象，调用的就是这个类型的函数
//----和对象有关系
//不构成多态，调用的就是p类型的函数 --- 跟类型有关
void Func(Person& p)
{
	p.BuyTicket();
}
int main()
{
	//int i = 1;
	//double d = 2.22;
	//cout << i;//调用的是cout.operator<<(int)
	//cout << d;

	Person ps;
	Student st;

	
	//Func(ps);
	//Func(st);
	//st.BuyTicket();
	st.Person::BuyTicket();
	return 0;
}
2.3.1协变和析构（两个例外）
  1. 协变(基类与派生类虚函数返回值类型不同)
    派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。
class A{};
class B : public A{};
class Person
{
public:
	/*virtual A* BuyTicket()
	{
		cout << "买票 -- 半价" << endl;
		return nullptr;
	}*/
	virtual Person* BuyTicket()
	{
		cout << "买票 -- 全价" << endl;
		return nullptr;
	}
};
class Student : public Person
{
public:
	// 子类中满足三同(函数名、参数、返回值)虚函数，叫做重写(覆盖)
	/*virtual B* BuyTicket() 
	{ 
		cout << "买票-半价" << endl; 
		return nullptr; 
	}*/
	virtual Student* BuyTicket() 
	{
		cout << "买票-半价" << endl;
		return nullptr;
	}
};
  1. 析构函数的重写(基类与派生类析构函数的名字不同)
    如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。
// 析构函数是虚函数，是否构成重写？-- 构成
// 析构函数名被特殊处理了，处理成了destructor
class Person {
public:
	~Person() 
	{ 
		cout << "~Person()" << endl;
	}
};

class Student : public Person {
public:
	~Student()
	{ 
		cout << "~Student()" << endl;
	}
};
int main()
{
	// 普通对象，析构函数是否虚函数,是否完成重写，都正确调用了
	 /*Person p;
	 Student s;*/
	
	// 动态申请的对象，如果给了父类指针管理，那么需要析构函数是虚函数
	Person* p1 = new Person; // operator new + 构造函数
	Person* p2 = new Student;
	
	// 析构函数 + operator delete
	//p1->destructor()   
	delete p1; 
	delete p2;
	// p2->destructor()
	return 0;
}
2.5C++11当中的final和override

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

1.final修饰的虚函数不能被重写

class Car
{
public:
virtual void Drive() final {}
};
class Benz :public Car
{
public:
virtual void Drive() {cout << "Benz-舒适" << endl;}
};
  1. override: 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错.
class Car{
public:
virtual void Drive(){}
};
class Benz :public Car {
public:
virtual void Drive() override {cout << "Benz-舒适" << endl;}
};
2.6重写（覆盖），重载，重定义（隐藏）的区别

三、抽象类

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

class Car
{
public:
	virtual void Drive() = 0;
};
class Benz :public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz-舒适" << endl;
	}
};
int main()
{
	Car* c = new Benz;
	return 0;
}

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

四、多态的原理 4.1虚函数表 
class Base
{
public:
	virtual void fun1()
	{
		cout << "void fun1()" << endl;
	}
	virtual void fun2()
	{
		cout << "void fun2()" << endl;
	}
private:
	int _b = 1;
	char _ch = 'A';
};

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

通过观察测试我们发现b对象是12bytes，除了_b成员，还多一个__vfptr放在对象的前面(注意有些平台可能会放到对象的最后面，这个跟平台有关)，对象中的这个指针我们叫做虚函数表指针(v代表virtual，f代表function)。
这里需要注意的是虚函数是在运行时编址

4.2多态的原理 
class Person {
public:
	virtual void BuyTicket()
	{ cout << "买票-全价" << endl; }

	void f()
	{
		cout << "f()" << endl;
	}
protected:
	int _a = 0;
};

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

void Func(Person& p)
{
	// 多态调用，在编译时，不能确定调用的是哪个函数
	// 运行时，去p指向对象的虚表中
	// 找到虚函数的地址。
	p.BuyTicket();
	p.f();
}

// 普通函数和虚函数存储的位置是否一样？
// 他们是一样的，都在代码段。只是虚函数要把地址存一到虚表，方便实现多态
int main()
{
	Person Mike;
	Func(Mike);

	Student Johnson;
	Func(Johnson);

	//Person& r1 = Johnson;
	//Person p = Johnson;

	//Person p1 = Mike;
	//Person p2 = Johnson;
	 不是多态，编译时确定地址
	//p1.BuyTicket();
	//p2.BuyTicket();

	//Person p1;
	//Person p2;

	//Student s1;
	//Student s2;

	return 0;
}

4.2.1单继承的虚函数表 
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;
	}

	virtual void Func4()
	{
		cout << "Derive::Func4()" << endl;
	}
private:
	int _d = 2;
};

int main()
{
	Base b;
	Derive d;
	Base* p1 = &b;
	p1->Func1();
	//p1 = &d;
	//p1->Func1();
	return 0;
}

4.2.2打印虚函数表 
//void PrintVFTable(VF_PTR table[])
// 打印虚函数表中内容
void PrintVFTable(VF_PTR* table)
{
	for (int i = 0; table[i] != nullptr; ++i)
	{
		printf("vft[%d]:%p->", i, table[i]);
		VF_PTR f = table[i];
		f();
	}
	cout << endl << endl;
}
int main()
{
	Base b;
	PrintVFTable((VF_PTR*)(*(void**)&b));
	Derive d;
	PrintVFTable((VF_PTR*)(*(void**)&d));
	return 0;
}

4.2.3多继承的虚函数表 
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; }
private:
	int d1;
};
int main()
{
	Derive der;
	PrintVFTable((VF_PTR*)(*(void**)&der));
	return 0;
}

五、 菱形继承和菱形虚拟继承 
class A
{
public:
	int _a;
};

//class B : public A
class B : virtual public A
{
public:
	virtual  void funcB()
	{
		cout << "void funcB()" << endl;
	}

	int _b;
};

//class C : public A
class C : virtual public A
{
public:
	virtual  void funcC()
	{
		cout << "void funcC()" << endl;
	}
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

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

	return 0;
}

结语 
希望本篇文章能给各位带来帮助，如有不足还请指正！！！
码字不易，各位大大给个收藏点赞吧！！！

各位大大记得点赞，关注，一键三连哦!!!

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/867034.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-12
下一篇 2022-05-12

发表评论

登录后才能评论

评论列表（0条）

保存