C++---多态

最新推荐文章于 2022-08-18 11:15:29 发布
最新推荐文章于 2022-08-18 11:15:29 发布
阅读量197 收藏 1
点赞数
分类专栏： C++ 文章标签： C++ 多态 虚函数 抽象类 虚函数表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53946312/article/details/120834462
版权

多态

多态：多种形态，具体是完成某种行为，当不同的对象去完成时会产生不同的状态

多态的定义及实现

int main()
{
	int i;
	char c;
	cin >> i;
	cin >> c;
	cout << i << endl;
	cout << c << endl;
	//看起来用的是一个函数，但实际不是，这就是多态实现的
	return 0;
}

多态的构成条件

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

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

虚函数

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

在这里插入图片描述

虚函数的重写

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

class Person
{
public:
	virtual void Buyticket()
	{
		cout << "买票--全票" << endl;
	}
};
//virtuel void f() 
//只有类的非静态成员函数可以是虚函数
class Old :public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void Buyticket()
	{
		cout << "买票--免费" << endl;
	}
};
class Stu:public Person
{
public:
	//子类的虚函数重写了父类的虚函数
	virtual void Buyticket()
	{
		cout << "买票--半票" << endl;
	}
};

void f(Person& p)
{
	//传不同类型的对象，调用的是不同函数，实现了调用的多种形态
	p.Buyticket();
}
void f(Person*  p)
{
	
	p->Buyticket();
}
int main()
{
	Person p;
	Stu s;
	Old o;
	f(p);
	f(s);
	f(o);
	cout << endl;
	f(&p);
	f(&s);
	f(&o);
	return 0;
}

在这里插入图片描述

虚函数重写的三个例外

协变

基类与派生类虚函数返回值类型不同
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。

class A{};
class B:public A{};
class Person
{
public:
	virtual A* f(){ 
		cout << "A* Person::f()" << endl;
		return new A;
	};
};

class Stu:public Person
{
public:
	virtual B* f(){
		cout << "B* Stu::f()" << endl;
		return new B;
	};
};
int main()
{
	Person p;
	Stu s;
	Person* ptr;
	ptr = &p;
	ptr->f();
	ptr = &s;
	ptr->f();
	return 0;
}

析构函数的重写

基类与派生类析构函数的名字不同
如果基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同。虽然函数名不相同，看起来违背了重写的规则，其实不然，这里可以理解为编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor。

class Person
{
public:
	//建议把父类析构函数定义为虚函数
	//这样子类的虚函数方便重写父类的虚函数
	virtual ~Person()
	{
		cout << "~Person()" << endl;

	}

};
class Stu:public Person
{
public:
	virtual ~Stu()
	{
		//Stu和Person析构函数的函数名看起来不相同，但是构成虚函数重写
		cout << "~Stun()" << endl;

	}

};
int main()
{
	Person p;
	Stu s;

	return 0;
}

在这里插入图片描述

class Person
{
public:
	//建议把父类析构函数定义为虚函数
	//这样子类的虚函数方便重写父类的虚函数
	 ~Person()
	{
		cout << "~Person()" << endl;

	}
	 //子函数没有重写父类
};
class Stu:public Person
{
public:
	 ~Stu()
	{
		//Stu和Person析构函数的函数名看起来不相同，但是构成虚函数重写
		cout << "~Stu()" << endl;

	}

};
int main()
{
	//在普通场景下，父子类的析构函数是否构成重写，不重要，没影响
	//Person p;
	//Stu s;
	Person* p1 = new Person;
	Person* p2 = new Stu;
	//多态行为
	//这里p2指向子类对象，应该调用子类析构函数，但是没有调用
	//那么肯内存泄漏(如果子类函数没做什么清理那就没什么事)
	//如果子类函数有清理那就存在资源泄漏
	delete p1;//p1->析构函数()+ operator delete(p1)
	delete p2;//p2->析构函数()+ operator delete(p2)

	return 0;
}

在这里插入图片描述
在这里插入图片描述

子类虚函数不加virtual

子类虚函数可以不加virtual 也算完成重写，但是父类虚函数不行。
子类是先继承父类的虚函数，继承后就有virtual属性了，子类只是重写了virtual函数。这样子类加不加virtual都一定完成了重写，保证了delete时一定能实现多态的正常调用析构函数

class Person
{
public:
	virtual void Buyticket()
	{
		cout << "买票--全票" << endl;
	}
};
class Stu: public Person 
{
public:
	//子类虚函数，不写virtual也认为是虚函数，完成重写
	 void Buyticket()
	{
		cout << "买票--半票" << endl;
	}
};
void f(Person& p)
{
	p.Buyticket();
}
int main()
{
	Person p;
	Stu s;
	f(p);
	f(s);

	return 0;
}

在这里插入图片描述

C++11 override和final

final

修饰虚函数，表示该虚函数不能被重写
在这里插入图片描述

override

检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错

class car
{
public:
	virtual void Drive(){}
};
class Benz :public car
{
public:
	virtual void Drive()override{ cout << "Benz-快" << endl; }
};
int main()
{

	return 0;
}

重载，覆盖(重写),隐藏(重定义)的区别

重载：

  • 两个函数在同一作用域，函数名/参数不同
    重写(覆盖)：
  • 两个函数分别在基类，派生类的作用域，函数名/参数/返回值必须相同(协变除外)；两个函数必须是虚函数
    重定义(隐藏):两个函数分别在基类和派生类作用域，函数名相同，两个基类和派生类的同名函数不构成重写就是重定义

抽象类

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

//抽象类-》不能实例化出对象
//作用：可以更好的表示现实世界中，没有实例对象对应的抽象类型 eg:植物，人，动物...
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 << "BWM--舒适" << endl;
	}
};
int main()
{
	car* pBen = new Benz;
	pBen->Drive();
	car* pBMW = new BMW;
	pBMW->Drive();

	return 0;
}

在这里插入图片描述

接口继承和实现继承

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

多态的原理

class Base
{
public:
	virtual void f1()
	{
		cout << "f1()" << endl;
	}
	virtual void f2()
	{
		cout << "f2()" << endl;
	}
	void f3()
	{
		cout << "f3()" << endl;
	}
private:
	int _i = 1;
	char _ch = '\0';

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

在这里插入图片描述

在这里插入图片描述

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

};
class Stu :public Person
{
public:
	virtual void Buyticket()
	{
		cout << "买票--半票" << endl;
	}
};
void f(Person& p)
{
	p.Buyticket();
}
int main()
{
	Person L;
	f(L);
	Stu s;
	f(s);
	return 0;
}

在这里插入图片描述

动态绑定与静态绑定

  • 静态绑定又称为前期绑定(早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载
  • 动态绑定又称后期绑定(晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。
  • 汇编代码能解释什么是静态(编译器)绑定和动态(运行时)绑定。
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

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

单继承中的虚函数表

class Base
{
public:
	virtual void f1()
	{
		cout << "Base::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "Base::f2()" << endl;
	}
private:
	int _b;
};
class Dr :public Base
{
public:
	virtual void f1()
	{
		cout << "Dr::f1()" << endl;
	}
	virtual void f3()
	{
		cout << "Dr::f3()" << endl;
	}
	virtual void f4()
	{
		cout << "Dr::f4()" << endl;
	}
private:
	int _d;
};
int main()
{
	Base ba;
	Dr dr;
	return 0;
}

在这里插入图片描述

class Base
{
public:
	virtual void f1()
	{
		cout << "Base::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "Base::f2()" << endl;
	}
private:
	int _b;
};
class Dr :public Base
{
public:
	virtual void f1()
	{
		cout << "Dr::f1()" << endl;
	}
	virtual void f3()
	{
		cout << "Dr::f3()" << endl;
	}
	virtual void f4()
	{
		cout << "Dr::f4()" << endl;
	}
private:
	int _d;
};
//写一个程序打印一个虚表，确认虚表中调用的函数
typedef void(*VF)();
//void PrintVF(VF ptr[])
void PrintVF(VF* ptr)
{
	printf("虚表地址:%p\n" ,ptr);
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("VF[%d]:%p->\n", i,ptr[i]);
		ptr[i]();
	}
	printf("\n");
}
int main()
{
	Base ba;
	PrintVF((VF*)(*(int*)&ba));
	Dr dr;
	PrintVF((VF*)(*(int*)&dr));
	return 0;
}

在这里插入图片描述

多继承中的虚函数表

class Base1
{
public:
	virtual void f1()
	{
		cout << "Base1::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "Base1::f2()" << endl;
	}
private:
	int _b1;
};
class Base2
{
public:
	virtual void f1()
	{
		cout << "Base2::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "Base2::f2()" << endl;
	}
private:
	int _b2;
};
class Dr :public Base1,public Base2
{
public:
	virtual void f1()
	{
		cout << "Dr::f1()" << endl;
	}
	virtual void f3()
	{
		cout << "Dr::f3()" << endl;
	}

private:
	int _d;
};
typedef void(*VF)();
void PrintVF(VF* ptr)
{
	printf("虚表地址:%p\n" ,ptr);
	for (int i = 0; ptr[i] != nullptr; i++)
	{
		printf("VF[%d]:%p->\n", i,ptr[i]);
		ptr[i]();
	}
	printf("\n");
}
int main()
{
	Base1 b1;
	Base2 b2;
	Dr dr;
	PrintVF((VF*)(*(int*)&b1));
	PrintVF((VF*)(*(int*)&b2));
	PrintVF((VF*)(*(int*)&dr));
	PrintVF((VF*)(*(int*)((char*)&dr + sizeof(Base1))));
	return 0;
}

在这里插入图片描述

菱形继承中的虚函数表

class A
{
public:
		virtual void f1()
		{
			cout << "A::f1()" << endl;
		}
	int _a;
};

class B :virtual public A
{
public:
	virtual void f1()
	{
		cout << "B::f1()" << endl;
	}
	int _b;
};
class C :virtual public A
{
public:
	virtual void f1()
	{
		cout << "C::f1()" << endl;
	}
	int _c;
};
class D : public B,public C
{
public:
	virtual void f1()
	{
		cout << "D::f1()" << endl;
	}
	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;
}

在这里插入图片描述

class A
{
public:
		virtual void f1()
		{
			cout << "A::f1()" << endl;
		}
	int _a;
};

class B :virtual public A
{
public:
	virtual void f1()
	{
		cout << "B::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "B::f2()" << endl;
	}
	int _b;
};
class C :virtual public A
{
public:
	virtual void f1()
	{
		cout << "C::f1()" << endl;
	}
	virtual void f2()
	{
		cout << "C::f2()" << endl;
	}
	int _c;
};
class D : public B,public C
{
public:
	virtual void f1()
	{
		cout << "D::f1()" << endl;
	}
	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;
}

在这里插入图片描述

总结

1.inline函数可以是虚函数吗？答：可以，不过编译器就忽略inline属性，这个函数就不再是inline，因为虚函数要放到虚表中去。
2.静态成员可以是虚函数吗？答：不能，因为静态成员函数没有this指针使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
3.构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
4.析构函数可以是虚函数吗？什么场景下析构函数是虚函数？答：可以，并且最好把基类的析构函数定义成虚函数。
5.对象访问普通函数快还是虚函数更快？答：首先如果是普通对象，是一样快的。如果是指针对象或者是引用对象，则调用的普通函数快，因为构成多态，运行时调用虚函数需要到虚函数表中去查找。
6.虚函数表是在什么阶段生成的，存在哪的？答：虚函数表是在编译阶段就生成的，一般情况下存在代码段(常量区)的。
7.抽象类的作用？答：抽象类强制重写了虚函数，另外抽象类体现出了接口继承关系。

qnbk
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 补充-多态
05-17
C++补充-多态,简绍了有很多有用的东西，值得学习参考！希望对你有用！
C++--多态
AI_ELF的博客
03-13 2203
C++—多态多态的定义及实现多态的构成条件虚函数虚函数的重写 多态的定义及实现 多态：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。 多态的构成条件 多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为 在继承中要构成多态有两个条件： 必须通过基类的指针或者引用调用虚函数 被调用的函数必须是虚函数，且派生类必须对基类的虚函数进行重写 #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream&gt
c++---多态
qq_68066657的博客
08-18 69
多态的区别和分类，动态多态的满足条件和使用方法。 纯虚函数和抽象类的使用目的。 虚析构和纯虚析构的区别与共性及使用。
浅析C++多态----多态实现原理
qq_52683550的博客
03-27 975
目录 C++为什么要引入多态？ 一.背景介绍 二.多态的实现原理 1.什么是多态？ 2.多态的分类 3.多态的实现原理 4.如何证明vptr指针？ 三.总结 一.背景介绍 虚函数重写：子类重新定义父类中有相同函数名，返回值和参数的虚函数 非虚函数重写：子类重新定义父类中有相同名称和参数的非虚函数 继承中的类型兼容性原则 1.子类对象可以作为父类对象使用 2.子类对象可以直接赋值给父类对象 3.子类对象可以初始化父类对象 4.父类指针可以直接指向子类对象 5.父类引用可以..
C++ 学习-多态
尖皇
01-14 948
多态 C++的三大特性之一 分类： 静态多态：函数重载 和 运算符重载，即复用函数名； 动态多态：派生类 和 虚函数 实现运行时的多态 区别： 静态多态的函数地址早绑定 ， 即 在编译阶段才确定函数地址 动态多态的函数地址晚绑定 ， 即 在运行阶段才确定函数地址 #include <iostream> using namespace std; class Animal { public: void speak() { cout <<"动物说话"<< en
C++-05继承和多态
最新发布
03-11
C++继承和多态的学习笔记
C++实验-多态
04-06
C++实验-多态
c++多态总结
08-30
c++多态总结，vptr总结，多态原理探究
C++二叉树进阶
weixin_53946312的博客
10-24 2121
二叉树进阶二叉搜索树二叉搜索树概念二级目录三级目录 二叉搜索树 二叉搜索树概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 时间复杂度：O(N)，只有当树的形状接近完全二叉树或者满二叉树，才能达到 logN 搜索二叉树延伸：AVLTree 红黑树(对搜索二叉树左右高度提出要求，非常接近完全二叉树，效率可达到 O(logN))
C++ 红黑树
weixin_53946312的博客
01-28 1429
红黑树
C++-- 二叉树的层序遍历
weixin_53946312的博客
10-24 1410
二叉树的层序遍历 题目要求： 题目来源：力扣 class Solution { public: vector<vector<int>> levelOrder(TreeNode* root) { if(root == nullptr) { return vector<vector<int>> (); } queue<TreeNode*> q;
把字符串转换成整数(C++)
weixin_53946312的博客
07-27 1136
把字符串转化成整数 题目描述： 思路： 要考虑正负数 要考虑数据是否溢出 题目来源：牛客 class Solution { public: int StrToInt(string str) { int len=str.size(); int flag=1; if(len==0) return 0; const char *cstr = str.c_str(); if(cstr == NULL)
C++ 两个数组的交集
weixin_53946312的博客
01-28 1009
两个数组的交集 题目来源：leetcode class Solution { public: vector<int> intersection(vector<int>& nums1, vector<int>& nums2) { //用unordered_set对num2中的元素去重 unordered_set<int> s2; for(auto e: nums2) {
C++ AVL树
weixin_53946312的博客
01-27 993
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
LRU Cache
weixin_53946312的博客
05-26 857
LRU CacheLRU Cache的实现 LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。 Cache：狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为I
C++ map和set
weixin_53946312的博客
01-27 844
map和set
找出字符串中只出现一次的字符(C++)
weixin_53946312的博客
07-27 805
找出字符串中只出现一次的字符 题目来源：牛客 思路： 对字符串的每一个字符进行hash映射 按顺序检测每一个字符是否只出现一次 #include<iostream> #include<string> #include<list> using namespace std; int Hash(int key) { return key - 'a'; } int FirstTimeChar(string &str) { int hashta
C++入门---基础语法
weixin_53946312的博客
05-21 782
这里写目录标题1、命名空间命名冲突1.1命名空间的定义1.2命名空间使用的三种方式1、指定作用域2、using namespace std3、对库里面常用的展开C++输入输出三级目录 1、命名空间 在C/C++中，变量，函数和类都是大量存在的，这些变量、函数和类的名称都将存在于全局作用域中，可能会导致很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。 命名冲突 #include <stdio.h> int main
无规矩不成方圆 - C/C++ 多态
05-23
在 C++ 中，多态是面向对象编程的一种重要概念。它允许我们使用基类的指针或引用来调用派生类的方法，从而实现动态绑定的效果。C++ 中的多态主要分为两种：静态多态和动态多态。 静态多态是指函数重载，它是在编译...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值